html-validate 11.2.0 → 11.3.0

package/dist/cjs/core.js

@@ -1075,6 +1075,7 @@ const MetaCopyableProperty = [
   "labelable",
   "submitButton",
   "attributes",
+  "patternAttributes",
   "aria",
   "permittedContent",
   "permittedDescendants",
@@ -1087,6 +1088,54 @@ function setMetaProperty(dst, key, value) {
   dst[key] = value;
 }
 
+const SYNTAX_CHARACTERS = /[$()*+.?[\\\]^{|}]/;
+const CONTROL_ESCAPES = /* @__PURE__ */ new Map([
+  ["	", "t"],
+  ["\n", "n"],
+  ["\v", "v"],
+  ["\f", "f"],
+  ["\r", "r"]
+]);
+const OTHER_PUNCTUATORS = /^[!"#%&',:;<=>@`~-]$/;
+const WHITE_SPACE = /^[\t\v\f\uFEFF\p{Zs}]$/u;
+const LINE_TERMINATOR = /^[\n\r\u2028\u2029]$/;
+const SURROGATE = /^[\uD800-\uDFFF]$/;
+function isDecimalDigitOrASCIILetter(ch) {
+  return /^[\dA-Za-z]$/.test(ch);
+}
+function needEscape(ch) {
+  return OTHER_PUNCTUATORS.test(ch) || WHITE_SPACE.test(ch) || LINE_TERMINATOR.test(ch) || SURROGATE.test(ch);
+}
+function unicodeEscape(ch) {
+  return `\\u${ch.codePointAt(0).toString(16).padStart(4, "0")}`;
+}
+function encodeForRegExpEscape(ch) {
+  if (SYNTAX_CHARACTERS.test(ch) || ch === "/") {
+    return `\\${ch}`;
+  }
+  if (CONTROL_ESCAPES.has(ch)) {
+    return `\\${CONTROL_ESCAPES.get(ch)}`;
+  }
+  if (needEscape(ch)) {
+    if (/[\u0000-\u00FF]/.test(ch)) {
+      return `\\x${ch.codePointAt(0).toString(16).padStart(2, "0")}`;
+    }
+    return ch.split("").map((c) => unicodeEscape(c)).join("");
+  }
+  return ch;
+}
+function regexpEscape(str) {
+  let escaped = "";
+  for (const c of str) {
+    if (escaped === "" && isDecimalDigitOrASCIILetter(c)) {
+      escaped += `\\x${c.codePointAt(0).toString(16).padStart(2, "0")}`;
+    } else {
+      escaped += encodeForRegExpEscape(c);
+    }
+  }
+  return escaped;
+}
+
 function isSet(value) {
   return value !== void 0;
 }
@@ -1124,18 +1173,35 @@ function migrateSingleAttribute(src, key) {
     return stripUndefined({ ...result, ...attr });
   }
 }
+function isPatternAttribute$1(key) {
+  return key.includes("*");
+}
+function patternToRegex(pattern) {
+  const escaped = pattern.split("*").map(regexpEscape).join(".+");
+  return new RegExp(`^${escaped}$`, "i");
+}
 function migrateAttributes(src) {
   const keys = [
     ...Object.keys(src.attributes ?? {}),
     ...src.requiredAttributes ?? [],
     ...src.deprecatedAttributes ?? []
-    /* eslint-disable-next-line sonarjs/no-alphabetical-sort -- not really needed in this case, this is a-z anyway */
-  ].toSorted();
+  ].filter((key) => !isPatternAttribute$1(key)).toSorted();
   const entries = keys.map((key) => {
     return [key, migrateSingleAttribute(src, key)];
   });
   return Object.fromEntries(entries);
 }
+function migratePatternAttributes(src) {
+  const attrs = src.attributes ?? {};
+  return Object.entries(attrs).filter(([key]) => isPatternAttribute$1(key)).map(([pattern]) => {
+    const { delete: deleted, ...attr } = migrateSingleAttribute(src, pattern);
+    const regexp = patternToRegex(pattern);
+    if (deleted) {
+      return { pattern, regexp, delete: true };
+    }
+    return { ...attr, pattern, regexp };
+  });
+}
 function normalizeAriaImplicitRole(value) {
   if (!value) {
     return () => null;
@@ -1160,6 +1226,7 @@ function migrateElement(src) {
     ...src,
     formAssociated: void 0,
     attributes: migrateAttributes(src),
+    patternAttributes: migratePatternAttributes(src),
     textContent: src.textContent,
     focusable: src.focusable ?? false,
     implicitRole,
@@ -1389,6 +1456,18 @@ class MetaTable {
       }
     }
     merged.attributes = mergedAttrs;
+    const mergedPatterns = [
+      ...b.patternAttributes,
+      ...a.patternAttributes ?? []
+    ];
+    const seenPatterns = /* @__PURE__ */ new Set();
+    merged.patternAttributes = mergedPatterns.filter((entry) => {
+      if (seenPatterns.has(entry.pattern)) {
+        return false;
+      }
+      seenPatterns.add(entry.pattern);
+      return !entry.delete;
+    });
     if (a.aria) {
       merged.aria = { ...a.aria, ...b.aria };
     }
@@ -3466,6 +3545,10 @@ function isKeywordIgnored(options, keyword, matcher = (list, it) => list.include
   return false;
 }
 
+function isPatternAttribute(attrName, dynamicAttributes) {
+  return dynamicAttributes.some((entry) => entry.regexp.test(attrName));
+}
+
 const ARIA_HIDDEN_CACHE = Symbol(isAriaHidden.name);
 const HTML_HIDDEN_CACHE = Symbol(isHTMLHidden.name);
 const INERT_CACHE = Symbol(isInert.name);
@@ -8968,18 +9051,7 @@ class NoTrailingWhitespace extends Rule {
   }
 }
 
-const skipPatterns = [
-  /^data-/i,
-  /^aria-/i,
-  /^on[a-z]/i,
-  /^xml(ns)?:/i,
-  /^:/,
-  /^@/,
-  /^ng-/i,
-  /^v-/i,
-  /^x-/i,
-  /^\[/
-];
+const skipPatterns = [/^:/, /^@/, /^ng-/i, /^v-/i, /^x-/i, /^\[/, /^#/];
 function isKnownDynamicAttr(attr) {
   return skipPatterns.some((pattern) => pattern.test(attr));
 }
@@ -9001,6 +9073,9 @@ class NoUnknownAttributes extends Rule {
       if (attr in meta.attributes) {
         return;
       }
+      if (isPatternAttribute(attr, meta.patternAttributes)) {
+        return;
+      }
       if (isKnownDynamicAttr(attr)) {
         return;
       }
@@ -12639,7 +12714,7 @@ class EventHandler {
 }
 
 const name = "html-validate";
-const version = "11.2.0";
+const version = "11.3.0";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function freeze(src) {