html-validate 8.25.1 → 8.27.0

package/dist/es/core.js

@@ -2,7 +2,7 @@ import Ajv from 'ajv';
 import { e as entities$1, h as html5, b as bundledElements } from './elements.js';
 import betterAjvErrors from '@sidvind/better-ajv-errors';
 import { n as naturalJoin } from './utils/natural-join.js';
-import fs from 'fs';
+import fs from 'node:fs';
 import kleur from 'kleur';
 import { stylish as stylish$1 } from '@html-validate/stylish';
 import semver from 'semver';
@@ -5049,6 +5049,27 @@ class CloseAttr extends Rule {
   }
 }
 
+function* ancestors(node) {
+  if (!node) {
+    return;
+  }
+  let ancestor = node;
+  while (ancestor && !ancestor.isRootElement()) {
+    yield ancestor;
+    ancestor = ancestor.parent;
+  }
+  if (ancestor) {
+    yield ancestor;
+  }
+}
+function findAncestor(node, predicate) {
+  for (const ancestor of ancestors(node)) {
+    if (predicate(ancestor)) {
+      return ancestor;
+    }
+  }
+  return null;
+}
 class CloseOrder extends Rule {
   documentation() {
     return {
@@ -5057,15 +5078,28 @@ class CloseOrder extends Rule {
     };
   }
   setup() {
+    let reported;
+    this.on("parse:begin", () => {
+      reported = /* @__PURE__ */ new Set();
+    });
+    this.on("tag:end", (event) => {
+      const current = event.target;
+      const active = event.previous;
+      if (current) {
+        return;
+      }
+      for (const ancestor of ancestors(active)) {
+        if (ancestor.isRootElement() || reported.has(ancestor.unique)) {
+          continue;
+        }
+        this.report(ancestor, `Unclosed element '<${ancestor.tagName}>'`, ancestor.location);
+        reported.add(ancestor.unique);
+      }
+    });
     this.on("tag:end", (event) => {
       const current = event.target;
       const active = event.previous;
       if (!current) {
-        this.report(
-          null,
-          `Missing close-tag, expected '</${active.tagName}>' but document ended before it was found.`,
-          event.location
-        );
         return;
       }
       if (current.voidElement) {
@@ -5082,15 +5116,32 @@ class CloseOrder extends Rule {
           offset: current.location.offset,
           size: current.tagName.length + 1
         };
-        this.report(null, "Unexpected close-tag, expected opening tag.", location);
+        this.report(null, `Stray end tag '</${current.tagName}>'`, location);
         return;
       }
-      if (current.tagName !== active.tagName) {
+      if (current.tagName === active.tagName) {
+        return;
+      }
+      const ancestor = findAncestor(active.parent, (node) => node.is(current.tagName));
+      if (ancestor && !ancestor.isRootElement()) {
+        for (const element of ancestors(active)) {
+          if (ancestor.isSameNode(element)) {
+            break;
+          }
+          if (reported.has(element.unique)) {
+            continue;
+          }
+          this.report(element, `Unclosed element '<${element.tagName}>'`, element.location);
+          reported.add(element.unique);
+        }
         this.report(
           null,
-          `Mismatched close-tag, expected '</${active.tagName}>' but found '</${current.tagName}>'.`,
+          `End tag '</${current.tagName}>' seen but there were open elements`,
           current.location
         );
+        reported.add(ancestor.unique);
+      } else {
+        this.report(null, `Stray end tag '</${current.tagName}>'`, current.location);
       }
     });
   }
@@ -10511,10 +10562,6 @@ var configurationSchema = {
 	properties: properties
 };
 
-const TRANSFORMER_API = {
-  VERSION: 1
-};
-
 var defaultConfig = {};
 
 const config$5 = {
@@ -10721,6 +10768,99 @@ const presets = {
   "html-validate:a17y": config$5
 };
 
+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;
+    const transformer2 = getNamedTransformerFromPlugin(name, plugins, pluginName, key);
+    validateTransformer(transformer2);
+    return transformer2;
+  }
+  const plugin = plugins.find((cur) => cur.name === name);
+  if (plugin) {
+    const transformer2 = getUnnamedTransformerFromPlugin(name, plugin);
+    validateTransformer(transformer2);
+    return transformer2;
+  }
+  const transformer = getTransformerFromModule(resolvers, name);
+  validateTransformer(transformer);
+  return transformer;
+}
+function getTransformerFunction(resolvers, name, plugins) {
+  try {
+    const transformer = loadTransformerFunction(resolvers, name, plugins);
+    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);
+    cache.set(name, transformer);
+    return transformer;
+  }
+}
+
 class ResolvedConfig {
   /**
    * @internal
@@ -10730,6 +10870,7 @@ class ResolvedConfig {
     this.plugins = plugins;
     this.rules = rules;
     this.transformers = transformers;
+    this.cache = /* @__PURE__ */ new Map();
     this.original = original;
   }
   /**
@@ -10753,48 +10894,48 @@ class ResolvedConfig {
    *
    * 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.
    */
-  transformSource(source, filename) {
+  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(source2, filename2);
+        return this.transformSource(resolvers, source2, filename2);
       }
     };
-    if (transformer) {
-      try {
-        return Array.from(transformer.fn.call(context, source), (cur) => {
-          cur.transformedBy ??= [];
-          cur.transformedBy.push(transformer.name);
-          return cur;
-        });
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        throw new NestedError(
-          `When transforming "${source.filename}": ${message}`,
-          ensureError(err)
-        );
-      }
-    } else {
+    if (!transformer) {
       return [source];
     }
+    const fn = getCachedTransformerFunction(this.cache, resolvers, transformer.name, this.plugins);
+    try {
+      const transformedSources = Array.from(fn.call(context, source));
+      for (const source2 of transformedSources) {
+        source2.transformedBy ??= [];
+        source2.transformedBy.push(transformer.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(filename) {
+  transformFilename(resolvers, filename) {
     const stdin = 0;
     const src = filename !== "/dev/stdin" ? filename : stdin;
     const data = fs.readFileSync(src, { encoding: "utf8" });
@@ -10806,10 +10947,12 @@ class ResolvedConfig {
       offset: 0,
       originalData: data
     };
-    return this.transformSource(source);
+    return this.transformSource(resolvers, source);
   }
   /**
    * Returns true if a transformer matches given filename.
+   *
+   * @public
    */
   canTransform(filename) {
     const entry = this.findTransformer(filename);
@@ -10928,6 +11071,12 @@ function toArray(value) {
     return [value];
   }
 }
+function transformerEntries(transform) {
+  return Object.entries(transform).map(([pattern, name]) => {
+    const regex = new RegExp(pattern);
+    return { pattern: regex, name };
+  });
+}
 class Config {
   /**
    * @internal
@@ -10942,10 +11091,10 @@ class Config {
     };
     this.config = mergeInternal(initial, options);
     this.configurations = /* @__PURE__ */ new Map();
-    this.initialized = false;
     this.resolvers = toArray(resolvers);
     this.metaTable = null;
     this.plugins = [];
+    this.transformers = transformerEntries(this.config.transform ?? {});
   }
   /**
    * Create a new blank configuration. See also `Config.defaultConfig()`.
@@ -11028,19 +11177,10 @@ class Config {
     return instance;
   }
   /**
-   * Initialize plugins, transforms etc.
-   *
-   * Must be called before trying to use config. Can safely be called multiple
-   * times.
-   *
    * @public
+   * @deprecated Not needed any longer, this is a dummy noop method.
    */
   init() {
-    if (this.initialized) {
-      return;
-    }
-    this.transformers = this.precompileTransformers(this.config.transform ?? {});
-    this.initialized = true;
   }
   /**
    * Returns true if this configuration is marked as "root".
@@ -11153,6 +11293,14 @@ class Config {
   getPlugins() {
     return this.plugins;
   }
+  /**
+   * Get all configured transformers.
+   *
+   * @internal
+   */
+  getTransformers() {
+    return this.transformers;
+  }
   loadPlugins(plugins) {
     return plugins.map((moduleName, index) => {
       if (typeof moduleName !== "string") {
@@ -11236,99 +11384,6 @@ class Config {
       transformers: this.transformers
     };
   }
-  precompileTransformers(transform) {
-    return Object.entries(transform).map(([pattern, name]) => {
-      try {
-        const fn = this.getTransformFunction(name);
-        const version = fn.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`
-          );
-        }
-        return {
-          // eslint-disable-next-line security/detect-non-literal-regexp -- expected to be a regexp
-          pattern: new RegExp(pattern),
-          name,
-          fn
-        };
-      } 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));
-        }
-      }
-    });
-  }
-  /**
-   * Get transformation function requested by configuration.
-   *
-   * Searches:
-   *
-   * - Named transformers from plugins.
-   * - Unnamed transformer from plugin.
-   * - Standalone modules (local or node_modules)
-   *
-   * @param name - Key from configuration
-   */
-  getTransformFunction(name) {
-    const match = name.match(/(.*):(.*)/);
-    if (match) {
-      const [, pluginName, key] = match;
-      return this.getNamedTransformerFromPlugin(name, pluginName, key);
-    }
-    const plugin = this.plugins.find((cur) => cur.name === name);
-    if (plugin) {
-      return this.getUnnamedTransformerFromPlugin(name, plugin);
-    }
-    return this.getTransformerFromModule(name);
-  }
-  /**
-   * @param name - Original name from configuration
-   * @param pluginName - Name of plugin
-   * @param key - Name of transform (from plugin)
-   */
-  getNamedTransformerFromPlugin(name, pluginName, key) {
-    const plugin = this.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 transformer`);
-    }
-    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;
-  }
-  /**
-   * @param name - Original name from configuration
-   * @param plugin - Plugin instance
-   */
-  getUnnamedTransformerFromPlugin(name, plugin) {
-    if (!plugin.transformer) {
-      throw new ConfigError(`Plugin does not expose any transformer`);
-    }
-    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;
-  }
-  getTransformerFromModule(name) {
-    return resolveTransformer(this.resolvers, name, { cache: true });
-  }
 }
 
 class ConfigLoader {
@@ -11346,6 +11401,12 @@ class ConfigLoader {
       configData ? this.loadFromObject(configData) : this.defaultConfig()
     );
   }
+  /**
+   * @internal
+   */
+  getResolvers() {
+    return this.resolvers;
+  }
   /**
    * @internal For testing only
    */
@@ -11646,8 +11707,9 @@ class Parser {
         node.closed = NodeClosed.EndTag;
       }
       this.closeElement(source, node, active, endToken.location);
+      const mismatched = node.tagName !== active.tagName;
       const voidClosed = !isStartTag && node.voidElement;
-      if (!voidClosed) {
+      if (!voidClosed && !mismatched) {
         this.dom.popActive();
       }
     } else if (isForeign) {
@@ -11665,6 +11727,9 @@ class Parser {
       location
     };
     this.trigger("tag:end", event);
+    if (node && node.tagName !== active.tagName && active.closed !== NodeClosed.ImplicitClosed) {
+      return;
+    }
     if (!active.isRootElement()) {
       this.trigger("element:ready", {
         target: active,
@@ -12525,11 +12590,9 @@ class StaticConfigLoader extends ConfigLoader {
   getConfigFor(_handle, configOverride) {
     const override = this.loadFromObject(configOverride ?? {});
     if (override.isRootFound()) {
-      override.init();
       return override.resolve();
     }
     const merged = this.globalConfig.merge(this.resolvers, override);
-    merged.init();
     return merged.resolve();
   }
   flushCache() {
@@ -12599,7 +12662,8 @@ class HtmlValidate {
   async validateSource(input, configOverride) {
     const source = normalizeSource(input);
     const config = await this.getConfigFor(source.filename, configOverride);
-    const transformedSource = config.transformSource(source);
+    const resolvers = this.configLoader.getResolvers();
+    const transformedSource = config.transformSource(resolvers, source);
     const engine = new Engine(config, Parser);
     return engine.lint(transformedSource);
   }
@@ -12613,7 +12677,8 @@ class HtmlValidate {
   validateSourceSync(input, configOverride) {
     const source = normalizeSource(input);
     const config = this.getConfigForSync(source.filename, configOverride);
-    const transformedSource = config.transformSource(source);
+    const resolvers = this.configLoader.getResolvers();
+    const transformedSource = config.transformSource(resolvers, source);
     const engine = new Engine(config, Parser);
     return engine.lint(transformedSource);
   }
@@ -12626,7 +12691,8 @@ class HtmlValidate {
    */
   async validateFile(filename) {
     const config = await this.getConfigFor(filename);
-    const source = config.transformFilename(filename);
+    const resolvers = this.configLoader.getResolvers();
+    const source = config.transformFilename(resolvers, filename);
     const engine = new Engine(config, Parser);
     return Promise.resolve(engine.lint(source));
   }
@@ -12639,7 +12705,8 @@ class HtmlValidate {
    */
   validateFileSync(filename) {
     const config = this.getConfigForSync(filename);
-    const source = config.transformFilename(filename);
+    const resolvers = this.configLoader.getResolvers();
+    const source = config.transformFilename(resolvers, filename);
     const engine = new Engine(config, Parser);
     return engine.lint(source);
   }
@@ -12707,7 +12774,8 @@ class HtmlValidate {
    */
   dumpTokens(filename) {
     const config = this.getConfigForSync(filename);
-    const source = config.transformFilename(filename);
+    const resolvers = this.configLoader.getResolvers();
+    const source = config.transformFilename(resolvers, filename);
     const engine = new Engine(config, Parser);
     return engine.dumpTokens(source);
   }
@@ -12722,7 +12790,8 @@ class HtmlValidate {
    */
   dumpEvents(filename) {
     const config = this.getConfigForSync(filename);
-    const source = config.transformFilename(filename);
+    const resolvers = this.configLoader.getResolvers();
+    const source = config.transformFilename(resolvers, filename);
     const engine = new Engine(config, Parser);
     return engine.dumpEvents(source);
   }
@@ -12737,7 +12806,8 @@ class HtmlValidate {
    */
   dumpTree(filename) {
     const config = this.getConfigForSync(filename);
-    const source = config.transformFilename(filename);
+    const resolvers = this.configLoader.getResolvers();
+    const source = config.transformFilename(resolvers, filename);
     const engine = new Engine(config, Parser);
     return engine.dumpTree(source);
   }
@@ -12752,7 +12822,8 @@ class HtmlValidate {
    */
   dumpSource(filename) {
     const config = this.getConfigForSync(filename);
-    const sources = config.transformFilename(filename);
+    const resolvers = this.configLoader.getResolvers();
+    const sources = config.transformFilename(resolvers, filename);
     return sources.reduce((result, source) => {
       const line = String(source.line);
       const column = String(source.column);
@@ -12947,7 +13018,7 @@ class HtmlValidate {
 }
 
 const name = "html-validate";
-const version = "8.25.1";
+const version = "8.26.0";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function definePlugin(plugin) {