html-validate 9.0.1 → 9.1.0

package/dist/cjs/core.js

@@ -1947,7 +1947,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);
@@ -2046,7 +2046,7 @@ function isQuotationMark(ch) {
 function isPseudoElement(ch, buffer) {
   return ch === ":" && buffer === ":";
 }
-function* splitPattern(pattern) {
+function* splitPattern$1(pattern) {
   if (pattern === "") {
     return;
   }
@@ -2148,7 +2148,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);
   }
 }
@@ -2166,7 +2166,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));
@@ -10733,24 +10733,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) {
@@ -10884,283 +10919,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__default.default.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__default.default.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__default.default({ strict: true, strictTuples: true, strictTypes: true });
 ajv.addMetaSchema(ajvSchemaDraft);
 ajv.addKeyword(ajvFunctionKeyword);
@@ -11179,7 +10937,7 @@ function mergeInternal(base, rhs) {
   }
   return dst;
 }
-function toArray(value) {
+function toArray$1(value) {
   if (Array.isArray(value)) {
     return value;
   } else {
@@ -11231,7 +10989,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 {
@@ -11317,7 +11075,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 ?? {});
@@ -12903,43 +12661,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__default.default.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__default.default.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;
@@ -12999,7 +12965,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);
   }
@@ -13014,7 +12980,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);
   }
@@ -13028,7 +12994,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));
   }
@@ -13042,7 +13008,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);
   }
@@ -13110,7 +13076,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);
   }
@@ -13126,7 +13092,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);
   }
@@ -13142,7 +13108,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);
   }
@@ -13158,7 +13124,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);
@@ -13357,7 +13323,7 @@ class HtmlValidate {
 }
 
 const name = "html-validate";
-const version = "9.0.1";
+const version = "9.1.0";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function definePlugin(plugin) {
@@ -13673,653 +13639,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);
@@ -14391,8 +14480,8 @@ exports.defineConfig = defineConfig;
 exports.definePlugin = definePlugin;
 exports.ensureError = ensureError;
 exports.esmResolver = esmResolver;
+exports.factory = factory;
 exports.getFormatter = getFormatter;
-exports.ignore = ignore;
 exports.isThenable = isThenable;
 exports.keywordPatternMatcher = keywordPatternMatcher;
 exports.name = name;