xo 0.48.0 → 0.49.0

package/node_modules/@typescript-eslint/typescript-estree/node_modules/ignore/legacy.js

@@ -1,498 +0,0 @@
-"use strict";
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-// A simple implementation of make-array
-function makeArray(subject) {
-  return Array.isArray(subject) ? subject : [subject];
-}
-
-var EMPTY = '';
-var SPACE = ' ';
-var ESCAPE = '\\';
-var REGEX_TEST_BLANK_LINE = /^\s+$/;
-var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
-var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
-var REGEX_SPLITALL_CRLF = /\r?\n/g; // /foo,
-// ./foo,
-// ../foo,
-// .
-// ..
-
-var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
-var SLASH = '/';
-var KEY_IGNORE = typeof Symbol !== 'undefined' ? Symbol["for"]('node-ignore')
-/* istanbul ignore next */
-: 'node-ignore';
-
-var define = function define(object, key, value) {
-  return Object.defineProperty(object, key, {
-    value: value
-  });
-};
-
-var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
-
-var RETURN_FALSE = function RETURN_FALSE() {
-  return false;
-}; // Sanitize the range of a regular expression
-// The cases are complicated, see test cases for details
-
-
-var sanitizeRange = function sanitizeRange(range) {
-  return range.replace(REGEX_REGEXP_RANGE, function (match, from, to) {
-    return from.charCodeAt(0) <= to.charCodeAt(0) ? match // Invalid range (out of order) which is ok for gitignore rules but
-    //   fatal for JavaScript regular expression, so eliminate it.
-    : EMPTY;
-  });
-}; // See fixtures #59
-
-
-var cleanRangeBackSlash = function cleanRangeBackSlash(slashes) {
-  var length = slashes.length;
-  return slashes.slice(0, length - length % 2);
-}; // > If the pattern ends with a slash,
-// > it is removed for the purpose of the following description,
-// > but it would only find a match with a directory.
-// > In other words, foo/ will match a directory foo and paths underneath it,
-// > but will not match a regular file or a symbolic link foo
-// >  (this is consistent with the way how pathspec works in general in Git).
-// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
-// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
-//      you could use option `mark: true` with `glob`
-// '`foo/`' should not continue with the '`..`'
-
-
-var REPLACERS = [// > Trailing spaces are ignored unless they are quoted with backslash ("\")
-[// (a\ ) -> (a )
-// (a  ) -> (a)
-// (a \ ) -> (a  )
-/\\?\s+$/, function (match) {
-  return match.indexOf('\\') === 0 ? SPACE : EMPTY;
-}], // replace (\ ) with ' '
-[/\\\s/g, function () {
-  return SPACE;
-}], // Escape metacharacters
-// which is written down by users but means special for regular expressions.
-// > There are 12 characters with special meanings:
-// > - the backslash \,
-// > - the caret ^,
-// > - the dollar sign $,
-// > - the period or dot .,
-// > - the vertical bar or pipe symbol |,
-// > - the question mark ?,
-// > - the asterisk or star *,
-// > - the plus sign +,
-// > - the opening parenthesis (,
-// > - the closing parenthesis ),
-// > - and the opening square bracket [,
-// > - the opening curly brace {,
-// > These special characters are often called "metacharacters".
-[/[\\$.|*+(){^]/g, function (match) {
-  return "\\".concat(match);
-}], [// > a question mark (?) matches a single character
-/(?!\\)\?/g, function () {
-  return '[^/]';
-}], // leading slash
-[// > A leading slash matches the beginning of the pathname.
-// > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
-// A leading slash matches the beginning of the pathname
-/^\//, function () {
-  return '^';
-}], // replace special metacharacter slash after the leading slash
-[/\//g, function () {
-  return '\\/';
-}], [// > A leading "**" followed by a slash means match in all directories.
-// > For example, "**/foo" matches file or directory "foo" anywhere,
-// > the same as pattern "foo".
-// > "**/foo/bar" matches file or directory "bar" anywhere that is directly
-// >   under directory "foo".
-// Notice that the '*'s have been replaced as '\\*'
-/^\^*\\\*\\\*\\\//, // '**/foo' <-> 'foo'
-function () {
-  return '^(?:.*\\/)?';
-}], // starting
-[// there will be no leading '/'
-//   (which has been replaced by section "leading slash")
-// If starts with '**', adding a '^' to the regular expression also works
-/^(?=[^^])/, function startingReplacer() {
-  // If has a slash `/` at the beginning or middle
-  return !/\/(?!$)/.test(this) // > Prior to 2.22.1
-  // > If the pattern does not contain a slash /,
-  // >   Git treats it as a shell glob pattern
-  // Actually, if there is only a trailing slash,
-  //   git also treats it as a shell glob pattern
-  // After 2.22.1 (compatible but clearer)
-  // > If there is a separator at the beginning or middle (or both)
-  // > of the pattern, then the pattern is relative to the directory
-  // > level of the particular .gitignore file itself.
-  // > Otherwise the pattern may also match at any level below
-  // > the .gitignore level.
-  ? '(?:^|\\/)' // > Otherwise, Git treats the pattern as a shell glob suitable for
-  // >   consumption by fnmatch(3)
-  : '^';
-}], // two globstars
-[// Use lookahead assertions so that we could match more than one `'/**'`
-/\\\/\\\*\\\*(?=\\\/|$)/g, // Zero, one or several directories
-// should not use '*', or it will be replaced by the next replacer
-// Check if it is not the last `'/**'`
-function (_, index, str) {
-  return index + 6 < str.length // case: /**/
-  // > A slash followed by two consecutive asterisks then a slash matches
-  // >   zero or more directories.
-  // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
-  // '/**/'
-  ? '(?:\\/[^\\/]+)*' // case: /**
-  // > A trailing `"/**"` matches everything inside.
-  // #21: everything inside but it should not include the current folder
-  : '\\/.+';
-}], // intermediate wildcards
-[// Never replace escaped '*'
-// ignore rule '\*' will match the path '*'
-// 'abc.*/' -> go
-// 'abc.*'  -> skip this rule
-/(^|[^\\]+)\\\*(?=.+)/g, // '*.js' matches '.js'
-// '*.js' doesn't match 'abc'
-function (_, p1) {
-  return "".concat(p1, "[^\\/]*");
-}], [// unescape, revert step 3 except for back slash
-// For example, if a user escape a '\\*',
-// after step 3, the result will be '\\\\\\*'
-/\\\\\\(?=[$.|*+(){^])/g, function () {
-  return ESCAPE;
-}], [// '\\\\' -> '\\'
-/\\\\/g, function () {
-  return ESCAPE;
-}], [// > The range notation, e.g. [a-zA-Z],
-// > can be used to match one of the characters in a range.
-// `\` is escaped by step 3
-/(\\)?\[([^\]/]*?)(\\*)($|\])/g, function (match, leadEscape, range, endEscape, close) {
-  return leadEscape === ESCAPE // '\\[bar]' -> '\\\\[bar\\]'
-  ? "\\[".concat(range).concat(cleanRangeBackSlash(endEscape)).concat(close) : close === ']' ? endEscape.length % 2 === 0 // A normal case, and it is a range notation
-  // '[bar]'
-  // '[bar\\\\]'
-  ? "[".concat(sanitizeRange(range)).concat(endEscape, "]") // Invalid range notaton
-  // '[bar\\]' -> '[bar\\\\]'
-  : '[]' : '[]';
-}], // ending
-[// 'js' will not match 'js.'
-// 'ab' will not match 'abc'
-/(?:[^*])$/, // WTF!
-// https://git-scm.com/docs/gitignore
-// changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
-// which re-fixes #24, #38
-// > If there is a separator at the end of the pattern then the pattern
-// > will only match directories, otherwise the pattern can match both
-// > files and directories.
-// 'js*' will not match 'a.js'
-// 'js/' will not match 'a.js'
-// 'js' will match 'a.js' and 'a.js/'
-function (match) {
-  return /\/$/.test(match) // foo/ will not match 'foo'
-  ? "".concat(match, "$") // foo matches 'foo' and 'foo/'
-  : "".concat(match, "(?=$|\\/$)");
-}], // trailing wildcard
-[/(\^|\\\/)?\\\*$/, function (_, p1) {
-  var prefix = p1 // '\^':
-  // '/*' does not match EMPTY
-  // '/*' does not match everything
-  // '\\\/':
-  // 'abc/*' does not match 'abc/'
-  ? "".concat(p1, "[^/]+") // 'a*' matches 'a'
-  // 'a*' matches 'aa'
-  : '[^/]*';
-  return "".concat(prefix, "(?=$|\\/$)");
-}]]; // A simple cache, because an ignore rule only has only one certain meaning
-
-var regexCache = Object.create(null); // @param {pattern}
-
-var makeRegex = function makeRegex(pattern, ignoreCase) {
-  var source = regexCache[pattern];
-
-  if (!source) {
-    source = REPLACERS.reduce(function (prev, current) {
-      return prev.replace(current[0], current[1].bind(pattern));
-    }, pattern);
-    regexCache[pattern] = source;
-  }
-
-  return ignoreCase ? new RegExp(source, 'i') : new RegExp(source);
-};
-
-var isString = function isString(subject) {
-  return typeof subject === 'string';
-}; // > A blank line matches no files, so it can serve as a separator for readability.
-
-
-var checkPattern = function checkPattern(pattern) {
-  return pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) // > A line starting with # serves as a comment.
-  && pattern.indexOf('#') !== 0;
-};
-
-var splitPattern = function splitPattern(pattern) {
-  return pattern.split(REGEX_SPLITALL_CRLF);
-};
-
-var IgnoreRule = function IgnoreRule(origin, pattern, negative, regex) {
-  _classCallCheck(this, IgnoreRule);
-
-  this.origin = origin;
-  this.pattern = pattern;
-  this.negative = negative;
-  this.regex = regex;
-};
-
-var createRule = function createRule(pattern, ignoreCase) {
-  var origin = pattern;
-  var negative = false; // > An optional prefix "!" which negates the pattern;
-
-  if (pattern.indexOf('!') === 0) {
-    negative = true;
-    pattern = pattern.substr(1);
-  }
-
-  pattern = pattern // > Put a backslash ("\") in front of the first "!" for patterns that
-  // >   begin with a literal "!", for example, `"\!important!.txt"`.
-  .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!') // > Put a backslash ("\") in front of the first hash for patterns that
-  // >   begin with a hash.
-  .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#');
-  var regex = makeRegex(pattern, ignoreCase);
-  return new IgnoreRule(origin, pattern, negative, regex);
-};
-
-var throwError = function throwError(message, Ctor) {
-  throw new Ctor(message);
-};
-
-var checkPath = function checkPath(path, originalPath, doThrow) {
-  if (!isString(path)) {
-    return doThrow("path must be a string, but got `".concat(originalPath, "`"), TypeError);
-  } // We don't know if we should ignore EMPTY, so throw
-
-
-  if (!path) {
-    return doThrow("path must not be empty", TypeError);
-  } // Check if it is a relative path
-
-
-  if (checkPath.isNotRelative(path)) {
-    var r = '`path.relative()`d';
-    return doThrow("path should be a ".concat(r, " string, but got \"").concat(originalPath, "\""), RangeError);
-  }
-
-  return true;
-};
-
-var isNotRelative = function isNotRelative(path) {
-  return REGEX_TEST_INVALID_PATH.test(path);
-};
-
-checkPath.isNotRelative = isNotRelative;
-
-checkPath.convert = function (p) {
-  return p;
-};
-
-var Ignore = /*#__PURE__*/function () {
-  function Ignore() {
-    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-        _ref$ignorecase = _ref.ignorecase,
-        ignorecase = _ref$ignorecase === void 0 ? true : _ref$ignorecase,
-        _ref$ignoreCase = _ref.ignoreCase,
-        ignoreCase = _ref$ignoreCase === void 0 ? ignorecase : _ref$ignoreCase,
-        _ref$allowRelativePat = _ref.allowRelativePaths,
-        allowRelativePaths = _ref$allowRelativePat === void 0 ? false : _ref$allowRelativePat;
-
-    _classCallCheck(this, Ignore);
-
-    define(this, KEY_IGNORE, true);
-    this._rules = [];
-    this._ignoreCase = ignoreCase;
-    this._allowRelativePaths = allowRelativePaths;
-
-    this._initCache();
-  }
-
-  _createClass(Ignore, [{
-    key: "_initCache",
-    value: function _initCache() {
-      this._ignoreCache = Object.create(null);
-      this._testCache = Object.create(null);
-    }
-  }, {
-    key: "_addPattern",
-    value: function _addPattern(pattern) {
-      // #32
-      if (pattern && pattern[KEY_IGNORE]) {
-        this._rules = this._rules.concat(pattern._rules);
-        this._added = true;
-        return;
-      }
-
-      if (checkPattern(pattern)) {
-        var rule = createRule(pattern, this._ignoreCase);
-        this._added = true;
-
-        this._rules.push(rule);
-      }
-    } // @param {Array<string> | string | Ignore} pattern
-
-  }, {
-    key: "add",
-    value: function add(pattern) {
-      this._added = false;
-      makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._addPattern, this); // Some rules have just added to the ignore,
-      // making the behavior changed.
-
-      if (this._added) {
-        this._initCache();
-      }
-
-      return this;
-    } // legacy
-
-  }, {
-    key: "addPattern",
-    value: function addPattern(pattern) {
-      return this.add(pattern);
-    } //          |           ignored : unignored
-    // negative |   0:0   |   0:1   |   1:0   |   1:1
-    // -------- | ------- | ------- | ------- | --------
-    //     0    |  TEST   |  TEST   |  SKIP   |    X
-    //     1    |  TESTIF |  SKIP   |  TEST   |    X
-    // - SKIP: always skip
-    // - TEST: always test
-    // - TESTIF: only test if checkUnignored
-    // - X: that never happen
-    // @param {boolean} whether should check if the path is unignored,
-    //   setting `checkUnignored` to `false` could reduce additional
-    //   path matching.
-    // @returns {TestResult} true if a file is ignored
-
-  }, {
-    key: "_testOne",
-    value: function _testOne(path, checkUnignored) {
-      var ignored = false;
-      var unignored = false;
-
-      this._rules.forEach(function (rule) {
-        var negative = rule.negative;
-
-        if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
-          return;
-        }
-
-        var matched = rule.regex.test(path);
-
-        if (matched) {
-          ignored = !negative;
-          unignored = negative;
-        }
-      });
-
-      return {
-        ignored: ignored,
-        unignored: unignored
-      };
-    } // @returns {TestResult}
-
-  }, {
-    key: "_test",
-    value: function _test(originalPath, cache, checkUnignored, slices) {
-      var path = originalPath // Supports nullable path
-      && checkPath.convert(originalPath);
-      checkPath(path, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
-      return this._t(path, cache, checkUnignored, slices);
-    }
-  }, {
-    key: "_t",
-    value: function _t(path, cache, checkUnignored, slices) {
-      if (path in cache) {
-        return cache[path];
-      }
-
-      if (!slices) {
-        // path/to/a.js
-        // ['path', 'to', 'a.js']
-        slices = path.split(SLASH);
-      }
-
-      slices.pop(); // If the path has no parent directory, just test it
-
-      if (!slices.length) {
-        return cache[path] = this._testOne(path, checkUnignored);
-      }
-
-      var parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices); // If the path contains a parent directory, check the parent first
-
-
-      return cache[path] = parent.ignored // > It is not possible to re-include a file if a parent directory of
-      // >   that file is excluded.
-      ? parent : this._testOne(path, checkUnignored);
-    }
-  }, {
-    key: "ignores",
-    value: function ignores(path) {
-      return this._test(path, this._ignoreCache, false).ignored;
-    }
-  }, {
-    key: "createFilter",
-    value: function createFilter() {
-      var _this = this;
-
-      return function (path) {
-        return !_this.ignores(path);
-      };
-    }
-  }, {
-    key: "filter",
-    value: function filter(paths) {
-      return makeArray(paths).filter(this.createFilter());
-    } // @returns {TestResult}
-
-  }, {
-    key: "test",
-    value: function test(path) {
-      return this._test(path, this._testCache, true);
-    }
-  }]);
-
-  return Ignore;
-}();
-
-var factory = function factory(options) {
-  return new Ignore(options);
-};
-
-var isPathValid = function isPathValid(path) {
-  return checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
-};
-
-factory.isPathValid = isPathValid; // Fixes typescript
-
-factory["default"] = factory;
-module.exports = factory; // Windows
-// --------------------------------------------------------------
-
-/* istanbul ignore if  */
-
-if ( // Detect `process` so that it can run in browsers.
-typeof process !== 'undefined' && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === 'win32')) {
-  /* eslint no-control-regex: "off" */
-  var makePosix = function makePosix(str) {
-    return /^\\\\\?\\/.test(str) || /[\0-\x1F"<>\|]+/.test(str) ? str : str.replace(/\\/g, '/');
-  };
-
-  checkPath.convert = makePosix; // 'C:\\foo'     <- 'C:\\foo' has been converted to 'C:/'
-  // 'd:\\foo'
-
-  var REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-
-  checkPath.isNotRelative = function (path) {
-    return REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
-  };
-}

package/node_modules/@typescript-eslint/typescript-estree/node_modules/ignore/package.json

@@ -1,71 +0,0 @@
-{
-  "name": "ignore",
-  "version": "5.2.0",
-  "description": "Ignore is a manager and filter for .gitignore rules, the one used by eslint, gitbook and many others.",
-  "files": [
-    "legacy.js",
-    "index.js",
-    "index.d.ts",
-    "LICENSE-MIT"
-  ],
-  "scripts": {
-    "prepublishOnly": "npm run build",
-    "build": "babel -o legacy.js index.js",
-    "test:lint": "eslint .",
-    "test:tsc": "tsc ./test/ts/simple.ts --lib ES6",
-    "test:ts": "node ./test/ts/simple.js",
-    "tap": "tap --reporter classic",
-    "test:git": "npm run tap test/git-check-ignore.js",
-    "test:ignore": "npm run tap test/ignore.js",
-    "test:others": "npm run tap test/others.js",
-    "test:cases": "npm run tap test/*.js -- --coverage",
-    "test:only": "npm run test:lint && npm run test:tsc && npm run test:ts && npm run test:cases",
-    "test": "npm run test:only",
-    "test:win32": "IGNORE_TEST_WIN32=1 npm run test",
-    "posttest": "tap --coverage-report=html && codecov"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:kaelzhang/node-ignore.git"
-  },
-  "keywords": [
-    "ignore",
-    ".gitignore",
-    "gitignore",
-    "npmignore",
-    "rules",
-    "manager",
-    "filter",
-    "regexp",
-    "regex",
-    "fnmatch",
-    "glob",
-    "asterisks",
-    "regular-expression"
-  ],
-  "author": "kael",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/kaelzhang/node-ignore/issues"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.8.4",
-    "@babel/core": "^7.9.6",
-    "@babel/preset-env": "^7.9.6",
-    "codecov": "^3.7.0",
-    "debug": "^4.1.1",
-    "eslint": "^7.0.0",
-    "eslint-config-ostai": "^3.0.0",
-    "eslint-plugin-import": "^2.20.2",
-    "mkdirp": "^1.0.4",
-    "pre-suf": "^1.1.1",
-    "rimraf": "^3.0.2",
-    "spawn-sync": "^2.0.0",
-    "tap": "^14.10.7",
-    "tmp": "0.2.1",
-    "typescript": "^3.9.3"
-  },
-  "engines": {
-    "node": ">= 4"
-  }
-}

package/node_modules/micromatch/CHANGELOG.md

@@ -1,109 +0,0 @@
-# Release history
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
-and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
-
-<details>
-  <summary><strong>Guiding Principles</strong></summary>
-
-- Changelogs are for humans, not machines.
-- There should be an entry for every single version.
-- The same types of changes should be grouped.
-- Versions and sections should be linkable.
-- The latest version comes first.
-- The release date of each versions is displayed.
-- Mention whether you follow Semantic Versioning.
-
-</details>
-
-<details>
-  <summary><strong>Types of changes</strong></summary>
-
-Changelog entries are classified using the following labels _(from [keep-a-changelog](http://keepachangelog.com/)_):
-
-- `Added` for new features.
-- `Changed` for changes in existing functionality.
-- `Deprecated` for soon-to-be removed features.
-- `Removed` for now removed features.
-- `Fixed` for any bug fixes.
-- `Security` in case of vulnerabilities.
-
-</details>
-
-## [4.0.0] - 2019-03-20
-
-### Added
-
-- Adds support for `options.onMatch`. See the readme for details
-- Adds support for `options.onIgnore`. See the readme for details
-- Adds support for `options.onResult`. See the readme for details
-
-
-### Breaking changes
-
-- Require Node.js >= 8.6
-- Removed support for passing an array of brace patterns to `micromatch.braces()`.
-- To strictly enforce closing brackets (for `{`, `[`, and `(`), you must now use `strictBrackets=true` instead of `strictErrors`.
-- `cache` - caching and all related options and methods have been removed
-- `options.unixify` was renamed to `options.windows`
-- `options.nodupes` Was removed. Duplicates are always removed by default. You can override this with custom behavior by using the `onMatch`, `onResult` and `onIgnore` functions.
-- `options.snapdragon` was removed, as snapdragon is no longer used.
-- `options.sourcemap` was removed, as snapdragon is no longer used, which provided sourcemap support.
-
-## [3.0.0] - 2017-04-11
-
-Complete overhaul, with 36,000+ new unit tests validated against actual output generated by Bash and minimatch. More specifically, 35,000+ of the tests:
-
- - micromatch results are directly compared to bash results
- - in rare cases, when micromatch and bash disagree, micromatch's results are compared to minimatch's results
- - micromatch is much more accurate than minimatch, so there were cases where I had to make assumptions. I'll try to document these.
-
-This refactor introduces a parser and compiler that are supersets of more granular parsers and compilers from other sub-modules. Each of these sub-modules has a singular responsibility and focuses on a certain type of matching that aligns with a specific part of the Bash "expansion" API.
-
-These sub-modules work like plugins to seamlessly create the micromatch parser/compiler, so that strings are parsed in one pass, an [AST is created](https://gist.github.com/jonschlinkert/099c8914f56529f75bc757cc9e5e8e2a), then a new string is generated by the compiler.
-
-Here are those sub-modules with links to related prs on those modules if you want to see how they contribute to this code:
-
-[nanomatch](https://github.com/jonschlinkert/nanomatch) (new library) - glob expansion (`*`, `**`, `?` and `[...]`))
-[braces](https://github.com/jonschlinkert/braces/pull/10) - brace expansion (`{1..10}`, `{a,b,c}`, etc)
-[extglob](https://github.com/jonschlinkert/extglob/pull/5) - extended globs (`!(a|b)`, `@(!(foo|bar))`, etc)
-[expand-brackets](https://github.com/jonschlinkert/expand-brackets/pull/5) - POSIX character classes `[[:alpha:][:digit:]]`
-
-**Added**
-
- - source map support (optionally created when using parse or compile - I have no idea what the use case is yet, but they come for free) (note that source maps are not generated for brace expansion at present, since the braces compiler uses a different strategy. I'll update if/when this changes).
- - parser is exposed, so that implementors can customize or override specific micromatch parsers if necessary
- - compiler is exposed, so that implementors can customize or override specific micromatch compilers if necessary
-
-**Fixed**
-
- - more accurate matching (passes 100% of Bash 4.3 of the brace expansion and extglob unit tests, as well as all Bash glob tests that are relevant to node.js usage, all minimatch tests, all brace-expansion tests, and also passes a couple of tests that bash fails)
- - even safer - micromatch has always generated optimized patterns so it's not subject to DoS exploits like minimatch (completely different than the regex DoS issue, minimatch and multimatch are still openly exposed to being used for DoS attacks), but more safeguards were built into this refactor
-
-**Changed**
-
- - the public API of this library did not change in this version and should be safe to upgrade without changing implentor code. However, we have released this as a major version for the following reasons:
-   - out of an abundance of caution due to the large amount of code changed in this release
-   - we have improved parser accuracy to such a degree that some implementors using invalid globs have noted change in behavior. If this is the case for you, please check that you are using a valid glob expression before logging a bug with this library
-
-## [1.0.1] - 2016-12-12
-
-**Added**
-
-- Support for windows path edge cases where backslashes are used in brackets or other unusual combinations.
-
-## [1.0.0] - 2016-12-12
-
-Stable release.
-
-## [0.1.0] - 2016-10-08
-
-First release.
-
-
-[Unreleased]: https://github.com/jonschlinkert/micromatch/compare/0.1.0...HEAD
-[0.2.0]: https://github.com/jonschlinkert/micromatch/compare/0.1.0...0.2.0
-
-[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog