html-validate 7.18.0 → 8.0.0

package/dist/es/core.js

@@ -1,15 +1,15 @@
-import fs from 'fs';
-import * as espree from 'espree';
-import * as walk from 'acorn-walk';
 import path from 'path';
 import semver from 'semver';
 import kleur from 'kleur';
+import fs$1 from 'node:fs';
+import path$1 from 'node:path';
 import Ajv from 'ajv';
 import deepmerge from 'deepmerge';
 import { e as entities$1, h as html5, b as bundledElements } from './elements.js';
-import { createRequire } from 'module';
 import { i as isKeywordIgnored, C as CaseStyle, n as naturalJoin, c as classifyNodeText, T as TextClassification, h as hasAltText, p as partition, a as isHTMLHidden, b as isAriaHidden, d as hasAccessibleName, k as keywordPatternMatcher, e as inAccessibilityTree, f as hasAriaLabel } from './rules-helper.js';
+import fs from 'fs';
 import betterAjvErrors from '@sidvind/better-ajv-errors';
+import { createRequire } from 'module';
 import { codeFrameColumns } from '@babel/code-frame';
 import { stylish as stylish$2 } from '@html-validate/stylish';
 
@@ -3157,232 +3157,11 @@ var configurationSchema = {
 	properties: properties
 };
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion -- declarations say
- * location fields are optional but they are always present when `{loc: true}` */
-function joinTemplateLiteral(nodes) {
-    let offset = nodes[0].start + 1;
-    let output = "";
-    for (const node of nodes) {
-        output += " ".repeat(node.start + 1 - offset);
-        output += node.value.raw;
-        offset = node.end - 2;
-    }
-    return output;
-}
-/**
- * Compute source offset from line and column and the given markup.
- *
- * @param position - Line and column.
- * @param data - Source markup.
- * @returns The byte offset into the markup which line and column corresponds to.
- */
-function computeOffset(position, data) {
-    let line = position.line;
-    let column = position.column + 1;
-    for (let i = 0; i < data.length; i++) {
-        if (line > 1) {
-            /* not yet on the correct line */
-            if (data[i] === "\n") {
-                line--;
-            }
-        }
-        else if (column > 1) {
-            /* not yet on the correct column */
-            column--;
-        }
-        else {
-            /* line/column found, return current position */
-            return i;
-        }
-    }
-    /* istanbul ignore next: should never reach this line unless espree passes bad
-     * positions, no sane way to test */
-    throw new Error("Failed to compute location offset from position");
-}
-function extractLiteral(node, filename, data) {
-    switch (node.type) {
-        /* ignored nodes */
-        case "FunctionExpression":
-        case "Identifier":
-            return null;
-        case "Literal":
-            if (typeof node.value !== "string") {
-                return null;
-            }
-            return {
-                data: node.value.toString(),
-                filename,
-                line: node.loc.start.line,
-                column: node.loc.start.column + 1,
-                offset: computeOffset(node.loc.start, data) + 1,
-            };
-        case "TemplateLiteral":
-            return {
-                data: joinTemplateLiteral(node.quasis),
-                filename,
-                line: node.loc.start.line,
-                column: node.loc.start.column + 1,
-                offset: computeOffset(node.loc.start, data) + 1,
-            };
-        case "TaggedTemplateExpression":
-            return {
-                data: joinTemplateLiteral(node.quasi.quasis),
-                filename,
-                line: node.quasi.loc.start.line,
-                column: node.quasi.loc.start.column + 1,
-                offset: computeOffset(node.quasi.loc.start, data) + 1,
-            };
-        case "ArrowFunctionExpression": {
-            const whitelist = ["Literal", "TemplateLiteral"];
-            if (whitelist.includes(node.body.type)) {
-                return extractLiteral(node.body, filename, data);
-            }
-            else {
-                return null;
-            }
-        }
-        /* istanbul ignore next: this only provides a better error, all currently known nodes are tested */
-        default: {
-            const loc = node.loc.start;
-            const context = `${filename}:${loc.line}:${loc.column}`;
-            throw new Error(`Unhandled node type "${node.type}" at "${context}" in extractLiteral`);
-        }
-    }
-}
-function compareKey(node, key, filename) {
-    switch (node.type) {
-        case "Identifier":
-            return node.name === key;
-        case "Literal":
-            return node.value === key;
-        /* istanbul ignore next: this only provides a better error, all currently known nodes are tested */
-        default: {
-            const loc = node.loc.start;
-            const context = `${filename}:${loc.line}:${loc.column}`;
-            throw new Error(`Unhandled node type "${node.type}" at "${context}" in compareKey`);
-        }
-    }
-}
-/**
- * @public
- */
-class TemplateExtractor {
-    constructor(ast, filename, data) {
-        this.ast = ast;
-        this.filename = filename;
-        this.data = data;
-    }
-    static fromFilename(filename) {
-        const source = fs.readFileSync(filename, "utf-8");
-        const ast = espree.parse(source, {
-            ecmaVersion: 2017,
-            sourceType: "module",
-            loc: true,
-        });
-        return new TemplateExtractor(ast, filename, source);
-    }
-    /**
-     * Create a new [[TemplateExtractor]] from javascript source code.
-     *
-     * `Source` offsets will be relative to the string, i.e. offset 0 is the first
-     * character of the string. If the string is only a subset of a larger string
-     * the offsets must be adjusted manually.
-     *
-     * @param source - Source code.
-     * @param filename - Optional filename to set in the resulting
-     * `Source`. Defauls to `"inline"`.
-     */
-    static fromString(source, filename) {
-        const ast = espree.parse(source, {
-            ecmaVersion: 2017,
-            sourceType: "module",
-            loc: true,
-        });
-        return new TemplateExtractor(ast, filename || "inline", source);
-    }
-    /**
-     * Convenience function to create a [[Source]] instance from an existing file.
-     *
-     * @param filename - Filename with javascript source code. The file must exist
-     * and be readable by the user.
-     * @returns An array of Source's suitable for passing to [[Engine]] linting
-     * functions.
-     */
-    static createSource(filename) {
-        const data = fs.readFileSync(filename, "utf-8");
-        return [
-            {
-                column: 1,
-                data,
-                filename,
-                line: 1,
-                offset: 0,
-            },
-        ];
-    }
-    /**
-     * Extract object properties.
-     *
-     * Given a key `"template"` this method finds all objects literals with a
-     * `"template"` property and creates a [[Source]] instance with proper offsets
-     * with the value of the property. For instance:
-     *
-     * ```
-     * const myObj = {
-     *   foo: 'bar',
-     * };
-     * ```
-     *
-     * The above snippet would yield a `Source` with the content `bar`.
-     *
-     */
-    extractObjectProperty(key) {
-        const result = [];
-        const { filename, data } = this;
-        const node = this.ast;
-        walk.simple(node, {
-            Property(node) {
-                if (compareKey(node.key, key, filename)) {
-                    const source = extractLiteral(node.value, filename, data);
-                    if (source) {
-                        source.filename = filename;
-                        result.push(source);
-                    }
-                }
-            },
-        });
-        return result;
-    }
-}
-
 var TRANSFORMER_API;
 (function (TRANSFORMER_API) {
     TRANSFORMER_API[TRANSFORMER_API["VERSION"] = 1] = "VERSION";
 })(TRANSFORMER_API || (TRANSFORMER_API = {}));
 
-/**
- * Similar to `require(..)` but removes the cached copy first.
- */
-function requireUncached(require, moduleId) {
-    const filename = require.resolve(moduleId);
-    /* remove references from the parent module to prevent memory leak */
-    const m = require.cache[filename];
-    if (m && m.parent) {
-        const { parent } = m;
-        for (let i = parent.children.length - 1; i >= 0; i--) {
-            if (parent.children[i].id === filename) {
-                parent.children.splice(i, 1);
-            }
-        }
-    }
-    /* remove old module from cache */
-    delete require.cache[filename];
-    /* eslint-disable-next-line import/no-dynamic-require, security/detect-non-literal-require -- as expected but should be moved to upcoming resolver class */
-    return require(filename);
-}
-
-const legacyRequire = createRequire(import.meta.url);
-
 /**
  * @public
  */
@@ -3400,11 +3179,6 @@ function parseSeverity(value) {
         case 0:
         case "off":
             return Severity.DISABLED;
-        /* istanbul ignore next: deprecated code which will be removed later */
-        case "disable":
-            // eslint-disable-next-line no-console -- expected to log
-            console.warn(`Deprecated alias "disabled" will be removed, replace with severity "off"`);
-            return Severity.DISABLED;
         case 1:
         case "warn":
             return Severity.WARN;
@@ -3739,6 +3513,8 @@ class Rule {
      * Called when requesting additional documentation for a rule. Some rules
      * provide additional context to provide context-aware suggestions.
      *
+     * @public
+     * @virtual
      * @param context - Error context given by a reported error.
      * @returns Rule documentation and url with additional details or `null` if no
      * additional documentation is available.
@@ -3749,15 +3525,15 @@ class Rule {
     }
 }
 
-var Style$2;
+var Style$1;
 (function (Style) {
     Style["EXTERNAL"] = "external";
     Style["RELATIVE_BASE"] = "relative-base";
     Style["RELATIVE_PATH"] = "relative-path";
     Style["ABSOLUTE"] = "absolute";
     Style["ANCHOR"] = "anchor";
-})(Style$2 || (Style$2 = {}));
-const defaults$w = {
+})(Style$1 || (Style$1 = {}));
+const defaults$v = {
     allowExternal: true,
     allowRelative: true,
     allowAbsolute: true,
@@ -3770,11 +3546,11 @@ const mapping$1 = {
     script: "src",
 };
 const description = {
-    [Style$2.EXTERNAL]: "External links are not allowed by current configuration.",
-    [Style$2.RELATIVE_BASE]: "Links relative to <base> are not allowed by current configuration.",
-    [Style$2.RELATIVE_PATH]: "Relative links are not allowed by current configuration.",
-    [Style$2.ABSOLUTE]: "Absolute links are not allowed by current configuration.",
-    [Style$2.ANCHOR]: null,
+    [Style$1.EXTERNAL]: "External links are not allowed by current configuration.",
+    [Style$1.RELATIVE_BASE]: "Links relative to <base> are not allowed by current configuration.",
+    [Style$1.RELATIVE_PATH]: "Relative links are not allowed by current configuration.",
+    [Style$1.ABSOLUTE]: "Absolute links are not allowed by current configuration.",
+    [Style$1.ANCHOR]: null,
 };
 function parseAllow(value) {
     if (typeof value === "boolean") {
@@ -3801,7 +3577,7 @@ function matchList(value, list) {
 }
 class AllowedLinks extends Rule {
     constructor(options) {
-        super({ ...defaults$w, ...options });
+        super({ ...defaults$v, ...options });
         this.allowExternal = parseAllow(this.options.allowExternal);
         this.allowRelative = parseAllow(this.options.allowRelative);
         this.allowAbsolute = parseAllow(this.options.allowAbsolute);
@@ -3847,19 +3623,19 @@ class AllowedLinks extends Rule {
             const link = event.value.toString();
             const style = this.getStyle(link);
             switch (style) {
-                case Style$2.ANCHOR:
+                case Style$1.ANCHOR:
                     /* anchor links are always allowed by this rule */
                     break;
-                case Style$2.ABSOLUTE:
+                case Style$1.ABSOLUTE:
                     this.handleAbsolute(link, event, style);
                     break;
-                case Style$2.EXTERNAL:
+                case Style$1.EXTERNAL:
                     this.handleExternal(link, event, style);
                     break;
-                case Style$2.RELATIVE_BASE:
+                case Style$1.RELATIVE_BASE:
                     this.handleRelativeBase(link, event, style);
                     break;
-                case Style$2.RELATIVE_PATH:
+                case Style$1.RELATIVE_PATH:
                     this.handleRelativePath(link, event, style);
                     break;
             }
@@ -3877,21 +3653,21 @@ class AllowedLinks extends Rule {
     getStyle(value) {
         /* http://example.net or //example.net */
         if (value.match(/^([a-z]+:)?\/\//g)) {
-            return Style$2.EXTERNAL;
+            return Style$1.EXTERNAL;
         }
         switch (value[0]) {
             /* /foo/bar */
             case "/":
-                return Style$2.ABSOLUTE;
+                return Style$1.ABSOLUTE;
             /* ../foo/bar */
             case ".":
-                return Style$2.RELATIVE_PATH;
+                return Style$1.RELATIVE_PATH;
             /* #foo */
             case "#":
-                return Style$2.ANCHOR;
+                return Style$1.ANCHOR;
             /* foo/bar */
             default:
-                return Style$2.RELATIVE_BASE;
+                return Style$1.RELATIVE_BASE;
         }
     }
     handleAbsolute(target, event, style) {
@@ -3949,7 +3725,7 @@ var RuleContext$1;
     RuleContext["MISSING_ALT"] = "missing-alt";
     RuleContext["MISSING_HREF"] = "missing-href";
 })(RuleContext$1 || (RuleContext$1 = {}));
-const defaults$v = {
+const defaults$u = {
     accessible: true,
 };
 function findByTarget(target, siblings) {
@@ -3987,7 +3763,7 @@ function getDescription$1(context) {
 }
 class AreaAlt extends Rule {
     constructor(options) {
-        super({ ...defaults$v, ...options });
+        super({ ...defaults$u, ...options });
     }
     static schema() {
         return {
@@ -4167,13 +3943,13 @@ class ConfigError extends UserError {
     }
 }
 
-const defaults$u = {
+const defaults$t = {
     style: "lowercase",
     ignoreForeign: true,
 };
 class AttrCase extends Rule {
     constructor(options) {
-        super({ ...defaults$u, ...options });
+        super({ ...defaults$t, ...options });
         this.style = new CaseStyle(this.options.style, "attr-case");
     }
     static schema() {
@@ -4521,7 +4297,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$t = {
+const defaults$s = {
     pattern: DEFAULT_PATTERN,
     ignoreForeign: true,
 };
@@ -4558,7 +4334,7 @@ function generateDescription(name, pattern) {
 }
 class AttrPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$t, ...options });
+        super({ ...defaults$s, ...options });
         this.pattern = generateRegexp(this.options.pattern);
     }
     static schema() {
@@ -4619,7 +4395,7 @@ var QuoteStyle;
     QuoteStyle["AUTO_QUOTE"] = "auto";
     QuoteStyle["ANY_QUOTE"] = "any";
 })(QuoteStyle || (QuoteStyle = {}));
-const defaults$s = {
+const defaults$r = {
     style: "auto",
     unquoted: false,
 };
@@ -4686,8 +4462,8 @@ class AttrQuotes extends Rule {
         };
     }
     constructor(options) {
-        super({ ...defaults$s, ...options });
-        this.style = parseStyle$4(this.options.style);
+        super({ ...defaults$r, ...options });
+        this.style = parseStyle$3(this.options.style);
     }
     setup() {
         this.on("attr", (event) => {
@@ -4734,7 +4510,7 @@ class AttrQuotes extends Rule {
         }
     }
 }
-function parseStyle$4(style) {
+function parseStyle$3(style) {
     switch (style.toLowerCase()) {
         case "auto":
             return QuoteStyle.AUTO_QUOTE;
@@ -4856,13 +4632,13 @@ class AttributeAllowedValues extends Rule {
     }
 }
 
-const defaults$r = {
+const defaults$q = {
     style: "omit",
 };
 class AttributeBooleanStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$r, ...options });
-        this.hasInvalidStyle = parseStyle$3(this.options.style);
+        super({ ...defaults$q, ...options });
+        this.hasInvalidStyle = parseStyle$2(this.options.style);
     }
     static schema() {
         return {
@@ -4910,7 +4686,7 @@ class AttributeBooleanStyle extends Rule {
         return Boolean((_a = rules[attr.key]) === null || _a === void 0 ? void 0 : _a.boolean);
     }
 }
-function parseStyle$3(style) {
+function parseStyle$2(style) {
     switch (style.toLowerCase()) {
         case "omit":
             return (attr) => attr.value !== null;
@@ -4937,13 +4713,13 @@ function reportMessage$1(attr, style) {
     return "";
 }
 
-const defaults$q = {
+const defaults$p = {
     style: "omit",
 };
 class AttributeEmptyStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$q, ...options });
-        this.hasInvalidStyle = parseStyle$2(this.options.style);
+        super({ ...defaults$p, ...options });
+        this.hasInvalidStyle = parseStyle$1(this.options.style);
     }
     static schema() {
         return {
@@ -5001,7 +4777,7 @@ function isEmptyValue(attr) {
     }
     return attr.value === null || attr.value === "";
 }
-function parseStyle$2(style) {
+function parseStyle$1(style) {
     switch (style.toLowerCase()) {
         case "omit":
             return (attr) => attr.value !== null;
@@ -5098,12 +4874,12 @@ function describePattern(pattern) {
     }
 }
 
-const defaults$p = {
+const defaults$o = {
     pattern: "kebabcase",
 };
 class ClassPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$p, ...options });
+        super({ ...defaults$o, ...options });
         this.pattern = parsePattern(this.options.pattern);
     }
     static schema() {
@@ -5212,13 +4988,13 @@ class CloseOrder extends Rule {
     }
 }
 
-const defaults$o = {
+const defaults$n = {
     include: null,
     exclude: null,
 };
 class Deprecated extends Rule {
     constructor(options) {
-        super({ ...defaults$o, ...options });
+        super({ ...defaults$n, ...options });
     }
     static schema() {
         return {
@@ -5381,12 +5157,12 @@ let NoStyleTag$1 = class NoStyleTag extends Rule {
     }
 };
 
-const defaults$n = {
+const defaults$m = {
     style: "uppercase",
 };
 class DoctypeStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$n, ...options });
+        super({ ...defaults$m, ...options });
     }
     static schema() {
         return {
@@ -5418,12 +5194,12 @@ class DoctypeStyle extends Rule {
     }
 }
 
-const defaults$m = {
+const defaults$l = {
     style: "lowercase",
 };
 class ElementCase extends Rule {
     constructor(options) {
-        super({ ...defaults$m, ...options });
+        super({ ...defaults$l, ...options });
         this.style = new CaseStyle(this.options.style, "element-case");
     }
     static schema() {
@@ -5489,14 +5265,14 @@ class ElementCase extends Rule {
     }
 }
 
-const defaults$l = {
+const defaults$k = {
     pattern: "^[a-z][a-z0-9\\-._]*-[a-z0-9\\-._]*$",
     whitelist: [],
     blacklist: [],
 };
 class ElementName extends Rule {
     constructor(options) {
-        super({ ...defaults$l, ...options });
+        super({ ...defaults$k, ...options });
         /* eslint-disable-next-line security/detect-non-literal-regexp -- expected to be a regexp */
         this.pattern = new RegExp(this.options.pattern);
     }
@@ -5537,7 +5313,7 @@ class ElementName extends Rule {
                 ...context.blacklist.map((cur) => `- ${cur}`),
             ];
         }
-        if (context.pattern !== defaults$l.pattern) {
+        if (context.pattern !== defaults$k.pattern) {
             return [
                 `<${context.tagName}> is not a valid element name. This project is configured to only allow names matching the following regular expression:`,
                 "",
@@ -6081,7 +5857,7 @@ class EmptyTitle extends Rule {
     }
 }
 
-const defaults$k = {
+const defaults$j = {
     allowArrayBrackets: true,
     shared: ["radio", "button", "reset", "submit"],
 };
@@ -6114,7 +5890,7 @@ function getDocumentation(context) {
 }
 class FormDupName extends Rule {
     constructor(options) {
-        super({ ...defaults$k, ...options });
+        super({ ...defaults$j, ...options });
     }
     static schema() {
         return {
@@ -6274,7 +6050,7 @@ class FormDupName extends Rule {
     }
 }
 
-const defaults$j = {
+const defaults$i = {
     allowMultipleH1: false,
     minInitialRank: "h1",
     sectioningRoots: ["dialog", '[role="dialog"]', '[role="alertdialog"]'],
@@ -6305,7 +6081,7 @@ function parseMaxInitial(value) {
 }
 class HeadingLevel extends Rule {
     constructor(options) {
-        super({ ...defaults$j, ...options });
+        super({ ...defaults$i, ...options });
         this.stack = [];
         this.minInitialRank = parseMaxInitial(this.options.minInitialRank);
         this.sectionRoots = this.options.sectioningRoots.map((it) => new Pattern(it));
@@ -6463,12 +6239,12 @@ class HeadingLevel extends Rule {
     }
 }
 
-const defaults$i = {
+const defaults$h = {
     pattern: "kebabcase",
 };
 class IdPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$i, ...options });
+        super({ ...defaults$h, ...options });
         this.pattern = parsePattern(this.options.pattern);
     }
     static schema() {
@@ -6750,12 +6526,12 @@ function findLabelByParent(el) {
     return [];
 }
 
-const defaults$h = {
+const defaults$g = {
     maxlength: 70,
 };
 class LongTitle extends Rule {
     constructor(options) {
-        super({ ...defaults$h, ...options });
+        super({ ...defaults$g, ...options });
         this.maxlength = this.options.maxlength;
     }
     static schema() {
@@ -6981,13 +6757,13 @@ class MultipleLabeledControls extends Rule {
     }
 }
 
-const defaults$g = {
+const defaults$f = {
     include: null,
     exclude: null,
 };
 class NoAutoplay extends Rule {
     constructor(options) {
-        super({ ...defaults$g, ...options });
+        super({ ...defaults$f, ...options });
     }
     documentation(context) {
         const tagName = context ? ` on <${context.tagName}>` : "";
@@ -7228,14 +7004,14 @@ Omitted end tags can be ambigious for humans to read and many editors have troub
     }
 }
 
-const defaults$f = {
+const defaults$e = {
     include: null,
     exclude: null,
     allowedProperties: ["display"],
 };
 class NoInlineStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$f, ...options });
+        super({ ...defaults$e, ...options });
     }
     static schema() {
         return {
@@ -7437,7 +7213,7 @@ class NoMultipleMain extends Rule {
     }
 }
 
-const defaults$e = {
+const defaults$d = {
     relaxed: false,
 };
 const textRegexp = /([<>]|&(?![a-zA-Z0-9#]+;))/g;
@@ -7454,7 +7230,7 @@ const replacementTable = {
 };
 class NoRawCharacters extends Rule {
     constructor(options) {
-        super({ ...defaults$e, ...options });
+        super({ ...defaults$d, ...options });
         this.relaxed = this.options.relaxed;
     }
     static schema() {
@@ -7632,13 +7408,13 @@ class NoRedundantRole extends Rule {
 }
 
 const xmlns = /^(.+):.+$/;
-const defaults$d = {
+const defaults$c = {
     ignoreForeign: true,
     ignoreXML: true,
 };
 class NoSelfClosing extends Rule {
     constructor(options) {
-        super({ ...defaults$d, ...options });
+        super({ ...defaults$c, ...options });
     }
     static schema() {
         return {
@@ -7727,13 +7503,13 @@ class NoTrailingWhitespace extends Rule {
     }
 }
 
-const defaults$c = {
+const defaults$b = {
     include: null,
     exclude: null,
 };
 class NoUnknownElements extends Rule {
     constructor(options) {
-        super({ ...defaults$c, ...options });
+        super({ ...defaults$b, ...options });
     }
     static schema() {
         return {
@@ -7845,13 +7621,13 @@ const replacement = {
     reset: '<button type="reset">',
     image: '<button type="button">',
 };
-const defaults$b = {
+const defaults$a = {
     include: null,
     exclude: null,
 };
 class PreferButton extends Rule {
     constructor(options) {
-        super({ ...defaults$b, ...options });
+        super({ ...defaults$a, ...options });
     }
     static schema() {
         return {
@@ -7926,7 +7702,7 @@ class PreferButton extends Rule {
     }
 }
 
-const defaults$a = {
+const defaults$9 = {
     mapping: {
         article: "article",
         banner: "header",
@@ -7956,7 +7732,7 @@ const defaults$a = {
 };
 class PreferNativeElement extends Rule {
     constructor(options) {
-        super({ ...defaults$a, ...options });
+        super({ ...defaults$9, ...options });
     }
     static schema() {
         return {
@@ -8076,12 +7852,12 @@ class PreferTbody extends Rule {
     }
 }
 
-const defaults$9 = {
+const defaults$8 = {
     tags: ["script", "style"],
 };
 class RequireCSPNonce extends Rule {
     constructor(options) {
-        super({ ...defaults$9, ...options });
+        super({ ...defaults$8, ...options });
     }
     static schema() {
         return {
@@ -8132,7 +7908,7 @@ class RequireCSPNonce extends Rule {
     }
 }
 
-const defaults$8 = {
+const defaults$7 = {
     target: "all",
     include: null,
     exclude: null,
@@ -8144,7 +7920,7 @@ const supportSri = {
 };
 class RequireSri extends Rule {
     constructor(options) {
-        super({ ...defaults$8, ...options });
+        super({ ...defaults$7, ...options });
         this.target = this.options.target;
     }
     static schema() {
@@ -8306,7 +8082,7 @@ class SvgFocusable extends Rule {
     }
 }
 
-const defaults$7 = {
+const defaults$6 = {
     characters: [
         { pattern: " ", replacement: "&nbsp;", description: "non-breaking space" },
         { pattern: "-", replacement: "&#8209;", description: "non-breaking hyphen" },
@@ -8345,7 +8121,7 @@ function matchAll(text, regexp) {
 }
 class TelNonBreaking extends Rule {
     constructor(options) {
-        super({ ...defaults$7, ...options });
+        super({ ...defaults$6, ...options });
         this.regex = constructRegex(this.options.characters);
     }
     static schema() {
@@ -8633,7 +8409,7 @@ class TextContent extends Rule {
     }
 }
 
-const defaults$6 = {
+const defaults$5 = {
     ignoreCase: false,
     requireSemicolon: true,
 };
@@ -8675,7 +8451,7 @@ function getDescription(context, options) {
 }
 class UnknownCharReference extends Rule {
     constructor(options) {
-        super({ ...defaults$6, ...options });
+        super({ ...defaults$5, ...options });
     }
     static schema() {
         return {
@@ -8792,12 +8568,12 @@ var RuleContext;
     RuleContext[RuleContext["LEADING_CHARACTER"] = 3] = "LEADING_CHARACTER";
     RuleContext[RuleContext["DISALLOWED_CHARACTER"] = 4] = "DISALLOWED_CHARACTER";
 })(RuleContext || (RuleContext = {}));
-const defaults$5 = {
+const defaults$4 = {
     relaxed: false,
 };
 class ValidID extends Rule {
     constructor(options) {
-        super({ ...defaults$5, ...options });
+        super({ ...defaults$4, ...options });
     }
     static schema() {
         return {
@@ -8874,119 +8650,39 @@ class ValidID extends Rule {
     }
 }
 
-var Style$1;
+class VoidContent extends Rule {
+    documentation(tagName) {
+        const doc = {
+            description: "HTML void elements cannot have any content and must not have content or end tag.",
+            url: "https://html-validate.org/rules/void-content.html",
+        };
+        if (tagName) {
+            doc.description = `<${tagName}> is a void element and must not have content or end tag.`;
+        }
+        return doc;
+    }
+    setup() {
+        this.on("tag:end", (event) => {
+            const node = event.target; // The current element being closed.
+            if (!node) {
+                return;
+            }
+            if (!node.voidElement) {
+                return;
+            }
+            if (node.closed === NodeClosed.EndTag) {
+                this.report(null, `End tag for <${node.tagName}> must be omitted`, node.location, node.tagName);
+            }
+        });
+    }
+}
+
+var Style;
 (function (Style) {
-    Style[Style["Any"] = 0] = "Any";
     Style[Style["AlwaysOmit"] = 1] = "AlwaysOmit";
     Style[Style["AlwaysSelfclose"] = 2] = "AlwaysSelfclose";
-})(Style$1 || (Style$1 = {}));
-const defaults$4 = {
-    style: "omit",
-};
-class Void extends Rule {
-    get deprecated() {
-        return true;
-    }
-    static schema() {
-        return {
-            style: {
-                enum: ["any", "omit", "selfclose", "selfclosing"],
-                type: "string",
-            },
-        };
-    }
-    documentation() {
-        return {
-            description: "HTML void elements cannot have any content and must not have an end tag.",
-            url: "https://html-validate.org/rules/void.html",
-        };
-    }
-    constructor(options) {
-        super({ ...defaults$4, ...options });
-        this.style = parseStyle$1(this.options.style);
-    }
-    setup() {
-        this.on("tag:end", (event) => {
-            const current = event.target; // The current element being closed
-            const active = event.previous; // The current active element (that is, the current element on the stack)
-            if (current && current.meta) {
-                this.validateCurrent(current);
-            }
-            if (active && active.meta) {
-                this.validateActive(active, active.meta);
-            }
-        });
-    }
-    validateCurrent(node) {
-        if (node.voidElement && node.closed === NodeClosed.EndTag) {
-            this.report(null, `End tag for <${node.tagName}> must be omitted`, node.location);
-        }
-    }
-    validateActive(node, meta) {
-        /* ignore foreign elements, they may or may not be self-closed and both are
-         * valid */
-        if (meta.foreign) {
-            return;
-        }
-        const selfOrOmitted = node.closed === NodeClosed.VoidOmitted || node.closed === NodeClosed.VoidSelfClosed;
-        if (node.voidElement) {
-            if (this.style === Style$1.AlwaysOmit && node.closed === NodeClosed.VoidSelfClosed) {
-                this.report(node, `Expected omitted end tag <${node.tagName}> instead of self-closing element <${node.tagName}/>`);
-            }
-            if (this.style === Style$1.AlwaysSelfclose && node.closed === NodeClosed.VoidOmitted) {
-                this.report(node, `Expected self-closing element <${node.tagName}/> instead of omitted end-tag <${node.tagName}>`);
-            }
-        }
-        if (selfOrOmitted && node.voidElement === false) {
-            this.report(node, `End tag for <${node.tagName}> must not be omitted`);
-        }
-    }
-}
-function parseStyle$1(name) {
-    switch (name) {
-        case "any":
-            return Style$1.Any;
-        case "omit":
-            return Style$1.AlwaysOmit;
-        case "selfclose":
-        case "selfclosing":
-            return Style$1.AlwaysSelfclose;
-    }
-}
-
-class VoidContent extends Rule {
-    documentation(tagName) {
-        const doc = {
-            description: "HTML void elements cannot have any content and must not have content or end tag.",
-            url: "https://html-validate.org/rules/void-content.html",
-        };
-        if (tagName) {
-            doc.description = `<${tagName}> is a void element and must not have content or end tag.`;
-        }
-        return doc;
-    }
-    setup() {
-        this.on("tag:end", (event) => {
-            const node = event.target; // The current element being closed.
-            if (!node) {
-                return;
-            }
-            if (!node.voidElement) {
-                return;
-            }
-            if (node.closed === NodeClosed.EndTag) {
-                this.report(null, `End tag for <${node.tagName}> must be omitted`, node.location, node.tagName);
-            }
-        });
-    }
-}
-
-var Style;
-(function (Style) {
-    Style[Style["AlwaysOmit"] = 1] = "AlwaysOmit";
-    Style[Style["AlwaysSelfclose"] = 2] = "AlwaysSelfclose";
-})(Style || (Style = {}));
-const defaults$3 = {
+})(Style || (Style = {}));
+const defaults$3 = {
     style: "omit",
 };
 class VoidStyle extends Rule {
@@ -9455,7 +9151,6 @@ const bundledRules = {
     "text-content": TextContent,
     "unrecognized-char-ref": UnknownCharReference,
     "valid-id": ValidID,
-    void: Void,
     "void-content": VoidContent,
     "void-style": VoidStyle,
     ...WCAG,
@@ -9748,7 +9443,112 @@ class ResolvedConfig {
     }
 }
 
-let rootDirCache = null;
+function haveResolver(key, value) {
+    return key in value;
+}
+function haveConfigResolver(value) {
+    return haveResolver("resolveConfig", value);
+}
+function haveElementsResolver(value) {
+    return haveResolver("resolveElements", value);
+}
+function havePluginResolver(value) {
+    return haveResolver("resolvePlugin", value);
+}
+function haveTransformerResolver(value) {
+    return haveResolver("resolveTransformer", value);
+}
+/**
+ * @internal
+ */
+function resolveConfig(resolvers, id, options) {
+    for (const resolver of resolvers.filter(haveConfigResolver)) {
+        const config = resolver.resolveConfig(id, options);
+        if (config) {
+            return config;
+        }
+    }
+    throw new UserError(`Failed to load configuration from "${id}"`);
+}
+/**
+ * @internal
+ */
+function resolveElements(resolvers, id, options) {
+    for (const resolver of resolvers.filter(haveElementsResolver)) {
+        const elements = resolver.resolveElements(id, options);
+        if (elements) {
+            return elements;
+        }
+    }
+    throw new UserError(`Failed to load elements from "${id}"`);
+}
+/**
+ * @internal
+ */
+function resolvePlugin(resolvers, id, options) {
+    for (const resolver of resolvers.filter(havePluginResolver)) {
+        const plugin = resolver.resolvePlugin(id, options);
+        if (plugin) {
+            return plugin;
+        }
+    }
+    throw new UserError(`Failed to load plugin from "${id}"`);
+}
+/**
+ * @internal
+ */
+function resolveTransformer(resolvers, id, options) {
+    for (const resolver of resolvers.filter(haveTransformerResolver)) {
+        const transformer = resolver.resolveTransformer(id, options);
+        if (transformer) {
+            return transformer;
+        }
+    }
+    throw new UserError(`Failed to load transformer from "${id}"`);
+}
+
+/**
+ * Create a new resolver for static content, i.e. plugins or transformers known
+ * at compile time.
+ *
+ * @public
+ * @since 8.0.0
+ */
+function staticResolver(map = {}) {
+    const { elements = {}, configs = {}, plugins = {}, transformers = {} } = map;
+    return {
+        name: "static-qresolver",
+        addElements(id, value) {
+            elements[id] = value;
+        },
+        addConfig(id, value) {
+            configs[id] = value;
+        },
+        addPlugin(id, value) {
+            plugins[id] = value;
+        },
+        addTransformer(id, value) {
+            transformers[id] = value;
+        },
+        resolveElements(id) {
+            var _a;
+            return (_a = elements[id]) !== null && _a !== void 0 ? _a : null;
+        },
+        resolveConfig(id) {
+            var _a;
+            return (_a = configs[id]) !== null && _a !== void 0 ? _a : null;
+        },
+        resolvePlugin(id) {
+            var _a;
+            return (_a = plugins[id]) !== null && _a !== void 0 ? _a : null;
+        },
+        resolveTransformer(id) {
+            var _a;
+            return (_a = transformers[id]) !== null && _a !== void 0 ? _a : null;
+        },
+    };
+}
+
 const ajv = new Ajv({ strict: true, strictTuples: true, strictTypes: true });
 ajv.addMetaSchema(ajvSchemaDraft);
 const validator = ajv.compile(configurationSchema);
@@ -9771,30 +9571,13 @@ function mergeInternal(base, rhs) {
     }
     return dst;
 }
-/**
- * @internal
- */
-function configDataFromFile(filename) {
-    let json;
-    try {
-        /* load using require as it can process both js and json */
-        /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- technical debt, should be refactored into something more typesafe */
-        json = requireUncached(legacyRequire, filename);
-    }
-    catch (err) {
-        throw new ConfigError(`Failed to read configuration from "${filename}"`, ensureError(err));
-    }
-    /* expand any relative paths */
-    for (const key of ["extends", "elements", "plugins"]) {
-        /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- technical debt, should be refactored into something more typesafe */
-        const value = json[key];
-        if (!value)
-            continue;
-        json[key] = value.map((ref) => {
-            return Config.expandRelative(ref, path.dirname(filename));
-        });
+function toArray(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    else {
+        return [value];
     }
-    return json;
 }
 /**
  * Configuration holder.
@@ -9808,7 +9591,7 @@ class Config {
      * Create a new blank configuration. See also `Config.defaultConfig()`.
      */
     static empty() {
-        return new Config({
+        return new Config([], {
             extends: [],
             rules: {},
             plugins: [],
@@ -9818,9 +9601,9 @@ class Config {
     /**
      * Create configuration from object.
      */
-    static fromObject(options, filename = null) {
+    static fromObject(resolvers, options, filename = null) {
         Config.validate(options, filename);
-        return new Config(options);
+        return new Config(resolvers, options);
     }
     /**
      * Read configuration from filename.
@@ -9831,9 +9614,9 @@ class Config {
      * @internal
      * @param filename - The file to read from
      */
-    static fromFile(filename) {
-        const configdata = configDataFromFile(filename);
-        return Config.fromObject(configdata, filename);
+    static fromFile(resolvers, filename) {
+        const configData = resolveConfig(toArray(resolvers), filename, { cache: false });
+        return Config.fromObject(resolvers, configData, filename);
     }
     /**
      * Validate configuration data.
@@ -9863,12 +9646,12 @@ class Config {
      * Load a default configuration object.
      */
     static defaultConfig() {
-        return new Config(defaultConfig);
+        return new Config([], defaultConfig);
     }
     /**
      * @internal
      */
-    constructor(options) {
+    constructor(resolvers, options) {
         var _a;
         this.transformers = [];
         const initial = {
@@ -9877,10 +9660,10 @@ class Config {
             rules: {},
             transform: {},
         };
-        this.config = mergeInternal(initial, options || {});
+        this.config = mergeInternal(initial, options);
         this.metaTable = null;
-        this.rootDir = this.findRootDir();
         this.initialized = false;
+        this.resolvers = toArray(resolvers);
         /* load plugins */
         this.plugins = this.loadPlugins(this.config.plugins || []);
         this.configurations = this.loadConfigurations(this.plugins);
@@ -9926,8 +9709,8 @@ class Config {
      * @public
      * @param rhs - Configuration to merge with this one.
      */
-    merge(rhs) {
-        return new Config(mergeInternal(this.config, rhs.config));
+    merge(resolvers, rhs) {
+        return new Config(resolvers, mergeInternal(this.config, rhs.config));
     }
     extendConfig(entries) {
         if (entries.length === 0) {
@@ -9941,7 +9724,7 @@ class Config {
                 extended = this.configurations.get(entry);
             }
             else {
-                extended = Config.fromFile(entry).config;
+                extended = Config.fromFile(this.resolvers, entry).config;
             }
             base = mergeInternal(base, extended);
         }
@@ -9978,30 +9761,20 @@ class Config {
                 metaTable.loadFromObject(bundled);
                 continue;
             }
-            /* assume it is loadable with require() */
-            const id = entry.replace("<rootDir>", this.rootDir);
+            /* load with resolver */
             try {
-                const data = legacyRequire(id);
-                metaTable.loadFromObject(data, id);
+                const data = resolveElements(this.resolvers, entry, { cache: false });
+                metaTable.loadFromObject(data, entry);
             }
             catch (err) {
                 /* istanbul ignore next: only used as a fallback */
                 const message = err instanceof Error ? err.message : String(err);
-                throw new ConfigError(`Failed to load elements from "${id}": ${message}`, ensureError(err));
+                throw new ConfigError(`Failed to load elements from "${entry}": ${message}`, ensureError(err));
             }
         }
         metaTable.init();
         return (this.metaTable = metaTable);
     }
-    /**
-     * @internal exposed for testing only
-     */
-    static expandRelative(src, currentPath) {
-        if (src[0] === ".") {
-            return path.normalize(`${currentPath}/${src}`);
-        }
-        return src;
-    }
     /**
      * Get a copy of internal configuration data.
      *
@@ -10053,7 +9826,7 @@ class Config {
                 return plugin;
             }
             try {
-                const plugin = legacyRequire(moduleName.replace("<rootDir>", this.rootDir));
+                const plugin = resolvePlugin(this.resolvers, moduleName, { cache: true });
                 plugin.name = plugin.name || moduleName;
                 plugin.originalName = moduleName;
                 return plugin;
@@ -10226,57 +9999,7 @@ class Config {
         return plugin.transformer;
     }
     getTransformerFromModule(name) {
-        /* expand <rootDir> */
-        const moduleName = name.replace("<rootDir>", this.rootDir);
-        /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- technical debt, the code kinda does the right thing but it should be reflected in the typing too */
-        const fn = legacyRequire(moduleName);
-        /* sanity check */
-        if (typeof fn !== "function") {
-            /* this is not a proper transformer, is it a plugin exposing a transformer? */
-            if (fn.transformer) {
-                throw new ConfigError(`Module is not a valid transformer. This looks like a plugin, did you forget to load the plugin first?`);
-            }
-            throw new ConfigError(`Module is not a valid transformer.`);
-        }
-        return fn;
-    }
-    /**
-     * @internal
-     */
-    get rootDirCache() {
-        /* return global instance */
-        return rootDirCache;
-    }
-    set rootDirCache(value) {
-        /* set global instance */
-        rootDirCache = value;
-    }
-    /**
-     * @internal
-     */
-    findRootDir() {
-        const cache = this.rootDirCache;
-        if (cache !== null) {
-            return cache;
-        }
-        /* try to locate package.json */
-        let current = process.cwd();
-        // eslint-disable-next-line no-constant-condition -- break outs when filesystem is traversed
-        while (true) {
-            const search = path.join(current, "package.json");
-            if (fs.existsSync(search)) {
-                return (this.rootDirCache = current);
-            }
-            /* get the parent directory */
-            const child = current;
-            current = path.dirname(current);
-            /* stop if this is the root directory */
-            if (current === child) {
-                break;
-            }
-        }
-        /* default to working directory if no package.json is found */
-        return (this.rootDirCache = process.cwd());
+        return resolveTransformer(this.resolvers, name, { cache: true });
     }
 }
 
@@ -10289,19 +10012,25 @@ class Config {
  * @public
  */
 class ConfigLoader {
-    constructor(config, configFactory = Config) {
-        const defaults = configFactory.empty();
-        this.configFactory = configFactory;
-        this.globalConfig = defaults.merge(config ? this.loadFromObject(config) : this.defaultConfig());
+    constructor(resolvers, config) {
+        const defaults = Config.empty();
+        this.resolvers = resolvers;
+        this.globalConfig = defaults.merge(this.resolvers, config ? this.loadFromObject(config) : this.defaultConfig());
+    }
+    /**
+     * @internal For testing only
+     */
+    _getGlobalConfig() {
+        return this.globalConfig.get();
     }
     empty() {
-        return this.configFactory.empty();
+        return Config.empty();
     }
     loadFromObject(options, filename) {
-        return this.configFactory.fromObject(options, filename);
+        return Config.fromObject(this.resolvers, options, filename);
     }
     loadFromFile(filename) {
-        return this.configFactory.fromFile(filename);
+        return Config.fromFile(this.resolvers, filename);
     }
 }
 
@@ -11289,7 +11018,7 @@ class Engine {
     /**
      * Get rule documentation.
      */
-    getRuleDocumentation(ruleId, context) {
+    getRuleDocumentation({ ruleId, context, }) {
         const rules = this.config.getRules();
         const ruleData = rules.get(ruleId);
         if (ruleData) {
@@ -11526,6 +11255,10 @@ class Engine {
     }
 }
 
+const defaultResolvers$1 = [];
+function hasResolver$1(value) {
+    return Array.isArray(value[0]);
+}
 /**
  * The static configuration loader does not do any per-handle lookup. Only the
  * global or per-call configuration is used.
@@ -11536,13 +11269,23 @@ class Engine {
  * @public
  */
 class StaticConfigLoader extends ConfigLoader {
+    constructor(...args) {
+        if (hasResolver$1(args)) {
+            const [resolvers, config] = args;
+            super(resolvers, config);
+        }
+        else {
+            const [config] = args;
+            super(defaultResolvers$1, config);
+        }
+    }
     getConfigFor(_handle, configOverride) {
         const override = this.loadFromObject(configOverride || {});
         if (override.isRootFound()) {
             override.init();
             return override.resolve();
         }
-        const merged = this.globalConfig.merge(override);
+        const merged = this.globalConfig.merge(this.resolvers, override);
         merged.init();
         return merged.resolve();
     }
@@ -11595,6 +11338,33 @@ class HtmlValidate {
         };
         return this.validateSource(source, options);
     }
+    validateStringSync(str, arg1, arg2, arg3) {
+        const filename = typeof arg1 === "string" ? arg1 : "inline";
+        const options = isConfigData(arg1) ? arg1 : isConfigData(arg2) ? arg2 : undefined;
+        const hooks = isSourceHooks(arg1) ? arg1 : isSourceHooks(arg2) ? arg2 : arg3;
+        const source = {
+            data: str,
+            filename,
+            line: 1,
+            column: 1,
+            offset: 0,
+            hooks,
+        };
+        return this.validateSourceSync(source, options);
+    }
+    /**
+     * Parse and validate HTML from [[Source]].
+     *
+     * @public
+     * @param input - Source to parse.
+     * @returns Report output.
+     */
+    async validateSource(input, configOverride) {
+        const config = await this.getConfigFor(input.filename, configOverride);
+        const source = config.transformSource(input);
+        const engine = new Engine(config, Parser);
+        return engine.lint(source);
+    }
     /**
      * Parse and validate HTML from [[Source]].
      *
@@ -11602,8 +11372,8 @@ class HtmlValidate {
      * @param input - Source to parse.
      * @returns Report output.
      */
-    validateSource(input, configOverride) {
-        const config = this.getConfigFor(input.filename, configOverride);
+    validateSourceSync(input, configOverride) {
+        const config = this.getConfigForSync(input.filename, configOverride);
         const source = config.transformSource(input);
         const engine = new Engine(config, Parser);
         return engine.lint(source);
@@ -11615,8 +11385,21 @@ class HtmlValidate {
      * @param filename - Filename to read and parse.
      * @returns Report output.
      */
-    validateFile(filename) {
-        const config = this.getConfigFor(filename);
+    async validateFile(filename) {
+        const config = await this.getConfigFor(filename);
+        const source = config.transformFilename(filename);
+        const engine = new Engine(config, Parser);
+        return Promise.resolve(engine.lint(source));
+    }
+    /**
+     * Parse and validate HTML from file.
+     *
+     * @public
+     * @param filename - Filename to read and parse.
+     * @returns Report output.
+     */
+    validateFileSync(filename) {
+        const config = this.getConfigForSync(filename);
         const source = config.transformFilename(filename);
         const engine = new Engine(config, Parser);
         return engine.lint(source);
@@ -11628,8 +11411,38 @@ class HtmlValidate {
      * @param filenames - Filenames to read and parse.
      * @returns Report output.
      */
-    validateMultipleFiles(filenames) {
-        return Reporter.merge(filenames.map((filename) => this.validateFile(filename)));
+    async validateMultipleFiles(filenames) {
+        const report = Reporter.merge(filenames.map((filename) => this.validateFileSync(filename)));
+        return Promise.resolve(report);
+    }
+    /**
+     * Parse and validate HTML from multiple files. Result is merged together to a
+     * single report.
+     *
+     * @param filenames - Filenames to read and parse.
+     * @returns Report output.
+     */
+    validateMultipleFilesSync(filenames) {
+        return Reporter.merge(filenames.map((filename) => this.validateFileSync(filename)));
+    }
+    /**
+     * Returns true if the given filename can be validated.
+     *
+     * A file is considered to be validatable if the extension is `.html` or if a
+     * transformer matches the filename.
+     *
+     * This is mostly useful for tooling to determine whenever to validate the
+     * file or not. CLI tools will run on all the given files anyway.
+     */
+    async canValidate(filename) {
+        /* .html is always supported */
+        const extension = path.extname(filename).toLowerCase();
+        if (extension === ".html") {
+            return true;
+        }
+        /* test if there is a matching transformer */
+        const config = await this.getConfigFor(filename);
+        return config.canTransform(filename);
     }
     /**
      * Returns true if the given filename can be validated.
@@ -11640,14 +11453,14 @@ class HtmlValidate {
      * This is mostly useful for tooling to determine whenever to validate the
      * file or not. CLI tools will run on all the given files anyway.
      */
-    canValidate(filename) {
+    canValidateSync(filename) {
         /* .html is always supported */
         const extension = path.extname(filename).toLowerCase();
         if (extension === ".html") {
             return true;
         }
         /* test if there is a matching transformer */
-        const config = this.getConfigFor(filename);
+        const config = this.getConfigForSync(filename);
         return config.canTransform(filename);
     }
     /**
@@ -11660,7 +11473,7 @@ class HtmlValidate {
      * @param filename - Filename to tokenize.
      */
     dumpTokens(filename) {
-        const config = this.getConfigFor(filename);
+        const config = this.getConfigForSync(filename);
         const source = config.transformFilename(filename);
         const engine = new Engine(config, Parser);
         return engine.dumpTokens(source);
@@ -11675,7 +11488,7 @@ class HtmlValidate {
      * @param filename - Filename to dump events from.
      */
     dumpEvents(filename) {
-        const config = this.getConfigFor(filename);
+        const config = this.getConfigForSync(filename);
         const source = config.transformFilename(filename);
         const engine = new Engine(config, Parser);
         return engine.dumpEvents(source);
@@ -11690,7 +11503,7 @@ class HtmlValidate {
      * @param filename - Filename to dump DOM tree from.
      */
     dumpTree(filename) {
-        const config = this.getConfigFor(filename);
+        const config = this.getConfigForSync(filename);
         const source = config.transformFilename(filename);
         const engine = new Engine(config, Parser);
         return engine.dumpTree(source);
@@ -11705,7 +11518,7 @@ class HtmlValidate {
      * @param filename - Filename to dump source from.
      */
     dumpSource(filename) {
-        const config = this.getConfigFor(filename);
+        const config = this.getConfigForSync(filename);
         const sources = config.transformFilename(filename);
         return sources.reduce((result, source) => {
             result.push(`Source ${source.filename}@${source.line}:${source.column} (offset: ${source.offset})`);
@@ -11741,37 +11554,95 @@ class HtmlValidate {
      * handled by html-validate but the path will be used when resolving
      * configuration. As a rule-of-thumb, set it to the elements json file.
      */
-    getElementsSchema(filename) {
-        const config = this.getConfigFor(filename !== null && filename !== void 0 ? filename : "inline");
+    async getElementsSchema(filename) {
+        const config = await this.getConfigFor(filename !== null && filename !== void 0 ? filename : "inline");
         const metaTable = config.getMetaTable();
         return metaTable.getJSONSchema();
     }
+    /**
+     * Get effective metadata element schema.
+     *
+     * If a filename is given the configured plugins can extend the
+     * schema. Filename must not be an existing file or a filetype normally
+     * handled by html-validate but the path will be used when resolving
+     * configuration. As a rule-of-thumb, set it to the elements json file.
+     */
+    getElementsSchemaSync(filename) {
+        const config = this.getConfigForSync(filename !== null && filename !== void 0 ? filename : "inline");
+        const metaTable = config.getMetaTable();
+        return metaTable.getJSONSchema();
+    }
+    async getContextualDocumentation(message, filenameOrConfig = "inline") {
+        const config = typeof filenameOrConfig === "string"
+            ? await this.getConfigFor(filenameOrConfig)
+            : await filenameOrConfig;
+        const engine = new Engine(config, Parser);
+        return engine.getRuleDocumentation(message);
+    }
+    getContextualDocumentationSync(message, filenameOrConfig = "inline") {
+        const config = typeof filenameOrConfig === "string"
+            ? this.getConfigForSync(filenameOrConfig)
+            : filenameOrConfig;
+        const engine = new Engine(config, Parser);
+        return engine.getRuleDocumentation(message);
+    }
     /**
      * Get contextual documentation for the given rule.
      *
      * Typical usage:
      *
      * ```js
-     * const report = htmlvalidate.validateFile("my-file.html");
+     * const report = await htmlvalidate.validateFile("my-file.html");
      * for (const result of report.results){
-     *   const config = htmlvalidate.getConfigFor(result.filePath);
+     *   const config = await htmlvalidate.getConfigFor(result.filePath);
      *   for (const message of result.messages){
-     *     const documentation = htmlvalidate.getRuleDocumentation(message.ruleId, config, message.context);
+     *     const documentation = await htmlvalidate.getRuleDocumentation(message.ruleId, config, message.context);
      *     // do something with documentation
      *   }
      * }
      * ```
      *
+     * @public
+     * @deprecated Deprecated since 8.0.0, use [[getContextualDocumentation]] instead.
      * @param ruleId - Rule to get documentation for.
      * @param config - If set it provides more accurate description by using the
      * correct configuration for the file.
      * @param context - If set to `Message.context` some rules can provide
      * contextual details and suggestions.
      */
-    getRuleDocumentation(ruleId, config = null, context = null) {
+    async getRuleDocumentation(ruleId, config = null, context = null) {
         const c = config || this.getConfigFor("inline");
+        const engine = new Engine(await c, Parser);
+        return engine.getRuleDocumentation({ ruleId, context });
+    }
+    /**
+     * Get contextual documentation for the given rule.
+     *
+     * Typical usage:
+     *
+     * ```js
+     * const report = htmlvalidate.validateFileSync("my-file.html");
+     * for (const result of report.results){
+     *   const config = htmlvalidate.getConfigForSync(result.filePath);
+     *   for (const message of result.messages){
+     *     const documentation = htmlvalidate.getRuleDocumentationSync(message.ruleId, config, message.context);
+     *     // do something with documentation
+     *   }
+     * }
+     * ```
+     *
+     * @public
+     * @deprecated Deprecated since 8.0.0, use [[getContextualDocumentationSync]] instead.
+     * @param ruleId - Rule to get documentation for.
+     * @param config - If set it provides more accurate description by using the
+     * correct configuration for the file.
+     * @param context - If set to `Message.context` some rules can provide
+     * contextual details and suggestions.
+     */
+    getRuleDocumentationSync(ruleId, config = null, context = null) {
+        const c = config || this.getConfigForSync("inline");
         const engine = new Engine(c, Parser);
-        return engine.getRuleDocumentation(ruleId, context);
+        return engine.getRuleDocumentation({ ruleId, context });
     }
     /**
      * Create a parser configured for given filename.
@@ -11779,8 +11650,8 @@ class HtmlValidate {
      * @internal
      * @param source - Source to use.
      */
-    getParserFor(source) {
-        const config = this.getConfigFor(source.filename);
+    async getParserFor(source) {
+        const config = await this.getConfigFor(source.filename);
         return new Parser(config);
     }
     /**
@@ -11794,11 +11665,19 @@ class HtmlValidate {
      */
     getConfigFor(filename, configOverride) {
         const config = this.configLoader.getConfigFor(filename, configOverride);
-        /* for backwards compatibility only */
-        if (config instanceof Config) {
-            return config.resolve();
-        }
-        return config;
+        return Promise.resolve(config);
+    }
+    /**
+     * Get configuration for given filename.
+     *
+     * See [[FileSystemConfigLoader]] for details.
+     *
+     * @public
+     * @param filename - Filename to get configuration for.
+     * @param configOverride - Configuration to apply last.
+     */
+    getConfigForSync(filename, configOverride) {
+        return this.configLoader.getConfigFor(filename, configOverride);
     }
     /**
      * Flush configuration cache. Clears full cache unless a filename is given.
@@ -11817,7 +11696,7 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "7.18.0";
+const version = "8.0.0";
 /** @public */
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
@@ -11843,6 +11722,7 @@ const defaults$1 = {
  * option is used a warning is displayed on the console.
  *
  * @public
+ * @since v5.0.0
  * @param name - Name of plugin
  * @param declared - What library versions the plugin support (e.g. declared peerDependencies)
  * @returns - `true` if version is compatible
@@ -11863,6 +11743,27 @@ function compatibilityCheck(name, declared, options) {
     return false;
 }
 
+/**
+ * Similar to `require(..)` but removes the cached copy first.
+ */
+function requireUncached(require, moduleId) {
+    const filename = require.resolve(moduleId);
+    /* remove references from the parent module to prevent memory leak */
+    const m = require.cache[filename];
+    if (m && m.parent) {
+        const { parent } = m;
+        for (let i = parent.children.length - 1; i >= 0; i--) {
+            if (parent.children[i].id === filename) {
+                parent.children.splice(i, 1);
+            }
+        }
+    }
+    /* remove old module from cache */
+    delete require.cache[filename];
+    /* eslint-disable-next-line import/no-dynamic-require, security/detect-non-literal-require -- as expected but should be moved to upcoming resolver class */
+    return require(filename);
+}
+
 const ruleIds = new Set(Object.keys(rules));
 /**
  * Returns true if given ruleId is an existing builtin rule. It does not handle
@@ -11879,14 +11780,149 @@ function ruleExists(ruleId) {
     return ruleIds.has(ruleId);
 }
 
+const legacyRequire = createRequire(import.meta.url);
+
+let cachedRootDir = null;
+/**
+ * @internal
+ */
+function determineRootDirImpl(intial, fs) {
+    /* try to locate package.json */
+    let current = intial;
+    // eslint-disable-next-line no-constant-condition -- break outs when filesystem is traversed
+    while (true) {
+        const search = path$1.join(current, "package.json");
+        if (fs.existsSync(search)) {
+            return current;
+        }
+        /* get the parent directory */
+        const child = current;
+        current = path$1.dirname(current);
+        /* stop if this is the root directory */
+        if (current === child) {
+            break;
+        }
+    }
+    /* default to working directory if no package.json is found */
+    return intial;
+}
+/**
+ * Try to determine root directory based on the location of the closest
+ * `package.json`. Fallbacks on `process.cwd()` if no package.json was found.
+ *
+ * @internal
+ */
+/* istanbul ignore next: cached version of determineRootDirImpl, no need to test */
+function determineRootDir() {
+    if (cachedRootDir === null) {
+        cachedRootDir = determineRootDirImpl(process.cwd(), fs$1);
+    }
+    return cachedRootDir;
+}
+
+/**
+ * @internal
+ */
+function expandRelativePath(value, { cwd }) {
+    if (typeof value === "string" && value[0] === ".") {
+        return path$1.normalize(path$1.join(cwd, value));
+    }
+    else {
+        return value;
+    }
+}
+
+function isRequireError(error) {
+    return Boolean(error && typeof error === "object" && "code" in error);
+}
+function isTransformer(value) {
+    return typeof value === "function";
+}
+/**
+ * Create a new resolver for NodeJS packages using `require(..)`.
+ *
+ * If the module name contains `<rootDir>` (e.g. `<rootDir/foo`) it will be
+ * expanded relative to the root directory either explicitly set by the
+ * `rootDir` parameter or determined automatically by the closest `package.json`
+ * file (starting at the current working directory).
+ *
+ * @public
+ * @since 8.0.0
+ */
+function nodejsResolver(options = {}) {
+    var _a;
+    const rootDir = (_a = options.rootDir) !== null && _a !== void 0 ? _a : determineRootDir();
+    function internalRequire(id, { cache }) {
+        const moduleName = id.replace("<rootDir>", rootDir);
+        try {
+            /* istanbul ignore else: the tests only runs the cached versions to get
+             * unmodified access to `require`, the implementation of `requireUncached`
+             * is assumed to be tested elsewhere */
+            if (cache) {
+                return legacyRequire(moduleName);
+            }
+            else {
+                return requireUncached(legacyRequire, moduleName);
+            }
+        }
+        catch (err) {
+            if (isRequireError(err) && err.code === "MODULE_NOT_FOUND") {
+                return null;
+            }
+            throw err;
+        }
+    }
+    return {
+        name: "nodejs-resolver",
+        resolveElements(id, options) {
+            return internalRequire(id, options);
+        },
+        resolveConfig(id, options) {
+            var _a, _b, _c;
+            const configData = internalRequire(id, options);
+            if (!configData) {
+                return null;
+            }
+            /* expand any relative paths */
+            const cwd = path$1.dirname(id);
+            const expand = (value) => expandRelativePath(value, { cwd });
+            configData.elements = (_a = configData.elements) === null || _a === void 0 ? void 0 : _a.map(expand);
+            configData.extends = (_b = configData.extends) === null || _b === void 0 ? void 0 : _b.map(expand);
+            configData.plugins = (_c = configData.plugins) === null || _c === void 0 ? void 0 : _c.map(expand);
+            return configData;
+        },
+        resolvePlugin(id, options) {
+            return internalRequire(id, options);
+        },
+        resolveTransformer(id, options) {
+            const mod = internalRequire(id, options);
+            if (!mod) {
+                return null;
+            }
+            if (isTransformer(mod)) {
+                return mod;
+            }
+            /* this is not a proper transformer, is it a plugin exposing a transformer? */
+            if (mod.transformer) {
+                throw new ConfigError(`Module "${id}" is not a valid transformer. This looks like a plugin, did you forget to load the plugin first?`);
+            }
+            throw new ConfigError(`Module "${id}" is not a valid transformer.`);
+        },
+    };
+}
+
 /**
  * @internal
  */
-function findConfigurationFiles(directory) {
+function findConfigurationFiles(fs, directory) {
     return ["json", "cjs", "js"]
-        .map((extension) => path.join(directory, `.htmlvalidate.${extension}`))
+        .map((extension) => path$1.join(directory, `.htmlvalidate.${extension}`))
         .filter((filePath) => fs.existsSync(filePath));
 }
+const defaultResolvers = [nodejsResolver()];
+function hasResolver(value) {
+    return Array.isArray(value[0]);
+}
 /**
  * Loads configuration by traversing filesystem.
  *
@@ -11915,12 +11951,20 @@ function findConfigurationFiles(directory) {
  * @public
  */
 class FileSystemConfigLoader extends ConfigLoader {
-    /**
-     * @param config - Global configuration
-     * @param configFactory - Optional configuration factory
-     */
-    constructor(config, configFactory = Config) {
-        super(config, configFactory);
+    constructor(...args) {
+        var _a, _b;
+        if (hasResolver(args)) {
+            /* istanbul ignore next */
+            const [resolvers, config, options = {}] = args;
+            super(resolvers, config);
+            this.fs = /* istanbul ignore next */ (_a = options.fs) !== null && _a !== void 0 ? _a : fs$1;
+        }
+        else {
+            /* istanbul ignore next */
+            const [config, options = {}] = args;
+            super(defaultResolvers, config);
+            this.fs = /* istanbul ignore next */ (_b = options.fs) !== null && _b !== void 0 ? _b : fs$1;
+        }
         this.cache = new Map();
     }
     /**
@@ -11940,12 +11984,14 @@ class FileSystemConfigLoader extends ConfigLoader {
         /* special case when the global configuration is marked as root, should not
          * try to load and more configuration files */
         if (this.globalConfig.isRootFound()) {
-            const merged = this.globalConfig.merge(override);
+            const merged = this.globalConfig.merge(this.resolvers, override);
             merged.init();
             return merged.resolve();
         }
         const config = this.fromFilename(filename);
-        const merged = config ? config.merge(override) : this.globalConfig.merge(override);
+        const merged = config
+            ? config.merge(this.resolvers, override)
+            : this.globalConfig.merge(this.resolvers, override);
         merged.init();
         return merged.resolve();
     }
@@ -11977,15 +12023,15 @@ class FileSystemConfigLoader extends ConfigLoader {
             return cache;
         }
         let found = false;
-        let current = path.resolve(path.dirname(filename));
+        let current = path$1.resolve(path$1.dirname(filename));
         let config = this.empty();
         // eslint-disable-next-line no-constant-condition -- it will break out when filesystem is traversed
         while (true) {
             /* search configuration files in current directory */
-            for (const configFile of findConfigurationFiles(current)) {
+            for (const configFile of findConfigurationFiles(this.fs, current)) {
                 const local = this.loadFromFile(configFile);
                 found = true;
-                config = local.merge(config);
+                config = local.merge(this.resolvers, config);
             }
             /* stop if a configuration with "root" is set to true */
             if (config.isRootFound()) {
@@ -11993,7 +12039,7 @@ class FileSystemConfigLoader extends ConfigLoader {
             }
             /* get the parent directory */
             const child = current;
-            current = path.dirname(current);
+            current = path$1.dirname(current);
             /* stop if this is the root directory */
             if (current === child) {
                 break;
@@ -12007,8 +12053,14 @@ class FileSystemConfigLoader extends ConfigLoader {
         this.cache.set(filename, config);
         return config;
     }
+    /**
+     * @internal For testing only
+     */
+    _getInternalCache() {
+        return this.cache;
+    }
     defaultConfig() {
-        return this.configFactory.defaultConfig();
+        return Config.defaultConfig();
     }
 }
 
@@ -12263,5 +12315,5 @@ function getFormatter(name) {
     return (_a = availableFormatters[name]) !== null && _a !== void 0 ? _a : null;
 }
 
-export { Attribute as A, isTextNode as B, Config as C, DynamicValue as D, EventHandler as E, FileSystemConfigLoader as F, isElementNode as G, HtmlValidate as H, generateIdSelector as I, name as J, bugs as K, MetaTable as M, NodeClosed as N, Presets as P, ResolvedConfig as R, Severity as S, TextNode as T, UserError as U, Validator as V, WrappedError as W, ConfigError as a, ConfigLoader as b, StaticConfigLoader as c, DOMTokenList as d, HtmlElement as e, DOMNode as f, DOMTree as g, NodeType as h, SchemaValidationError as i, NestedError as j, TextContent$1 as k, MetaCopyableProperty as l, Rule as m, Reporter as n, TemplateExtractor as o, definePlugin as p, Parser as q, ruleExists as r, sliceLocation as s, getFormatter as t, legacyRequire as u, version as v, ensureError as w, configDataFromFile as x, compatibilityCheck as y, codeframe as z };
+export { Attribute as A, isTextNode as B, Config as C, DynamicValue as D, EventHandler as E, FileSystemConfigLoader as F, isElementNode as G, HtmlValidate as H, generateIdSelector as I, name as J, bugs as K, MetaTable as M, NodeClosed as N, Presets as P, ResolvedConfig as R, Severity as S, TextNode as T, UserError as U, Validator as V, WrappedError as W, ConfigError as a, ConfigLoader as b, StaticConfigLoader as c, DOMTokenList as d, HtmlElement as e, DOMNode as f, DOMTree as g, NodeType as h, SchemaValidationError as i, NestedError as j, TextContent$1 as k, MetaCopyableProperty as l, Rule as m, sliceLocation as n, Reporter as o, definePlugin as p, Parser as q, ruleExists as r, staticResolver as s, getFormatter as t, legacyRequire as u, version as v, ensureError as w, nodejsResolver as x, compatibilityCheck as y, codeframe as z };
 //# sourceMappingURL=core.js.map