html-validate 11.5.3 → 11.5.5

package/dist/esm/core.js

@@ -388,11 +388,11 @@ var deepmerge = /*@__PURE__*/getDefaultExportFromCjs(cjsExports);
 function stringify(value) {
   if (typeof value === "string") {
     return value;
-  } else {
-    return JSON.stringify(value);
   }
+  return JSON.stringify(value);
 }
 class WrappedError extends Error {
+  /* eslint-disable-next-line unicorn/custom-error-definition -- technical debt */
   constructor(message) {
     super(stringify(message));
     this.name = "WrappedError";
@@ -402,12 +402,12 @@ class WrappedError extends Error {
 function ensureError(value) {
   if (value instanceof Error) {
     return value;
-  } else {
-    return new WrappedError(value);
   }
+  return new WrappedError(value);
 }
 
 class NestedError extends Error {
+  /* eslint-disable-next-line unicorn/custom-error-definition -- technical debt */
   constructor(message, nested) {
     super(message);
     this.name = "NestedError";
@@ -420,6 +420,7 @@ Caused by: ${nested.stack}`;
 }
 
 class UserError extends NestedError {
+  /* eslint-disable-next-line unicorn/custom-error-definition -- technical debt */
   constructor(message, nested) {
     super(message, nested);
     this.name = "UserError";
@@ -1120,11 +1121,11 @@ const CONTROL_ESCAPES = /* @__PURE__ */ new Map([
   ["\r", "r"]
 ]);
 const OTHER_PUNCTUATORS = /^[!"#%&',:;<=>@`~-]$/;
-const WHITE_SPACE = /^[\t\v\f\uFEFF\p{Zs}]$/u;
+const WHITE_SPACE = /^[\t\v\f\u{FEFF}\p{Zs}]$/u;
 const LINE_TERMINATOR = /^[\n\r\u2028\u2029]$/;
 const SURROGATE = /^[\uD800-\uDFFF]$/;
 function isDecimalDigitOrASCIILetter(ch) {
-  return /^[\dA-Za-z]$/.test(ch);
+  return /^[\dA-Z]$/i.test(ch);
 }
 function needEscape(ch) {
   return OTHER_PUNCTUATORS.test(ch) || WHITE_SPACE.test(ch) || LINE_TERMINATOR.test(ch) || SURROGATE.test(ch);
@@ -1192,9 +1193,8 @@ function migrateSingleAttribute(src, key) {
       }
     }
     return stripUndefined(result);
-  } else {
-    return stripUndefined({ ...result, ...attr });
   }
+  return stripUndefined({ ...result, ...attr });
 }
 function isPatternAttribute$1(key) {
   return key.includes("*");
@@ -1208,7 +1208,7 @@ function migrateAttributes(src) {
     ...Object.keys(src.attributes ?? {}),
     ...src.requiredAttributes ?? [],
     ...src.deprecatedAttributes ?? []
-  ].filter((key) => !isPatternAttribute$1(key)).toSorted();
+  ].filter((key) => !isPatternAttribute$1(key)).toSorted((a, b) => a.localeCompare(b));
   const entries = keys.map((key) => {
     return [key, migrateSingleAttribute(src, key)];
   });
@@ -1288,11 +1288,10 @@ const dynamicKeys = [
 ];
 const schemaCache = /* @__PURE__ */ new Map();
 function clone(value) {
-  if (globalThis.structuredClone) {
-    return globalThis.structuredClone(value);
-  } else {
-    return JSON.parse(JSON.stringify(value));
+  if (Object.hasOwn(globalThis, "structuredClone")) {
+    return structuredClone(value);
   }
+  return JSON.parse(JSON.stringify(value));
 }
 class MetaTable {
   elements;
@@ -1382,9 +1381,8 @@ class MetaTable {
     const meta = this.elements[tagName.toLowerCase()] ?? this.elements["*"];
     if (meta) {
       return { ...meta };
-    } else {
-      return null;
     }
+    return null;
   }
   /**
    * Find all tags which has enabled given property.
@@ -1426,16 +1424,15 @@ class MetaTable {
     const cached = schemaCache.get(hash);
     if (cached) {
       return cached;
-    } else {
-      const ajv = new Ajv({ strict: true, strictTuples: true, strictTypes: true });
-      ajv.addMetaSchema(ajvSchemaDraft);
-      ajv.addKeyword(ajvFunctionKeyword);
-      ajv.addKeyword(ajvRegexpKeyword);
-      ajv.addKeyword({ keyword: "copyable" });
-      const validate = ajv.compile(this.schema);
-      schemaCache.set(hash, validate);
-      return validate;
     }
+    const ajv = new Ajv({ strict: true, strictTuples: true, strictTypes: true });
+    ajv.addMetaSchema(ajvSchemaDraft);
+    ajv.addKeyword(ajvFunctionKeyword);
+    ajv.addKeyword(ajvRegexpKeyword);
+    ajv.addKeyword({ keyword: "copyable" });
+    const validate = ajv.compile(this.schema);
+    schemaCache.set(hash, validate);
+    return validate;
   }
   /**
    * @public
@@ -1517,14 +1514,13 @@ function expandProperties(node, entry) {
   }
 }
 function compileRegexString(value) {
-  const match = /^\/(.*(?=\/))\/(i?)$/.exec(value);
+  const match = /^\/(.*)\/(i?)$/.exec(value);
   if (match) {
     const [, expr, flags] = match;
     if (expr.startsWith("^") || expr.endsWith("$")) {
       return new RegExp(expr, flags);
-    } else {
-      return new RegExp(`^${expr}$`, flags);
     }
+    return new RegExp(`^${expr}$`, flags);
   }
   return null;
 }
@@ -1585,7 +1581,7 @@ class Attribute {
    * @param keyLocation - Source location of attribute name.
    * @param valueLocation - Source location of attribute value.
    * @param originalAttribute - If this attribute was dynamically added via a
-   * transformation (e.g. vuejs `:id` generating the `id` attribute) this
+   * transformation (e.g. Vue.js `:id` generating the `id` attribute) this
    * parameter should be set to the attribute name of the source attribute (`:id`).
    */
   constructor(key, value, keyLocation, valueLocation, originalAttribute) {
@@ -1629,9 +1625,8 @@ class Attribute {
     }
     if (pattern instanceof RegExp) {
       return this.value.match(pattern) !== null;
-    } else {
-      return this.value === pattern;
     }
+    return this.value === pattern;
   }
 }
 
@@ -1707,7 +1702,9 @@ const Node = {
 
 const DOCUMENT_NODE_NAME = "#document";
 const TEXT_CONTENT = /* @__PURE__ */ Symbol("textContent");
-let counter = 0;
+const state$1 = {
+  counter: 0
+};
 class DOMNode {
   nodeName;
   nodeType;
@@ -1746,7 +1743,7 @@ class DOMNode {
     this.disabledRules = /* @__PURE__ */ new Set();
     this.blockedRules = /* @__PURE__ */ new Map();
     this.childNodes = [];
-    this.unique = counter++;
+    this.unique = state$1.counter++;
     this.cache = null;
   }
   /**
@@ -1762,9 +1759,8 @@ class DOMNode {
   cacheGet(key) {
     if (this.cache) {
       return this.cache.get(key);
-    } else {
-      return void 0;
     }
+    return void 0;
   }
   cacheSet(key, value) {
     if (this.cache) {
@@ -1780,9 +1776,8 @@ class DOMNode {
   cacheRemove(key) {
     if (this.cache) {
       return this.cache.delete(key);
-    } else {
-      return false;
     }
+    return false;
   }
   /**
    * Check if key exists in cache.
@@ -2002,9 +1997,8 @@ class DOMTokenList extends Array {
   location(n) {
     if (this.locations) {
       return this.locations[n];
-    } else {
-      throw new Error("Trying to access DOMTokenList location when base location isn't set");
     }
+    throw new Error("Trying to access DOMTokenList location when base location isn't set");
   }
   contains(token) {
     return this.includes(token);
@@ -2072,7 +2066,7 @@ function nthChild(node, args) {
   if (!args) {
     throw new Error("Missing argument to nth-child");
   }
-  const n = Number.parseInt(args.trim(), 10);
+  const n = Math.trunc(Number(args.trim()));
   const cur = getNthChild(node);
   return cur === n;
 }
@@ -2091,9 +2085,8 @@ function factory(name, context) {
   const fn = table[name];
   if (fn) {
     return fn.bind(context);
-  } else {
-    throw new Error(`Pseudo-class "${name}" is not implemented`);
   }
+  throw new Error(`Pseudo-class "${name}" is not implemented`);
 }
 
 function stripslashes(value) {
@@ -2119,7 +2112,7 @@ function createIdCondition(raw) {
   };
 }
 function createAttributeCondition(attr) {
-  const match = /^(.+?)(?:([$*^|~]?=)"([^"]+?)")?$/.exec(attr);
+  const match = /^(.+?)(?:([$*^|~]?=)"([^"]+)")?$/.exec(attr);
   const key = match[1];
   const op = match[2];
   const rawValue = match[3];
@@ -2182,7 +2175,6 @@ function* splitCompound(pattern) {
   let quoted = false;
   while (cur < end) {
     const ch = pattern[cur];
-    const buffer = pattern.slice(begin, cur);
     if (ch === "\\") {
       cur += 2;
       continue;
@@ -2199,6 +2191,7 @@ function* splitCompound(pattern) {
       cur += 1;
       continue;
     }
+    const buffer = pattern.slice(begin, cur);
     if (isPseudoElement(ch, buffer)) {
       cur += 1;
       continue;
@@ -2219,7 +2212,7 @@ class Compound {
   selector;
   conditions;
   constructor(pattern) {
-    const match = /^([+>~-]?)((?:\*|[^#.:[]+)?)([^]*)$/.exec(pattern);
+    const match = /^([+>~-]?)((?:\*|[^#.:[]+)?)([\s\S]*)$/.exec(pattern);
     if (!match) {
       throw new Error(`Failed to create selector pattern from "${pattern}"`);
     }
@@ -2233,7 +2226,7 @@ class Compound {
     return node.is(this.tagName) && this.conditions.every((cur) => cur.match(node, context));
   }
   createCondition(pattern) {
-    switch (pattern[0]) {
+    switch (pattern.at(0)) {
       case ".":
         return createClassCondition(pattern.slice(1));
       case "#":
@@ -2426,9 +2419,9 @@ class ComplexSelector {
       case Combinator.CHILD:
         return root.childElements.filter((node) => node.is(pattern.tagName));
       case Combinator.ADJACENT_SIBLING:
-        return ComplexSelector.findAdjacentSibling(root);
+        return this.findAdjacentSibling(root);
       case Combinator.GENERAL_SIBLING:
-        return ComplexSelector.findGeneralSibling(root);
+        return this.findGeneralSibling(root);
       case Combinator.SCOPE:
         return [root];
     }
@@ -2466,12 +2459,11 @@ const codepoints = {
   "\r": "\\d "
 };
 function escapeSelectorComponent(text) {
-  return text.toString().replaceAll(/([\t\n\r]|[^\w-])/gi, (_, ch) => {
-    if (codepoints[ch]) {
+  return text.toString().replaceAll(/([^\w-])/g, (_, ch) => {
+    if (Object.hasOwn(codepoints, ch)) {
       return codepoints[ch];
-    } else {
-      return `\\${ch}`;
     }
+    return `\\${ch}`;
   });
 }
 
@@ -2634,10 +2626,10 @@ class HtmlElement extends DOMNode {
    */
   static fromTokens(startToken, endToken, parent, metaTable, namespace = "") {
     const name = startToken.data[2];
-    const tagName = namespace ? `${namespace}:${name}` : name;
     if (!name) {
       throw new Error("tagName cannot be empty");
     }
+    const tagName = namespace ? `${namespace}:${name}` : name;
     const meta = metaTable ? metaTable.getMetaFor(tagName) : null;
     const open = startToken.data[1] !== "/";
     const closed = isClosed(endToken, meta);
@@ -2659,9 +2651,8 @@ class HtmlElement extends DOMNode {
   get annotatedName() {
     if (this.annotation) {
       return this.annotation;
-    } else {
-      return `<${this.tagName}>`;
     }
+    return `<${this.tagName}>`;
   }
   /**
    * Get list of IDs referenced by `aria-labelledby`.
@@ -2880,13 +2871,13 @@ class HtmlElement extends DOMNode {
     if (!tabindex) {
       return this.cacheSet(TABINDEX, null);
     }
-    if (tabindex.value === null) {
+    if (tabindex.value === null || tabindex.value === "") {
       return this.cacheSet(TABINDEX, null);
     }
     if (tabindex.value instanceof DynamicValue) {
       return this.cacheSet(TABINDEX, 0);
     }
-    const parsed = Number.parseInt(tabindex.value, 10);
+    const parsed = Math.trunc(Number(tabindex.value));
     if (Number.isNaN(parsed)) {
       return this.cacheSet(TABINDEX, null);
     }
@@ -2902,11 +2893,11 @@ class HtmlElement extends DOMNode {
     const tagName = this.tagName.toLowerCase();
     if (tagName === "script") {
       return "script";
-    } else if (tagName === "style") {
+    }
+    if (tagName === "style") {
       return "css";
-    } else {
-      return "text";
     }
+    return "text";
   }
   /**
    * Get a list of all attributes on this node.
@@ -2918,16 +2909,15 @@ class HtmlElement extends DOMNode {
   }
   hasAttribute(key) {
     key = key.toLowerCase();
-    return key in this.attr;
+    return Object.hasOwn(this.attr, key);
   }
   getAttribute(key, all = false) {
     key = key.toLowerCase();
-    if (key in this.attr) {
+    if (Object.hasOwn(this.attr, key)) {
       const matches = this.attr[key];
       return all ? matches : matches[0];
-    } else {
-      return all ? [] : null;
     }
+    return all ? [] : null;
   }
   /**
    * Get attribute value.
@@ -2945,17 +2935,17 @@ class HtmlElement extends DOMNode {
     const attr = this.getAttribute(key);
     if (attr) {
       return attr.value !== null ? attr.value.toString() : null;
-    } else {
-      return null;
     }
+    return null;
   }
-  /**
-   * Add text as a child node to this element.
-   *
-   * @param text - Text to add.
-   * @param location - Source code location of this text.
-   */
   appendText(text, location) {
+    if (typeof text !== "string") {
+      if ("dynamic" in text) {
+        text = new DynamicValue(text.dynamic);
+      } else {
+        text = new DynamicValue(text.expr);
+      }
+    }
     this.childNodes.push(new TextNode(text, location));
   }
   /**
@@ -3025,14 +3015,13 @@ class HtmlElement extends DOMNode {
     const next = it.next();
     if (next.done) {
       return null;
-    } else {
-      return next.value;
     }
+    return next.value;
   }
   querySelectorAll(selector) {
     const it = this.querySelectorImpl(selector);
     const unique = new Set(it);
-    return Array.from(unique.values());
+    return Array.from(unique);
   }
   *querySelectorImpl(selectorList) {
     if (!selectorList) {
@@ -3053,9 +3042,8 @@ class HtmlElement extends DOMNode {
     function visit(node) {
       if (callback(node)) {
         return true;
-      } else {
-        return node.childElements.some(visit);
       }
+      return node.childElements.some(visit);
     }
   }
   /**
@@ -3230,7 +3218,7 @@ class Validator {
       return true;
     }
     return rules.some((rule) => {
-      return Validator.validatePermittedRule(node, rule);
+      return this.validatePermittedRule(node, rule);
     });
   }
   /**
@@ -3257,9 +3245,7 @@ class Validator {
       const [, category, quantifier] = /^(@?.*?)([*?]?)$/.exec(rule);
       const limit = category && quantifier && parseQuantifier(quantifier);
       if (limit) {
-        const siblings = children.filter(
-          (cur) => Validator.validatePermittedCategory(cur, rule, true)
-        );
+        const siblings = children.filter((cur) => this.validatePermittedCategory(cur, rule, true));
         if (siblings.length > limit) {
           for (const child of siblings.slice(limit)) {
             cb(child, category);
@@ -3290,12 +3276,12 @@ class Validator {
     let prev = null;
     for (const node of children) {
       const old = i;
-      while (rules[i] && !Validator.validatePermittedCategory(node, rules[i], true)) {
+      while (rules[i] && !this.validatePermittedCategory(node, rules[i], true)) {
         i++;
       }
       if (i >= rules.length) {
-        const orderSpecified = rules.find(
-          (cur) => Validator.validatePermittedCategory(node, cur, true)
+        const orderSpecified = rules.some(
+          (cur) => this.validatePermittedCategory(node, cur, true)
         );
         if (orderSpecified) {
           cb(node, prev);
@@ -3334,7 +3320,7 @@ class Validator {
     }
     return rules.filter((tagName) => {
       const haveMatchingChild = node.childElements.some(
-        (child) => Validator.validatePermittedCategory(child, tagName, false)
+        (child) => this.validatePermittedCategory(child, tagName, false)
       );
       return !haveMatchingChild;
     });
@@ -3381,36 +3367,35 @@ class Validator {
     return rule.enum.some((entry) => {
       if (typeof entry === "string") {
         return caseInsensitiveValue === entry;
-      } else if (entry instanceof RegExp) {
+      }
+      if (entry instanceof RegExp) {
         return entry.test(value);
-      } else if (entry.pattern instanceof RegExp) {
+      }
+      if (entry.pattern instanceof RegExp) {
         return entry.pattern.test(value);
-      } else {
-        throw new TypeError("RegExp was not precompiled when it should have been");
       }
+      throw new TypeError("RegExp was not precompiled when it should have been");
     });
   }
   static validatePermittedRule(node, rule, isExclude = false) {
     if (typeof rule === "string") {
-      return Validator.validatePermittedCategory(node, rule, !isExclude);
-    } else if (Array.isArray(rule)) {
+      return this.validatePermittedCategory(node, rule, !isExclude);
+    }
+    if (Array.isArray(rule)) {
       return rule.every((inner) => {
-        return Validator.validatePermittedRule(node, inner, isExclude);
+        return this.validatePermittedRule(node, inner, isExclude);
       });
-    } else {
-      validateKeys(rule);
-      if (rule.exclude) {
-        if (Array.isArray(rule.exclude)) {
-          return !rule.exclude.some((inner) => {
-            return Validator.validatePermittedRule(node, inner, true);
-          });
-        } else {
-          return !Validator.validatePermittedRule(node, rule.exclude, true);
-        }
-      } else {
-        return true;
+    }
+    validateKeys(rule);
+    if (rule.exclude) {
+      if (Array.isArray(rule.exclude)) {
+        return rule.exclude.every((inner) => {
+          return !this.validatePermittedRule(node, inner, true);
+        });
       }
+      return !this.validatePermittedRule(node, rule.exclude, true);
     }
+    return true;
   }
   /**
    * Validate node against a content category.
@@ -3426,7 +3411,7 @@ class Validator {
    */
   /* eslint-disable-next-line complexity -- rule does not like switch */
   static validatePermittedCategory(node, category, defaultMatch) {
-    const [, rawCategory] = /^(@?.*?)([*?]?)$/.exec(category);
+    const [, rawCategory] = /^(@?.*?)[*?]?$/.exec(category);
     if (!rawCategory.startsWith("@")) {
       return node.matches(rawCategory);
     }
@@ -3459,10 +3444,11 @@ class Validator {
 }
 function validateKeys(rule) {
   for (const key of Object.keys(rule)) {
-    if (!allowedKeys.has(key)) {
-      const str = JSON.stringify(rule);
-      throw new Error(`Permitted rule "${str}" contains unknown property "${key}"`);
+    if (allowedKeys.has(key)) {
+      continue;
     }
+    const str = JSON.stringify(rule);
+    throw new Error(`Permitted rule "${str}" contains unknown property "${key}"`);
   }
 }
 function parseQuantifier(quantifier) {
@@ -3529,9 +3515,8 @@ function ariaNaming(element) {
   if (role) {
     if (role instanceof DynamicValue) {
       return element.cacheSet(cacheKey, defaultValue);
-    } else {
-      return element.cacheSet(cacheKey, byRole(role));
     }
+    return element.cacheSet(cacheKey, byRole(role));
   }
   const meta = element.meta;
   if (!meta) {
@@ -3716,9 +3701,8 @@ function isPresentation(node) {
   const role = node.getAttribute("role");
   if (role && (role.value === "presentation" || role.value === "none")) {
     return node.cacheSet(ROLE_PRESENTATION_CACHE, true);
-  } else {
-    return node.cacheSet(ROLE_PRESENTATION_CACHE, false);
   }
+  return node.cacheSet(ROLE_PRESENTATION_CACHE, false);
 }
 
 const cachePrefix = classifyNodeText.name;
@@ -3736,13 +3720,14 @@ function getCachekey(options) {
   const { accessible = false, ignoreHiddenRoot = false } = options;
   if (accessible && ignoreHiddenRoot) {
     return IGNORE_HIDDEN_ROOT_A11Y_CACHE_KEY;
-  } else if (ignoreHiddenRoot) {
+  }
+  if (ignoreHiddenRoot) {
     return IGNORE_HIDDEN_ROOT_HTML_CACHE_KEY;
-  } else if (accessible) {
+  }
+  if (accessible) {
     return A11Y_CACHE_KEY;
-  } else {
-    return HTML_CACHE_KEY;
   }
+  return HTML_CACHE_KEY;
 }
 function isSpecialEmpty(node) {
   return node.is("select") || node.is("textarea");
@@ -3774,7 +3759,7 @@ function classifyNodeText(node, options = {}) {
 }
 function findTextNodes(node, options) {
   const { accessible = false } = options;
-  let text = [];
+  const text = [];
   for (const child of node.childNodes) {
     if (isTextNode(child)) {
       text.push(child);
@@ -3785,7 +3770,7 @@ function findTextNodes(node, options) {
       if (accessible && isAriaHidden(child, true).bySelf) {
         continue;
       }
-      text = text.concat(findTextNodes(child, options));
+      text.push(...findTextNodes(child, options));
     }
   }
   return text;
@@ -3846,14 +3831,17 @@ function format(value, quote = false) {
   return String(value);
 }
 function interpolate(text, data) {
-  return text.replaceAll(/{{\s*([^\s{}]+)\s*}}/g, (match, key) => {
+  return text.replaceAll(/\{\{\s*([^\s{}]+)\s*\}\}/g, (match, key) => {
     return data[key] !== void 0 ? format(data[key]) : match;
   });
 }
 
-const ajv$1 = new Ajv({ strict: true, strictTuples: true, strictTypes: true });
-ajv$1.addMetaSchema(ajvSchemaDraft);
-ajv$1.addKeyword(ajvRegexpKeyword);
+const ajv$1 = (() => {
+  const ajv2 = new Ajv({ strict: true, strictTuples: true, strictTypes: true });
+  ajv2.addMetaSchema(ajvSchemaDraft);
+  ajv2.addKeyword(ajvRegexpKeyword);
+  return ajv2;
+})();
 function getSchemaValidator(ruleId, properties) {
   const $id = `rule/${ruleId}`;
   const cached = ajv$1.getSchema($id);
@@ -3874,10 +3862,9 @@ function isErrorDescriptor(value) {
 function unpackErrorDescriptor(value) {
   if (isErrorDescriptor(value)) {
     return value[0];
-  } else {
-    const [node, message, location, context] = value;
-    return { node, message, location, context };
   }
+  const [node, message, location, context] = value;
+  return { node, message, location, context };
 }
 class Rule {
   reporter;
@@ -4083,17 +4070,18 @@ class Rule {
     const callback = args.pop();
     const filter = args.pop() ?? (() => true);
     return this.parser.on(event, (_event, data) => {
-      if (this.isEnabled() && filter(data)) {
-        this.event = data;
-        const { tracker } = this;
-        if (tracker) {
-          const start = performance.now();
-          callback(data);
-          const end = performance.now();
-          tracker.trackRule(this.name, end - start);
-        } else {
-          callback(data);
-        }
+      if (!this.isEnabled() || !filter(data)) {
+        return;
+      }
+      this.event = data;
+      const { tracker } = this;
+      if (tracker) {
+        const start = performance.now();
+        callback(data);
+        const end = performance.now();
+        tracker.trackRule(this.name, end - start);
+      } else {
+        callback(data);
       }
     });
   }
@@ -4163,7 +4151,7 @@ class Rule {
    * @public
    * @virtual
    * @param context - Error context given by a reported error.
-   * @returns Rule documentation and url with additional details or `null` if no
+   * @returns Rule documentation and URL with additional details or `null` if no
    * additional documentation is available.
    */
   documentation(_context) {
@@ -4202,7 +4190,7 @@ function parseAllow(value) {
   };
 }
 function matchList(value, list) {
-  if (list.include && !list.include.some((it) => it.test(value))) {
+  if (list.include?.every((it) => !it.test(value))) {
     return false;
   }
   if (list.exclude?.some((it) => it.test(value))) {
@@ -4287,10 +4275,10 @@ class AllowedLinks extends Rule {
     return Boolean(attr && attr === key);
   }
   getStyle(value) {
-    if (/^([a-z]+:)?\/\//g.test(value)) {
+    if (/^(?:[a-z]+:)?\/\//.test(value)) {
       return "external" /* EXTERNAL */;
     }
-    switch (value[0]) {
+    switch (value.at(0)) {
       /* /foo/bar */
       case "/":
         return "absolute" /* ABSOLUTE */;
@@ -4309,7 +4297,8 @@ class AllowedLinks extends Rule {
     const { allowAbsolute } = this;
     if (allowAbsolute === true) {
       return;
-    } else if (allowAbsolute === false) {
+    }
+    if (allowAbsolute === false) {
       this.report(
         event.target,
         "Link destination must not be absolute url",
@@ -4329,7 +4318,8 @@ class AllowedLinks extends Rule {
     const { allowExternal } = this;
     if (allowExternal === true) {
       return;
-    } else if (allowExternal === false) {
+    }
+    if (allowExternal === false) {
       this.report(
         event.target,
         "Link destination must not be external url",
@@ -4349,7 +4339,8 @@ class AllowedLinks extends Rule {
     const { allowRelative } = this;
     if (allowRelative === true) {
       return false;
-    } else if (allowRelative === false) {
+    }
+    if (allowRelative === false) {
       this.report(
         event.target,
         "Link destination must not be relative url",
@@ -4357,7 +4348,8 @@ class AllowedLinks extends Rule {
         style
       );
       return true;
-    } else if (!matchList(target, allowRelative)) {
+    }
+    if (!matchList(target, allowRelative)) {
       this.report(
         event.target,
         "Relative link to this destination is not allowed by current configuration",
@@ -4372,7 +4364,8 @@ class AllowedLinks extends Rule {
     const { allowBase } = this.options;
     if (this.handleRelativePath(target, event, style)) {
       return;
-    } else if (!allowBase) {
+    }
+    if (!allowBase) {
       this.report(
         event.target,
         "Relative links must be relative to current folder",
@@ -4590,12 +4583,11 @@ class AriaLabelMisuse extends Rule {
         ].join("\n"),
         url
       };
-    } else {
-      return {
-        description: [`\`${context.attr}\` can only be used on:`, "", ...lines].join("\n"),
-        url
-      };
     }
+    return {
+      description: [`\`${context.attr}\` can only be used on:`, "", ...lines].join("\n"),
+      url
+    };
   }
   setup() {
     this.on("dom:ready", (event) => {
@@ -4653,6 +4645,7 @@ class AriaLabelMisuse extends Rule {
 }
 
 class ConfigError extends UserError {
+  /* eslint-disable-next-line unicorn/custom-error-definition -- technical debt */
   constructor(message, nested) {
     super(message, nested);
     this.name = "ConfigError";
@@ -4773,9 +4766,8 @@ class AttrCase extends Rule {
   isIgnored(node) {
     if (this.options.ignoreForeign) {
       return Boolean(node.meta?.foreign);
-    } else {
-      return false;
     }
+    return false;
   }
 }
 
@@ -4825,10 +4817,11 @@ class Context {
     let lastNewline = -1;
     let newlines = 0;
     for (let i = 0; i < n; i++) {
-      if (this.string[i] === "\n") {
-        newlines++;
-        lastNewline = i;
+      if (this.string[i] !== "\n") {
+        continue;
       }
+      newlines++;
+      lastNewline = i;
     }
     if (newlines > 0) {
       this.line += newlines;
@@ -4890,28 +4883,29 @@ const MATCH_DOCTYPE_CLOSE = /^>/;
 const MATCH_XML_TAG = /^<\?xml.*?\?>\s+/;
 const MATCH_TAG_OPEN = /^<(\/?)([\w:\-]+)/;
 const MATCH_TAG_CLOSE = /^\/?>/;
-const MATCH_TEXT = /^[^]*?(?=(?:[\t ]*(?:\r\n|\r|\n)|<[^ ]|$))/;
+const MATCH_TEXT = /^[\s\S]*?(?=[\t ]*(?:\r\n|\r|\n)|<[^ ]|$)/;
 const MATCH_TEMPLATING = /^(?:<%.*?%>|<\?.*?\?>|<\$.*?\$>)/s;
-const MATCH_TAG_LOOKAHEAD = /^[^]*?(?=<|$)/;
+const MATCH_TAG_LOOKAHEAD = /^[\s\S]*?(?=<|$)/;
 const MATCH_ATTR_START = /^([^\t\n\f\r "'/<=>]+)/;
-const MATCH_ATTR_SINGLE = /^(\s*=\s*)'([^']*?)(')/;
-const MATCH_ATTR_DOUBLE = /^(\s*=\s*)"([^"]*?)(")/;
+const MATCH_ATTR_SINGLE = /^(\s*=\s*)'([^']*)(')/;
+const MATCH_ATTR_DOUBLE = /^(\s*=\s*)"([^"]*)(")/;
 const MATCH_ATTR_UNQUOTED = /^(\s*=\s*)([^\t\n\f\r "'<>][^\t\n\f\r <>]*)/;
 const MATCH_CDATA_BEGIN = /^<!\[CDATA\[/;
-const MATCH_CDATA_END = /^[^]*?]]>/;
-const MATCH_SCRIPT_DATA = /^[^]*?(?=<\/script)/;
+const MATCH_CDATA_END = /^[\s\S]*?\]\]>/;
+const MATCH_SCRIPT_DATA = /^[\s\S]*?(?=<\/script)/;
 const MATCH_SCRIPT_END = /^<(\/)(script)/;
-const MATCH_STYLE_DATA = /^[^]*?(?=<\/style)/;
+const MATCH_STYLE_DATA = /^[\s\S]*?(?=<\/style)/;
 const MATCH_STYLE_END = /^<(\/)(style)/;
-const MATCH_TEXTAREA_DATA = /^[^]*?(?=<\/textarea)/;
+const MATCH_TEXTAREA_DATA = /^[\s\S]*?(?=<\/textarea)/;
 const MATCH_TEXTAREA_END = /^<(\/)(textarea)/;
-const MATCH_TITLE_DATA = /^[^]*?(?=<\/title)/;
+const MATCH_TITLE_DATA = /^[\s\S]*?(?=<\/title)/;
 const MATCH_TITLE_END = /^<(\/)(title)/;
-const MATCH_DIRECTIVE = /^(<!--\s*\[?)(html-validate-)([\da-z-]+)(\s*)(.*?)(]?\s*-->)/;
-const MATCH_COMMENT = /^<!--([^]*?)-->/;
-const MATCH_CONDITIONAL = /^<!\[([^\]]*?)]>/;
+const MATCH_DIRECTIVE = /^(<!--\s*\[?)(html-validate-)([\da-z-]+)(\s*)(.*?)(\]?\s*-->)/;
+const MATCH_COMMENT = /^<!--([\s\S]*?)-->/;
+const MATCH_CONDITIONAL = /^<!\[([^\]]*)\]>/;
 class InvalidTokenError extends Error {
   location;
+  /* eslint-disable-next-line unicorn/custom-error-definition -- technical debt */
   constructor(location, message) {
     super(message);
     this.name = "InvalidTokenError";
@@ -4995,9 +4989,8 @@ class Lexer {
   evalNextState(nextState, token) {
     if (typeof nextState === "function") {
       return nextState(token);
-    } else {
-      return nextState;
     }
+    return nextState;
   }
   *match(context, tests, error) {
     const n = tests.length;
@@ -5084,27 +5077,26 @@ class Lexer {
         case ContentModel.SCRIPT:
           if (selfClosed) {
             return State.SCRIPT;
-          } else {
-            return State.TEXT;
           }
+          return State.TEXT;
+        /* <script/> (not legal but handle it anyway so the lexer doesn't choke on it) */
         case ContentModel.STYLE:
           if (selfClosed) {
             return State.STYLE;
-          } else {
-            return State.TEXT;
           }
+          return State.TEXT;
+        /* <style/> */
         case ContentModel.TEXTAREA:
           if (selfClosed) {
             return State.TEXTAREA;
-          } else {
-            return State.TEXT;
           }
+          return State.TEXT;
+        /* <textarea/> */
         case ContentModel.TITLE:
           if (selfClosed) {
             return State.TITLE;
-          } else {
-            return State.TEXT;
           }
+          return State.TEXT;
       }
     }
     yield* this.match(
@@ -5191,7 +5183,7 @@ class Lexer {
   }
 }
 
-const whitespace = /(\s+)/;
+const whitespace = /\s+/;
 class AttrDelimiter extends Rule {
   documentation() {
     return {
@@ -5223,17 +5215,15 @@ const defaults$y = {
 function generateRegexp(pattern) {
   if (Array.isArray(pattern)) {
     return new RegExp(`^(${pattern.join("|")})$`, "i");
-  } else {
-    return new RegExp(`^${pattern}$`, "i");
   }
+  return new RegExp(`^${pattern}$`, "i");
 }
 function generateMessage(name, pattern) {
   if (Array.isArray(pattern)) {
     const patterns = pattern.map((it) => `/${it}/`).join(", ");
     return `Attribute "${name}" should match one of [${patterns}]`;
-  } else {
-    return `Attribute "${name}" should match /${pattern}/`;
   }
+  return `Attribute "${name}" should match /${pattern}/`;
 }
 function generateDescription(name, pattern) {
   if (Array.isArray(pattern)) {
@@ -5242,9 +5232,8 @@ function generateDescription(name, pattern) {
       "",
       ...pattern.map((it) => `- \`/${it}/\``)
     ].join("\n");
-  } else {
-    return `Attribute "${name}" should match the regular expression \`/${pattern}/\``;
   }
+  return `Attribute "${name}" should match the regular expression \`/${pattern}/\``;
 }
 class AttrPattern extends Rule {
   pattern;
@@ -5290,9 +5279,8 @@ class AttrPattern extends Rule {
   isIgnored(node) {
     if (this.options.ignoreForeign) {
       return Boolean(node.meta?.foreign);
-    } else {
-      return false;
     }
+    return false;
   }
 }
 
@@ -5403,9 +5391,8 @@ class AttrQuotes extends Rule {
   resolveQuotemark(value, style) {
     if (style === "auto" /* AUTO_QUOTE */) {
       return value.includes('"') ? "'" : '"';
-    } else {
-      return style;
     }
+    return style;
   }
 }
 function parseStyle$3(style) {
@@ -5463,11 +5450,11 @@ class AttributeAllowedValues extends Rule {
       const allowedList = allowed.enum.map((value2) => {
         if (typeof value2 === "string") {
           return `- \`"${value2}"\``;
-        } else if (value2 instanceof RegExp) {
+        }
+        if (value2 instanceof RegExp) {
           return `- \`${value2.toString()}\``;
-        } else {
-          return `- ${value2.name}`;
         }
+        return `- ${value2.name}`;
       });
       docs.description = [
         `The \`<${element}>\` element does not allow the attribute \`${attribute}\` to have the value \`"${value}"\`.`,
@@ -5511,9 +5498,8 @@ class AttributeAllowedValues extends Rule {
     const { key, value } = attr;
     if (value !== null) {
       return `Attribute "${key}" has invalid value "${value.toString()}"`;
-    } else {
-      return `Attribute "${key}" is missing value`;
     }
+    return `Attribute "${key}" is missing value`;
   }
   getLocation(attr) {
     return attr.valueLocation ?? attr.keyLocation;
@@ -5800,10 +5786,10 @@ class AutocompletePassword extends Rule {
       const tokens = new DOMTokenList(raw, autocomplete.valueLocation);
       const index = tokens.findIndex((token) => !isGroupingToken(token));
       const value = tokens.item(index);
-      const location = tokens.location(index);
       if (!value) {
         return;
       }
+      const location = tokens.location(index);
       if (value === "off") {
         const context = { kind: "off" };
         this.report({
@@ -5888,9 +5874,8 @@ function parsePattern(pattern) {
 function toArray$2(value) {
   if (Array.isArray(value)) {
     return value;
-  } else {
-    return [value];
   }
+  return [value];
 }
 function validateAllowedPatterns(patterns, allowedPatterns, ruleId) {
   const extraneous = patterns.filter(isNamedPattern).filter((p) => !allowedPatterns.has(p));
@@ -5976,7 +5961,7 @@ class ClassPattern extends BasePatternRule {
     });
   }
   static schema() {
-    return BasePatternRule.schema();
+    return super.schema();
   }
   documentation(context) {
     return {
@@ -6057,10 +6042,10 @@ class CloseOrder extends Rule {
     });
     this.on("tag:end", (event) => {
       const current = event.target;
-      const active = event.previous;
       if (current) {
         return;
       }
+      const active = event.previous;
       for (const ancestor of ancestors(active)) {
         if (ancestor.isRootElement() || reported.has(ancestor.unique)) {
           continue;
@@ -6071,13 +6056,13 @@ class CloseOrder extends Rule {
     });
     this.on("tag:end", (event) => {
       const current = event.target;
-      const active = event.previous;
       if (!current) {
         return;
       }
       if (current.voidElement) {
         return;
       }
+      const active = event.previous;
       if (active.closed === Node.CLOSED_IMPLICIT_CLOSED) {
         return;
       }
@@ -6172,7 +6157,7 @@ class Deprecated extends Rule {
       text.push(context.documentation);
     }
     const doc = {
-      description: text.map((cur) => cur.replaceAll("$tagname", context.tagName)).join("\n\n"),
+      description: text.map((cur) => cur.replaceAll("$tagname", () => context.tagName)).join("\n\n"),
       url: "https://html-validate.org/rules/deprecated.html"
     };
     return doc;
@@ -6571,7 +6556,7 @@ class ElementName extends Rule {
     ];
   }
   setup() {
-    const xmlns = /^(.+):.+$/;
+    const xmlns = /^[^:]+:.+$/;
     this.on("tag:start", (event) => {
       const target = event.target;
       const tagName = target.tagName;
@@ -6610,13 +6595,12 @@ function isNativeTemplate(node) {
 function getTransparentChildren(node, transparent) {
   if (typeof transparent === "boolean") {
     return node.childElements;
-  } else {
-    return node.childElements.filter((it) => {
-      return transparent.some((category) => {
-        return Validator.validatePermittedCategory(it, category, false);
-      });
-    });
   }
+  return node.childElements.filter((it) => {
+    return transparent.some((category) => {
+      return Validator.validatePermittedCategory(it, category, false);
+    });
+  });
 }
 function getRuleDescription$2(context) {
   switch (context.kind) {
@@ -6648,6 +6632,7 @@ class ElementPermittedContent extends Rule {
         [
           () => this.validatePermittedContent(node, parent),
           () => this.validatePermittedDescendant(node, parent)
+          /* eslint-disable-next-line unicorn/no-unused-array-method-return -- technical debt, should use iterator helpers */
         ].some((fn) => fn());
       });
     });
@@ -6793,14 +6778,12 @@ function getRuleDescription$1(context) {
     const allowed = rules.filter(isCategoryOrTag).map((it) => {
       if (isCategory$1(it)) {
         return `- any ${it.slice(1)} element`;
-      } else {
-        return `- \`<${it}>\``;
       }
+      return `- \`<${it}>\``;
     });
     return [preamble, "", "Allowed parents one of:", "", ...allowed];
-  } else {
-    return [preamble];
   }
+  return [preamble];
 }
 function formatMessage$1(node, parent, rules) {
   const nodeName = node.annotatedName;
@@ -6852,7 +6835,7 @@ class ElementPermittedParent extends Rule {
 }
 
 function isTagnameOnly(value) {
-  return /^[\dA-Za-z-]+$/.test(value);
+  return /^[\dA-Z-]+$/i.test(value);
 }
 function getRuleDescription(context) {
   const escaped = context.ancestor.map((it) => `\`${it}\``);
@@ -6915,9 +6898,8 @@ function normalizeRequired(element, attr) {
       default:
         return result;
     }
-  } else {
-    return required ? defaultMessage : false;
   }
+  return required ? defaultMessage : false;
 }
 class ElementRequiredAttributes extends Rule {
   documentation(context) {
@@ -6999,7 +6981,8 @@ const selector = ["h1", "h2", "h3", "h4", "h5", "h6"].join(",");
 function hasImgAltText$1(node) {
   if (node.is("img")) {
     return hasAltText(node);
-  } else if (node.is("svg")) {
+  }
+  if (node.is("svg")) {
     return node.textContent.trim() !== "";
   }
   return false;
@@ -7280,21 +7263,19 @@ class FormDupName extends Rule {
     const existing = group.cacheGet(UNIQUE_CACHE_KEY);
     if (existing) {
       return existing;
-    } else {
-      const elements = /* @__PURE__ */ new Map();
-      group.cacheSet(UNIQUE_CACHE_KEY, elements);
-      return elements;
     }
+    const elements = /* @__PURE__ */ new Map();
+    group.cacheSet(UNIQUE_CACHE_KEY, elements);
+    return elements;
   }
   getSharedElements(group) {
     const existing = group.cacheGet(SHARED_CACHE_KEY);
     if (existing) {
       return existing;
-    } else {
-      const elements = /* @__PURE__ */ new Map();
-      group.cacheSet(SHARED_CACHE_KEY, elements);
-      return elements;
     }
+    const elements = /* @__PURE__ */ new Map();
+    group.cacheSet(SHARED_CACHE_KEY, elements);
+    return elements;
   }
 }
 
@@ -7308,12 +7289,11 @@ function isRelevant$5(event) {
   return Boolean(node.meta?.heading);
 }
 function extractLevel(node) {
-  const match = /^[Hh](\d)$/.exec(node.tagName);
+  const match = /^H(\d)$/i.exec(node.tagName);
   if (match) {
-    return Number.parseInt(match[1], 10);
-  } else {
-    return null;
+    return Math.trunc(Number(match[1]));
   }
+  return null;
 }
 function parseMaxInitial(value) {
   if (value === false || value === "any") {
@@ -7323,7 +7303,7 @@ function parseMaxInitial(value) {
   if (!match) {
     return 1;
   }
-  return Number.parseInt(match[1], 10);
+  return Math.trunc(Number(match[1]));
 }
 class HeadingLevel extends Rule {
   minInitialRank;
@@ -7590,7 +7570,7 @@ class IdPattern extends BasePatternRule {
     });
   }
   static schema() {
-    return BasePatternRule.schema();
+    return super.schema();
   }
   documentation(context) {
     return {
@@ -7812,24 +7792,23 @@ function isHidden(node, context) {
   const { reference } = context;
   if (reference?.isSameNode(node)) {
     return false;
-  } else {
-    return !inAccessibilityTree(node);
   }
+  return !inAccessibilityTree(node);
 }
 function hasImgAltText(node, context) {
   if (node.is("img")) {
     return hasAltText(node);
-  } else if (node.is("svg")) {
+  }
+  if (node.is("svg")) {
     return node.textContent.trim() !== "";
-  } else {
-    for (const img of node.querySelectorAll("img, svg")) {
-      const hasName = hasAccessibleNameImpl(img, context);
-      if (hasName) {
-        return true;
-      }
+  }
+  for (const img of node.querySelectorAll("img, svg")) {
+    const hasName = hasAccessibleNameImpl(img, context);
+    if (hasName) {
+      return true;
     }
-    return false;
   }
+  return false;
 }
 function hasLabel(node) {
   const value = node.getAttributeValue("aria-label") ?? "";
@@ -7960,7 +7939,7 @@ class InputMissingLabel extends Rule {
       this.report(elem, `<${elem.tagName}> element has <label> but <label> element is hidden`);
       return;
     }
-    if (!labels.some((label) => hasAccessibleName(root, label))) {
+    if (labels.every((label) => !hasAccessibleName(root, label))) {
       this.report(elem, `<${elem.tagName}> element has <label> but <label> has no text`);
     }
   }
@@ -8147,12 +8126,11 @@ function parseContent(text) {
   const match = /^(\d+)(?:\s*;\s*url=(.*))?/i.exec(text);
   if (match) {
     return {
-      delay: Number.parseInt(match[1], 10),
+      delay: Math.trunc(Number(match[1])),
       url: match[2]
     };
-  } else {
-    return null;
   }
+  return null;
 }
 
 class MissingDoctype extends Rule {
@@ -8229,7 +8207,7 @@ class NamePattern extends BasePatternRule {
     });
   }
   static schema() {
-    return BasePatternRule.schema();
+    return super.schema();
   }
   documentation(context) {
     return {
@@ -8412,10 +8390,10 @@ class NoDeprecatedAttr extends Rule {
     this.on("attr", (event) => {
       const node = event.target;
       const meta = node.meta;
-      const attr = event.key.toLowerCase();
       if (meta === null) {
         return;
       }
+      const attr = event.key.toLowerCase();
       const metaAttribute = meta.attributes[attr];
       if (!metaAttribute) {
         return;
@@ -8449,7 +8427,7 @@ class NoDupAttr extends Rule {
         return;
       }
       const name = event.key.toLowerCase();
-      if (name in attr) {
+      if (Object.hasOwn(attr, name)) {
         this.report(event.target, `Attribute "${name}" duplicated`, event.keyLocation);
       }
       attr[event.key] = true;
@@ -8522,10 +8500,9 @@ function getExisting(element, root) {
   const existing = group.cacheGet(CACHE_KEY);
   if (existing) {
     return existing;
-  } else {
-    const existing2 = /* @__PURE__ */ new Set();
-    return group.cacheSet(CACHE_KEY, existing2);
   }
+  const value = /* @__PURE__ */ new Set();
+  return group.cacheSet(CACHE_KEY, value);
 }
 
 function isRelevant$2(event) {
@@ -8796,10 +8773,11 @@ class NoMissingReferences extends Rule {
     }
   }
   validateSingle(document, node, attr, id) {
-    if (idMissing(document, id)) {
-      const context = { key: attr.key, value: id };
-      this.report(node, `Element references missing id "${id}"`, attr.valueLocation, context);
+    if (!idMissing(document, id)) {
+      return;
     }
+    const context = { key: attr.key, value: id };
+    this.report(node, `Element references missing id "${id}"`, attr.valueLocation, context);
   }
   validateList(document, node, attr, values) {
     const parsed = new DOMTokenList(values, attr.valueLocation);
@@ -8839,9 +8817,9 @@ class NoMultipleMain extends Rule {
 const defaults$f = {
   relaxed: false
 };
-const textRegexp = /(<|&(?![\d#A-Za-z]+;))/g;
-const unquotedAttrRegexp = /(["'<=>`]|&(?![\d#A-Za-z]+;))/g;
-const matchTemplate = /^(<%.*?%>|<\?.*?\?>|<\$.*?\$>)$/s;
+const textRegexp = /(<|&(?![\d#A-Z]+;))/gi;
+const unquotedAttrRegexp = /(["'<=>`]|&(?![\d#A-Z]+;))/gi;
+const matchTemplate = /^(?:<%.*?%>|<\?.*?\?>|<\$.*?\$>)$/s;
 const replacementTable = {
   '"': "&quot;",
   "&": "&amp;",
@@ -9073,7 +9051,7 @@ class NoRedundantRole extends Rule {
   }
 }
 
-const xmlns = /^(.+):.+$/;
+const xmlns = /^[^:]+:.+$/;
 const defaults$d = {
   ignoreForeign: true,
   ignoreXML: true
@@ -9195,11 +9173,11 @@ class NoUnknownAttributes extends Rule {
     this.on("attr", (event) => {
       const node = event.target;
       const meta = node.meta;
-      const attr = event.key.toLowerCase();
       if (meta === null) {
         return;
       }
-      if (attr in meta.attributes) {
+      const attr = event.key.toLowerCase();
+      if (Object.hasOwn(meta.attributes, attr)) {
         return;
       }
       if (isPatternAttribute(attr, meta.patternAttributes)) {
@@ -9606,7 +9584,7 @@ const defaults$7 = {
   include: null,
   exclude: null
 };
-const crossorigin = new RegExp("^(\\w+://|//)");
+const crossorigin = /^(?:\w+:\/\/|\/\/)/;
 const supportSri = {
   link: "href",
   script: "src"
@@ -9819,7 +9797,10 @@ function constructRegex(characters) {
   return new RegExp(pattern, "g");
 }
 function getText(node) {
-  const match = /^(\s*)(.*)$/.exec(node.textContent);
+  const match = /^(\s*)(\S.*)$/.exec(node.textContent);
+  if (!match) {
+    return [0, ""];
+  }
   const [, leading, text] = match;
   return [leading.length, text.trimEnd()];
 }
@@ -9972,9 +9953,8 @@ function hasDefaultText(node) {
 function isNonEmptyText(node) {
   if (isTextNode(node)) {
     return node.isDynamic || node.textContent.trim() !== "";
-  } else {
-    return false;
   }
+  return false;
 }
 function haveAccessibleText(node) {
   if (!inAccessibilityTree(node)) {
@@ -10109,15 +10089,14 @@ function getTextFromReference(document, id) {
   const ref = document.querySelector(selector);
   if (ref) {
     return ref.textContent;
-  } else {
-    return selector;
   }
+  return selector;
 }
 function groupBy(values, callback) {
   const result = {};
   for (const value of values) {
     const key = callback(value);
-    if (key in result) {
+    if (Object.hasOwn(result, key)) {
       result[key].push(value);
     } else {
       result[key] = [value];
@@ -10217,7 +10196,7 @@ const defaults$5 = {
   ignoreCase: false,
   requireSemicolon: true
 };
-const regexp$1 = /&(?:[\da-z]+|#x?[\da-f]+)(;|[^\da-z]|$)/gi;
+const regexp$1 = /&(?:[\da-z]+|#x?[\da-f]+)([^\da-z]|$)/gi;
 const lowercaseEntities = entities$1.map((it) => it.toLowerCase());
 function isNumerical(entity) {
   return entity.startsWith("&#");
@@ -10296,9 +10275,8 @@ class UnknownCharReference extends Rule {
   get entities() {
     if (this.options.ignoreCase) {
       return lowercaseEntities;
-    } else {
-      return entities$1;
     }
+    return entities$1;
   }
   findCharacterReferences(node, text, location, { isAttribute }) {
     const delimiter = text.search(/[#?]/);
@@ -10664,7 +10642,6 @@ class ValidAutocomplete extends Rule {
   }
   validateControlAutocomplete(node, tokens, keyLocation) {
     const type = node.getAttributeValue("type") ?? "text";
-    const mantle = type !== "hidden" ? "expectation" : "anchor";
     if (isDisallowedType(node, type)) {
       const context = {
         msg: 0 /* InvalidAttribute */,
@@ -10679,6 +10656,7 @@ class ValidAutocomplete extends Rule {
       return;
     }
     if (tokens.includes("on") || tokens.includes("off")) {
+      const mantle = type !== "hidden" ? "expectation" : "anchor";
       this.validateOnOff(node, mantle, tokens);
       return;
     }
@@ -10802,44 +10780,46 @@ class ValidAutocomplete extends Rule {
    * Ensure contact token is only used with field names from the second list.
    */
   validateContact(node, tokens, order) {
-    if (order.includes("contact") && order.includes("field1")) {
-      const a = order.indexOf("field1");
-      const b = order.indexOf("contact");
+    if (!order.includes("contact") || !order.includes("field1")) {
+      return;
+    }
+    const a = order.indexOf("field1");
+    const b = order.indexOf("contact");
+    const context = {
+      msg: 4 /* InvalidCombination */,
+      /* eslint-disable @typescript-eslint/no-non-null-assertion -- it must be present of it wouldn't be found */
+      first: tokens.item(a),
+      second: tokens.item(b)
+      /* eslint-enable @typescript-eslint/no-non-null-assertion */
+    };
+    this.report({
+      node,
+      message: getTerminalMessage(context),
+      location: tokens.location(b),
+      context
+    });
+  }
+  validateOrder(node, tokens, order) {
+    const indicies = order.map((it) => expectedOrder.indexOf(it));
+    for (let i = 0; i < indicies.length - 1; i++) {
+      if (indicies[0] <= indicies[i + 1]) {
+        continue;
+      }
       const context = {
-        msg: 4 /* InvalidCombination */,
+        msg: 2 /* InvalidOrder */,
         /* eslint-disable @typescript-eslint/no-non-null-assertion -- it must be present of it wouldn't be found */
-        first: tokens.item(a),
-        second: tokens.item(b)
+        first: tokens.item(i),
+        second: tokens.item(i + 1)
         /* eslint-enable @typescript-eslint/no-non-null-assertion */
       };
       this.report({
         node,
         message: getTerminalMessage(context),
-        location: tokens.location(b),
+        location: tokens.location(i + 1),
         context
       });
     }
   }
-  validateOrder(node, tokens, order) {
-    const indicies = order.map((it) => expectedOrder.indexOf(it));
-    for (let i = 0; i < indicies.length - 1; i++) {
-      if (indicies[0] > indicies[i + 1]) {
-        const context = {
-          msg: 2 /* InvalidOrder */,
-          /* eslint-disable @typescript-eslint/no-non-null-assertion -- it must be present of it wouldn't be found */
-          first: tokens.item(i),
-          second: tokens.item(i + 1)
-          /* eslint-enable @typescript-eslint/no-non-null-assertion */
-        };
-        this.report({
-          node,
-          message: getTerminalMessage(context),
-          location: tokens.location(i + 1),
-          context
-        });
-      }
-    }
-  }
   validateControlGroup(node, tokens, fieldTokens) {
     const numFields = fieldTokens.filter(Boolean).length;
     if (numFields === 0) {
@@ -10931,7 +10911,7 @@ class ValidID extends Rule {
   documentation(context) {
     const { relaxed } = this.options;
     const { kind, id } = context;
-    const message = this.messages[kind].replace(`"{{ id }}"`, "`{{ id }}`").replace("id", "ID").replace(/^(.)/, (m) => m.toUpperCase());
+    const message = this.messages[kind].replace(`"{{ id }}"`, "`{{ id }}`").replace("id", "ID").replace(/^./, (m) => m.toUpperCase());
     const relaxedDescription = relaxed ? [] : [
       "  - ID must begin with a letter",
       "  - ID must only contain letters, digits, `-` and `_`"
@@ -10969,7 +10949,7 @@ class ValidID extends Rule {
       if (relaxed) {
         return;
       }
-      if (/^[^\p{L}]/u.test(value)) {
+      if (new RegExp("^\\P{L}", "u").test(value)) {
         const context = { kind: 3 /* LEADING_CHARACTER */, id: value };
         this.report(event.target, this.messages[context.kind], event.valueLocation, context);
         return;
@@ -11330,7 +11310,7 @@ function isSimpleTable(table) {
     return false;
   }
   const numColumns = cells[0].length;
-  if (!cells.every((row) => row.length === numColumns)) {
+  if (cells.some((row) => row.length !== numColumns)) {
     return false;
   }
   const shape = getShape(cells);
@@ -11984,7 +11964,7 @@ class ResolvedConfig {
 }
 
 function haveResolver(key, value) {
-  return key in value;
+  return Object.hasOwn(value, key);
 }
 function haveConfigResolver(value) {
   return haveResolver("resolveConfig", value);
@@ -11999,7 +11979,10 @@ function haveTransformerResolver(value) {
   return haveResolver("resolveTransformer", value);
 }
 function resolveConfig(resolvers, id, options) {
-  for (const resolver of resolvers.filter(haveConfigResolver)) {
+  for (const resolver of resolvers) {
+    if (!haveConfigResolver(resolver)) {
+      continue;
+    }
     const config = resolver.resolveConfig(id, options);
     if (isThenable(config)) {
       return resolveConfigAsync(resolvers, id, options);
@@ -12011,7 +11994,10 @@ function resolveConfig(resolvers, id, options) {
   throw new UserError(`Failed to load configuration from "${id}"`);
 }
 async function resolveConfigAsync(resolvers, id, options) {
-  for (const resolver of resolvers.filter(haveConfigResolver)) {
+  for (const resolver of resolvers) {
+    if (!haveConfigResolver(resolver)) {
+      continue;
+    }
     const config = await resolver.resolveConfig(id, options);
     if (config) {
       return config;
@@ -12020,7 +12006,10 @@ async function resolveConfigAsync(resolvers, id, options) {
   throw new UserError(`Failed to load configuration from "${id}"`);
 }
 function resolveElements(resolvers, id, options) {
-  for (const resolver of resolvers.filter(haveElementsResolver)) {
+  for (const resolver of resolvers) {
+    if (!haveElementsResolver(resolver)) {
+      continue;
+    }
     const elements = resolver.resolveElements(id, options);
     if (isThenable(elements)) {
       return resolveElementsAsync(resolvers, id, options);
@@ -12032,7 +12021,10 @@ function resolveElements(resolvers, id, options) {
   throw new UserError(`Failed to load elements from "${id}"`);
 }
 async function resolveElementsAsync(resolvers, id, options) {
-  for (const resolver of resolvers.filter(haveElementsResolver)) {
+  for (const resolver of resolvers) {
+    if (!haveElementsResolver(resolver)) {
+      continue;
+    }
     const elements = await resolver.resolveElements(id, options);
     if (elements) {
       return elements;
@@ -12041,7 +12033,10 @@ async function resolveElementsAsync(resolvers, id, options) {
   throw new UserError(`Failed to load elements from "${id}"`);
 }
 function resolvePlugin(resolvers, id, options) {
-  for (const resolver of resolvers.filter(havePluginResolver)) {
+  for (const resolver of resolvers) {
+    if (!havePluginResolver(resolver)) {
+      continue;
+    }
     const plugin = resolver.resolvePlugin(id, options);
     if (isThenable(plugin)) {
       return resolvePluginAsync(resolvers, id, options);
@@ -12053,7 +12048,10 @@ function resolvePlugin(resolvers, id, options) {
   throw new UserError(`Failed to load plugin from "${id}"`);
 }
 async function resolvePluginAsync(resolvers, id, options) {
-  for (const resolver of resolvers.filter(havePluginResolver)) {
+  for (const resolver of resolvers) {
+    if (!havePluginResolver(resolver)) {
+      continue;
+    }
     const plugin = await resolver.resolvePlugin(id, options);
     if (plugin) {
       return plugin;
@@ -12062,7 +12060,10 @@ async function resolvePluginAsync(resolvers, id, options) {
   throw new UserError(`Failed to load plugin from "${id}"`);
 }
 function resolveTransformer(resolvers, id, options) {
-  for (const resolver of resolvers.filter(haveTransformerResolver)) {
+  for (const resolver of resolvers) {
+    if (!haveTransformerResolver(resolver)) {
+      continue;
+    }
     const transformer = resolver.resolveTransformer(id, options);
     if (isThenable(transformer)) {
       return resolveTransformerAsync(resolvers, id, options);
@@ -12074,7 +12075,10 @@ function resolveTransformer(resolvers, id, options) {
   throw new UserError(`Failed to load transformer from "${id}"`);
 }
 async function resolveTransformerAsync(resolvers, id, options) {
-  for (const resolver of resolvers.filter(haveTransformerResolver)) {
+  for (const resolver of resolvers) {
+    if (!haveTransformerResolver(resolver)) {
+      continue;
+    }
     const transformer = await resolver.resolveTransformer(id, options);
     if (transformer) {
       return transformer;
@@ -12114,9 +12118,12 @@ function staticResolver(map = {}) {
   };
 }
 
-const ajv = new Ajv({ strict: true, strictTuples: true, strictTypes: true });
-ajv.addMetaSchema(ajvSchemaDraft);
-ajv.addKeyword(ajvFunctionKeyword);
+const ajv = (() => {
+  const ajv2 = new Ajv({ strict: true, strictTuples: true, strictTypes: true });
+  ajv2.addMetaSchema(ajvSchemaDraft);
+  ajv2.addKeyword(ajvFunctionKeyword);
+  return ajv2;
+})();
 const validator = ajv.compile(configurationSchema);
 function overwriteMerge(_a, b) {
   return b;
@@ -12135,18 +12142,16 @@ function mergeInternal(base, rhs) {
 function toArray$1(value) {
   if (Array.isArray(value)) {
     return value;
-  } else {
-    return [value];
   }
+  return [value];
 }
 function transformerEntries(transform) {
   return Object.entries(transform).map(([pattern, value]) => {
     const regex = new RegExp(pattern);
     if (typeof value === "string") {
       return { kind: "import", pattern: regex, name: value };
-    } else {
-      return { kind: "function", pattern: regex, function: value };
     }
+    return { kind: "function", pattern: regex, function: value };
   });
 }
 class Config {
@@ -12171,8 +12176,8 @@ class Config {
    * Create configuration from object.
    */
   static fromObject(resolvers, options, filename = null) {
-    Config.validate(options, filename);
-    return Config.create(resolvers, options);
+    this.validate(options, filename);
+    return this.create(resolvers, options);
   }
   /**
    * Read configuration from filename.
@@ -12186,10 +12191,9 @@ class Config {
   static fromFile(resolvers, filename) {
     const configData = resolveConfig(toArray$1(resolvers), filename, { cache: false });
     if (isThenable(configData)) {
-      return configData.then((configData2) => Config.fromObject(resolvers, configData2, filename));
-    } else {
-      return Config.fromObject(resolvers, configData, filename);
+      return configData.then((configData2) => this.fromObject(resolvers, configData2, filename));
     }
+    return this.fromObject(resolvers, configData, filename);
   }
   /**
    * Validate configuration data.
@@ -12211,8 +12215,8 @@ class Config {
       );
     }
     if (configData.rules) {
-      const normalizedRules = Config.getRulesObject(configData.rules);
-      for (const [ruleId, [, ruleOptions]] of normalizedRules.entries()) {
+      const normalizedRules = this.getRulesObject(configData.rules);
+      for (const [ruleId, [, ruleOptions]] of normalizedRules) {
         const cls = bundledRules[ruleId];
         const path = `/rules/${ruleId}/1`;
         Rule.validateOptions(cls, ruleId, path, ruleOptions, filename, configData);
@@ -12235,9 +12239,8 @@ class Config {
       return plugins.then((plugins2) => {
         return instance.init(options, plugins2);
       });
-    } else {
-      return instance.init(options, plugins);
     }
+    return instance.init(options, plugins);
   }
   init(options, plugins) {
     this.plugins = plugins;
@@ -12254,9 +12257,8 @@ class Config {
     const extendedConfig = this.extendConfig(this.config.extends ?? []);
     if (isThenable(extendedConfig)) {
       return extendedConfig.then((extended) => update(extended));
-    } else {
-      return update(extendedConfig);
     }
+    return update(extendedConfig);
   }
   /**
    * @internal
@@ -12298,12 +12300,11 @@ class Config {
         instance.extendMeta(instance.plugins);
         return instance;
       });
-    } else {
-      instance.plugins = plugins;
-      instance.configurations = instance.loadConfigurations(instance.plugins);
-      instance.extendMeta(instance.plugins);
-      return instance;
     }
+    instance.plugins = plugins;
+    instance.configurations = instance.loadConfigurations(instance.plugins);
+    instance.extendMeta(instance.plugins);
+    return instance;
   }
   extendConfig(entries) {
     if (entries.length === 0) {
@@ -12359,20 +12360,19 @@ class Config {
       const result = this.getElementsFromEntry(entry);
       if (isThenable(result)) {
         return result.then((result2) => {
-          const [obj, filename] = result2;
-          metaTable.loadFromObject(obj, filename);
-          const next2 = source.shift();
-          if (next2) {
-            return loadEntry(next2);
+          const [obj2, filename2] = result2;
+          metaTable.loadFromObject(obj2, filename2);
+          const next3 = source.shift();
+          if (next3) {
+            return loadEntry(next3);
           }
         });
-      } else {
-        const [obj, filename] = result;
-        metaTable.loadFromObject(obj, filename);
-        const next2 = source.shift();
-        if (next2) {
-          return loadEntry(next2);
-        }
+      }
+      const [obj, filename] = result;
+      metaTable.loadFromObject(obj, filename);
+      const next2 = source.shift();
+      if (next2) {
+        return loadEntry(next2);
       }
     };
     const next = source.shift();
@@ -12402,9 +12402,8 @@ class Config {
         return obj.then((obj2) => {
           return [obj2, entry];
         });
-      } else {
-        return [obj, entry];
       }
+      return [obj, entry];
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       throw new ConfigError(
@@ -12466,7 +12465,7 @@ class Config {
     const loadPlugin = (entry, index) => {
       if (typeof entry !== "string") {
         const plugin = entry;
-        plugin.name = plugin.name || `:unnamedPlugin@${String(index + 1)}`;
+        plugin.name ||= `:unnamedPlugin@${String(index + 1)}`;
         plugin.originalName = `:unnamedPlugin@${String(index + 1)}`;
         loaded.push(plugin);
         const next2 = loading.shift();
@@ -12478,22 +12477,21 @@ class Config {
           const plugin = resolvePlugin(this.resolvers, entry, { cache: true });
           if (isThenable(plugin)) {
             return plugin.then((plugin2) => {
-              plugin2.name = plugin2.name || entry;
+              plugin2.name ||= entry;
               plugin2.originalName = entry;
               loaded.push(plugin2);
-              const next2 = loading.shift();
-              if (next2) {
-                return loadPlugin(next2, index + 1);
+              const next3 = loading.shift();
+              if (next3) {
+                return loadPlugin(next3, index + 1);
               }
             });
-          } else {
-            plugin.name = plugin.name || entry;
-            plugin.originalName = entry;
-            loaded.push(plugin);
-            const next2 = loading.shift();
-            if (next2) {
-              return loadPlugin(next2, index + 1);
-            }
+          }
+          plugin.name ||= entry;
+          plugin.originalName = entry;
+          loaded.push(plugin);
+          const next2 = loading.shift();
+          if (next2) {
+            return loadPlugin(next2, index + 1);
           }
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -12519,7 +12517,8 @@ class Config {
       configs.set(name, config);
     }
     for (const plugin of plugins) {
-      for (const [name, config] of Object.entries(plugin.configs ?? {})) {
+      const entries = Object.entries(plugin.configs ?? {});
+      for (const [name, config] of entries) {
         if (!config) {
           continue;
         }
@@ -12563,9 +12562,8 @@ class Config {
       return resolveData.then((resolveData2) => {
         return new ResolvedConfig(resolveData2, this.get());
       });
-    } else {
-      return new ResolvedConfig(resolveData, this.get());
     }
+    return new ResolvedConfig(resolveData, this.get());
   }
   /**
    * Same as [[resolve]] but returns the raw configuration data instead of
@@ -12584,14 +12582,13 @@ class Config {
           transformers: this.transformers
         };
       });
-    } else {
-      return {
-        metaTable,
-        plugins: this.getPlugins(),
-        rules: this.getRules(),
-        transformers: this.transformers
-      };
     }
+    return {
+      metaTable,
+      plugins: this.getPlugins(),
+      rules: this.getRules(),
+      transformers: this.transformers
+    };
   }
 }
 
@@ -12635,10 +12632,9 @@ class ConfigLoader {
         this._globalConfig = config2;
         return this._globalConfig;
       });
-    } else {
-      this._globalConfig = config;
-      return this._globalConfig;
     }
+    this._globalConfig = config;
+    return this._globalConfig;
   }
   /**
    * Get the global configuration.
@@ -12720,9 +12716,8 @@ class StaticConfigLoader extends ConfigLoader {
     const override = this.loadFromObject(configOverride ?? {});
     if (isThenable(override)) {
       return override.then((override2) => this._resolveConfig(override2));
-    } else {
-      return this._resolveConfig(override);
     }
+    return this._resolveConfig(override);
   }
   flushCache() {
   }
@@ -12739,25 +12734,22 @@ class StaticConfigLoader extends ConfigLoader {
     const globalConfig = this.getGlobalConfig();
     if (isThenable(globalConfig)) {
       return globalConfig.then((globalConfig2) => {
-        const merged = globalConfig2.merge(this.resolvers, override);
-        if (isThenable(merged)) {
-          return merged.then((merged2) => {
-            return merged2.resolve();
+        const merged2 = globalConfig2.merge(this.resolvers, override);
+        if (isThenable(merged2)) {
+          return merged2.then((merged3) => {
+            return merged3.resolve();
           });
-        } else {
-          return merged.resolve();
         }
+        return merged2.resolve();
+      });
+    }
+    const merged = globalConfig.merge(this.resolvers, override);
+    if (isThenable(merged)) {
+      return merged.then((merged2) => {
+        return merged2.resolve();
       });
-    } else {
-      const merged = globalConfig.merge(this.resolvers, override);
-      if (isThenable(merged)) {
-        return merged.then((merged2) => {
-          return merged2.resolve();
-        });
-      } else {
-        return merged.resolve();
-      }
     }
+    return merged.resolve();
   }
 }
 
@@ -12844,7 +12836,7 @@ class EventHandler {
 }
 
 const name = "html-validate";
-const version = "11.5.3";
+const version = "11.5.5";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function freeze(src) {
@@ -12882,7 +12874,7 @@ class Reporter {
     for (const report of reports) {
       for (const result of report.results) {
         const key = result.filePath;
-        if (key in merged) {
+        if (Object.hasOwn(merged, key)) {
           merged[key].messages = [...merged[key].messages, ...result.messages];
         } else {
           merged[key] = { ...result };
@@ -12906,7 +12898,7 @@ class Reporter {
    */
   add(options) {
     const { rule, message, severity, node, location, context } = options;
-    if (!(location.filename in this.result)) {
+    if (!Object.hasOwn(this.result, location.filename)) {
       this.result[location.filename] = [];
     }
     const ruleUrl = rule.documentation(context)?.url;
@@ -12934,7 +12926,7 @@ class Reporter {
    * @internal
    */
   addManual(filename, message) {
-    if (!(filename in this.result)) {
+    if (!Object.hasOwn(this.result, filename)) {
       this.result[filename] = [];
     }
     this.result[filename].push(message);
@@ -12945,6 +12937,7 @@ class Reporter {
   save(sources) {
     const report = {
       valid: this.isValid(),
+      /* eslint-disable-next-line unicorn/prefer-object-iterable-methods -- technical debt */
       results: Object.keys(this.result).map((filePath) => {
         const messages = Array.from(this.result[filePath], freeze).toSorted(messageSort);
         const source = (sources ?? []).find((source2) => filePath === source2.filename);
@@ -13009,7 +13002,7 @@ function definePlugin(plugin) {
   return plugin;
 }
 
-const regexp = /<!(?:--)?\[(.*?)](?:--)?>/g;
+const regexp = /<!(?:--)?\[(.*?)\](?:--)?>/g;
 function* parseConditionalComment(comment, commentLocation) {
   let match;
   while ((match = regexp.exec(comment)) !== null) {
@@ -13026,6 +13019,7 @@ function* parseConditionalComment(comment, commentLocation) {
 
 class ParserError extends Error {
   location;
+  /* eslint-disable-next-line unicorn/custom-error-definition -- technical debt */
   constructor(location, message) {
     super(message);
     this.name = "ParserError";
@@ -13189,9 +13183,8 @@ class Parser {
     const open = !token.data[1];
     if (open) {
       return this.wouldCloseElement(token, active);
-    } else {
-      return this.closeOptionalEndTag(token, active);
     }
+    return this.closeOptionalEndTag(token, active);
   }
   /**
    * Returns `true` if the element’s end tag may be omitted, either because
@@ -13543,9 +13536,8 @@ class Parser {
     const quote = token.data[3];
     if (quote) {
       return sliceLocation(token.location, 2, -1);
-    } else {
-      return sliceLocation(token.location, 1);
     }
+    return sliceLocation(token.location, 1);
   }
   /**
    * Take attribute key and value token an returns a new location referring to
@@ -13833,13 +13825,14 @@ class PerformanceTracker {
    */
   getResult() {
     const events = Array.from(
-      this.eventData.entries(),
+      this.eventData,
       ([event, { count, time }]) => ({ event, count, time })
     ).toSorted((a, b) => b.time - a.time);
-    const rules = Array.from(
-      this.ruleData.entries(),
-      ([rule, { count, time }]) => ({ rule, count, time })
-    ).toSorted((a, b) => b.time - a.time);
+    const rules = Array.from(this.ruleData, ([rule, { count, time }]) => ({
+      rule,
+      count,
+      time
+    })).toSorted((a, b) => b.time - a.time);
     return {
       events,
       rules,
@@ -13886,9 +13879,11 @@ function dumpTree(root) {
   return lines;
 }
 
-let blockerCounter = 1;
+const state = {
+  blockerCounter: 1
+};
 function createBlocker() {
-  const id = blockerCounter++;
+  const id = state.blockerCounter++;
   return id;
 }
 
@@ -14024,9 +14019,8 @@ class Engine {
       const [, options] = ruleData;
       const rule = this.instantiateRule(ruleId, options);
       return rule.documentation(context);
-    } else {
-      return null;
     }
+    return null;
   }
   /**
    * Create a new parser instance with the current configuration.
@@ -14155,7 +14149,8 @@ class Engine {
   initRules(config) {
     const availableRules = {};
     for (const plugin of config.getPlugins()) {
-      for (const [name, rule] of Object.entries(plugin.rules ?? {})) {
+      const entries = Object.entries(plugin.rules ?? {});
+      for (const [name, rule] of entries) {
         if (!rule) {
           continue;
         }
@@ -14183,7 +14178,7 @@ class Engine {
    */
   setupRules(config, parser) {
     const rules = {};
-    for (const [ruleId, [severity, options]] of config.getRules().entries()) {
+    for (const [ruleId, [severity, options]] of config.getRules()) {
       rules[ruleId] = this.loadRule(ruleId, config, severity, options, parser, this.report);
     }
     return rules;
@@ -14207,9 +14202,8 @@ class Engine {
     if (this.availableRules[name]) {
       const RuleConstructor = this.availableRules[name];
       return new RuleConstructor(options);
-    } else {
-      return this.missingRule(name);
     }
+    return this.missingRule(name);
   }
   missingRule(name) {
     return new class MissingRule extends Rule {
@@ -14305,34 +14299,30 @@ function getTransformerFunction(resolvers, name, plugins) {
         validateTransformer(transformer2);
         return transformer2;
       });
-    } else {
-      validateTransformer(transformer);
-      return transformer;
     }
+    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));
     }
+    throw new ConfigError(`Failed to load transformer "${name}"`, ensureError(err));
   }
 }
 function getCachedTransformerFunction(cache, resolvers, name, plugins) {
   const cached = cache.get(name);
   if (cached) {
     return cached;
-  } else {
-    const transformer = getTransformerFunction(resolvers, name, plugins);
-    if (isThenable(transformer)) {
-      return transformer.then((transformer2) => {
-        cache.set(name, transformer2);
-        return transformer2;
-      });
-    } else {
-      cache.set(name, transformer);
-      return transformer;
-    }
   }
+  const transformer = getTransformerFunction(resolvers, name, plugins);
+  if (isThenable(transformer)) {
+    return transformer.then((transformer2) => {
+      cache.set(name, transformer2);
+      return transformer2;
+    });
+  }
+  cache.set(name, transformer);
+  return transformer;
 }
 
 function isIterable(value) {
@@ -14348,6 +14338,9 @@ const asyncInSyncTransformError = "Cannot use async transformer from sync functi
 async function transformSource(resolvers, config, source, filename) {
   const { cache } = config;
   const transformer = config.findTransformer(filename ?? source.filename);
+  if (!transformer) {
+    return [source];
+  }
   const context = {
     hasChain(filename2) {
       return config.canTransform(filename2);
@@ -14356,9 +14349,6 @@ async function transformSource(resolvers, config, source, filename) {
       return transformSource(resolvers, config, source2, filename2);
     }
   };
-  if (!transformer) {
-    return [source];
-  }
   const fn = transformer.kind === "import" ? await getCachedTransformerFunction(cache, resolvers, transformer.name, config.getPlugins()) : transformer.function;
   const name = transformer.kind === "import" ? transformer.name : transformer.function.name;
   try {
@@ -14377,6 +14367,9 @@ async function transformSource(resolvers, config, source, filename) {
 function transformSourceSync(resolvers, config, source, filename) {
   const { cache } = config;
   const transformer = config.findTransformer(filename ?? source.filename);
+  if (!transformer) {
+    return [source];
+  }
   const context = {
     hasChain(filename2) {
       return config.canTransform(filename2);
@@ -14385,14 +14378,11 @@ function transformSourceSync(resolvers, config, source, filename) {
       return transformSourceSync(resolvers, config, source2, filename2);
     }
   };
-  if (!transformer) {
-    return [source];
-  }
   const fn = transformer.kind === "import" ? getCachedTransformerFunction(cache, resolvers, transformer.name, config.getPlugins()) : transformer.function;
-  const name = transformer.kind === "import" ? transformer.name : transformer.function.name;
   if (isThenable(fn)) {
     throw new UserError(asyncInSyncTransformError);
   }
+  const name = transformer.kind === "import" ? transformer.name : transformer.function.name;
   try {
     const result = fn.call(context, source);
     if (isThenable(result)) {
@@ -14494,7 +14484,7 @@ function checkstyleFormatter(results) {
 `;
     for (const message of messages) {
       const ruleId = xmlescape(`htmlvalidate.rules.${message.ruleId}`);
-      output += "    ";
+      output += " ".repeat(4);
       output += [
         `<error line="${xmlescape(message.line)}"`,
         `column="${xmlescape(message.column)}"`,
@@ -14581,9 +14571,8 @@ function codeFrameColumns(rawLines, loc) {
         ].join("");
       }
       return [">", gutter, line.length > 0 ? ` ${line}` : "", markerLine].join("");
-    } else {
-      return [" ", gutter, line.length > 0 ? ` ${line}` : ""].join("");
     }
+    return [" ", gutter, line.length > 0 ? ` ${line}` : ""].join("");
   }).join("\n");
 }