html-validate 8.23.0 → 8.24.1

package/dist/es/core.js

@@ -242,139 +242,149 @@ function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-var isMergeableObject = function isMergeableObject(value) {
-	return isNonNullObject(value)
-		&& !isSpecial(value)
-};
+var cjs;
+var hasRequiredCjs;
 
-function isNonNullObject(value) {
-	return !!value && typeof value === 'object'
-}
+function requireCjs () {
+	if (hasRequiredCjs) return cjs;
+	hasRequiredCjs = 1;
 
-function isSpecial(value) {
-	var stringValue = Object.prototype.toString.call(value);
+	var isMergeableObject = function isMergeableObject(value) {
+		return isNonNullObject(value)
+			&& !isSpecial(value)
+	};
 
-	return stringValue === '[object RegExp]'
-		|| stringValue === '[object Date]'
-		|| isReactElement(value)
-}
+	function isNonNullObject(value) {
+		return !!value && typeof value === 'object'
+	}
 
-// 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 isSpecial(value) {
+		var stringValue = Object.prototype.toString.call(value);
 
-function isReactElement(value) {
-	return value.$$typeof === REACT_ELEMENT_TYPE
-}
+		return stringValue === '[object RegExp]'
+			|| stringValue === '[object Date]'
+			|| isReactElement(value)
+	}
 
-function emptyTarget(val) {
-	return Array.isArray(val) ? [] : {}
-}
+	// 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 cloneUnlessOtherwiseSpecified(value, options) {
-	return (options.clone !== false && options.isMergeableObject(value))
-		? deepmerge(emptyTarget(value), value, options)
-		: value
-}
+	function isReactElement(value) {
+		return value.$$typeof === REACT_ELEMENT_TYPE
+	}
 
-function defaultArrayMerge(target, source, options) {
-	return target.concat(source).map(function(element) {
-		return cloneUnlessOtherwiseSpecified(element, options)
-	})
-}
+	function emptyTarget(val) {
+		return Array.isArray(val) ? [] : {}
+	}
 
-function getMergeFunction(key, options) {
-	if (!options.customMerge) {
-		return deepmerge
+	function cloneUnlessOtherwiseSpecified(value, options) {
+		return (options.clone !== false && options.isMergeableObject(value))
+			? deepmerge(emptyTarget(value), value, options)
+			: value
 	}
-	var customMerge = options.customMerge(key);
-	return typeof customMerge === 'function' ? customMerge : deepmerge
-}
 
-function getEnumerableOwnPropertySymbols(target) {
-	return Object.getOwnPropertySymbols
-		? Object.getOwnPropertySymbols(target).filter(function(symbol) {
-			return Object.propertyIsEnumerable.call(target, symbol)
+	function defaultArrayMerge(target, source, options) {
+		return target.concat(source).map(function(element) {
+			return cloneUnlessOtherwiseSpecified(element, options)
 		})
-		: []
-}
+	}
 
-function getKeys(target) {
-	return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
-}
+	function getMergeFunction(key, options) {
+		if (!options.customMerge) {
+			return deepmerge
+		}
+		var customMerge = options.customMerge(key);
+		return typeof customMerge === 'function' ? customMerge : deepmerge
+	}
 
-function propertyIsOnObject(object, property) {
-	try {
-		return property in object
-	} catch(_) {
-		return false
+	function getEnumerableOwnPropertySymbols(target) {
+		return Object.getOwnPropertySymbols
+			? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+				return Object.propertyIsEnumerable.call(target, symbol)
+			})
+			: []
 	}
-}
 
-// Protects from prototype poisoning and unexpected merging up the prototype chain.
-function propertyIsUnsafe(target, key) {
-	return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
-		&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
-			&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
-}
+	function getKeys(target) {
+		return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
+	}
 
-function mergeObject(target, source, options) {
-	var destination = {};
-	if (options.isMergeableObject(target)) {
-		getKeys(target).forEach(function(key) {
-			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
-		});
+	function propertyIsOnObject(object, property) {
+		try {
+			return property in object
+		} catch(_) {
+			return false
+		}
+	}
+
+	// Protects from prototype poisoning and unexpected merging up the prototype chain.
+	function propertyIsUnsafe(target, key) {
+		return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
+			&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
+				&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
 	}
-	getKeys(source).forEach(function(key) {
-		if (propertyIsUnsafe(target, key)) {
-			return
+
+	function mergeObject(target, source, options) {
+		var destination = {};
+		if (options.isMergeableObject(target)) {
+			getKeys(target).forEach(function(key) {
+				destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+			});
 		}
+		getKeys(source).forEach(function(key) {
+			if (propertyIsUnsafe(target, key)) {
+				return
+			}
 
-		if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
-			destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+			if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+				destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+			} else {
+				destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+			}
+		});
+		return destination
+	}
+
+	function deepmerge(target, source, options) {
+		options = options || {};
+		options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+		options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+		// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
+		// implementations can use it. The caller may not replace it.
+		options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+
+		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 {
-			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+			return mergeObject(target, source, options)
 		}
-	});
-	return destination
-}
-
-function deepmerge(target, source, options) {
-	options = options || {};
-	options.arrayMerge = options.arrayMerge || defaultArrayMerge;
-	options.isMergeableObject = options.isMergeableObject || isMergeableObject;
-	// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
-	// implementations can use it. The caller may not replace it.
-	options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
-
-	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')
-	}
+	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)
-	}, {})
-};
+		return array.reduce(function(prev, next) {
+			return deepmerge(prev, next, options)
+		}, {})
+	};
 
-var deepmerge_1 = deepmerge;
+	var deepmerge_1 = deepmerge;
 
-var cjs = deepmerge_1;
+	cjs = deepmerge_1;
+	return cjs;
+}
 
-var deepmerge$1 = /*@__PURE__*/getDefaultExportFromCjs(cjs);
+var cjsExports = /*@__PURE__*/ requireCjs();
+var deepmerge = /*@__PURE__*/getDefaultExportFromCjs(cjsExports);
 
 function stringify(value) {
   if (typeof value === "string") {
@@ -1207,7 +1217,7 @@ class MetaTable {
    */
   extendValidationSchema(patch) {
     if (patch.properties) {
-      this.schema = deepmerge$1(this.schema, {
+      this.schema = deepmerge(this.schema, {
         patternProperties: {
           "^[^$].*$": {
             properties: patch.properties
@@ -1216,7 +1226,7 @@ class MetaTable {
       });
     }
     if (patch.definitions) {
-      this.schema = deepmerge$1(this.schema, {
+      this.schema = deepmerge(this.schema, {
         definitions: patch.definitions
       });
     }
@@ -1354,7 +1364,7 @@ class MetaTable {
     }
   }
   mergeElement(a, b) {
-    const merged = deepmerge$1(a, b, { arrayMerge: overwriteMerge$1 });
+    const merged = deepmerge(a, b, { arrayMerge: overwriteMerge$1 });
     const filteredAttrs = Object.entries(
       merged.attributes
     ).filter(([, attr]) => {
@@ -1970,7 +1980,7 @@ const table = {
   "nth-child": nthChild,
   scope
 };
-function factory$1(name, context) {
+function factory(name, context) {
   const fn = table[name];
   if (fn) {
     return fn.bind(context);
@@ -2069,7 +2079,7 @@ function isQuotationMark(ch) {
 function isPseudoElement(ch, buffer) {
   return ch === ":" && buffer === ":";
 }
-function* splitPattern$1(pattern) {
+function* splitPattern(pattern) {
   if (pattern === "") {
     return;
   }
@@ -2163,7 +2173,7 @@ class PseudoClassMatcher extends Matcher {
     this.args = args;
   }
   match(node, context) {
-    const fn = factory$1(this.name, context);
+    const fn = factory(this.name, context);
     return fn(node, this.args);
   }
 }
@@ -2177,7 +2187,7 @@ class Pattern {
     this.selector = pattern;
     this.combinator = parseCombinator(match.shift(), pattern);
     this.tagName = match.shift() || "*";
-    this.pattern = Array.from(splitPattern$1(match[0]), (it) => this.createMatcher(it));
+    this.pattern = Array.from(splitPattern(match[0]), (it) => this.createMatcher(it));
   }
   match(node, context) {
     return node.is(this.tagName) && this.pattern.every((cur) => cur.match(node, context));
@@ -4504,6 +4514,9 @@ class AttrQuotes extends Rule {
   }
   setup() {
     this.on("attr", (event) => {
+      if (event.originalAttribute) {
+        return;
+      }
       if (event.value === null) {
         return;
       }
@@ -10435,7 +10448,7 @@ const TRANSFORMER_API = {
 
 var defaultConfig = {};
 
-const config$4 = {
+const config$5 = {
   rules: {
     "area-alt": ["error", { accessible: true }],
     "aria-hidden-body": "error",
@@ -10468,6 +10481,25 @@ const config$4 = {
   }
 };
 
+const config$4 = {
+  rules: {
+    /* doctype is usually not included when fetching source code from browser */
+    "missing-doctype": "off",
+    /* some frameworks (such as jQuery) often uses inline style, e.g. for
+     * showing/hiding elements so it is counter-productive to check for inline
+     * style. If anything it should be used on original sorce code only. */
+    "no-inline-style": "off",
+    /* scripts will often add markup with trailing whitespace */
+    "no-trailing-whitespace": "off",
+    /* browser normalizes boolean attributes */
+    "attribute-boolean-style": "off",
+    "attribute-empty-style": "off",
+    /* the browser will often do what it wants, out of users control */
+    "void-style": "off",
+    "no-self-closing": "off"
+  }
+};
+
 const config$3 = {
   rules: {
     "input-missing-label": "error",
@@ -10608,7 +10640,8 @@ const config = {
 };
 
 const presets = {
-  "html-validate:a11y": config$4,
+  "html-validate:a11y": config$5,
+  "html-validate:browser": config$4,
   "html-validate:document": config$3,
   "html-validate:prettier": config$2,
   "html-validate:recommended": config$1,
@@ -10616,9 +10649,8 @@ const presets = {
   /* @deprecated aliases */
   "htmlvalidate:recommended": config$1,
   "htmlvalidate:document": config$3,
-  "html-validate:a17y": config$4
+  "html-validate:a17y": config$5
 };
-var Presets = presets;
 
 class ResolvedConfig {
   /**
@@ -10810,9 +10842,9 @@ function overwriteMerge(a, b) {
   return b;
 }
 function mergeInternal(base, rhs) {
-  const dst = deepmerge$1(base, { ...rhs, rules: {} });
+  const dst = deepmerge(base, { ...rhs, rules: {} });
   if (rhs.rules) {
-    dst.rules = deepmerge$1(dst.rules, rhs.rules, { arrayMerge: overwriteMerge });
+    dst.rules = deepmerge(dst.rules, rhs.rules, { arrayMerge: overwriteMerge });
   }
   const root = Boolean(base.root) || Boolean(rhs.root);
   if (root) {
@@ -11076,7 +11108,7 @@ class Config {
   }
   loadConfigurations(plugins) {
     const configs = /* @__PURE__ */ new Map();
-    for (const [name, config] of Object.entries(Presets)) {
+    for (const [name, config] of Object.entries(presets)) {
       Config.validate(config, name);
       configs.set(name, config);
     }
@@ -12839,651 +12871,660 @@ class HtmlValidate {
 }
 
 const name = "html-validate";
-const version = "8.23.0";
+const version = "8.24.1";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function definePlugin(plugin) {
   return plugin;
 }
 
-// A simple implementation of make-array
-function makeArray (subject) {
-  return Array.isArray(subject)
-    ? subject
-    : [subject]
-}
-
-const EMPTY = '';
-const SPACE = ' ';
-const ESCAPE = '\\';
-const REGEX_TEST_BLANK_LINE = /^\s+$/;
-const REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
-const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
-const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
-const REGEX_SPLITALL_CRLF = /\r?\n/g;
-// /foo,
-// ./foo,
-// ../foo,
-// .
-// ..
-const REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
-
-const SLASH = '/';
-
-// Do not use ternary expression here, since "istanbul ignore next" is buggy
-let TMP_KEY_IGNORE = 'node-ignore';
-/* istanbul ignore else */
-if (typeof Symbol !== 'undefined') {
-  TMP_KEY_IGNORE = Symbol.for('node-ignore');
-}
-const KEY_IGNORE = TMP_KEY_IGNORE;
-
-const define = (object, key, value) =>
-  Object.defineProperty(object, key, {value});
-
-const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
-
-const RETURN_FALSE = () => false;
-
-// Sanitize the range of a regular expression
-// The cases are complicated, see test cases for details
-const sanitizeRange = range => range.replace(
-  REGEX_REGEXP_RANGE,
-  (match, from, to) => 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
-const cleanRangeBackSlash = slashes => {
-  const {length} = slashes;
-  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 '`..`'
-const REPLACERS = [
-
-  [
-    // remove BOM
-    // TODO:
-    // Other similar zero-width characters?
-    /^\uFEFF/,
-    () => EMPTY
-  ],
-
-  // > Trailing spaces are ignored unless they are quoted with backslash ("\")
-  [
-    // (a\ ) -> (a )
-    // (a  ) -> (a)
-    // (a ) -> (a)
-    // (a \ ) -> (a  )
-    /((?:\\\\)*?)(\\?\s+)$/,
-    (_, m1, m2) => m1 + (
-      m2.indexOf('\\') === 0
-        ? SPACE
-        : EMPTY
-    )
-  ],
-
-  // replace (\ ) with ' '
-  // (\ ) -> ' '
-  // (\\ ) -> '\\ '
-  // (\\\ ) -> '\\ '
-  [
-    /(\\+?)\s/g,
-    (_, m1) => {
-      const {length} = m1;
-      return m1.slice(0, length - length % 2) + 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,
-    match => `\\${match}`
-  ],
-
-  [
-    // > a question mark (?) matches a single character
-    /(?!\\)\?/g,
-    () => '[^/]'
-  ],
-
-  // 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
-    /^\//,
-    () => '^'
-  ],
-
-  // replace special metacharacter slash after the leading slash
-  [
-    /\//g,
-    () => '\\/'
-  ],
-
-  [
-    // > 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'
-    () => '^(?:.*\\/)?'
-  ],
-
-  // 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 `'/**'`
-    (_, index, str) => 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
-      : '\\/.+'
-  ],
-
-  // normal intermediate wildcards
-  [
-    // Never replace escaped '*'
-    // ignore rule '\*' will match the path '*'
-
-    // 'abc.*/' -> go
-    // 'abc.*'  -> skip this rule,
-    //    coz trailing single wildcard will be handed by [trailing wildcard]
-    /(^|[^\\]+)(\\\*)+(?=.+)/g,
-
-    // '*.js' matches '.js'
-    // '*.js' doesn't match 'abc'
-    (_, p1, p2) => {
-      // 1.
-      // > An asterisk "*" matches anything except a slash.
-      // 2.
-      // > Other consecutive asterisks are considered regular asterisks
-      // > and will match according to the previous rules.
-      const unescaped = p2.replace(/\\\*/g, '[^\\/]*');
-      return p1 + unescaped
-    }
-  ],
-
-  [
-    // unescape, revert step 3 except for back slash
-    // For example, if a user escape a '\\*',
-    // after step 3, the result will be '\\\\\\*'
-    /\\\\\\(?=[$.|*+(){^])/g,
-    () => ESCAPE
-  ],
-
-  [
-    // '\\\\' -> '\\'
-    /\\\\/g,
-    () => 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,
-    (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE
-      // '\\[bar]' -> '\\\\[bar\\]'
-      ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`
-      : close === ']'
-        ? endEscape.length % 2 === 0
-          // A normal case, and it is a range notation
-          // '[bar]'
-          // '[bar\\\\]'
-          ? `[${sanitizeRange(range)}${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/'
-    match => /\/$/.test(match)
-      // foo/ will not match 'foo'
-      ? `${match}$`
-      // foo matches 'foo' and 'foo/'
-      : `${match}(?=$|\\/$)`
-  ],
-
-  // trailing wildcard
-  [
-    /(\^|\\\/)?\\\*$/,
-    (_, p1) => {
-      const prefix = p1
-        // '\^':
-        // '/*' does not match EMPTY
-        // '/*' does not match everything
-
-        // '\\\/':
-        // 'abc/*' does not match 'abc/'
-        ? `${p1}[^/]+`
-
-        // 'a*' matches 'a'
-        // 'a*' matches 'aa'
-        : '[^/]*';
-
-      return `${prefix}(?=$|\\/$)`
-    }
-  ],
-];
-
-// A simple cache, because an ignore rule only has only one certain meaning
-const regexCache = Object.create(null);
-
-// @param {pattern}
-const makeRegex = (pattern, ignoreCase) => {
-  let source = regexCache[pattern];
-
-  if (!source) {
-    source = REPLACERS.reduce(
-      (prev, [matcher, replacer]) =>
-        prev.replace(matcher, replacer.bind(pattern)),
-      pattern
-    );
-    regexCache[pattern] = source;
-  }
-
-  return ignoreCase
-    ? new RegExp(source, 'i')
-    : new RegExp(source)
-};
-
-const isString = subject => typeof subject === 'string';
-
-// > A blank line matches no files, so it can serve as a separator for readability.
-const checkPattern = pattern => pattern
-  && isString(pattern)
-  && !REGEX_TEST_BLANK_LINE.test(pattern)
-  && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern)
-
-  // > A line starting with # serves as a comment.
-  && pattern.indexOf('#') !== 0;
-
-const splitPattern = pattern => pattern.split(REGEX_SPLITALL_CRLF);
-
-class IgnoreRule {
-  constructor (
-    origin,
-    pattern,
-    negative,
-    regex
-  ) {
-    this.origin = origin;
-    this.pattern = pattern;
-    this.negative = negative;
-    this.regex = regex;
-  }
-}
-
-const createRule = (pattern, ignoreCase) => {
-  const origin = pattern;
-  let 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, '#');
-
-  const regex = makeRegex(pattern, ignoreCase);
-
-  return new IgnoreRule(
-    origin,
-    pattern,
-    negative,
-    regex
-  )
-};
-
-const throwError = (message, Ctor) => {
-  throw new Ctor(message)
-};
-
-const checkPath = (path, originalPath, doThrow) => {
-  if (!isString(path)) {
-    return doThrow(
-      `path must be a string, but got \`${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)) {
-    const r = '`path.relative()`d';
-    return doThrow(
-      `path should be a ${r} string, but got "${originalPath}"`,
-      RangeError
-    )
-  }
-
-  return true
-};
-
-const isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path);
-
-checkPath.isNotRelative = isNotRelative;
-checkPath.convert = p => p;
-
-class Ignore {
-  constructor ({
-    ignorecase = true,
-    ignoreCase = ignorecase,
-    allowRelativePaths = false
-  } = {}) {
-    define(this, KEY_IGNORE, true);
-
-    this._rules = [];
-    this._ignoreCase = ignoreCase;
-    this._allowRelativePaths = allowRelativePaths;
-    this._initCache();
-  }
-
-  _initCache () {
-    this._ignoreCache = Object.create(null);
-    this._testCache = Object.create(null);
-  }
-
-  _addPattern (pattern) {
-    // #32
-    if (pattern && pattern[KEY_IGNORE]) {
-      this._rules = this._rules.concat(pattern._rules);
-      this._added = true;
-      return
-    }
-
-    if (checkPattern(pattern)) {
-      const rule = createRule(pattern, this._ignoreCase);
-      this._added = true;
-      this._rules.push(rule);
-    }
-  }
-
-  // @param {Array<string> | string | Ignore} pattern
-  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
-  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
-  _testOne (path, checkUnignored) {
-    let ignored = false;
-    let unignored = false;
-
-    this._rules.forEach(rule => {
-      const {negative} = rule;
-      if (
-        unignored === negative && ignored !== unignored
-        || negative && !ignored && !unignored && !checkUnignored
-      ) {
-        return
-      }
-
-      const matched = rule.regex.test(path);
-
-      if (matched) {
-        ignored = !negative;
-        unignored = negative;
-      }
-    });
-
-    return {
-      ignored,
-      unignored
-    }
-  }
-
-  // @returns {TestResult}
-  _test (originalPath, cache, checkUnignored, slices) {
-    const path = originalPath
-      // Supports nullable path
-      && checkPath.convert(originalPath);
-
-    checkPath(
-      path,
-      originalPath,
-      this._allowRelativePaths
-        ? RETURN_FALSE
-        : throwError
-    );
-
-    return this._t(path, cache, checkUnignored, slices)
-  }
-
-  _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)
-    }
-
-    const 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)
-  }
-
-  ignores (path) {
-    return this._test(path, this._ignoreCache, false).ignored
-  }
-
-  createFilter () {
-    return path => !this.ignores(path)
-  }
-
-  filter (paths) {
-    return makeArray(paths).filter(this.createFilter())
-  }
-
-  // @returns {TestResult}
-  test (path) {
-    return this._test(path, this._testCache, true)
-  }
-}
-
-const factory = options => new Ignore(options);
-
-const isPathValid = path =>
-  checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
-
-factory.isPathValid = isPathValid;
+var ignore$1;
+var hasRequiredIgnore;
 
-// Fixes typescript
-factory.default = factory;
-
-var ignore = factory;
+function requireIgnore () {
+	if (hasRequiredIgnore) return ignore$1;
+	hasRequiredIgnore = 1;
+	// A simple implementation of make-array
+	function makeArray (subject) {
+	  return Array.isArray(subject)
+	    ? subject
+	    : [subject]
+	}
 
-// 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" */
-  const makePosix = str => /^\\\\\?\\/.test(str)
-  || /["<>|\u0000-\u001F]+/u.test(str)
-    ? str
-    : str.replace(/\\/g, '/');
+	const EMPTY = '';
+	const SPACE = ' ';
+	const ESCAPE = '\\';
+	const REGEX_TEST_BLANK_LINE = /^\s+$/;
+	const REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+	const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+	const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+	const REGEX_SPLITALL_CRLF = /\r?\n/g;
+	// /foo,
+	// ./foo,
+	// ../foo,
+	// .
+	// ..
+	const REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+
+	const SLASH = '/';
+
+	// Do not use ternary expression here, since "istanbul ignore next" is buggy
+	let TMP_KEY_IGNORE = 'node-ignore';
+	/* istanbul ignore else */
+	if (typeof Symbol !== 'undefined') {
+	  TMP_KEY_IGNORE = Symbol.for('node-ignore');
+	}
+	const KEY_IGNORE = TMP_KEY_IGNORE;
+
+	const define = (object, key, value) =>
+	  Object.defineProperty(object, key, {value});
+
+	const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+
+	const RETURN_FALSE = () => false;
+
+	// Sanitize the range of a regular expression
+	// The cases are complicated, see test cases for details
+	const sanitizeRange = range => range.replace(
+	  REGEX_REGEXP_RANGE,
+	  (match, from, to) => 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
+	const cleanRangeBackSlash = slashes => {
+	  const {length} = slashes;
+	  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 '`..`'
+	const REPLACERS = [
+
+	  [
+	    // remove BOM
+	    // TODO:
+	    // Other similar zero-width characters?
+	    /^\uFEFF/,
+	    () => EMPTY
+	  ],
+
+	  // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+	  [
+	    // (a\ ) -> (a )
+	    // (a  ) -> (a)
+	    // (a ) -> (a)
+	    // (a \ ) -> (a  )
+	    /((?:\\\\)*?)(\\?\s+)$/,
+	    (_, m1, m2) => m1 + (
+	      m2.indexOf('\\') === 0
+	        ? SPACE
+	        : EMPTY
+	    )
+	  ],
+
+	  // replace (\ ) with ' '
+	  // (\ ) -> ' '
+	  // (\\ ) -> '\\ '
+	  // (\\\ ) -> '\\ '
+	  [
+	    /(\\+?)\s/g,
+	    (_, m1) => {
+	      const {length} = m1;
+	      return m1.slice(0, length - length % 2) + 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,
+	    match => `\\${match}`
+	  ],
+
+	  [
+	    // > a question mark (?) matches a single character
+	    /(?!\\)\?/g,
+	    () => '[^/]'
+	  ],
+
+	  // 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
+	    /^\//,
+	    () => '^'
+	  ],
+
+	  // replace special metacharacter slash after the leading slash
+	  [
+	    /\//g,
+	    () => '\\/'
+	  ],
+
+	  [
+	    // > 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'
+	    () => '^(?:.*\\/)?'
+	  ],
+
+	  // 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 `'/**'`
+	    (_, index, str) => 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
+	      : '\\/.+'
+	  ],
+
+	  // normal intermediate wildcards
+	  [
+	    // Never replace escaped '*'
+	    // ignore rule '\*' will match the path '*'
+
+	    // 'abc.*/' -> go
+	    // 'abc.*'  -> skip this rule,
+	    //    coz trailing single wildcard will be handed by [trailing wildcard]
+	    /(^|[^\\]+)(\\\*)+(?=.+)/g,
+
+	    // '*.js' matches '.js'
+	    // '*.js' doesn't match 'abc'
+	    (_, p1, p2) => {
+	      // 1.
+	      // > An asterisk "*" matches anything except a slash.
+	      // 2.
+	      // > Other consecutive asterisks are considered regular asterisks
+	      // > and will match according to the previous rules.
+	      const unescaped = p2.replace(/\\\*/g, '[^\\/]*');
+	      return p1 + unescaped
+	    }
+	  ],
+
+	  [
+	    // unescape, revert step 3 except for back slash
+	    // For example, if a user escape a '\\*',
+	    // after step 3, the result will be '\\\\\\*'
+	    /\\\\\\(?=[$.|*+(){^])/g,
+	    () => ESCAPE
+	  ],
+
+	  [
+	    // '\\\\' -> '\\'
+	    /\\\\/g,
+	    () => 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,
+	    (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE
+	      // '\\[bar]' -> '\\\\[bar\\]'
+	      ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`
+	      : close === ']'
+	        ? endEscape.length % 2 === 0
+	          // A normal case, and it is a range notation
+	          // '[bar]'
+	          // '[bar\\\\]'
+	          ? `[${sanitizeRange(range)}${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/'
+	    match => /\/$/.test(match)
+	      // foo/ will not match 'foo'
+	      ? `${match}$`
+	      // foo matches 'foo' and 'foo/'
+	      : `${match}(?=$|\\/$)`
+	  ],
+
+	  // trailing wildcard
+	  [
+	    /(\^|\\\/)?\\\*$/,
+	    (_, p1) => {
+	      const prefix = p1
+	        // '\^':
+	        // '/*' does not match EMPTY
+	        // '/*' does not match everything
+
+	        // '\\\/':
+	        // 'abc/*' does not match 'abc/'
+	        ? `${p1}[^/]+`
+
+	        // 'a*' matches 'a'
+	        // 'a*' matches 'aa'
+	        : '[^/]*';
+
+	      return `${prefix}(?=$|\\/$)`
+	    }
+	  ],
+	];
+
+	// A simple cache, because an ignore rule only has only one certain meaning
+	const regexCache = Object.create(null);
+
+	// @param {pattern}
+	const makeRegex = (pattern, ignoreCase) => {
+	  let source = regexCache[pattern];
+
+	  if (!source) {
+	    source = REPLACERS.reduce(
+	      (prev, [matcher, replacer]) =>
+	        prev.replace(matcher, replacer.bind(pattern)),
+	      pattern
+	    );
+	    regexCache[pattern] = source;
+	  }
+
+	  return ignoreCase
+	    ? new RegExp(source, 'i')
+	    : new RegExp(source)
+	};
+
+	const isString = subject => typeof subject === 'string';
+
+	// > A blank line matches no files, so it can serve as a separator for readability.
+	const checkPattern = pattern => pattern
+	  && isString(pattern)
+	  && !REGEX_TEST_BLANK_LINE.test(pattern)
+	  && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern)
+
+	  // > A line starting with # serves as a comment.
+	  && pattern.indexOf('#') !== 0;
+
+	const splitPattern = pattern => pattern.split(REGEX_SPLITALL_CRLF);
+
+	class IgnoreRule {
+	  constructor (
+	    origin,
+	    pattern,
+	    negative,
+	    regex
+	  ) {
+	    this.origin = origin;
+	    this.pattern = pattern;
+	    this.negative = negative;
+	    this.regex = regex;
+	  }
+	}
 
-  checkPath.convert = makePosix;
+	const createRule = (pattern, ignoreCase) => {
+	  const origin = pattern;
+	  let 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, '#');
+
+	  const regex = makeRegex(pattern, ignoreCase);
+
+	  return new IgnoreRule(
+	    origin,
+	    pattern,
+	    negative,
+	    regex
+	  )
+	};
+
+	const throwError = (message, Ctor) => {
+	  throw new Ctor(message)
+	};
+
+	const checkPath = (path, originalPath, doThrow) => {
+	  if (!isString(path)) {
+	    return doThrow(
+	      `path must be a string, but got \`${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)) {
+	    const r = '`path.relative()`d';
+	    return doThrow(
+	      `path should be a ${r} string, but got "${originalPath}"`,
+	      RangeError
+	    )
+	  }
+
+	  return true
+	};
+
+	const isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path);
+
+	checkPath.isNotRelative = isNotRelative;
+	checkPath.convert = p => p;
+
+	class Ignore {
+	  constructor ({
+	    ignorecase = true,
+	    ignoreCase = ignorecase,
+	    allowRelativePaths = false
+	  } = {}) {
+	    define(this, KEY_IGNORE, true);
+
+	    this._rules = [];
+	    this._ignoreCase = ignoreCase;
+	    this._allowRelativePaths = allowRelativePaths;
+	    this._initCache();
+	  }
+
+	  _initCache () {
+	    this._ignoreCache = Object.create(null);
+	    this._testCache = Object.create(null);
+	  }
+
+	  _addPattern (pattern) {
+	    // #32
+	    if (pattern && pattern[KEY_IGNORE]) {
+	      this._rules = this._rules.concat(pattern._rules);
+	      this._added = true;
+	      return
+	    }
+
+	    if (checkPattern(pattern)) {
+	      const rule = createRule(pattern, this._ignoreCase);
+	      this._added = true;
+	      this._rules.push(rule);
+	    }
+	  }
+
+	  // @param {Array<string> | string | Ignore} pattern
+	  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
+	  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
+	  _testOne (path, checkUnignored) {
+	    let ignored = false;
+	    let unignored = false;
+
+	    this._rules.forEach(rule => {
+	      const {negative} = rule;
+	      if (
+	        unignored === negative && ignored !== unignored
+	        || negative && !ignored && !unignored && !checkUnignored
+	      ) {
+	        return
+	      }
+
+	      const matched = rule.regex.test(path);
+
+	      if (matched) {
+	        ignored = !negative;
+	        unignored = negative;
+	      }
+	    });
+
+	    return {
+	      ignored,
+	      unignored
+	    }
+	  }
+
+	  // @returns {TestResult}
+	  _test (originalPath, cache, checkUnignored, slices) {
+	    const path = originalPath
+	      // Supports nullable path
+	      && checkPath.convert(originalPath);
+
+	    checkPath(
+	      path,
+	      originalPath,
+	      this._allowRelativePaths
+	        ? RETURN_FALSE
+	        : throwError
+	    );
+
+	    return this._t(path, cache, checkUnignored, slices)
+	  }
+
+	  _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)
+	    }
+
+	    const 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)
+	  }
+
+	  ignores (path) {
+	    return this._test(path, this._ignoreCache, false).ignored
+	  }
+
+	  createFilter () {
+	    return path => !this.ignores(path)
+	  }
+
+	  filter (paths) {
+	    return makeArray(paths).filter(this.createFilter())
+	  }
+
+	  // @returns {TestResult}
+	  test (path) {
+	    return this._test(path, this._testCache, true)
+	  }
+	}
 
-  // 'C:\\foo'     <- 'C:\\foo' has been converted to 'C:/'
-  // 'd:\\foo'
-  const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-  checkPath.isNotRelative = path =>
-    REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path)
-    || isNotRelative(path);
+	const factory = options => new Ignore(options);
+
+	const isPathValid = path =>
+	  checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+
+	factory.isPathValid = isPathValid;
+
+	// Fixes typescript
+	factory.default = factory;
+
+	ignore$1 = 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" */
+	  const makePosix = str => /^\\\\\?\\/.test(str)
+	  || /["<>|\u0000-\u001F]+/u.test(str)
+	    ? str
+	    : str.replace(/\\/g, '/');
+
+	  checkPath.convert = makePosix;
+
+	  // 'C:\\foo'     <- 'C:\\foo' has been converted to 'C:/'
+	  // 'd:\\foo'
+	  const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+	  checkPath.isNotRelative = path =>
+	    REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path)
+	    || isNotRelative(path);
+	}
+	return ignore$1;
 }
 
-var ignore$1 = /*@__PURE__*/getDefaultExportFromCjs(ignore);
+var ignoreExports = /*@__PURE__*/ requireIgnore();
+var ignore = /*@__PURE__*/getDefaultExportFromCjs(ignoreExports);
 
 const entities = {
   ">": "&gt;",
@@ -13794,5 +13835,5 @@ function compatibilityCheckImpl(name, declared, options) {
   return false;
 }
 
-export { Attribute as A, definePlugin as B, Config as C, DOMNode as D, Parser as E, ruleExists as F, walk as G, HtmlValidate as H, EventHandler as I, compatibilityCheckImpl as J, codeframe as K, name as L, MetaCopyableProperty as M, NodeClosed as N, bugs as O, Presets as P, ResolvedConfig as R, Severity as S, TextNode as T, UserError as U, Validator as V, WrappedError as W, ConfigError as a, ConfigLoader as b, defineConfig as c, deepmerge$1 as d, ensureError as e, StaticConfigLoader as f, getFormatter as g, DOMTokenList as h, ignore$1 as i, DOMTree as j, DynamicValue as k, HtmlElement as l, NodeType as m, NestedError as n, SchemaValidationError as o, MetaTable as p, TextContent$1 as q, Rule as r, staticResolver as s, ariaNaming as t, TextClassification as u, version as v, classifyNodeText as w, keywordPatternMatcher as x, sliceLocation as y, Reporter as z };
+export { Attribute as A, Reporter as B, Config as C, DOMNode as D, definePlugin as E, ruleExists as F, walk as G, HtmlValidate as H, EventHandler as I, compatibilityCheckImpl as J, codeframe as K, name as L, MetaCopyableProperty as M, NodeClosed as N, bugs as O, Parser as P, ResolvedConfig as R, Severity as S, TextNode as T, UserError as U, Validator as V, WrappedError as W, ConfigError as a, ConfigLoader as b, defineConfig as c, deepmerge as d, ensureError as e, StaticConfigLoader as f, getFormatter as g, DOMTokenList as h, ignore as i, DOMTree as j, DynamicValue as k, HtmlElement as l, NodeType as m, NestedError as n, SchemaValidationError as o, presets as p, MetaTable as q, TextContent$1 as r, staticResolver as s, Rule as t, ariaNaming as u, version as v, TextClassification as w, classifyNodeText as x, keywordPatternMatcher as y, sliceLocation as z };
 //# sourceMappingURL=core.js.map