html-validate 9.0.0 → 9.1.0

package/dist/es/core.js

@@ -1937,7 +1937,7 @@ const table = {
   "nth-child": nthChild,
   scope
 };
-function factory(name, context) {
+function factory$1(name, context) {
   const fn = table[name];
   if (fn) {
     return fn.bind(context);
@@ -2036,7 +2036,7 @@ function isQuotationMark(ch) {
 function isPseudoElement(ch, buffer) {
   return ch === ":" && buffer === ":";
 }
-function* splitPattern(pattern) {
+function* splitPattern$1(pattern) {
   if (pattern === "") {
     return;
   }
@@ -2138,7 +2138,7 @@ class PseudoClassMatcher extends Matcher {
     this.args = args;
   }
   match(node, context) {
-    const fn = factory(this.name, context);
+    const fn = factory$1(this.name, context);
     return fn(node, this.args);
   }
 }
@@ -2156,7 +2156,7 @@ class Pattern {
     this.selector = pattern;
     this.combinator = parseCombinator(match.shift(), pattern);
     this.tagName = match.shift() || "*";
-    this.pattern = Array.from(splitPattern(match[0]), (it) => this.createMatcher(it));
+    this.pattern = Array.from(splitPattern$1(match[0]), (it) => this.createMatcher(it));
   }
   match(node, context) {
     return node.is(this.tagName) && this.pattern.every((cur) => cur.match(node, context));
@@ -10723,24 +10723,59 @@ const presets = {
   "html-validate:standard": config
 };
 
-function getNamedTransformerFromPlugin(name, plugins, pluginName, key) {
-  const plugin = plugins.find((cur) => cur.name === pluginName);
-  if (!plugin) {
-    throw new ConfigError(`No plugin named "${pluginName}" has been loaded`);
+class ResolvedConfig {
+  metaTable;
+  plugins;
+  rules;
+  transformers;
+  /** The original data this resolved configuration was created from */
+  original;
+  /**
+   * @internal
+   */
+  cache;
+  /**
+   * @internal
+   */
+  constructor({ metaTable, plugins, rules, transformers }, original) {
+    this.metaTable = metaTable;
+    this.plugins = plugins;
+    this.rules = rules;
+    this.transformers = transformers;
+    this.cache = /* @__PURE__ */ new Map();
+    this.original = original;
   }
-  if (!plugin.transformer) {
-    throw new ConfigError(`Plugin does not expose any transformers`);
+  /**
+   * Returns the (merged) configuration data used to create this resolved
+   * configuration.
+   */
+  getConfigData() {
+    return this.original;
   }
-  if (typeof plugin.transformer === "function") {
-    throw new ConfigError(
-      `Transformer "${name}" refers to named transformer but plugin exposes only unnamed, use "${pluginName}" instead.`
-    );
+  getMetaTable() {
+    return this.metaTable;
   }
-  const transformer = plugin.transformer[key];
-  if (!transformer) {
-    throw new ConfigError(`Plugin "${pluginName}" does not expose a transformer named "${key}".`);
+  getPlugins() {
+    return this.plugins;
+  }
+  getRules() {
+    return this.rules;
+  }
+  /**
+   * Returns true if a transformer matches given filename.
+   *
+   * @public
+   */
+  canTransform(filename) {
+    return Boolean(this.findTransformer(filename));
+  }
+  /**
+   * @internal
+   */
+  findTransformer(filename) {
+    const match = this.transformers.find((entry) => entry.pattern.test(filename));
+    return match ?? null;
   }
-  return transformer;
 }
 
 function haveResolver(key, value) {
@@ -10874,283 +10909,6 @@ function staticResolver(map = {}) {
   };
 }
 
-function getTransformerFromModule(resolvers, name) {
-  return resolveTransformer(resolvers, name, { cache: true });
-}
-
-function getUnnamedTransformerFromPlugin(name, plugin) {
-  if (!plugin.transformer) {
-    throw new ConfigError(`Plugin does not expose any transformers`);
-  }
-  if (typeof plugin.transformer !== "function") {
-    if (plugin.transformer.default) {
-      return plugin.transformer.default;
-    }
-    throw new ConfigError(
-      `Transformer "${name}" refers to unnamed transformer but plugin exposes only named.`
-    );
-  }
-  return plugin.transformer;
-}
-
-const TRANSFORMER_API = {
-  VERSION: 1
-};
-
-function validateTransformer(transformer) {
-  const version = transformer.api ?? 0;
-  if (version !== TRANSFORMER_API.VERSION) {
-    throw new ConfigError(
-      `Transformer uses API version ${String(version)} but only version ${String(TRANSFORMER_API.VERSION)} is supported`
-    );
-  }
-}
-function loadTransformerFunction(resolvers, name, plugins) {
-  const match = name.match(/(.*):(.*)/);
-  if (match) {
-    const [, pluginName, key] = match;
-    return getNamedTransformerFromPlugin(name, plugins, pluginName, key);
-  }
-  const plugin = plugins.find((cur) => cur.name === name);
-  if (plugin) {
-    return getUnnamedTransformerFromPlugin(name, plugin);
-  }
-  return getTransformerFromModule(resolvers, name);
-}
-function getTransformerFunction(resolvers, name, plugins) {
-  try {
-    const transformer = loadTransformerFunction(resolvers, name, plugins);
-    if (isThenable(transformer)) {
-      return transformer.then((transformer2) => {
-        validateTransformer(transformer2);
-        return transformer2;
-      });
-    } else {
-      validateTransformer(transformer);
-      return transformer;
-    }
-  } catch (err) {
-    if (err instanceof ConfigError) {
-      throw new ConfigError(`Failed to load transformer "${name}": ${err.message}`, err);
-    } else {
-      throw new ConfigError(`Failed to load transformer "${name}"`, ensureError(err));
-    }
-  }
-}
-function getCachedTransformerFunction(cache, resolvers, name, plugins) {
-  const cached = cache.get(name);
-  if (cached) {
-    return cached;
-  } else {
-    const transformer = getTransformerFunction(resolvers, name, plugins);
-    if (isThenable(transformer)) {
-      return transformer.then((transformer2) => {
-        cache.set(name, transformer2);
-        return transformer2;
-      });
-    } else {
-      cache.set(name, transformer);
-      return transformer;
-    }
-  }
-}
-
-function isIterable(value) {
-  return Boolean(value && typeof value === "object" && Symbol.iterator in value);
-}
-function isNonThenableArray(value) {
-  return !value.some(isThenable);
-}
-function toArray$1(value) {
-  return isIterable(value) ? Array.from(value) : [value];
-}
-const asyncInSyncTransformError = "Cannot use async transformer from sync function";
-class ResolvedConfig {
-  metaTable;
-  plugins;
-  rules;
-  transformers;
-  cache;
-  /** The original data this resolved configuration was created from */
-  original;
-  /**
-   * @internal
-   */
-  constructor({ metaTable, plugins, rules, transformers }, original) {
-    this.metaTable = metaTable;
-    this.plugins = plugins;
-    this.rules = rules;
-    this.transformers = transformers;
-    this.cache = /* @__PURE__ */ new Map();
-    this.original = original;
-  }
-  /**
-   * Returns the (merged) configuration data used to create this resolved
-   * configuration.
-   */
-  getConfigData() {
-    return this.original;
-  }
-  getMetaTable() {
-    return this.metaTable;
-  }
-  getPlugins() {
-    return this.plugins;
-  }
-  getRules() {
-    return this.rules;
-  }
-  /**
-   * Transform a source.
-   *
-   * When transforming zero or more new sources will be generated.
-   *
-   * @internal
-   * @param source - Current source to transform.
-   * @param filename - If set it is the filename used to match
-   * transformer. Default is to use filename from source.
-   * @returns A list of transformed sources ready for validation.
-   */
-  async transformSource(resolvers, source, filename) {
-    const transformer = this.findTransformer(filename ?? source.filename);
-    const context = {
-      hasChain: (filename2) => {
-        return !!this.findTransformer(filename2);
-      },
-      chain: (source2, filename2) => {
-        return this.transformSource(resolvers, source2, filename2);
-      }
-    };
-    if (!transformer) {
-      return Promise.resolve([source]);
-    }
-    const fn = transformer.kind === "import" ? await getCachedTransformerFunction(this.cache, resolvers, transformer.name, this.plugins) : transformer.function;
-    const name = transformer.kind === "import" ? transformer.name : transformer.function.name;
-    try {
-      const result = await fn.call(context, source);
-      const transformedSources = await Promise.all(toArray$1(result));
-      for (const source2 of transformedSources) {
-        source2.transformedBy ??= [];
-        source2.transformedBy.push(name);
-      }
-      return transformedSources;
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      throw new NestedError(`When transforming "${source.filename}": ${message}`, ensureError(err));
-    }
-  }
-  /**
-   * Transform a source.
-   *
-   * When transforming zero or more new sources will be generated.
-   *
-   * @internal
-   * @param source - Current source to transform.
-   * @param filename - If set it is the filename used to match
-   * transformer. Default is to use filename from source.
-   * @returns A list of transformed sources ready for validation.
-   */
-  /* eslint-disable-next-line complexity -- there is many ifs'n buts here but
-   * hard to break this down without loosing the little clarity that is still
-   * left */
-  transformSourceSync(resolvers, source, filename) {
-    const transformer = this.findTransformer(filename ?? source.filename);
-    const context = {
-      hasChain: (filename2) => {
-        return !!this.findTransformer(filename2);
-      },
-      chain: (source2, filename2) => {
-        return this.transformSourceSync(resolvers, source2, filename2);
-      }
-    };
-    if (!transformer) {
-      return [source];
-    }
-    const fn = transformer.kind === "import" ? getCachedTransformerFunction(this.cache, resolvers, transformer.name, this.plugins) : transformer.function;
-    const name = transformer.kind === "import" ? transformer.name : transformer.function.name;
-    if (isThenable(fn)) {
-      throw new UserError(asyncInSyncTransformError);
-    }
-    try {
-      const result = fn.call(context, source);
-      if (isThenable(result)) {
-        throw new UserError(asyncInSyncTransformError);
-      }
-      const transformedSources = toArray$1(result);
-      if (!isNonThenableArray(transformedSources)) {
-        throw new UserError(asyncInSyncTransformError);
-      }
-      for (const source2 of transformedSources) {
-        source2.transformedBy ??= [];
-        source2.transformedBy.push(name);
-      }
-      return transformedSources;
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      throw new NestedError(`When transforming "${source.filename}": ${message}`, ensureError(err));
-    }
-  }
-  /**
-   * Wrapper around [[transformSource]] which reads a file before passing it
-   * as-is to transformSource.
-   *
-   * @internal
-   * @param filename - Filename to transform (according to configured
-   * transformations)
-   * @returns A list of transformed sources ready for validation.
-   */
-  transformFilename(resolvers, filename) {
-    const stdin = 0;
-    const src = filename !== "/dev/stdin" ? filename : stdin;
-    const data = fs.readFileSync(src, { encoding: "utf8" });
-    const source = {
-      data,
-      filename,
-      line: 1,
-      column: 1,
-      offset: 0,
-      originalData: data
-    };
-    return this.transformSource(resolvers, source, filename);
-  }
-  /**
-   * Wrapper around [[transformSource]] which reads a file before passing it
-   * as-is to transformSource.
-   *
-   * @internal
-   * @param filename - Filename to transform (according to configured
-   * transformations)
-   * @returns A list of transformed sources ready for validation.
-   */
-  transformFilenameSync(resolvers, filename) {
-    const stdin = 0;
-    const src = filename !== "/dev/stdin" ? filename : stdin;
-    const data = fs.readFileSync(src, { encoding: "utf8" });
-    const source = {
-      data,
-      filename,
-      line: 1,
-      column: 1,
-      offset: 0,
-      originalData: data
-    };
-    return this.transformSourceSync(resolvers, source, filename);
-  }
-  /**
-   * Returns true if a transformer matches given filename.
-   *
-   * @public
-   */
-  canTransform(filename) {
-    const entry = this.findTransformer(filename);
-    return !!entry;
-  }
-  findTransformer(filename) {
-    const match = this.transformers.find((entry) => entry.pattern.test(filename));
-    return match ?? null;
-  }
-}
-
 const ajv = new Ajv({ strict: true, strictTuples: true, strictTypes: true });
 ajv.addMetaSchema(ajvSchemaDraft);
 ajv.addKeyword(ajvFunctionKeyword);
@@ -11169,7 +10927,7 @@ function mergeInternal(base, rhs) {
   }
   return dst;
 }
-function toArray(value) {
+function toArray$1(value) {
   if (Array.isArray(value)) {
     return value;
   } else {
@@ -11221,7 +10979,7 @@ class Config {
    * @param filename - The file to read from
    */
   static fromFile(resolvers, filename) {
-    const configData = resolveConfig(toArray(resolvers), filename, { cache: false });
+    const configData = resolveConfig(toArray$1(resolvers), filename, { cache: false });
     if (isThenable(configData)) {
       return configData.then((configData2) => Config.fromObject(resolvers, configData2, filename));
     } else {
@@ -11307,7 +11065,7 @@ class Config {
     };
     this.config = mergeInternal(initial, options);
     this.configurations = /* @__PURE__ */ new Map();
-    this.resolvers = toArray(resolvers);
+    this.resolvers = toArray$1(resolvers);
     this.metaTable = null;
     this.plugins = [];
     this.transformers = transformerEntries(this.config.transform ?? {});
@@ -12893,43 +12651,251 @@ class StaticConfigLoader extends ConfigLoader {
       return this._resolveConfig(override);
     }
   }
-  flushCache() {
+  flushCache() {
+  }
+  defaultConfig() {
+    return this.loadFromObject({
+      extends: ["html-validate:recommended"],
+      elements: ["html5"]
+    });
+  }
+  _resolveConfig(override) {
+    if (override.isRootFound()) {
+      return override.resolve();
+    }
+    const globalConfig = this.getGlobalConfig();
+    if (isThenable(globalConfig)) {
+      return globalConfig.then((globalConfig2) => {
+        const merged = globalConfig2.merge(this.resolvers, override);
+        if (isThenable(merged)) {
+          return merged.then((merged2) => {
+            return merged2.resolve();
+          });
+        } else {
+          return merged.resolve();
+        }
+      });
+    } else {
+      const merged = globalConfig.merge(this.resolvers, override);
+      if (isThenable(merged)) {
+        return merged.then((merged2) => {
+          return merged2.resolve();
+        });
+      } else {
+        return merged.resolve();
+      }
+    }
+  }
+}
+
+function getNamedTransformerFromPlugin(name, plugins, pluginName, key) {
+  const plugin = plugins.find((cur) => cur.name === pluginName);
+  if (!plugin) {
+    throw new ConfigError(`No plugin named "${pluginName}" has been loaded`);
+  }
+  if (!plugin.transformer) {
+    throw new ConfigError(`Plugin does not expose any transformers`);
+  }
+  if (typeof plugin.transformer === "function") {
+    throw new ConfigError(
+      `Transformer "${name}" refers to named transformer but plugin exposes only unnamed, use "${pluginName}" instead.`
+    );
+  }
+  const transformer = plugin.transformer[key];
+  if (!transformer) {
+    throw new ConfigError(`Plugin "${pluginName}" does not expose a transformer named "${key}".`);
+  }
+  return transformer;
+}
+
+function getTransformerFromModule(resolvers, name) {
+  return resolveTransformer(resolvers, name, { cache: true });
+}
+
+function getUnnamedTransformerFromPlugin(name, plugin) {
+  if (!plugin.transformer) {
+    throw new ConfigError(`Plugin does not expose any transformers`);
+  }
+  if (typeof plugin.transformer !== "function") {
+    if (plugin.transformer.default) {
+      return plugin.transformer.default;
+    }
+    throw new ConfigError(
+      `Transformer "${name}" refers to unnamed transformer but plugin exposes only named.`
+    );
+  }
+  return plugin.transformer;
+}
+
+const TRANSFORMER_API = {
+  VERSION: 1
+};
+
+function validateTransformer(transformer) {
+  const version = transformer.api ?? 0;
+  if (version !== TRANSFORMER_API.VERSION) {
+    throw new ConfigError(
+      `Transformer uses API version ${String(version)} but only version ${String(TRANSFORMER_API.VERSION)} is supported`
+    );
+  }
+}
+function loadTransformerFunction(resolvers, name, plugins) {
+  const match = name.match(/(.*):(.*)/);
+  if (match) {
+    const [, pluginName, key] = match;
+    return getNamedTransformerFromPlugin(name, plugins, pluginName, key);
+  }
+  const plugin = plugins.find((cur) => cur.name === name);
+  if (plugin) {
+    return getUnnamedTransformerFromPlugin(name, plugin);
+  }
+  return getTransformerFromModule(resolvers, name);
+}
+function getTransformerFunction(resolvers, name, plugins) {
+  try {
+    const transformer = loadTransformerFunction(resolvers, name, plugins);
+    if (isThenable(transformer)) {
+      return transformer.then((transformer2) => {
+        validateTransformer(transformer2);
+        return transformer2;
+      });
+    } else {
+      validateTransformer(transformer);
+      return transformer;
+    }
+  } catch (err) {
+    if (err instanceof ConfigError) {
+      throw new ConfigError(`Failed to load transformer "${name}": ${err.message}`, err);
+    } else {
+      throw new ConfigError(`Failed to load transformer "${name}"`, ensureError(err));
+    }
+  }
+}
+function getCachedTransformerFunction(cache, resolvers, name, plugins) {
+  const cached = cache.get(name);
+  if (cached) {
+    return cached;
+  } else {
+    const transformer = getTransformerFunction(resolvers, name, plugins);
+    if (isThenable(transformer)) {
+      return transformer.then((transformer2) => {
+        cache.set(name, transformer2);
+        return transformer2;
+      });
+    } else {
+      cache.set(name, transformer);
+      return transformer;
+    }
+  }
+}
+
+function isIterable(value) {
+  return Boolean(value && typeof value === "object" && Symbol.iterator in value);
+}
+function toArray(value) {
+  return isIterable(value) ? Array.from(value) : [value];
+}
+function isNonThenableArray(value) {
+  return !value.some(isThenable);
+}
+const asyncInSyncTransformError = "Cannot use async transformer from sync function";
+async function transformSource(resolvers, config, source, filename) {
+  const { cache } = config;
+  const transformer = config.findTransformer(filename ?? source.filename);
+  const context = {
+    hasChain(filename2) {
+      return config.canTransform(filename2);
+    },
+    chain(source2, filename2) {
+      return transformSource(resolvers, config, source2, filename2);
+    }
+  };
+  if (!transformer) {
+    return Promise.resolve([source]);
+  }
+  const fn = transformer.kind === "import" ? await getCachedTransformerFunction(cache, resolvers, transformer.name, config.getPlugins()) : transformer.function;
+  const name = transformer.kind === "import" ? transformer.name : transformer.function.name;
+  try {
+    const result = await fn.call(context, source);
+    const transformedSources = await Promise.all(toArray(result));
+    for (const source2 of transformedSources) {
+      source2.transformedBy ??= [];
+      source2.transformedBy.push(name);
+    }
+    return transformedSources;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new NestedError(`When transforming "${source.filename}": ${message}`, ensureError(err));
+  }
+}
+function transformSourceSync(resolvers, config, source, filename) {
+  const { cache } = config;
+  const transformer = config.findTransformer(filename ?? source.filename);
+  const context = {
+    hasChain(filename2) {
+      return config.canTransform(filename2);
+    },
+    chain(source2, filename2) {
+      return transformSourceSync(resolvers, config, source2, filename2);
+    }
+  };
+  if (!transformer) {
+    return [source];
   }
-  defaultConfig() {
-    return this.loadFromObject({
-      extends: ["html-validate:recommended"],
-      elements: ["html5"]
-    });
+  const fn = transformer.kind === "import" ? getCachedTransformerFunction(cache, resolvers, transformer.name, config.getPlugins()) : transformer.function;
+  const name = transformer.kind === "import" ? transformer.name : transformer.function.name;
+  if (isThenable(fn)) {
+    throw new UserError(asyncInSyncTransformError);
   }
-  _resolveConfig(override) {
-    if (override.isRootFound()) {
-      return override.resolve();
+  try {
+    const result = fn.call(context, source);
+    if (isThenable(result)) {
+      throw new UserError(asyncInSyncTransformError);
     }
-    const globalConfig = this.getGlobalConfig();
-    if (isThenable(globalConfig)) {
-      return globalConfig.then((globalConfig2) => {
-        const merged = globalConfig2.merge(this.resolvers, override);
-        if (isThenable(merged)) {
-          return merged.then((merged2) => {
-            return merged2.resolve();
-          });
-        } else {
-          return merged.resolve();
-        }
-      });
-    } else {
-      const merged = globalConfig.merge(this.resolvers, override);
-      if (isThenable(merged)) {
-        return merged.then((merged2) => {
-          return merged2.resolve();
-        });
-      } else {
-        return merged.resolve();
-      }
+    const transformedSources = toArray(result);
+    if (!isNonThenableArray(transformedSources)) {
+      throw new UserError(asyncInSyncTransformError);
     }
+    for (const source2 of transformedSources) {
+      source2.transformedBy ??= [];
+      source2.transformedBy.push(name);
+    }
+    return transformedSources;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new NestedError(`When transforming "${source.filename}": ${message}`, ensureError(err));
   }
 }
 
+function transformFilename(resolvers, config, filename) {
+  const stdin = 0;
+  const src = filename !== "/dev/stdin" ? filename : stdin;
+  const data = fs.readFileSync(src, { encoding: "utf8" });
+  const source = {
+    data,
+    filename,
+    line: 1,
+    column: 1,
+    offset: 0,
+    originalData: data
+  };
+  return transformSource(resolvers, config, source, filename);
+}
+function transformFilenameSync(resolvers, config, filename) {
+  const stdin = 0;
+  const src = filename !== "/dev/stdin" ? filename : stdin;
+  const data = fs.readFileSync(src, { encoding: "utf8" });
+  const source = {
+    data,
+    filename,
+    line: 1,
+    column: 1,
+    offset: 0,
+    originalData: data
+  };
+  return transformSourceSync(resolvers, config, source, filename);
+}
+
 function isSourceHooks(value) {
   if (!value || typeof value === "string") {
     return false;
@@ -12989,7 +12955,7 @@ class HtmlValidate {
     const source = normalizeSource(input);
     const config = await this.getConfigFor(source.filename, configOverride);
     const resolvers = this.configLoader.getResolvers();
-    const transformedSource = await config.transformSource(resolvers, source);
+    const transformedSource = await transformSource(resolvers, config, source);
     const engine = new Engine(config, Parser);
     return engine.lint(transformedSource);
   }
@@ -13004,7 +12970,7 @@ class HtmlValidate {
     const source = normalizeSource(input);
     const config = this.getConfigForSync(source.filename, configOverride);
     const resolvers = this.configLoader.getResolvers();
-    const transformedSource = config.transformSourceSync(resolvers, source);
+    const transformedSource = transformSourceSync(resolvers, config, source);
     const engine = new Engine(config, Parser);
     return engine.lint(transformedSource);
   }
@@ -13018,7 +12984,7 @@ class HtmlValidate {
   async validateFile(filename) {
     const config = await this.getConfigFor(filename);
     const resolvers = this.configLoader.getResolvers();
-    const source = await config.transformFilename(resolvers, filename);
+    const source = await transformFilename(resolvers, config, filename);
     const engine = new Engine(config, Parser);
     return Promise.resolve(engine.lint(source));
   }
@@ -13032,7 +12998,7 @@ class HtmlValidate {
   validateFileSync(filename) {
     const config = this.getConfigForSync(filename);
     const resolvers = this.configLoader.getResolvers();
-    const source = config.transformFilenameSync(resolvers, filename);
+    const source = transformFilenameSync(resolvers, config, filename);
     const engine = new Engine(config, Parser);
     return engine.lint(source);
   }
@@ -13044,8 +13010,7 @@ class HtmlValidate {
    * @returns Report output.
    */
   async validateMultipleFiles(filenames) {
-    const report = Reporter.merge(filenames.map((filename) => this.validateFileSync(filename)));
-    return Promise.resolve(report);
+    return Reporter.merge(filenames.map((filename) => this.validateFile(filename)));
   }
   /**
    * Parse and validate HTML from multiple files. Result is merged together to a
@@ -13101,7 +13066,7 @@ class HtmlValidate {
   async dumpTokens(filename) {
     const config = await this.getConfigFor(filename);
     const resolvers = this.configLoader.getResolvers();
-    const source = await config.transformFilename(resolvers, filename);
+    const source = await transformFilename(resolvers, config, filename);
     const engine = new Engine(config, Parser);
     return engine.dumpTokens(source);
   }
@@ -13117,7 +13082,7 @@ class HtmlValidate {
   async dumpEvents(filename) {
     const config = await this.getConfigFor(filename);
     const resolvers = this.configLoader.getResolvers();
-    const source = await config.transformFilename(resolvers, filename);
+    const source = await transformFilename(resolvers, config, filename);
     const engine = new Engine(config, Parser);
     return engine.dumpEvents(source);
   }
@@ -13133,7 +13098,7 @@ class HtmlValidate {
   async dumpTree(filename) {
     const config = await this.getConfigFor(filename);
     const resolvers = this.configLoader.getResolvers();
-    const source = await config.transformFilename(resolvers, filename);
+    const source = await transformFilename(resolvers, config, filename);
     const engine = new Engine(config, Parser);
     return engine.dumpTree(source);
   }
@@ -13149,7 +13114,7 @@ class HtmlValidate {
   async dumpSource(filename) {
     const config = await this.getConfigFor(filename);
     const resolvers = this.configLoader.getResolvers();
-    const sources = await config.transformFilename(resolvers, filename);
+    const sources = await transformFilename(resolvers, config, filename);
     return sources.reduce((result, source) => {
       const line = String(source.line);
       const column = String(source.column);
@@ -13348,7 +13313,7 @@ class HtmlValidate {
 }
 
 const name = "html-validate";
-const version = "9.0.0";
+const version = "9.1.0";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function definePlugin(plugin) {
@@ -13664,653 +13629,776 @@ function compatibilityCheckImpl(name, declared, options) {
   return false;
 }
 
-var ignore$1;
-var hasRequiredIgnore;
+// A simple implementation of make-array
+function makeArray (subject) {
+  return Array.isArray(subject)
+    ? subject
+    : [subject]
+}
+
+const UNDEFINED = undefined;
+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;
+
+// Invalid:
+// - /foo,
+// - ./foo,
+// - ../foo,
+// - .
+// - ..
+// Valid:
+// - .foo
+const REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+
+const REGEX_TEST_TRAILING_SLASH = /\/$/;
+
+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});
+  return value
+};
 
-function requireIgnore () {
-	if (hasRequiredIgnore) return ignore$1;
-	hasRequiredIgnore = 1;
-	// A simple implementation of make-array
-	function makeArray (subject) {
-	  return Array.isArray(subject)
-	    ? subject
-	    : [subject]
-	}
+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)
+};
 
-	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`
 
-	// > 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)
-	};
+// '`foo/`' should not continue with the '`..`'
+const REPLACERS = [
 
-	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;
-	  }
-	}
+  [
+    // Remove BOM
+    // TODO:
+    // Other similar zero-width characters?
+    /^\uFEFF/,
+    () => EMPTY
+  ],
 
-	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
-	  )
-	};
+  // > 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
+    )
+  ],
 
-	const throwError = (message, Ctor) => {
-	  throw new Ctor(message)
-	};
+  // Replace (\ ) with ' '
+  // (\ ) -> ' '
+  // (\\ ) -> '\\ '
+  // (\\\ ) -> '\\ '
+  [
+    /(\\+?)\s/g,
+    (_, m1) => {
+      const {length} = m1;
+      return m1.slice(0, length - length % 2) + SPACE
+    }
+  ],
 
-	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
-	};
+  // 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}`
+  ],
 
-	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)
-	  }
-	}
+  [
+    // > a question mark (?) matches a single character
+    /(?!\\)\?/g,
+    () => '[^/]'
+  ],
 
-	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;
+  // 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}(?=$|\\/$)`
+  ]
+];
+
+const REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+const MODE_IGNORE = 'regex';
+const MODE_CHECK_IGNORE = 'checkRegex';
+const UNDERSCORE = '_';
+
+const TRAILING_WILD_CARD_REPLACERS = {
+  [MODE_IGNORE] (_, 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}(?=$|\\/$)`
+  },
+
+  [MODE_CHECK_IGNORE] (_, p1) {
+    // When doing `git check-ignore`
+    const prefix = p1
+      // '\\\/':
+      // 'abc/*' DOES match 'abc/' !
+      ? `${p1}[^/]*`
+
+      // 'a*' matches 'a'
+      // 'a*' matches 'aa'
+      : '[^/]*';
+
+    return `${prefix}(?=$|\\/$)`
+  }
+};
+
+// @param {pattern}
+const makeRegexPrefix = pattern => REPLACERS.reduce(
+  (prev, [matcher, replacer]) =>
+    prev.replace(matcher, replacer.bind(pattern)),
+  pattern
+);
+
+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)
+.filter(Boolean);
+
+class IgnoreRule {
+  constructor (
+    pattern,
+    mark,
+    body,
+    ignoreCase,
+    negative,
+    prefix
+  ) {
+    this.pattern = pattern;
+    this.mark = mark;
+    this.negative = negative;
+
+    define(this, 'body', body);
+    define(this, 'ignoreCase', ignoreCase);
+    define(this, 'regexPrefix', prefix);
+  }
+
+  get regex () {
+    const key = UNDERSCORE + MODE_IGNORE;
+
+    if (this[key]) {
+      return this[key]
+    }
+
+    return this._make(MODE_IGNORE, key)
+  }
+
+  get checkRegex () {
+    const key = UNDERSCORE + MODE_CHECK_IGNORE;
+
+    if (this[key]) {
+      return this[key]
+    }
+
+    return this._make(MODE_CHECK_IGNORE, key)
+  }
+
+  _make (mode, key) {
+    const str = this.regexPrefix.replace(
+      REGEX_REPLACE_TRAILING_WILDCARD,
+
+      // It does not need to bind pattern
+      TRAILING_WILD_CARD_REPLACERS[mode]
+    );
+
+    const regex = this.ignoreCase
+      ? new RegExp(str, 'i')
+      : new RegExp(str);
+
+    return define(this, key, regex)
+  }
+}
+
+const createRule = ({
+  pattern,
+  mark
+}, ignoreCase) => {
+  let negative = false;
+  let body = pattern;
+
+  // > An optional prefix "!" which negates the pattern;
+  if (body.indexOf('!') === 0) {
+    negative = true;
+    body = body.substr(1);
+  }
+
+  body = body
+  // > 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 regexPrefix = makeRegexPrefix(body);
+
+  return new IgnoreRule(
+    pattern,
+    mark,
+    body,
+    ignoreCase,
+    negative,
+    regexPrefix
+  )
+};
+
+class RuleManager {
+  constructor (ignoreCase) {
+    this._ignoreCase = ignoreCase;
+    this._rules = [];
+  }
+
+  _add (pattern) {
+    // #32
+    if (pattern && pattern[KEY_IGNORE]) {
+      this._rules = this._rules.concat(pattern._rules._rules);
+      this._added = true;
+      return
+    }
+
+    if (isString(pattern)) {
+      pattern = {
+        pattern
+      };
+    }
+
+    if (checkPattern(pattern.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._add, this);
+
+    return this._added
+  }
+
+  // Test one single path without recursively checking parent directories
+  //
+  // - checkUnignored `boolean` whether should check if the path is unignored,
+  //   setting `checkUnignored` to `false` could reduce additional
+  //   path matching.
+  // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+
+  // @returns {TestResult} true if a file is ignored
+  test (path, checkUnignored, mode) {
+    let ignored = false;
+    let unignored = false;
+    let matchedRule;
+
+    this._rules.forEach(rule => {
+      const {negative} = rule;
+
+      //          |           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
+      if (
+        unignored === negative && ignored !== unignored
+        || negative && !ignored && !unignored && !checkUnignored
+      ) {
+        return
+      }
+
+      const matched = rule[mode].test(path);
+
+      if (!matched) {
+        return
+      }
+
+      ignored = !negative;
+      unignored = negative;
+
+      matchedRule = negative
+        ? UNDEFINED
+        : rule;
+    });
+
+    const ret = {
+      ignored,
+      unignored
+    };
+
+    if (matchedRule) {
+      ret.rule = matchedRule;
+    }
+
+    return ret
+  }
+}
+
+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;
+
+// On windows, the following function will be replaced
+/* istanbul ignore next */
+checkPath.convert = p => p;
+
+
+class Ignore {
+  constructor ({
+    ignorecase = true,
+    ignoreCase = ignorecase,
+    allowRelativePaths = false
+  } = {}) {
+    define(this, KEY_IGNORE, true);
+
+    this._rules = new RuleManager(ignoreCase);
+    this._strictPathCheck = !allowRelativePaths;
+    this._initCache();
+  }
+
+  _initCache () {
+    // A cache for the result of `.ignores()`
+    this._ignoreCache = Object.create(null);
+
+    // A cache for the result of `.test()`
+    this._testCache = Object.create(null);
+  }
+
+  add (pattern) {
+    if (this._rules.add(pattern)) {
+      // Some rules have just added to the ignore,
+      //   making the behavior changed,
+      //   so we need to re-initialize the result cache
+      this._initCache();
+    }
+
+    return this
+  }
+
+  // legacy
+  addPattern (pattern) {
+    return this.add(pattern)
+  }
+
+  // @returns {TestResult}
+  _test (originalPath, cache, checkUnignored, slices) {
+    const path = originalPath
+      // Supports nullable path
+      && checkPath.convert(originalPath);
+
+    checkPath(
+      path,
+      originalPath,
+      this._strictPathCheck
+        ? throwError
+        : RETURN_FALSE
+    );
+
+    return this._t(path, cache, checkUnignored, slices)
+  }
+
+  checkIgnore (path) {
+    // If the path doest not end with a slash, `.ignores()` is much equivalent
+    //   to `git check-ignore`
+    if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
+      return this.test(path)
+    }
+
+    const slices = path.split(SLASH).filter(Boolean);
+    slices.pop();
+
+    if (slices.length) {
+      const parent = this._t(
+        slices.join(SLASH) + SLASH,
+        this._testCache,
+        true,
+        slices
+      );
+
+      if (parent.ignored) {
+        return parent
+      }
+    }
+
+    return this._rules.test(path, false, MODE_CHECK_IGNORE)
+  }
+
+  _t (
+    // The path to be tested
+    path,
+
+    // The cache for the result of a certain checking
+    cache,
+
+    // Whether should check if the path is unignored
+    checkUnignored,
+
+    // The path slices
+    slices
+  ) {
+    if (path in cache) {
+      return cache[path]
+    }
+
+    if (!slices) {
+      // path/to/a.js
+      // ['path', 'to', 'a.js']
+      slices = path.split(SLASH).filter(Boolean);
+    }
+
+    slices.pop();
+
+    // If the path has no parent directory, just test it
+    if (!slices.length) {
+      return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE)
+    }
+
+    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._rules.test(path, checkUnignored, MODE_IGNORE)
+  }
+
+  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)
+  }
 }
 
-var ignoreExports = /*@__PURE__*/ requireIgnore();
-var ignore = /*@__PURE__*/getDefaultExportFromCjs(ignoreExports);
+const factory = options => new Ignore(options);
+
+const isPathValid = path =>
+  checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+
+factory.isPathValid = isPathValid;
+
+
+// Windows
+// --------------------------------------------------------------
+/* istanbul ignore next */
+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 REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+  checkPath.isNotRelative = path =>
+    REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path)
+    || isNotRelative(path);
+}
 
 function importFunction(id) {
   return import(id);
@@ -14343,5 +14431,5 @@ function esmResolver() {
 
 var workerPath = "./jest-worker.js";
 
-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, isThenable as K, workerPath as L, MetaCopyableProperty as M, NodeClosed as N, codeframe as O, Parser as P, esmResolver as Q, ResolvedConfig as R, Severity as S, TextNode as T, UserError as U, Validator as V, WrappedError as W, name as X, bugs as Y, 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 };
+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, isThenable as K, workerPath as L, MetaCopyableProperty as M, NodeClosed as N, codeframe as O, Parser as P, esmResolver as Q, ResolvedConfig as R, Severity as S, TextNode as T, UserError as U, Validator as V, WrappedError as W, name as X, bugs as Y, ConfigError as a, ConfigLoader as b, defineConfig as c, deepmerge as d, ensureError as e, factory as f, getFormatter as g, StaticConfigLoader as h, DOMTokenList 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