html-validate 8.10.0 → 8.11.1

package/dist/cjs/browser.js

@@ -45,6 +45,7 @@ exports.TextNode = core.TextNode;
 exports.UserError = core.UserError;
 exports.Validator = core.Validator;
 exports.WrappedError = core.WrappedError;
+exports.ariaNaming = core.ariaNaming;
 exports.classifyNodeText = core.classifyNodeText;
 exports.configPresets = core.Presets;
 exports.defineConfig = core.defineConfig;

package/dist/cjs/browser.js.map

@@ -1 +1 @@
-{"version":3,"file":"browser.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"browser.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/core.js

@@ -594,8 +594,13 @@ const patternProperties = {
 			implicitRole: {
 				title: "Implicit ARIA role for this element",
 				description: "Some elements have implicit ARIA roles.",
+				deprecated: true,
 				"function": true
 			},
+			aria: {
+				title: "WAI-ARIA properties for this element",
+				$ref: "#/definitions/Aria"
+			},
 			scriptSupporting: {
 				title: "Mark element as script-supporting",
 				description: "Script-supporting elements are elements which can be inserted where othersise not permitted to assist in templating",
@@ -692,6 +697,39 @@ const patternProperties = {
 	}
 };
 const definitions = {
+	Aria: {
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			implicitRole: {
+				title: "Implicit ARIA role for this element",
+				description: "Some elements have implicit ARIA roles.",
+				anyOf: [
+					{
+						type: "string"
+					},
+					{
+						"function": true
+					}
+				]
+			},
+			naming: {
+				title: "Prohibit or allow this element to be named by aria-label or aria-labelledby",
+				anyOf: [
+					{
+						type: "string",
+						"enum": [
+							"prohibited",
+							"allowed"
+						]
+					},
+					{
+						"function": true
+					}
+				]
+			}
+		}
+	},
 	contentCategory: {
 		anyOf: [
 			{
@@ -992,6 +1030,7 @@ const MetaCopyableProperty = [
   "formAssociated",
   "labelable",
   "attributes",
+  "aria",
   "permittedContent",
   "permittedDescendants",
   "permittedOrder",
@@ -1052,7 +1091,27 @@ function migrateAttributes(src) {
   });
   return Object.fromEntries(entries);
 }
+function normalizeAriaImplicitRole(value) {
+  if (!value) {
+    return () => null;
+  }
+  if (typeof value === "string") {
+    return () => value;
+  }
+  return value;
+}
+function normalizeAriaNaming(value) {
+  if (!value) {
+    return () => "allowed";
+  }
+  if (typeof value === "string") {
+    return () => value;
+  }
+  return value;
+}
 function migrateElement(src) {
+  var _a, _b;
+  const implicitRole = normalizeAriaImplicitRole(src.implicitRole ?? ((_a = src.aria) == null ? void 0 : _a.implicitRole));
   const result = {
     ...src,
     ...{
@@ -1061,7 +1120,11 @@ function migrateElement(src) {
     attributes: migrateAttributes(src),
     textContent: src.textContent,
     focusable: src.focusable ?? false,
-    implicitRole: src.implicitRole ?? (() => null)
+    implicitRole,
+    aria: {
+      implicitRole,
+      naming: normalizeAriaNaming((_b = src.aria) == null ? void 0 : _b.naming)
+    }
   };
   delete result.deprecatedAttributes;
   delete result.requiredAttributes;
@@ -1900,11 +1963,82 @@ function factory$1(name, context) {
   }
 }
 
+const escapedCodepoints = ["9", "a", "d"];
+function* splitSelectorElements(selector) {
+  let begin = 0;
+  let end = 0;
+  function initialState(ch, p) {
+    if (ch === "\\") {
+      return 1 /* ESCAPED */;
+    }
+    if (ch === " ") {
+      end = p;
+      return 2 /* WHITESPACE */;
+    }
+    return 0 /* INITIAL */;
+  }
+  function escapedState(ch) {
+    if (escapedCodepoints.includes(ch)) {
+      return 1 /* ESCAPED */;
+    }
+    return 0 /* INITIAL */;
+  }
+  function* whitespaceState(ch, p) {
+    if (ch === " ") {
+      return 2 /* WHITESPACE */;
+    }
+    yield selector.slice(begin, end);
+    begin = p;
+    end = p;
+    return 0 /* INITIAL */;
+  }
+  let state = 0 /* INITIAL */;
+  for (let p = 0; p < selector.length; p++) {
+    const ch = selector[p];
+    switch (state) {
+      case 0 /* INITIAL */:
+        state = initialState(ch, p);
+        break;
+      case 1 /* ESCAPED */:
+        state = escapedState(ch);
+        break;
+      case 2 /* WHITESPACE */:
+        state = yield* whitespaceState(ch, p);
+        break;
+    }
+  }
+  if (begin !== selector.length) {
+    yield selector.slice(begin);
+  }
+}
+
 function stripslashes(value) {
   return value.replace(/\\(.)/g, "$1");
 }
+function unescapeCodepoint(value) {
+  const replacement = {
+    "\\9 ": "	",
+    "\\a ": "\n",
+    "\\d ": "\r"
+  };
+  return value.replace(
+    /(\\[\u0039\u0061\u0064] )/g,
+    (_, codepoint) => replacement[codepoint]
+  );
+}
 function escapeSelectorComponent(text) {
-  return text.toString().replace(/([^a-z0-9_-])/gi, "\\$1");
+  const codepoints = {
+    "	": "\\9 ",
+    "\n": "\\a ",
+    "\r": "\\d "
+  };
+  return text.toString().replace(/([\t\n\r]|[^a-z0-9_-])/gi, (_, ch) => {
+    if (codepoints[ch]) {
+      return codepoints[ch];
+    } else {
+      return `\\${ch}`;
+    }
+  });
 }
 function generateIdSelector(id) {
   const escaped = escapeSelectorComponent(id);
@@ -2019,7 +2153,10 @@ class PseudoClassMatcher extends Matcher {
 }
 class Pattern {
   constructor(pattern) {
-    const match = pattern.match(/^([~+\->]?)((?:[*]|[^.#[:]+)?)(.*)$/);
+    const match = pattern.match(/^([~+\->]?)((?:[*]|[^.#[:]+)?)([^]*)$/);
+    if (!match) {
+      throw new Error(`Failed to create selector pattern from "${pattern}"`);
+    }
     match.shift();
     this.selector = pattern;
     this.combinator = parseCombinator(match.shift(), pattern);
@@ -2074,13 +2211,8 @@ class Selector {
   }
   static parse(selector) {
     selector = selector.replace(/([+~>]) /g, "$1");
-    let begin = 0;
-    const delimiter = /((?:[^\\]) +|$)/g;
-    return Array.from(selector.matchAll(delimiter), (match) => {
-      const end = match.index + 1;
-      const part = selector.slice(begin, end);
-      begin = end + 1;
-      return new Pattern(part);
+    return Array.from(splitSelectorElements(selector), (element) => {
+      return new Pattern(unescapeCodepoint(element));
     });
   }
   static findCandidates(root, pattern) {
@@ -2411,7 +2543,8 @@ class HtmlElement extends DOMNode {
       return this.cacheSet(ROLE, role.value);
     }
     if (this.metaElement) {
-      const implicitRole = this.metaElement.implicitRole(this._adapter);
+      const { aria } = this.metaElement;
+      const implicitRole = aria.implicitRole(this._adapter);
       return this.cacheSet(ROLE, implicitRole);
     }
     return this.cacheSet(ROLE, null);
@@ -3153,6 +3286,48 @@ function interpolate(text, data) {
   });
 }
 
+const cacheKey = Symbol("aria-naming");
+const defaultValue = "allowed";
+const prohibitedRoles = [
+  "caption",
+  "code",
+  "deletion",
+  "emphasis",
+  "generic",
+  "insertion",
+  "paragraph",
+  "presentation",
+  "strong",
+  "subscript",
+  "superscript"
+];
+function byRole(role) {
+  return prohibitedRoles.includes(role) ? "prohibited" : "allowed";
+}
+function byMeta(element, meta) {
+  return meta.aria.naming(element._adapter);
+}
+function ariaNaming(element) {
+  var _a;
+  const cached = element.cacheGet(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const role = (_a = element.getAttribute("role")) == null ? void 0 : _a.value;
+  if (role) {
+    if (role instanceof DynamicValue) {
+      return element.cacheSet(cacheKey, defaultValue);
+    } else {
+      return element.cacheSet(cacheKey, byRole(role));
+    }
+  }
+  const meta = element.meta;
+  if (!meta) {
+    return element.cacheSet(cacheKey, defaultValue);
+  }
+  return element.cacheSet(cacheKey, byMeta(element, meta));
+}
+
 const patternCache = /* @__PURE__ */ new Map();
 function compileStringPattern(pattern) {
   const regexp = pattern.replace(/[*]+/g, ".+");
@@ -3671,7 +3846,7 @@ class Rule {
   }
 }
 
-const defaults$u = {
+const defaults$v = {
   allowExternal: true,
   allowRelative: true,
   allowAbsolute: true,
@@ -3712,7 +3887,7 @@ function matchList(value, list) {
 }
 class AllowedLinks extends Rule {
   constructor(options) {
-    super({ ...defaults$u, ...options });
+    super({ ...defaults$v, ...options });
     this.allowExternal = parseAllow(this.options.allowExternal);
     this.allowRelative = parseAllow(this.options.allowRelative);
     this.allowAbsolute = parseAllow(this.options.allowAbsolute);
@@ -3876,7 +4051,7 @@ class AllowedLinks extends Rule {
   }
 }
 
-const defaults$t = {
+const defaults$u = {
   accessible: true
 };
 function findByTarget(target, siblings) {
@@ -3906,7 +4081,7 @@ function getDescription$1(context) {
 }
 class AreaAlt extends Rule {
   constructor(options) {
-    super({ ...defaults$t, ...options });
+    super({ ...defaults$u, ...options });
   }
   static schema() {
     return {
@@ -3985,6 +4160,9 @@ class AriaHiddenBody extends Rule {
   }
 }
 
+const defaults$t = {
+  allowAnyNamable: false
+};
 const whitelisted = [
   "main",
   "nav",
@@ -4023,6 +4201,9 @@ function isValidUsage(target, meta) {
   return false;
 }
 class AriaLabelMisuse extends Rule {
+  constructor(options) {
+    super({ ...defaults$t, ...options });
+  }
   documentation() {
     const valid = [
       "Interactive elements",
@@ -4065,6 +4246,9 @@ ${lines}`,
     if (isValidUsage(target, meta)) {
       return;
     }
+    if (this.options.allowAnyNamable && ariaNaming(target) === "allowed") {
+      return;
+    }
     this.report(target, `"aria-label" cannot be used on this element`, attr.keyLocation);
   }
 }
@@ -7562,7 +7746,7 @@ class NoRedundantRole extends Rule {
       if (!meta) {
         return;
       }
-      const implicitRole = meta.implicitRole(target._adapter);
+      const implicitRole = meta.aria.implicitRole(target._adapter);
       if (!implicitRole) {
         return;
       }
@@ -9344,7 +9528,7 @@ const config$4 = {
   rules: {
     "area-alt": ["error", { accessible: true }],
     "aria-hidden-body": "error",
-    "aria-label-misuse": "error",
+    "aria-label-misuse": ["error", { allowAnyNamable: false }],
     "deprecated-rule": "warn",
     "empty-heading": "error",
     "empty-title": "error",
@@ -9396,7 +9580,7 @@ const config$1 = {
   rules: {
     "area-alt": ["error", { accessible: true }],
     "aria-hidden-body": "error",
-    "aria-label-misuse": "error",
+    "aria-label-misuse": ["error", { allowAnyNamable: false }],
     "attr-case": "error",
     "attr-delimiter": "error",
     "attr-quotes": "error",
@@ -9477,6 +9661,7 @@ var recommended = config$1;
 const config = {
   rules: {
     "area-alt": ["error", { accessible: false }],
+    "aria-label-misuse": ["error", { allowAnyNamable: true }],
     "attr-spacing": "error",
     "attribute-allowed-values": "error",
     "attribute-misuse": "error",
@@ -11729,7 +11914,7 @@ class HtmlValidate {
 }
 
 const name = "html-validate";
-const version = "8.10.0";
+const version = "8.11.1";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function definePlugin(plugin) {
@@ -12636,6 +12821,7 @@ exports.TextNode = TextNode;
 exports.UserError = UserError;
 exports.Validator = Validator;
 exports.WrappedError = WrappedError;
+exports.ariaNaming = ariaNaming;
 exports.bugs = bugs;
 exports.classifyNodeText = classifyNodeText;
 exports.codeframe = codeframe;