@techsio/storybook-better-a11y 0.0.1

package/dist/212.js.LICENSE.txt

@@ -0,0 +1,19 @@
+/**
+ * @license React
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */

package/dist/699.js

@@ -0,0 +1,529 @@
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { expect } from "storybook/test";
+import { ElementA11yParameterError } from "storybook/internal/preview-errors";
+import { global } from "@storybook/global";
+import { addons, useCallback, useEffect, waitForAnimations } from "storybook/preview-api";
+import { EVENTS, filters, filterDefs, PANEL_ID } from "./100.js";
+var preview_namespaceObject = {};
+__webpack_require__.r(preview_namespaceObject);
+__webpack_require__.d(preview_namespaceObject, {
+    afterEach: ()=>afterEach,
+    decorators: ()=>decorators,
+    initialGlobals: ()=>initialGlobals,
+    parameters: ()=>preview_parameters
+});
+const { document: a11yRunnerUtils_document } = global;
+const withLinkPaths = (results, storyId)=>{
+    const pathname = a11yRunnerUtils_document.location.pathname.replace(/iframe\.html$/, '');
+    const enhancedResults = {
+        ...results
+    };
+    const propertiesToAugment = [
+        'incomplete',
+        'passes',
+        'violations'
+    ];
+    propertiesToAugment.forEach((key)=>{
+        if (Array.isArray(results[key])) enhancedResults[key] = results[key].map((result)=>({
+                ...result,
+                nodes: result.nodes.map((node, index)=>{
+                    const id = `${key}.${result.id}.${index + 1}`;
+                    const linkPath = `${pathname}?path=/story/${storyId}&addonPanel=${PANEL_ID}&a11ySelection=${id}`;
+                    return {
+                        id,
+                        ...node,
+                        linkPath
+                    };
+                })
+            }));
+    });
+    return enhancedResults;
+};
+const { document: apcaChecker_document } = global;
+const DEFAULT_APCA_OPTIONS = {
+    level: 'bronze',
+    useCase: 'body'
+};
+const APCA_LC_STEPS = [
+    15,
+    20,
+    25,
+    30,
+    35,
+    40,
+    45,
+    50,
+    55,
+    60,
+    65,
+    70,
+    75,
+    80,
+    85,
+    90,
+    95,
+    100,
+    105,
+    110,
+    115,
+    120,
+    125
+];
+const APCA_MAX_CONTRAST_LC = 90;
+function getComputedColor(element, property) {
+    const computed = global.getComputedStyle(element);
+    return computed[property] || '';
+}
+function getEffectiveBackgroundColor(element) {
+    let current = element;
+    while(current && current !== apcaChecker_document.body){
+        const bgColor = getComputedColor(current, 'backgroundColor');
+        if (bgColor && 'rgba(0, 0, 0, 0)' !== bgColor && 'transparent' !== bgColor) return bgColor;
+        current = current.parentElement;
+    }
+    return 'rgb(255, 255, 255)';
+}
+function parseColor(color) {
+    const match = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+    if (!match) return null;
+    return [
+        parseInt(match[1], 10),
+        parseInt(match[2], 10),
+        parseInt(match[3], 10)
+    ];
+}
+function normalizeUseCase(value, fallback) {
+    if (!value) return fallback;
+    const normalized = value.toLowerCase().replace(/\s+/g, '-');
+    if (normalized.includes('body')) return 'body';
+    if (normalized.includes('sub') || normalized.includes('logo')) return 'sub-fluent';
+    if (normalized.includes('non') || normalized.includes('incidental') || normalized.includes('spot')) return 'non-fluent';
+    if (normalized.includes('fluent')) return 'fluent';
+    return fallback;
+}
+function getUseCaseForElement(element, fallback) {
+    const attr = element.getAttribute('data-apca-usecase') ?? element.getAttribute('data-apca-use-case') ?? element.getAttribute('data-apca-usage');
+    return normalizeUseCase(attr, fallback);
+}
+function normalizeWeightBucket(fontWeight) {
+    const weight = Number.isFinite(fontWeight) ? fontWeight : 400;
+    const clamped = Math.max(100, Math.min(900, weight));
+    return 100 * Math.round(clamped / 100);
+}
+function getBronzeThreshold(useCase, fontSize) {
+    if ('body' === useCase) return {
+        threshold: 75,
+        preferred: 90
+    };
+    if ('fluent' === useCase) {
+        if (fontSize > 32) return {
+            threshold: 45
+        };
+        if (fontSize >= 16) return {
+            threshold: 60
+        };
+        return {
+            threshold: 75
+        };
+    }
+    return null;
+}
+function getMinFontSize(level, useCase) {
+    if ('bronze' === level) return;
+    if ('sub-fluent' === useCase) return 'gold' === level ? 12 : 10;
+    if ('fluent' === useCase || 'body' === useCase) return 'gold' === level ? 16 : 14;
+}
+function getMaxContrast(level, useCase, fontSize, fontWeight) {
+    if ('bronze' === level) {
+        if ('fluent' === useCase && fontSize > 32 && fontWeight >= 700) return APCA_MAX_CONTRAST_LC;
+        return;
+    }
+    if (('body' === useCase || 'fluent' === useCase) && fontSize > 36) return APCA_MAX_CONTRAST_LC;
+}
+function getBaseThresholdFromLookup(fontSize, fontWeight, allowNonContent, fontLookupAPCA) {
+    const weightBucket = normalizeWeightBucket(fontWeight);
+    const weightIndex = Math.round(weightBucket / 100);
+    for (const lc of APCA_LC_STEPS){
+        const row = fontLookupAPCA(lc, 2);
+        const requiredSize = Number(row[weightIndex]);
+        if (!Number.isFinite(requiredSize)) continue;
+        if (999 === requiredSize) continue;
+        if (777 === requiredSize && !allowNonContent) continue;
+        const minSize = 777 === requiredSize ? 0 : requiredSize;
+        if (fontSize >= minSize) return lc;
+    }
+    return null;
+}
+function getApcaThreshold(level, useCase, fontSize, fontWeight, fontLookupAPCA) {
+    if ('bronze' === level) {
+        const bronzeThreshold = getBronzeThreshold(useCase, fontSize);
+        if (!bronzeThreshold) return {
+            threshold: null,
+            skip: true
+        };
+        return {
+            threshold: bronzeThreshold.threshold,
+            maxContrast: getMaxContrast(level, useCase, fontSize, fontWeight)
+        };
+    }
+    const minFontSize = getMinFontSize(level, useCase);
+    const baseThreshold = getBaseThresholdFromLookup(fontSize, fontWeight, 'non-fluent' === useCase, fontLookupAPCA);
+    if (null === baseThreshold) return {
+        threshold: null,
+        minFontSize,
+        note: 'Font size/weight is below the minimums in the APCA lookup table for this use case.'
+    };
+    let threshold = baseThreshold;
+    if ('sub-fluent' === useCase) threshold = Math.max(threshold - 15, 'silver' === level ? 40 : 45);
+    else if ('non-fluent' === useCase) threshold = Math.max(threshold - ('silver' === level ? 30 : 20), 30);
+    if ('body' === useCase && 'gold' === level && threshold < 75) threshold += 15;
+    return {
+        threshold,
+        minFontSize,
+        maxContrast: getMaxContrast(level, useCase, fontSize, fontWeight)
+    };
+}
+function hasReadableText(element) {
+    const text = element.textContent?.trim() || '';
+    return text.length > 0 && !element.hasAttribute('aria-hidden');
+}
+function isVisible(element) {
+    const computed = global.getComputedStyle(element);
+    return 'none' !== computed.display && 'hidden' !== computed.visibility && '0' !== computed.opacity;
+}
+async function runAPCACheck(context = apcaChecker_document, options = DEFAULT_APCA_OPTIONS) {
+    const { APCAcontrast, sRGBtoY, fontLookupAPCA } = await import("apca-w3");
+    const apcaOptions = {
+        ...DEFAULT_APCA_OPTIONS,
+        ...options
+    };
+    const violations = [];
+    const root = context instanceof Document ? context.body : context;
+    const textElements = root.querySelectorAll('p, span, div, h1, h2, h3, h4, h5, h6, a, button, label, td, th, li, input, textarea');
+    textElements.forEach((element)=>{
+        if (!isVisible(element) || !hasReadableText(element)) return;
+        const foreground = getComputedColor(element, 'color');
+        const background = getEffectiveBackgroundColor(element);
+        const fgColor = parseColor(foreground);
+        const bgColor = parseColor(background);
+        if (!fgColor || !bgColor) return;
+        const computed = global.getComputedStyle(element);
+        const fontSize = parseFloat(computed.fontSize);
+        const fontWeight = parseInt(computed.fontWeight, 10);
+        try {
+            const fgLuminance = sRGBtoY(fgColor);
+            const bgLuminance = sRGBtoY(bgColor);
+            const contrastValue = Math.abs(APCAcontrast(fgLuminance, bgLuminance));
+            const useCase = getUseCaseForElement(element, apcaOptions.useCase);
+            const level = apcaOptions.level;
+            const { threshold, minFontSize, maxContrast, note, skip } = getApcaThreshold(level, useCase, fontSize, fontWeight, fontLookupAPCA);
+            if (skip) return;
+            const messages = [];
+            if (null === threshold) {
+                if (note) messages.push(note);
+            } else {
+                if (contrastValue < threshold) messages.push(`APCA contrast of ${contrastValue.toFixed(1)} Lc is below the minimum of ${threshold} Lc for ${level} ${useCase} text.`);
+                if (void 0 !== maxContrast && contrastValue > maxContrast) messages.push(`APCA contrast of ${contrastValue.toFixed(1)} Lc exceeds the maximum of ${maxContrast} Lc for ${level} ${useCase} text at ${fontSize.toFixed(1)}px.`);
+            }
+            if (minFontSize && fontSize < minFontSize) messages.push(`Font size ${fontSize.toFixed(1)}px is below the minimum ${minFontSize}px for ${level} ${useCase} text.`);
+            if (messages.length > 0) violations.push({
+                element,
+                foreground,
+                background,
+                contrastValue,
+                fontSize,
+                fontWeight,
+                threshold,
+                maxContrast,
+                useCase,
+                level,
+                minFontSize,
+                note
+            });
+        } catch (error) {
+            console.warn('APCA calculation error:', error);
+        }
+    });
+    const nodes = violations.map((violation)=>{
+        const impact = getImpact(violation.contrastValue, violation.threshold, violation.maxContrast);
+        const messages = [];
+        if (violation.note) messages.push(violation.note);
+        else if (null !== violation.threshold && violation.contrastValue < violation.threshold) messages.push(`APCA contrast of ${violation.contrastValue.toFixed(1)} Lc is below the minimum of ${violation.threshold} Lc for ${violation.level} ${violation.useCase} text.`);
+        if (void 0 !== violation.maxContrast && violation.contrastValue > violation.maxContrast) messages.push(`APCA contrast of ${violation.contrastValue.toFixed(1)} Lc exceeds the maximum of ${violation.maxContrast} Lc for ${violation.level} ${violation.useCase} text at ${violation.fontSize.toFixed(1)}px.`);
+        if (violation.minFontSize && violation.fontSize < violation.minFontSize) messages.push(`Font size ${violation.fontSize.toFixed(1)}px is below the minimum ${violation.minFontSize}px for ${violation.level} ${violation.useCase} text.`);
+        const rules = messages.map((message)=>({
+                id: 'apca-contrast',
+                impact,
+                message,
+                data: null,
+                relatedNodes: []
+            }));
+        const failureSummary = `Fix any of the following:\n  ${messages.join('\n  ')}`;
+        return {
+            html: violation.element.outerHTML,
+            target: [
+                getSelector(violation.element)
+            ],
+            any: rules,
+            all: [],
+            none: [],
+            impact,
+            failureSummary
+        };
+    });
+    return {
+        id: 'apca-contrast',
+        impact: nodes.length > 0 ? 'serious' : null,
+        tags: [
+            'wcag3',
+            'wcag30',
+            'apca',
+            'contrast'
+        ],
+        description: 'Ensures text has sufficient contrast using APCA (WCAG 3.0 method)',
+        help: 'Elements must have sufficient color contrast using APCA',
+        helpUrl: 'https://git.apcacontrast.com/',
+        nodes
+    };
+}
+function getSelector(element) {
+    if (element.id) return `#${element.id}`;
+    const path = [];
+    let current = element;
+    while(current && current !== apcaChecker_document.body){
+        let selector = current.tagName.toLowerCase();
+        if (current.className) {
+            const classes = current.className.split(' ').filter(Boolean);
+            if (classes.length > 0) selector += `.${classes[0]}`;
+        }
+        const parent = current.parentElement;
+        if (parent) {
+            const siblings = Array.from(parent.children);
+            const index = siblings.indexOf(current) + 1;
+            selector += `:nth-child(${index})`;
+        }
+        path.unshift(selector);
+        current = parent;
+    }
+    return path.join(' > ');
+}
+function getImpact(contrastValue, threshold, maxContrast) {
+    if (null === threshold && void 0 === maxContrast) return 'serious';
+    const difference = void 0 !== maxContrast && contrastValue > maxContrast ? contrastValue - maxContrast : (threshold ?? 0) - contrastValue;
+    if (difference > 30) return 'critical';
+    if (difference > 20) return 'serious';
+    if (difference > 10) return 'moderate';
+    return 'minor';
+}
+const { document: a11yRunner_document } = global;
+const channel = addons.getChannel();
+const DEFAULT_PARAMETERS = {
+    config: {},
+    options: {}
+};
+const DISABLED_RULES = [
+    'region'
+];
+const queue = [];
+let isRunning = false;
+const runNext = async ()=>{
+    if (0 === queue.length) {
+        isRunning = false;
+        return;
+    }
+    isRunning = true;
+    const next = queue.shift();
+    if (next) await next();
+    runNext();
+};
+const run = async (input = DEFAULT_PARAMETERS, storyId)=>{
+    const axeCore = await import("axe-core");
+    const axe = axeCore?.default || globalThis.axe;
+    const { config = {}, options = {} } = input;
+    if (input.element) throw new ElementA11yParameterError();
+    const context = {
+        include: a11yRunner_document?.body,
+        exclude: [
+            '.sb-wrapper',
+            '#storybook-docs',
+            '#storybook-highlights-root'
+        ]
+    };
+    if (input.context) {
+        const hasInclude = 'object' == typeof input.context && 'include' in input.context && void 0 !== input.context.include;
+        const hasExclude = 'object' == typeof input.context && 'exclude' in input.context && void 0 !== input.context.exclude;
+        if (hasInclude) context.include = input.context.include;
+        else if (!hasInclude && !hasExclude) context.include = input.context;
+        if (hasExclude) context.exclude = context.exclude.concat(input.context.exclude);
+    }
+    axe.reset();
+    const configWithDefault = {
+        ...config,
+        rules: [
+            ...DISABLED_RULES.map((id)=>({
+                    id,
+                    enabled: false
+                })),
+            ...config?.rules ?? []
+        ]
+    };
+    axe.configure(configWithDefault);
+    return new Promise((resolve, reject)=>{
+        const highlightsRoot = a11yRunner_document?.getElementById('storybook-highlights-root');
+        if (highlightsRoot) highlightsRoot.style.display = 'none';
+        const task = async ()=>{
+            try {
+                const result = await axe.run(context, options);
+                let contextElement = a11yRunner_document;
+                if (context.include instanceof Element) contextElement = context.include;
+                else if (Array.isArray(context.include)) {
+                    const first = context.include[0];
+                    if (first instanceof Element) contextElement = first;
+                    else if ('string' == typeof first) contextElement = a11yRunner_document.querySelector(first) || a11yRunner_document;
+                } else if ('string' == typeof context.include) contextElement = a11yRunner_document.querySelector(context.include) || a11yRunner_document;
+                const apcaResult = await runAPCACheck(contextElement, input.apca);
+                if (apcaResult.nodes.length > 0) result.violations.push(apcaResult);
+                else result.passes.push(apcaResult);
+                const resultWithLinks = withLinkPaths(result, storyId);
+                globalThis.__TECHSIO_A11Y_RESULTS__ = {
+                    storyId,
+                    results: resultWithLinks,
+                    timestamp: Date.now()
+                };
+                resolve(resultWithLinks);
+            } catch (error) {
+                reject(error);
+            }
+        };
+        queue.push(task);
+        if (!isRunning) runNext();
+        if (highlightsRoot) highlightsRoot.style.display = '';
+    });
+};
+channel.on(EVENTS.MANUAL, async (storyId, input = DEFAULT_PARAMETERS)=>{
+    try {
+        await waitForAnimations();
+        const result = await run(input, storyId);
+        const resultJson = JSON.parse(JSON.stringify(result));
+        channel.emit(EVENTS.RESULT, resultJson, storyId);
+    } catch (error) {
+        channel.emit(EVENTS.ERROR, error);
+    }
+});
+function getIsVitestStandaloneRun() {
+    try {
+        return 'false' === ({
+            MODE: "production",
+            DEV: false,
+            PROD: true,
+            BASE_URL: "/",
+            ASSET_PREFIX: "auto"
+        }).VITEST_STORYBOOK;
+    } catch (e) {
+        return false;
+    }
+}
+const knownFilters = Object.values(filters).map((f)=>f.filter);
+const knownFiltersRegExp = new RegExp(`\\b(${knownFilters.join('|')})\\b`, 'g');
+const withVisionSimulator = (StoryFn, { globals })=>{
+    const { vision } = globals;
+    const applyVisionFilter = useCallback(()=>{
+        const existingFilters = document.body.style.filter.replaceAll(knownFiltersRegExp, '').trim();
+        const visionFilter = filters[vision]?.filter;
+        if (visionFilter && document.body.classList.contains('sb-show-main')) if (existingFilters && 'none' !== existingFilters) document.body.style.filter = `${existingFilters} ${visionFilter}`;
+        else document.body.style.filter = visionFilter;
+        else document.body.style.filter = existingFilters || 'none';
+        return ()=>document.body.style.filter = existingFilters || 'none';
+    }, [
+        vision
+    ]);
+    useEffect(()=>{
+        const cleanup = applyVisionFilter();
+        const observer = new MutationObserver(()=>applyVisionFilter());
+        observer.observe(document.body, {
+            attributeFilter: [
+                'class'
+            ]
+        });
+        return ()=>{
+            cleanup();
+            observer.disconnect();
+        };
+    }, [
+        applyVisionFilter
+    ]);
+    useEffect(()=>{
+        document.body.insertAdjacentHTML('beforeend', filterDefs);
+        return ()=>{
+            const filterDefsElement = document.getElementById('storybook-a11y-vision-filters');
+            filterDefsElement?.parentElement?.removeChild(filterDefsElement);
+        };
+    }, []);
+    return StoryFn();
+};
+let vitestMatchersExtended = false;
+const decorators = [
+    withVisionSimulator
+];
+const afterEach = async ({ id: storyId, reporting, parameters, globals, viewMode })=>{
+    const a11yParameter = parameters.a11y;
+    const a11yGlobals = globals.a11y;
+    const shouldRunEnvironmentIndependent = a11yParameter?.disable !== true && a11yParameter?.test !== 'off' && a11yGlobals?.manual !== true;
+    const getMode = ()=>{
+        switch(a11yParameter?.test){
+            case 'todo':
+                return 'warning';
+            case 'error':
+            default:
+                return 'failed';
+        }
+    };
+    if (shouldRunEnvironmentIndependent && 'story' === viewMode) try {
+        const result = await run(a11yParameter, storyId);
+        if (result) {
+            const hasViolations = (result?.violations.length ?? 0) > 0;
+            reporting.addReport({
+                type: 'a11y',
+                version: 1,
+                result,
+                status: hasViolations ? getMode() : 'passed'
+            });
+            if (getIsVitestStandaloneRun()) {
+                if (hasViolations && 'failed' === getMode()) {
+                    if (!vitestMatchersExtended) {
+                        const { toHaveNoViolations } = await import("./212.js").then((mod)=>({
+                                toHaveNoViolations: mod.toHaveNoViolations
+                            }));
+                        expect.extend({
+                            toHaveNoViolations
+                        });
+                        vitestMatchersExtended = true;
+                    }
+                    expect(result).toHaveNoViolations();
+                }
+            }
+        }
+    } catch (e) {
+        reporting.addReport({
+            type: 'a11y',
+            version: 1,
+            result: {
+                error: e
+            },
+            status: 'failed'
+        });
+        if (getIsVitestStandaloneRun()) throw e;
+    }
+};
+const initialGlobals = {
+    a11y: {
+        manual: false
+    },
+    vision: void 0
+};
+const preview_parameters = {
+    a11y: {
+        test: 'todo'
+    }
+};
+export { afterEach, decorators, initialGlobals, preview_namespaceObject, preview_parameters as parameters };

package/dist/AccessibilityRuleMaps.d.ts

@@ -0,0 +1,9 @@
+export type AxeRuleMap = {
+    [axeId: string]: {
+        title: string;
+        axeSummary: string;
+        friendlySummary: string;
+    };
+};
+export declare const combinedRulesMap: AxeRuleMap;
+//# sourceMappingURL=AccessibilityRuleMaps.d.ts.map

package/dist/AccessibilityRuleMaps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccessibilityRuleMaps.d.ts","sourceRoot":"","sources":["../src/AccessibilityRuleMaps.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG;IAEvB,CAAC,KAAK,EAAE,MAAM,GAAG;QAEf,KAAK,EAAE,MAAM,CAAC;QAEd,UAAU,EAAE,MAAM,CAAC;QAEnB,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;CACH,CAAC;AA2kBF,eAAO,MAAM,gBAAgB,EAAE,UAS9B,CAAC"}

package/dist/a11yRunner.d.ts

@@ -0,0 +1,4 @@
+import type { AxeResults } from 'axe-core';
+import type { A11yParameters } from './params';
+export declare const run: (input: A11yParameters | undefined, storyId: string) => Promise<AxeResults>;
+//# sourceMappingURL=a11yRunner.d.ts.map

package/dist/a11yRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a11yRunner.d.ts","sourceRoot":"","sources":["../src/a11yRunner.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAA4B,MAAM,UAAU,CAAC;AAMrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAiC/C,eAAO,MAAM,GAAG,GAAU,OAAO,cAAc,YAAqB,EAAE,SAAS,MAAM,wBA4GpF,CAAC"}

package/dist/a11yRunnerUtils.d.ts

@@ -0,0 +1,4 @@
+import type { AxeResults } from 'axe-core';
+import type { EnhancedResults } from './types';
+export declare const withLinkPaths: (results: AxeResults, storyId: string) => EnhancedResults;
+//# sourceMappingURL=a11yRunnerUtils.d.ts.map

package/dist/a11yRunnerUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a11yRunnerUtils.d.ts","sourceRoot":"","sources":["../src/a11yRunnerUtils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,UAAU,CAAC;AAGnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAK/C,eAAO,MAAM,aAAa,GAAI,SAAS,UAAU,EAAE,SAAS,MAAM,KAsBtC,eAC3B,CAAC"}

package/dist/apcaChecker.d.ts

@@ -0,0 +1,13 @@
+import type { Result } from 'axe-core';
+type ApcaConformanceLevel = 'bronze' | 'silver' | 'gold';
+type ApcaUseCase = 'body' | 'fluent' | 'sub-fluent' | 'non-fluent';
+interface ApcaOptions {
+    level?: ApcaConformanceLevel;
+    useCase?: ApcaUseCase;
+}
+/**
+ * Run APCA contrast checks on the document
+ */
+export declare function runAPCACheck(context?: Element | Document, options?: ApcaOptions): Promise<Result>;
+export {};
+//# sourceMappingURL=apcaChecker.d.ts.map

package/dist/apcaChecker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apcaChecker.d.ts","sourceRoot":"","sources":["../src/apcaChecker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAc,MAAM,UAAU,CAAC;AAYnD,KAAK,oBAAoB,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AACzD,KAAK,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,YAAY,CAAC;AAEnE,UAAU,WAAW;IACnB,KAAK,CAAC,EAAE,oBAAoB,CAAC;IAC7B,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB;AA8OD;;GAEG;AACH,wBAAsB,YAAY,CAChC,OAAO,GAAE,OAAO,GAAG,QAAmB,EACtC,OAAO,GAAE,WAAkC,GAC1C,OAAO,CAAC,MAAM,CAAC,CAoKjB"}

package/dist/axeRuleMappingHelper.d.ts

@@ -0,0 +1,4 @@
+import type { EnhancedResult } from './types';
+export declare const getTitleForAxeResult: (axeResult: EnhancedResult) => string;
+export declare const getFriendlySummaryForAxeResult: (axeResult: EnhancedResult) => string | undefined;
+//# sourceMappingURL=axeRuleMappingHelper.d.ts.map

package/dist/axeRuleMappingHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axeRuleMappingHelper.d.ts","sourceRoot":"","sources":["../src/axeRuleMappingHelper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,eAAO,MAAM,oBAAoB,GAAI,WAAW,cAAc,KAAG,MACV,CAAC;AAExD,eAAO,MAAM,8BAA8B,GAAI,WAAW,cAAc,KAAG,MAAM,GAAG,SACV,CAAC"}

package/dist/components/A11YPanel.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const A11YPanel: React.FC;
+//# sourceMappingURL=A11YPanel.d.ts.map

package/dist/components/A11YPanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"A11YPanel.d.ts","sourceRoot":"","sources":["../../src/components/A11YPanel.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAuDvC,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,EAkL7B,CAAC"}

package/dist/components/A11yContext.d.ts

@@ -0,0 +1,31 @@
+import type { FC, PropsWithChildren } from 'react';
+import React from 'react';
+import type { A11yParameters } from '../params';
+import type { EnhancedResult, EnhancedResults, Status } from '../types';
+import { RuleType } from '../types';
+import type { TestDiscrepancy } from './TestDiscrepancyMessage';
+export interface A11yContextStore {
+    parameters: A11yParameters;
+    results: EnhancedResults | undefined;
+    highlighted: boolean;
+    toggleHighlight: () => void;
+    tab: RuleType;
+    handleCopyLink: (key: string) => void;
+    setTab: (type: RuleType) => void;
+    status: Status;
+    setStatus: (status: Status) => void;
+    error: unknown;
+    handleManual: () => void;
+    discrepancy: TestDiscrepancy;
+    selectedItems: Map<string, string>;
+    toggleOpen: (event: React.SyntheticEvent<Element>, type: RuleType, item: EnhancedResult) => void;
+    allExpanded: boolean;
+    handleCollapseAll: () => void;
+    handleExpandAll: () => void;
+    handleJumpToElement: (target: string) => void;
+    handleSelectionChange: (key: string) => void;
+}
+export declare const A11yContext: React.Context<A11yContextStore>;
+export declare const A11yContextProvider: FC<PropsWithChildren>;
+export declare const useA11yContext: () => A11yContextStore;
+//# sourceMappingURL=A11yContext.d.ts.map

package/dist/components/A11yContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"A11yContext.d.ts","sourceRoot":"","sources":["../../src/components/A11yContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AACnD,OAAO,KAA+E,MAAM,OAAO,CAAC;AA2BpG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAc,cAAc,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AACpF,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAMhE,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,cAAc,CAAC;IAC3B,OAAO,EAAE,eAAe,GAAG,SAAS,CAAC;IACrC,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,GAAG,EAAE,QAAQ,CAAC;IACd,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,MAAM,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,KAAK,EAAE,OAAO,CAAC;IACf,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,WAAW,EAAE,eAAe,CAAC;IAC7B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;IACjG,WAAW,EAAE,OAAO,CAAC;IACrB,iBAAiB,EAAE,MAAM,IAAI,CAAC;IAC9B,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,mBAAmB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,qBAAqB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9C;AASD,eAAO,MAAM,WAAW,iCAoBtB,CAAC;AAEH,eAAO,MAAM,mBAAmB,EAAE,EAAE,CAAC,iBAAiB,CA0YrD,CAAC;AAEF,eAAO,MAAM,cAAc,wBAAgC,CAAC"}

package/dist/components/Report/Details.d.ts

@@ -0,0 +1,11 @@
+import type { EnhancedResult, RuleType } from '../../types';
+interface DetailsProps {
+    id: string;
+    item: EnhancedResult;
+    type: RuleType;
+    selection: string | undefined;
+    handleSelectionChange: (key: string) => void;
+}
+export declare const Details: ({ id, item, type, selection, handleSelectionChange }: DetailsProps) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=Details.d.ts.map

package/dist/components/Report/Details.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Details.d.ts","sourceRoot":"","sources":["../../../src/components/Report/Details.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAsB,cAAc,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAyHhF,UAAU,YAAY;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,qBAAqB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9C;AAED,eAAO,MAAM,OAAO,GAAI,sDAAsD,YAAY,4CAiDzF,CAAC"}