bettera11y 0.2.1

package/dist/index.cjs

@@ -0,0 +1,853 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BETTERA11Y_API_VERSION: () => BETTERA11Y_API_VERSION,
+  MockAdapter: () => MockAdapter,
+  coreRules: () => coreRules,
+  createDiagnosticFingerprint: () => createDiagnosticFingerprint,
+  createEngine: () => createEngine,
+  createJsonReporter: () => createJsonReporter,
+  createMachineReporter: () => createMachineReporter,
+  createPrettyReporter: () => createPrettyReporter,
+  createRangeLocation: () => createRangeLocation,
+  defaultRules: () => defaultRules,
+  getSha256: () => getSha256,
+  positionFromOffset: () => positionFromOffset,
+  recommendedPreset: () => recommendedPreset,
+  selectorToSourceLocation: () => selectorToSourceLocation,
+  strictPreset: () => strictPreset,
+  translateSeverity: () => translateSeverity,
+  wcagAaBaselinePreset: () => wcagAaBaselinePreset
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/dom.ts
+var import_jsdom = require("jsdom");
+
+// src/utils/hash.ts
+var import_node_crypto = require("crypto");
+function getSha256(value) {
+  return (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
+}
+
+// src/utils/fingerprint.ts
+function createDiagnosticFingerprint(diagnostic) {
+  return getSha256(
+    JSON.stringify({
+      ruleId: diagnostic.ruleId,
+      message: diagnostic.message,
+      severity: diagnostic.severity,
+      selector: diagnostic.location?.selector,
+      start: diagnostic.location?.start,
+      end: diagnostic.location?.end
+    })
+  ).slice(0, 16);
+}
+
+// src/utils/positions.ts
+function positionFromOffset(source, offset) {
+  const safeOffset = Math.max(0, Math.min(offset, source.length));
+  let line = 1;
+  let column = 1;
+  for (let i = 0; i < safeOffset; i += 1) {
+    if (source[i] === "\n") {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return { line, column, offset: safeOffset };
+}
+function createRangeLocation(source, startOffset, endOffset, selector, sourcePath) {
+  return {
+    sourcePath,
+    selector,
+    start: positionFromOffset(source, startOffset),
+    end: positionFromOffset(source, endOffset)
+  };
+}
+function selectorToSourceLocation(source, selector, sourcePath) {
+  if (!selector) {
+    return { sourcePath };
+  }
+  const tag = selector.split(/[.#:\s>]/).find(Boolean);
+  if (!tag) {
+    return { sourcePath, selector };
+  }
+  const openTag = `<${tag}`;
+  const startOffset = source.indexOf(openTag);
+  if (startOffset === -1) {
+    return { sourcePath, selector };
+  }
+  const endOffset = startOffset + openTag.length;
+  return createRangeLocation(
+    source,
+    startOffset,
+    endOffset,
+    selector,
+    sourcePath
+  );
+}
+function translateSeverity(severity, target) {
+  if (target === "eslint") {
+    if (severity === "error") return 2;
+    if (severity === "warn") return 1;
+    return 0;
+  }
+  if (target === "vite") {
+    if (severity === "error") return "error";
+    if (severity === "warn") return "warning";
+    return "info";
+  }
+  return severity.toUpperCase();
+}
+
+// src/dom.ts
+function createDocumentFromHtml(html) {
+  return new import_jsdom.JSDOM(html).window.document;
+}
+function normalizeInputToHtml(input) {
+  if (input.kind === "html" || input.kind === "dom-snapshot") {
+    return input.html;
+  }
+  if (input.kind === "virtual-file") {
+    return input.content;
+  }
+  return input.fallbackHtml ?? null;
+}
+function createElementSelector(element) {
+  const id = element.getAttribute("id");
+  if (id) {
+    return `#${id}`;
+  }
+  const parts = [];
+  let current = element;
+  while (current && current.tagName.toLowerCase() !== "html") {
+    const tag = current.tagName.toLowerCase();
+    const parent = current.parentElement;
+    if (!parent) {
+      parts.unshift(tag);
+      break;
+    }
+    const siblings = Array.from(parent.children).filter(
+      (child) => child.tagName === current?.tagName
+    );
+    const index = siblings.indexOf(current) + 1;
+    parts.unshift(`${tag}:nth-of-type(${index})`);
+    current = parent;
+  }
+  return parts.join(" > ");
+}
+function locateElementInSource(source, element, selector, sourcePath) {
+  const tag = element.tagName.toLowerCase();
+  const openTag = `<${tag}`;
+  const offset = source.indexOf(openTag);
+  if (offset === -1) {
+    return { selector, sourcePath };
+  }
+  return createRangeLocation(
+    source,
+    offset,
+    offset + openTag.length,
+    selector,
+    sourcePath
+  );
+}
+
+// src/contracts/session.ts
+var BETTERA11Y_API_VERSION = "1";
+
+// src/engine.ts
+function createEngine(initialRules = [], config = {}) {
+  const ruleMap = /* @__PURE__ */ new Map();
+  const cache = /* @__PURE__ */ new Map();
+  initialRules.forEach((rule) => {
+    ruleMap.set(rule.meta.id, rule);
+  });
+  const listRules = () => Array.from(ruleMap.values()).sort(
+    (a, b) => a.meta.id.localeCompare(b.meta.id)
+  );
+  const run = async (input, signal) => {
+    if (signal?.aborted) {
+      throw new Error("Audit cancelled before start.");
+    }
+    const start = performance.now();
+    const html = normalizeInputToHtml(input);
+    if (!html) {
+      return {
+        diagnostics: [],
+        metadata: {
+          inputId: input.id,
+          sourcePath: input.source.path,
+          cacheHit: false,
+          durationMs: Number((performance.now() - start).toFixed(3)),
+          ruleTimingsMs: {}
+        }
+      };
+    }
+    const rules = listRules().filter(
+      (rule) => config.enabledRules?.[rule.meta.id] !== false
+    );
+    const cacheKey = getSha256(
+      `${config.apiVersion ?? BETTERA11Y_API_VERSION}:${input.source.contentHash ?? getSha256(html)}:${rules.map(
+        (rule) => `${rule.meta.id}:${config.severityOverrides?.[rule.meta.id] ?? "default"}`
+      ).join("|")}`
+    );
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      return {
+        ...cached.result,
+        metadata: {
+          ...cached.result.metadata,
+          cacheHit: true,
+          durationMs: Number((performance.now() - start).toFixed(3))
+        }
+      };
+    }
+    const document = createDocumentFromHtml(html);
+    const ruleTimingsMs = {};
+    const diagnostics = [];
+    for (const rule of rules) {
+      if (signal?.aborted) {
+        throw new Error("Audit cancelled.");
+      }
+      const ruleStart = performance.now();
+      const emitted = await rule.check({
+        document,
+        input,
+        createSelector: createElementSelector,
+        locate(element) {
+          const selector = createElementSelector(element);
+          return locateElementInSource(
+            html,
+            element,
+            selector,
+            input.source.path
+          );
+        },
+        signal
+      });
+      ruleTimingsMs[rule.meta.id] = Number(
+        (performance.now() - ruleStart).toFixed(3)
+      );
+      for (const item of emitted) {
+        const severity = config.severityOverrides?.[rule.meta.id] ?? item.severity ?? rule.meta.defaultSeverity;
+        const normalized = {
+          ...item,
+          severity,
+          category: item.category ?? rule.meta.category,
+          location: item.location ?? selectorToSourceLocation(html, void 0, input.source.path),
+          metadata: {
+            docsUrl: rule.meta.docsUrl,
+            tags: rule.meta.tags,
+            ...item.metadata
+          }
+        };
+        diagnostics.push({
+          ...normalized,
+          id: createDiagnosticFingerprint(normalized)
+        });
+      }
+    }
+    const result = {
+      diagnostics,
+      metadata: {
+        inputId: input.id,
+        sourcePath: input.source.path,
+        cacheHit: false,
+        durationMs: Number((performance.now() - start).toFixed(3)),
+        ruleTimingsMs
+      }
+    };
+    cache.set(cacheKey, { result, createdAt: Date.now() });
+    return result;
+  };
+  const runIncremental = async (request, signal) => {
+    const output = [];
+    for (const change of request.changes) {
+      output.push(await run(change, signal));
+    }
+    return output;
+  };
+  return {
+    registerRule(rule) {
+      ruleMap.set(rule.meta.id, rule);
+    },
+    unregisterRule(ruleId) {
+      ruleMap.delete(ruleId);
+    },
+    listRules,
+    run,
+    runIncremental,
+    createAuditSession(telemetry) {
+      let started = false;
+      return {
+        async start() {
+          started = true;
+          telemetry?.emit({ type: "session-start" });
+        },
+        async stop() {
+          started = false;
+          telemetry?.emit({ type: "session-stop" });
+        },
+        async run(input, signal) {
+          if (!started) {
+            throw new Error("Audit session must be started before run.");
+          }
+          const result = await run(input, signal);
+          telemetry?.emit({
+            type: "audit-run",
+            durationMs: result.metadata.durationMs,
+            cacheHit: result.metadata.cacheHit
+          });
+          return result;
+        },
+        async runIncremental(request, signal) {
+          if (!started) {
+            throw new Error(
+              "Audit session must be started before runIncremental."
+            );
+          }
+          return runIncremental(request, signal);
+        }
+      };
+    }
+  };
+}
+
+// src/reporters.ts
+function createJsonReporter() {
+  return {
+    format(result) {
+      return JSON.stringify(result, null, 2);
+    }
+  };
+}
+function createMachineReporter() {
+  return {
+    format(result) {
+      return JSON.stringify({
+        diagnostics: result.diagnostics,
+        metadata: result.metadata
+      });
+    }
+  };
+}
+function createPrettyReporter() {
+  return {
+    format(result) {
+      if (result.diagnostics.length === 0) {
+        return "No accessibility warnings detected.";
+      }
+      const lines = result.diagnostics.map((diagnostic, index) => {
+        const at = diagnostic.location?.selector ? ` at ${diagnostic.location.selector}` : "";
+        const remediation = diagnostic.remediation ? `
+    remediation: ${diagnostic.remediation}` : "";
+        return `${index + 1}. [${diagnostic.severity}] ${diagnostic.ruleId}: ${diagnostic.message}${at}${remediation}`;
+      });
+      return lines.join("\n");
+    }
+  };
+}
+
+// src/adapters.ts
+var MockAdapter = class {
+  emit;
+  options;
+  receivedInputs = [];
+  diagnostics = [];
+  started = false;
+  constructor(options) {
+    this.options = options;
+    this.emit = options.emit;
+  }
+  start() {
+    this.started = true;
+  }
+  stop() {
+    this.started = false;
+  }
+  async onInput(input) {
+    this.receivedInputs.push(input);
+    const result = await this.emit(input);
+    await this.onDiagnostics(result);
+  }
+  async onDiagnostics(result) {
+    this.diagnostics.push(result);
+    await this.options.diagnosticsSink?.onResult(result);
+  }
+  async pump() {
+    if (!this.options.inputProvider) {
+      return 0;
+    }
+    let processed = 0;
+    while (this.started) {
+      const input = await this.options.inputProvider.nextInput();
+      if (!input) {
+        break;
+      }
+      await this.onInput(input);
+      processed += 1;
+    }
+    return processed;
+  }
+};
+
+// src/rules/core/helpers.ts
+function hasAccessibleName(element) {
+  const ariaLabel = element.getAttribute("aria-label");
+  if (ariaLabel && ariaLabel.trim()) return true;
+  const ariaLabelledBy = element.getAttribute("aria-labelledby");
+  if (ariaLabelledBy && ariaLabelledBy.trim()) return true;
+  const title = element.getAttribute("title");
+  if (title && title.trim()) return true;
+  return Boolean(element.textContent?.trim());
+}
+
+// src/rules/core/forms-media-rules.ts
+var imageAltRule = {
+  meta: {
+    id: "image-alt",
+    description: "Detect images without alternative text.",
+    category: "media",
+    defaultSeverity: "warn",
+    tags: ["wcag-1.1.1"]
+  },
+  check({ document, locate }) {
+    if (!document) return [];
+    return Array.from(document.querySelectorAll("img")).flatMap((img) => {
+      if (img.hasAttribute("alt")) return [];
+      return [
+        {
+          ruleId: "image-alt",
+          message: "Image is missing an alt attribute.",
+          severity: "warn",
+          category: "media",
+          remediation: "Provide meaningful alt text or empty alt for decorative images.",
+          location: locate(img)
+        }
+      ];
+    });
+  }
+};
+var formControlLabelRule = {
+  meta: {
+    id: "form-control-label",
+    description: "Detect form controls without labels.",
+    category: "forms",
+    defaultSeverity: "error",
+    tags: ["forms", "wcag-3.3.2"]
+  },
+  check({ document, locate }) {
+    if (!document) return [];
+    const controls = Array.from(
+      document.querySelectorAll("input,select,textarea")
+    ).filter((el) => el.getAttribute("type")?.toLowerCase() !== "hidden");
+    return controls.flatMap((control) => {
+      const id = control.getAttribute("id");
+      const explicitLabel = id ? document.querySelector(`label[for="${id}"]`) : null;
+      const hasLabel = Boolean(explicitLabel) || Boolean(control.closest("label")) || Boolean(control.getAttribute("aria-label")) || Boolean(control.getAttribute("aria-labelledby"));
+      if (hasLabel) return [];
+      return [
+        {
+          ruleId: "form-control-label",
+          message: "Form control does not have an associated accessible label.",
+          severity: "error",
+          category: "forms",
+          remediation: "Associate a <label> or provide aria-label/aria-labelledby.",
+          location: locate(control)
+        }
+      ];
+    });
+  }
+};
+var buttonAccessibleNameRule = {
+  meta: {
+    id: "button-accessible-name",
+    description: "Ensure buttons have accessible names.",
+    category: "aria",
+    defaultSeverity: "error",
+    tags: ["controls", "wcag-4.1.2"]
+  },
+  check({ document, locate }) {
+    if (!document) return [];
+    const buttons = Array.from(document.querySelectorAll("button"));
+    return buttons.flatMap(
+      (button) => hasAccessibleName(button) ? [] : [
+        {
+          ruleId: "button-accessible-name",
+          message: "Button is missing an accessible name.",
+          severity: "error",
+          category: "aria",
+          remediation: "Provide text content, aria-label, or aria-labelledby.",
+          location: locate(button)
+        }
+      ]
+    );
+  }
+};
+
+// src/rules/core/structure-rules.ts
+var duplicateIdRule = {
+  meta: {
+    id: "duplicate-id",
+    description: "Detect duplicate element ids.",
+    category: "structure",
+    defaultSeverity: "error",
+    tags: ["wcag-4.1.1"]
+  },
+  check({ document, createSelector, locate }) {
+    if (!document) return [];
+    const idMap = /* @__PURE__ */ new Map();
+    document.querySelectorAll("[id]").forEach((element) => {
+      const id = element.getAttribute("id");
+      if (!id) return;
+      const list = idMap.get(id) ?? [];
+      list.push(element);
+      idMap.set(id, list);
+    });
+    return Array.from(idMap.entries()).flatMap(
+      ([id, elements]) => elements.length < 2 ? [] : elements.map((element) => {
+        const selector = createSelector(element);
+        return {
+          ruleId: "duplicate-id",
+          message: `Duplicate id "${id}" found.`,
+          severity: "error",
+          category: "structure",
+          remediation: "Ensure each id value is unique within a page.",
+          location: locate(element),
+          metadata: { tags: ["id", "structure"] }
+        };
+      })
+    );
+  }
+};
+var duplicateH1Rule = {
+  meta: {
+    id: "duplicate-h1",
+    description: "Detect multiple h1 elements in one document.",
+    category: "structure",
+    defaultSeverity: "warn",
+    tags: ["headings"]
+  },
+  check({ document, locate }) {
+    if (!document) return [];
+    const h1s = Array.from(document.querySelectorAll("h1"));
+    if (h1s.length <= 1) return [];
+    return h1s.map((h1) => ({
+      ruleId: "duplicate-h1",
+      message: "Multiple h1 elements found in the same document.",
+      severity: "warn",
+      category: "structure",
+      remediation: "Use a single primary h1 and nest sections under lower heading levels.",
+      location: locate(h1)
+    }));
+  }
+};
+var headingOrderRule = {
+  meta: {
+    id: "heading-order",
+    description: "Detect heading level jumps.",
+    category: "semantics",
+    defaultSeverity: "warn",
+    tags: ["headings", "wcag-1.3.1"]
+  },
+  check({ document, locate }) {
+    if (!document) return [];
+    const headings = Array.from(document.querySelectorAll("h1,h2,h3,h4,h5,h6"));
+    const diagnostics = [];
+    let previous = 0;
+    for (const heading of headings) {
+      const level = Number(heading.tagName.toLowerCase().slice(1));
+      if (previous > 0 && level > previous + 1) {
+        diagnostics.push({
+          ruleId: "heading-order",
+          message: `Heading level jumps from h${previous} to h${level}.`,
+          severity: "warn",
+          category: "semantics",
+          remediation: "Use sequential heading levels to preserve document outline.",
+          location: locate(heading)
+        });
+      }
+      previous = level;
+    }
+    return diagnostics;
+  }
+};
+var htmlLangRule = {
+  meta: {
+    id: "html-lang",
+    description: "Ensure html element defines a language.",
+    category: "semantics",
+    defaultSeverity: "error",
+    tags: ["wcag-3.1.1"]
+  },
+  check({ document, locate }) {
+    if (!document) return [];
+    const html = document.documentElement;
+    if (!html || html.getAttribute("lang")) return [];
+    return [
+      {
+        ruleId: "html-lang",
+        message: "The <html> element is missing a lang attribute.",
+        severity: "error",
+        category: "semantics",
+        remediation: 'Add a valid language code, for example <html lang="en">.',
+        location: locate(html)
+      }
+    ];
+  }
+};
+
+// src/rules/core/aria-keyboard-rules.ts
+var VALID_ARIA_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "aria-label",
+  "aria-labelledby",
+  "aria-describedby",
+  "aria-hidden",
+  "aria-expanded",
+  "aria-controls",
+  "aria-checked",
+  "aria-pressed",
+  "aria-current",
+  "aria-live",
+  "aria-invalid",
+  "aria-required",
+  "aria-selected",
+  "aria-role-description"
+]);
+var BOOLEAN_ARIA_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "aria-hidden",
+  "aria-expanded",
+  "aria-checked",
+  "aria-pressed",
+  "aria-invalid",
+  "aria-required",
+  "aria-selected"
+]);
+var invalidAriaRule = {
+  meta: {
+    id: "invalid-aria",
+    description: "Detect invalid aria attributes and values.",
+    category: "aria",
+    defaultSeverity: "error",
+    tags: ["aria", "wcag-4.1.2"]
+  },
+  check({ document, locate }) {
+    if (!document) return [];
+    const diagnostics = [];
+    for (const element of Array.from(document.querySelectorAll("*"))) {
+      for (const attr of element.getAttributeNames()) {
+        if (!attr.startsWith("aria-")) continue;
+        if (!VALID_ARIA_ATTRIBUTES.has(attr)) {
+          diagnostics.push({
+            ruleId: "invalid-aria",
+            message: `Invalid ARIA attribute "${attr}".`,
+            severity: "error",
+            category: "aria",
+            remediation: "Use only valid WAI-ARIA attributes.",
+            location: locate(element)
+          });
+          continue;
+        }
+        if (BOOLEAN_ARIA_ATTRIBUTES.has(attr)) {
+          const value = element.getAttribute(attr);
+          if (value !== "true" && value !== "false") {
+            diagnostics.push({
+              ruleId: "invalid-aria",
+              message: `ARIA boolean attribute "${attr}" must be "true" or "false".`,
+              severity: "error",
+              category: "aria",
+              remediation: `Set ${attr} to "true" or "false".`,
+              location: locate(element)
+            });
+          }
+        }
+      }
+    }
+    return diagnostics;
+  }
+};
+var interactiveRoleNameRule = {
+  meta: {
+    id: "interactive-role-name",
+    description: "Detect custom interactive roles without accessible names.",
+    category: "aria",
+    defaultSeverity: "warn",
+    tags: ["aria", "roles"]
+  },
+  check({ document, locate }) {
+    if (!document) return [];
+    const interactiveRoles = /* @__PURE__ */ new Set([
+      "button",
+      "switch",
+      "checkbox",
+      "menuitem"
+    ]);
+    return Array.from(document.querySelectorAll("[role]")).flatMap(
+      (element) => {
+        const role = element.getAttribute("role");
+        if (!role || !interactiveRoles.has(role) || hasAccessibleName(element)) {
+          return [];
+        }
+        return [
+          {
+            ruleId: "interactive-role-name",
+            message: `Element with role="${role}" is missing an accessible name.`,
+            severity: "warn",
+            category: "aria",
+            remediation: "Provide aria-label, aria-labelledby, or meaningful text content.",
+            location: locate(element)
+          }
+        ];
+      }
+    );
+  }
+};
+var positiveTabindexRule = {
+  meta: {
+    id: "positive-tabindex",
+    description: "Detect positive tabindex usage.",
+    category: "keyboard",
+    defaultSeverity: "warn",
+    tags: ["keyboard", "focus-order"]
+  },
+  check({ document, locate }) {
+    if (!document) return [];
+    return Array.from(document.querySelectorAll("[tabindex]")).flatMap(
+      (element) => {
+        const value = Number(element.getAttribute("tabindex"));
+        if (Number.isNaN(value) || value <= 0) return [];
+        return [
+          {
+            ruleId: "positive-tabindex",
+            message: "Positive tabindex can create confusing keyboard focus order.",
+            severity: "warn",
+            category: "keyboard",
+            remediation: 'Use tabindex="0" or rely on natural DOM order when possible.',
+            location: locate(element)
+          }
+        ];
+      }
+    );
+  }
+};
+
+// src/rules/core/landmark-rules.ts
+var mainLandmarkRule = {
+  meta: {
+    id: "main-landmark",
+    description: "Require exactly one main landmark.",
+    category: "landmarks",
+    defaultSeverity: "warn",
+    tags: ["landmarks", "wcag-1.3.1"]
+  },
+  check({ document, locate }) {
+    if (!document) return [];
+    const mains = Array.from(document.querySelectorAll("main, [role='main']"));
+    if (mains.length === 1) return [];
+    if (mains.length === 0) {
+      return [
+        {
+          ruleId: "main-landmark",
+          message: "Document is missing a main landmark.",
+          severity: "warn",
+          category: "landmarks",
+          remediation: 'Add a <main> element (or role="main") around core page content.'
+        }
+      ];
+    }
+    return mains.map((main) => ({
+      ruleId: "main-landmark",
+      message: "Document has multiple main landmarks.",
+      severity: "warn",
+      category: "landmarks",
+      remediation: "Keep only one top-level main landmark per page.",
+      location: locate(main)
+    }));
+  }
+};
+
+// src/rules/default-rules.ts
+var coreRules = [
+  duplicateIdRule,
+  duplicateH1Rule,
+  headingOrderRule,
+  htmlLangRule,
+  imageAltRule,
+  formControlLabelRule,
+  buttonAccessibleNameRule,
+  invalidAriaRule,
+  interactiveRoleNameRule,
+  positiveTabindexRule,
+  mainLandmarkRule
+];
+var defaultRules = coreRules;
+
+// src/presets/index.ts
+function byId(ids) {
+  const idSet = new Set(ids);
+  return coreRules.filter((rule) => idSet.has(rule.meta.id));
+}
+var recommendedPreset = byId([
+  "duplicate-id",
+  "heading-order",
+  "image-alt",
+  "form-control-label",
+  "button-accessible-name",
+  "invalid-aria",
+  "main-landmark"
+]);
+var strictPreset = [...coreRules];
+var wcagAaBaselinePreset = byId([
+  "duplicate-id",
+  "heading-order",
+  "html-lang",
+  "image-alt",
+  "form-control-label",
+  "button-accessible-name",
+  "invalid-aria",
+  "main-landmark",
+  "positive-tabindex"
+]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BETTERA11Y_API_VERSION,
+  MockAdapter,
+  coreRules,
+  createDiagnosticFingerprint,
+  createEngine,
+  createJsonReporter,
+  createMachineReporter,
+  createPrettyReporter,
+  createRangeLocation,
+  defaultRules,
+  getSha256,
+  positionFromOffset,
+  recommendedPreset,
+  selectorToSourceLocation,
+  strictPreset,
+  translateSeverity,
+  wcagAaBaselinePreset
+});
+//# sourceMappingURL=index.cjs.map