@surea11y/core 1.0.0

package/src/checks/automatic/form-control-programmatic-label-present.js

@@ -0,0 +1,409 @@
+'use strict';
+
+/**
+ * Optimized, regression-safe rewrite of:
+ * form-control-programmatic-label-present
+ *
+ * Goals:
+ * - Preserve semantics, schema, determinism, and no-throw behavior.
+ * - Reduce per-element DOM queries and avoid unnecessary helper calls.
+ *
+ * Key safety points:
+ * - Control discovery goes through helpers.queryAllSmart/queryAll (multi-root
+ *   and shadow-DOM aware), not a direct root/safeRoot DOM query -- ctx.root
+ *   is an array (multi-region contextSelector support), not a single element.
+ * - label[for] association uses a single precomputed Set of `for` values (document-wide, like original).
+ * - getFocusableInfo is only invoked when role is presentational and thus relevant.
+ * - aria-labelledby / aria-label helper resolution is only invoked when the attribute is present.
+ *
+ * WCAG mapping: matches technique H44 ("Using label elements to associate
+ * text labels with form controls"), which WCAG's own Techniques document
+ * lists as sufficient for 1.3.1, 3.3.2, AND 4.1.2 simultaneously — a label
+ * that programmatically associates with a control conveys the
+ * relationship (1.3.1), provides the instruction (3.3.2), and exposes the
+ * accessible name (4.1.2) all at once. This rule was originally only wired
+ * to 4.1.2, even though its own `tags` already listed wcag131/wcag332 and
+ * wcag-facets.js already had matching facet ids under those SCs.
+ */
+
+const id = 'form-control-programmatic-label-present';
+
+const meta = {
+  title: 'Form controls must have a programmatic label',
+  description:
+    'Checks that form controls have a programmatic label via <label>, aria-label, aria-labelledby, title, or placeholder.',
+  i18n: {
+    titleKey: 'formControl_programmaticLabelPresent_title',
+    descriptionKey: 'formControl_programmaticLabelPresent_description'
+  },
+  helpUrl: null,
+  tags: ['wcag2a', 'wcag131', 'wcag332', 'wcag412', 'forms', 'labels', 'atomic', 'automatic'],
+  wcagSc: ['1.3.1', '3.3.2', '4.1.2'],
+  normativeMappings: [
+    { standard: 'WCAG', version: '2.2', requirement: '1.3.1', title: 'Info and Relationships', conformanceLevel: 'A' },
+    { standard: 'WCAG', version: '2.2', requirement: '3.3.2', title: 'Labels or Instructions', conformanceLevel: 'A' },
+    { standard: 'WCAG', version: '2.2', requirement: '4.1.2', title: 'Name, Role, Value', conformanceLevel: 'A' }
+  ],
+  defaultSeverity: 'serious',
+  category: 'robust',
+  type: 'automatic',
+  defaultConfidence: 'medium',
+  coverage: {
+    facetsBySc: {
+      '1.3.1': ['form-control-programmatic-label-present'],
+      '3.3.2': ['form-control-labels-or-instructions-present'],
+      '4.1.2': ['form-control-name-present']
+    }
+  }
+};
+
+function runInPage(ctx) {
+  const { document, helpers, rule } = ctx;
+
+  const isAccTreeEligible = helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+  const getEligibilityInfo = helpers && typeof helpers.getEligibilityInfo === 'function' ? helpers.getEligibilityInfo : null;
+
+  const getFocusableInfo = helpers && typeof helpers.getFocusableInfo === 'function' ? helpers.getFocusableInfo : null;
+  const getAriaLabelInfo = helpers && typeof helpers.getAriaLabelInfo === 'function' ? helpers.getAriaLabelInfo : null;
+  const getAriaLabelledByInfo =
+    helpers && typeof helpers.getAriaLabelledByInfo === 'function' ? helpers.getAriaLabelledByInfo : null;
+
+  const getAttributeInfo = helpers && typeof helpers.getAttributeInfo === 'function' ? helpers.getAttributeInfo : null;
+  const getLabelMethod = helpers && typeof helpers.getLabelMethod === 'function' ? helpers.getLabelMethod : null;
+  const getContentNameInfo = helpers && typeof helpers.getContentNameInfo === 'function' ? helpers.getContentNameInfo : null;
+  const getAriaNameInfo = helpers && typeof helpers.getAriaNameInfo === 'function' ? helpers.getAriaNameInfo : null;
+
+  // A <label> counts as an association if it contributes a name either via
+  // its own aria-label/aria-labelledby (checked first, same ARIA-over-
+  // content precedence any element's accessible name gives — verified
+  // against a real page: <label aria-label="Toggle Navigation"><svg
+  // aria-hidden="true">...</svg></label> names its control "Toggle
+  // Navigation" even though the label's only child content is aria-hidden)
+  // or, failing that, non-empty ACCESSIBLE content (getContentNameInfo
+  // already excludes aria-hidden/display:none/inert descendants — a label
+  // whose only text is aria-hidden gives the control no real accessible
+  // name even though the structural association exists). See
+  // dom-helpers.js's labelContributesAccessibleName for the primary
+  // (shared-helper) path; this is the fallback-only mirror.
+  function labelHasAccessibleContent(labelEl) {
+    if (getAriaNameInfo) {
+      try {
+        const aria = getAriaNameInfo(labelEl, ctx);
+        if (aria && aria.present && trim(aria.value)) return true;
+      } catch {}
+    }
+    if (!getContentNameInfo) return true; // conservative: don't newly fail without the helper
+    try {
+      const info = getContentNameInfo(labelEl, ctx);
+      return !!(info && info.present && trim(info.value));
+    } catch {
+      return true;
+    }
+  }
+
+  const trim = (v) => (v == null ? '' : String(v)).trim();
+
+  const metrics = {
+    applicableCount: 0,
+    passCount: 0,
+    failCount: 0,
+    byMethod: { label: 0, 'aria-labelledby': 0, 'aria-label': 0, title: 0, placeholder: 0, none: 0 },
+    weakPassCount: 0
+  };
+
+  function getLabelStrength(method) {
+    if (method === 'label' || method === 'aria-labelledby') return 'strong';
+    if (method === 'aria-label') return 'medium';
+    if (method === 'title' || method === 'placeholder') return 'weak';
+    return 'none';
+  }
+
+  function getNonEmptyAttrViaHelper(el, name) {
+    if (!getAttributeInfo) return '';
+    try {
+      const info = getAttributeInfo(el, name);
+      return info && info.present ? trim(info.value) : '';
+    } catch {
+      return '';
+    }
+  }
+
+  // Build a document-wide Map of label[for] value -> label element once
+  // (O(#labels) instead of O(#controls) selector queries). Keeps the
+  // element reference (not just a presence flag) so hasLabelAssociation can
+  // check the label's actual accessible content.
+  const labelForMap = new Map();
+  try {
+    if (document && typeof document.getElementsByTagName === 'function') {
+      const labels = document.getElementsByTagName('label');
+      for (let i = 0; i < labels.length; i++) {
+        const lab = labels[i];
+        if (!lab || !lab.getAttribute) continue;
+        const f = trim(lab.getAttribute('for'));
+        if (f && !labelForMap.has(f)) labelForMap.set(f, lab);
+      }
+    }
+  } catch {
+    // no-throw
+  }
+
+  function isEligibleAcc(el) {
+    if (!isAccTreeEligible) return true;
+    try {
+      const r = isAccTreeEligible(el, ctx);
+      if (typeof r === 'boolean') return r;
+      return !!(r && r.eligible);
+    } catch {
+      return true;
+    }
+  }
+
+  function hasLabelAssociation(el) {
+    // 1) Native labels API — resolves both wrapping <label> and
+    // <label for="id"> as real elements in one call.
+    try {
+      if (el && 'labels' in el && el.labels && el.labels.length) {
+        return Array.prototype.some.call(el.labels, labelHasAccessibleContent);
+      }
+    } catch {}
+
+    // 2) Wrapped by <label>
+    try {
+      if (el && el.closest) {
+        const wrap = el.closest('label');
+        if (wrap) return labelHasAccessibleContent(wrap);
+      }
+    } catch {}
+
+    // 3) <label for="id">
+    try {
+      const idAttr = el && el.getAttribute ? trim(el.getAttribute('id')) : '';
+      if (!idAttr) return false;
+      const lab = labelForMap.get(idAttr);
+      return !!lab && labelHasAccessibleContent(lab);
+    } catch {
+      return false;
+    }
+  }
+
+  function computeLabelMethodFallback(el) {
+    // Deterministic priority order
+    if (hasLabelAssociation(el)) return { method: 'label', value: '' };
+
+    // Only resolve aria-labelledby if attribute exists
+    let raw = '';
+    try {
+      raw = el && el.getAttribute ? trim(el.getAttribute('aria-labelledby')) : '';
+    } catch {
+      raw = '';
+    }
+    if (raw && getAriaLabelledByInfo) {
+      try {
+        const info = getAriaLabelledByInfo(el, ctx, { maxRefs: 8 });
+        const v = info && info.present ? trim(info.value) : '';
+        if (v) return { method: 'aria-labelledby', value: v };
+      } catch {}
+    }
+
+    // Only resolve aria-label if attribute exists
+    raw = '';
+    try {
+      raw = el && el.getAttribute ? trim(el.getAttribute('aria-label')) : '';
+    } catch {
+      raw = '';
+    }
+    if (raw && getAriaLabelInfo) {
+      try {
+        const info = getAriaLabelInfo(el, ctx);
+        const v = info && info.present ? trim(info.value) : '';
+        if (v) return { method: 'aria-label', value: v };
+      } catch {}
+    }
+
+    // title / placeholder
+    const titleV = getNonEmptyAttrViaHelper(el, 'title') || (() => {
+      try { return trim(el.getAttribute('title')); } catch { return ''; }
+    })();
+    if (titleV) return { method: 'title', value: titleV };
+
+    // `placeholder` is only a valid name/hint source for text-entry input
+    // types and <textarea> — not checkbox/radio/range/color/date/... or
+    // <select>, which browsers/AT never read a placeholder from.
+    const isPlaceholderCapable = (() => {
+      try {
+        const tag = (el.tagName || '').toLowerCase();
+        if (tag === 'textarea') return true;
+        if (tag !== 'input') return false;
+        const type = trim(el.getAttribute('type') || 'text').toLowerCase() || 'text';
+        return ['text', 'search', 'tel', 'url', 'email', 'password', 'number'].includes(type);
+      } catch {
+        return false;
+      }
+    })();
+
+    const phV = isPlaceholderCapable && (getNonEmptyAttrViaHelper(el, 'placeholder') || (() => {
+      try { return trim(el.getAttribute('placeholder')); } catch { return ''; }
+    })());
+    if (phV) return { method: 'placeholder', value: phV };
+
+    return { method: 'none', value: '' };
+  }
+
+  function getLabelMethodSafe(el) {
+    if (getLabelMethod) {
+      try {
+        const r = getLabelMethod(el, ctx);
+        const m = r && typeof r.method === 'string' ? r.method : 'none';
+        const v = r && r.value != null ? trim(r.value) : '';
+        if (!Object.prototype.hasOwnProperty.call(metrics.byMethod, m)) return { method: 'none', value: '' };
+        return { method: m, value: v };
+      } catch {
+        // fall through
+      }
+    }
+    return computeLabelMethodFallback(el);
+  }
+
+  // Collect candidate nodes via the shared queryAllSmart/queryAll helpers
+  // (multi-root/shadow-DOM-aware, cached) rather than raw safeRoot DOM
+  // access -- safeRoot is ctx.root, which is an array with multi-region
+  // contextSelector support and never had a .querySelectorAll/
+  // .getElementsByTagName of its own to call directly.
+  const nodes = [];
+  try {
+    const sel = 'input,select,textarea';
+    const candidates = (helpers && typeof helpers.queryAllSmart === 'function')
+      ? helpers.queryAllSmart(sel)
+      : (helpers && typeof helpers.queryAll === 'function' ? helpers.queryAll(sel) : []);
+
+    for (const el of (candidates || [])) {
+      if (!el || !el.getAttribute) continue;
+      const tag = (el.tagName || '').toLowerCase();
+      if (tag === 'input') {
+        const t = trim(el.getAttribute('type')).toLowerCase();
+        // exclude hidden|submit|reset|button|image
+        if (t === 'hidden' || t === 'submit' || t === 'reset' || t === 'button' || t === 'image') continue;
+      }
+      nodes.push(el);
+    }
+  } catch {
+    // no-throw
+  }
+
+  if (!nodes.length) {
+    return {
+      ruleId: rule.ruleId,
+      outcome: 'notApplicable',
+      severity: 'minor',
+      occurrences: [],
+      data: { details: { metrics } }
+    };
+  }
+
+  const occurrences = [];
+
+  for (let i = 0; i < nodes.length; i++) {
+    const el = nodes[i];
+    if (!el || !el.getAttribute) continue;
+
+    if (!isEligibleAcc(el)) continue;
+
+    // role="presentation"/"none" exclusion only when NOT focusable
+    let role = '';
+    try {
+      role = trim(el.getAttribute('role')).toLowerCase();
+    } catch {
+      role = '';
+    }
+
+    if (role === 'presentation' || role === 'none') {
+      const fi = getFocusableInfo
+        ? (() => {
+            try {
+              return getFocusableInfo(el, ctx);
+            } catch {
+              return null;
+            }
+          })()
+        : null;
+      const tabbable = !!(fi && fi.tabbable);
+      if (!tabbable) continue;
+    }
+
+    metrics.applicableCount += 1;
+
+    const label = getLabelMethodSafe(el);
+    if (Object.prototype.hasOwnProperty.call(metrics.byMethod, label.method)) {
+      metrics.byMethod[label.method] += 1;
+    } else {
+      metrics.byMethod.none += 1;
+    }
+
+    const strength = getLabelStrength(label.method);
+    const ok = label.method !== 'none';
+
+    if (ok) {
+      metrics.passCount += 1;
+      if (strength === 'weak') metrics.weakPassCount += 1;
+      continue;
+    }
+
+    metrics.failCount += 1;
+
+    const vf = getEligibilityInfo ? (() => { try { return getEligibilityInfo(el, ctx, { targetSet: 'acc' }); } catch { return null; } })() : null;
+
+    const baseOccurrence = {
+      summary: 'Form control is missing a programmatic label.',
+      hint: 'Provide a <label> association, aria-label, aria-labelledby, title, or placeholder.',
+      i18n: {
+        summaryKey: 'formControl_programmaticLabelPresent_summary_fail',
+        hintKey: 'formControl_programmaticLabelPresent_hint_fail',
+        params: { element: (el.tagName || '').toLowerCase() }
+      },
+      data: {
+        visibilityFilter: vf
+          ? { targetSet: vf.targetSet, accEligible: vf.accEligible, reasons: vf.reasons }
+          : { targetSet: 'acc', accEligible: null, reasons: [] },
+        details: {
+          reasonCode: 'missing_programmatic_label',
+          labelMethod: 'none',
+          labelStrength: 'none'
+        }
+      }
+    };
+
+    if (helpers && typeof helpers.reportOccurrence === 'function') {
+      occurrences.push(helpers.reportOccurrence(el, baseOccurrence));
+    } else {
+      occurrences.push({ selector: '', html: '', ...baseOccurrence });
+    }
+  }
+
+  if (metrics.applicableCount === 0) {
+    return {
+      ruleId: rule.ruleId,
+      outcome: 'notApplicable',
+      severity: 'minor',
+      occurrences: [],
+      data: { details: { metrics } }
+    };
+  }
+  if (occurrences.length) {
+    return {
+      ruleId: rule.ruleId,
+      outcome: 'fail',
+      severity: rule.defaultSeverity || 'minor',
+      occurrences,
+      data: { details: { metrics } }
+    };
+  }
+  return {
+    ruleId: rule.ruleId,
+    outcome: 'pass',
+    severity: 'minor',
+    occurrences: [],
+    data: { details: { metrics } }
+  };
+}
+
+module.exports = { id, meta, runInPage };

package/src/checks/automatic/form-control-single-label.js

@@ -0,0 +1,117 @@
+'use strict';
+
+/**
+ * @check form-control-single-label
+ * @atomic true
+ * @summary A form control must not be associated with more than one <label>
+ * @standard WCAG 2.2
+ * @sc 3.3.2
+ * @applicability
+ *   Applies to labelable form controls (input, excluding
+ *   hidden/submit/reset/button/image; select; textarea).
+ * @expectation
+ *   At most one <label> is associated with the control — either by
+ *   wrapping it, or by a <label for="..."> pointing to its id
+ *   (deduplicated: a label that both wraps the control and
+ *   self-references it via for counts once). Multiple associated labels
+ *   are ambiguous: many screen readers only announce one of them, and it
+ *   is not deterministic which.
+ * @implementation-notes
+ * - Matches a widely-used reference engine's form-field-multiple-labels. Distinct, atomic
+ *   decision from form-control-programmatic-label-present (that
+ *   rule checks a label exists at all; this one checks there is at most
+ *   one).
+ */
+
+const id = 'form-control-single-label';
+
+const meta = {
+  title: 'Form controls must not have multiple labels',
+  description: 'Checks that a form control is associated with at most one <label> (by wrapping or by label[for]).',
+  i18n: {
+    titleKey: 'formControlSingleLabel_title',
+    descriptionKey: 'formControlSingleLabel_description'
+  },
+  helpUrl: null,
+  tags: ['wcag2a', 'wcag332', 'forms', 'atomic', 'automatic'],
+  wcagSc: ['3.3.2'],
+  normativeMappings: [
+    { standard: 'WCAG', version: '2.2', requirement: '3.3.2', title: 'Labels or Instructions', conformanceLevel: 'A' }
+  ],
+  defaultSeverity: 'moderate',
+  category: 'understandable',
+  type: 'automatic',
+  defaultConfidence: 'high',
+  coverage: { facetsBySc: { '3.3.2': ['form-control-single-label'] } }
+};
+
+function runInPage(ctx) {
+  const { document, root, helpers, rule } = ctx;
+  const safeRoot = root || document;
+
+  const selector = 'input:not([type="hidden"]):not([type="submit"]):not([type="reset"]):not([type="button"]):not([type="image"]),select,textarea';
+  const nodes = helpers.queryAllSmart ? helpers.queryAllSmart(selector, safeRoot) : helpers.queryAll(selector, safeRoot);
+
+  // Build a for-value -> label[] map once (avoids per-control dynamic
+  // attribute-selector construction / CSS.escape, which is not guaranteed
+  // to exist as a global in every runtime this engine executes in).
+  const labelsByFor = new Map();
+  const allLabels = document.getElementsByTagName ? document.getElementsByTagName('label') : [];
+  for (const lab of allLabels) {
+    if (!lab || !lab.getAttribute) continue;
+    const forValue = String(lab.getAttribute('for') || '').trim();
+    if (!forValue) continue;
+    if (!labelsByFor.has(forValue)) labelsByFor.set(forValue, []);
+    labelsByFor.get(forValue).push(lab);
+  }
+
+  const occurrences = [];
+  let applicableCount = 0;
+
+  for (const el of nodes) {
+    if (!el || !el.getAttribute) continue;
+
+    applicableCount += 1;
+
+    const labels = new Set();
+
+    const wrappingLabel = el.closest ? el.closest('label') : null;
+    if (wrappingLabel) labels.add(wrappingLabel);
+
+    const controlId = String(el.getAttribute('id') || '').trim();
+    if (controlId && labelsByFor.has(controlId)) {
+      for (const lab of labelsByFor.get(controlId)) labels.add(lab);
+    }
+
+    if (labels.size <= 1) continue;
+
+    const tag = el.tagName.toLowerCase();
+    const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
+    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : (el.outerHTML || '');
+
+    occurrences.push({
+      selector: stableSelector,
+      html,
+      summary: 'This form control is associated with more than one <label>.',
+      hint: 'Keep only one <label> per form control (either wrapping it or referencing it via for/id).',
+      i18n: {
+        summaryKey: 'formControlSingleLabel_summary_fail',
+        hintKey: 'formControlSingleLabel_hint_fail',
+        params: { element: tag, labelCount: String(labels.size) }
+      },
+      data: {
+        details: { reasonCode: 'FORM_FIELD_MULTIPLE_LABELS', element: tag, labelCount: labels.size }
+      }
+    });
+  }
+
+  if (applicableCount === 0) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+  if (occurrences.length) {
+    return { ruleId: rule.ruleId, outcome: 'fail', severity: rule.defaultSeverity || 'moderate', occurrences };
+  }
+  return { ruleId: rule.ruleId, outcome: 'pass', severity: 'minor', occurrences: [] };
+}
+
+module.exports = { id, meta, runInPage };

package/src/checks/automatic/html-xml-lang-mismatch.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * @check html-xml-lang-mismatch
+ * @atomic true
+ * @summary The lang and xml:lang attributes on <html> must not disagree
+ * @standard WCAG 2.2
+ * @sc 3.1.1
+ * @applicability
+ *   Applies when the <html> element has both a non-empty lang attribute
+ *   and a non-empty xml:lang attribute.
+ * @expectation
+ *   The primary language subtag (the part before the first "-") of lang
+ *   and xml:lang match, case-insensitively. When both attributes are
+ *   present but declare different languages, assistive technology and
+ *   user agents may resolve the page's language inconsistently.
+ * @implementation-notes
+ * - Distinct, atomic decision from html-lang-attr-present (that
+ *   rule checks presence/syntax of lang alone; this rule checks
+ *   agreement between lang and xml:lang when both exist).
+ * - Compares primary subtags only (not full tag equality), since e.g.
+ *   lang="en-US" and xml:lang="en-GB" both correctly declare English and
+ *   should not be flagged as disagreeing on language.
+ */
+
+const id = 'html-xml-lang-mismatch';
+
+const meta = {
+  title: 'lang and xml:lang must not disagree',
+  description: 'Checks that the <html> element\'s lang and xml:lang attributes declare the same primary language, when both are present.',
+  i18n: {
+    titleKey: 'htmlXmlLangMismatch_title',
+    descriptionKey: 'htmlXmlLangMismatch_description'
+  },
+  helpUrl: null,
+  tags: ['wcag2a', 'wcag311', 'structure', 'language', 'atomic', 'automatic'],
+  wcagSc: ['3.1.1'],
+  normativeMappings: [
+    { standard: 'WCAG', version: '2.2', requirement: '3.1.1', title: 'Language of Page', conformanceLevel: 'A' }
+  ],
+  defaultSeverity: 'serious',
+  category: 'understandable',
+  type: 'automatic',
+  defaultConfidence: 'high',
+  coverage: { facetsBySc: { '3.1.1': ['html-xml-lang-mismatch'] } }
+};
+
+function runInPage(ctx) {
+  const { document, helpers, rule } = ctx;
+
+  const html = document && document.documentElement;
+  const tag = (html && html.tagName) ? String(html.tagName).toLowerCase() : '';
+  if (!html || tag !== 'html') {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  const lang = String(html.getAttribute('lang') || '').trim();
+  const xmlLang = String(html.getAttribute('xml:lang') || '').trim();
+
+  if (!lang || !xmlLang) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  const primary = (s) => s.split('-')[0].toLowerCase();
+
+  if (primary(lang) === primary(xmlLang)) {
+    return { ruleId: rule.ruleId, outcome: 'pass', severity: 'minor', occurrences: [] };
+  }
+
+  const stableSelector = helpers.buildSelector ? helpers.buildSelector(html) : 'html';
+  const htmlSnippet = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(html) : (html.outerHTML || '').slice(0, 200);
+
+  const occurrences = [{
+    selector: stableSelector,
+    html: htmlSnippet,
+    summary: `The lang ("${lang}") and xml:lang ("${xmlLang}") attributes declare different languages.`,
+    hint: 'Make lang and xml:lang declare the same primary language, or remove the deprecated xml:lang attribute.',
+    i18n: {
+      summaryKey: 'htmlXmlLangMismatch_summary_fail',
+      hintKey: 'htmlXmlLangMismatch_hint_fail',
+      params: { lang, xmlLang }
+    },
+    data: {
+      details: { reasonCode: 'HTML_XML_LANG_MISMATCH', lang, xmlLang }
+    }
+  }];
+
+  return { ruleId: rule.ruleId, outcome: 'fail', severity: rule.defaultSeverity || 'serious', occurrences };
+}
+
+module.exports = { id, meta, runInPage };