wcag-a11y 0.1.0

package/dist/engine/rules/structure.js

@@ -0,0 +1,301 @@
+export const structureRules = [
+    {
+        id: 'heading-order',
+        wcag: '1.3.1',
+        level: 'A',
+        impact: 'moderate',
+        description: 'Heading levels must not be skipped (e.g. h1 → h3 skips h2)',
+        check: () => {
+            const getCssPath = (el) => {
+                if (el.id)
+                    return '#' + el.id;
+                const parts = [];
+                let node = el;
+                while (node && node.tagName !== 'BODY') {
+                    const parent = node.parentElement;
+                    if (!parent)
+                        break;
+                    const tag = node.tagName.toLowerCase();
+                    const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                    parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                    if (parent.id) {
+                        parts.unshift('#' + parent.id);
+                        break;
+                    }
+                    node = parent;
+                }
+                return parts.join(' > ') || el.tagName.toLowerCase();
+            };
+            const headings = Array.from(document.querySelectorAll('h1,h2,h3,h4,h5,h6'));
+            const violations = [];
+            let prevLevel = 0;
+            for (const h of headings) {
+                const level = parseInt(h.tagName[1]);
+                if (prevLevel > 0 && level > prevLevel + 1) {
+                    violations.push({ selector: getCssPath(h), html: h.outerHTML.slice(0, 200) });
+                }
+                prevLevel = level;
+            }
+            return violations;
+        },
+    },
+    {
+        id: 'page-title',
+        wcag: '2.4.2',
+        level: 'A',
+        impact: 'serious',
+        description: 'Page must have a non-empty <title> element',
+        check: () => {
+            const title = document.querySelector('title');
+            if (!title || !title.textContent?.trim()) {
+                return [{ selector: 'head', html: '<title> missing or empty' }];
+            }
+            return [];
+        },
+    },
+    {
+        id: 'landmark-one-main',
+        wcag: '2.4.1',
+        level: 'A',
+        impact: 'moderate',
+        description: 'Page must have exactly one <main> landmark',
+        check: () => {
+            const mains = Array.from(document.querySelectorAll('main, [role="main"]'));
+            if (mains.length === 0)
+                return [{ selector: 'body', html: 'No <main> landmark found' }];
+            if (mains.length > 1)
+                return mains.slice(1).map((el) => ({ selector: el.tagName.toLowerCase(), html: el.outerHTML.slice(0, 200) }));
+            return [];
+        },
+    },
+    {
+        id: 'list-structure',
+        wcag: '1.3.1',
+        level: 'A',
+        impact: 'moderate',
+        description: '<li> elements must be contained within <ul> or <ol>',
+        check: () => {
+            const getCssPath = (el) => {
+                if (el.id)
+                    return '#' + el.id;
+                const parts = [];
+                let node = el;
+                while (node && node.tagName !== 'BODY') {
+                    const parent = node.parentElement;
+                    if (!parent)
+                        break;
+                    const tag = node.tagName.toLowerCase();
+                    const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                    parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                    if (parent.id) {
+                        parts.unshift('#' + parent.id);
+                        break;
+                    }
+                    node = parent;
+                }
+                return parts.join(' > ') || el.tagName.toLowerCase();
+            };
+            const items = Array.from(document.querySelectorAll('li'));
+            return items
+                .filter((li) => !li.closest('ul, ol'))
+                .map((li) => ({ selector: getCssPath(li), html: li.outerHTML.slice(0, 200) }));
+        },
+    },
+    {
+        id: 'region-landmark',
+        wcag: '1.3.1',
+        level: 'A',
+        impact: 'moderate',
+        description: 'Page sections must use appropriate landmark roles (header, nav, main, footer)',
+        check: () => {
+            const hasHeader = document.querySelector('header, [role="banner"]') !== null;
+            const hasNav = document.querySelector('nav, [role="navigation"]') !== null;
+            const hasMain = document.querySelector('main, [role="main"]') !== null;
+            const violations = [];
+            if (!hasHeader)
+                violations.push({ selector: 'body', html: 'No <header> or role="banner" found' });
+            if (!hasNav)
+                violations.push({ selector: 'body', html: 'No <nav> or role="navigation" found' });
+            if (!hasMain)
+                violations.push({ selector: 'body', html: 'No <main> or role="main" found' });
+            return violations;
+        },
+    },
+    {
+        id: 'duplicate-id',
+        wcag: '4.1.1',
+        level: 'A',
+        impact: 'critical',
+        description: 'IDs must be unique — duplicate IDs break ARIA label associations',
+        check: () => {
+            const getCssPath = (el) => {
+                if (el.id)
+                    return '#' + el.id;
+                const parts = [];
+                let node = el;
+                while (node && node.tagName !== 'BODY') {
+                    const parent = node.parentElement;
+                    if (!parent)
+                        break;
+                    const tag = node.tagName.toLowerCase();
+                    const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                    parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                    if (parent.id) {
+                        parts.unshift('#' + parent.id);
+                        break;
+                    }
+                    node = parent;
+                }
+                return parts.join(' > ') || el.tagName.toLowerCase();
+            };
+            const allEls = Array.from(document.querySelectorAll('[id]'));
+            const seen = new Set();
+            const dupes = new Set();
+            for (const el of allEls) {
+                const id = el.getAttribute('id') ?? '';
+                if (id && seen.has(id))
+                    dupes.add(id);
+                else if (id)
+                    seen.add(id);
+            }
+            if (dupes.size === 0)
+                return [];
+            const results = [];
+            for (const id of dupes) {
+                const matches = Array.from(document.querySelectorAll(`[id="${id}"]`));
+                for (const el of matches) {
+                    results.push({ selector: getCssPath(el), html: el.outerHTML.slice(0, 200) });
+                }
+            }
+            return results;
+        },
+    },
+    {
+        id: 'frame-title',
+        wcag: '2.4.1',
+        level: 'A',
+        impact: 'serious',
+        description: '<iframe> elements must have a non-empty title attribute',
+        check: () => {
+            const getCssPath = (el) => {
+                if (el.id)
+                    return '#' + el.id;
+                const parts = [];
+                let node = el;
+                while (node && node.tagName !== 'BODY') {
+                    const parent = node.parentElement;
+                    if (!parent)
+                        break;
+                    const tag = node.tagName.toLowerCase();
+                    const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                    parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                    if (parent.id) {
+                        parts.unshift('#' + parent.id);
+                        break;
+                    }
+                    node = parent;
+                }
+                return parts.join(' > ') || el.tagName.toLowerCase();
+            };
+            const frames = Array.from(document.querySelectorAll('iframe, frame'));
+            return frames
+                .filter((el) => {
+                const title = el.getAttribute('title')?.trim() ?? '';
+                const ariaLabel = el.getAttribute('aria-label')?.trim() ?? '';
+                return !title && !ariaLabel;
+            })
+                .map((el) => ({ selector: getCssPath(el), html: el.outerHTML.slice(0, 200) }));
+        },
+    },
+    {
+        id: 'meta-viewport',
+        wcag: '1.4.4',
+        level: 'AA',
+        impact: 'critical',
+        description: 'Viewport meta must not prevent users from zooming (user-scalable=no or maximum-scale < 2)',
+        check: () => {
+            const metas = Array.from(document.querySelectorAll('meta[name="viewport"]'));
+            return metas
+                .filter((meta) => {
+                const content = meta.getAttribute('content') ?? '';
+                const disablesZoom = /user-scalable\s*=\s*no/i.test(content);
+                const maxScaleMatch = content.match(/maximum-scale\s*=\s*([\d.]+)/i);
+                const maxScale = maxScaleMatch ? parseFloat(maxScaleMatch[1]) : null;
+                return disablesZoom || (maxScale !== null && maxScale < 2);
+            })
+                .map((meta) => ({ selector: 'meta[name="viewport"]', html: meta.outerHTML }));
+        },
+    },
+    {
+        id: 'marquee',
+        wcag: '2.2.2',
+        level: 'A',
+        impact: 'serious',
+        description: '<marquee> elements cause accessibility issues — content moves automatically with no pause control',
+        check: () => {
+            const getCssPath = (el) => {
+                if (el.id)
+                    return '#' + el.id;
+                const parts = [];
+                let node = el;
+                while (node && node.tagName !== 'BODY') {
+                    const parent = node.parentElement;
+                    if (!parent)
+                        break;
+                    const tag = node.tagName.toLowerCase();
+                    const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                    parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                    if (parent.id) {
+                        parts.unshift('#' + parent.id);
+                        break;
+                    }
+                    node = parent;
+                }
+                return parts.join(' > ') || el.tagName.toLowerCase();
+            };
+            return Array.from(document.querySelectorAll('marquee'))
+                .map((el) => ({ selector: getCssPath(el), html: el.outerHTML.slice(0, 200) }));
+        },
+    },
+    {
+        id: 'p-as-heading',
+        wcag: '1.3.1',
+        level: 'A',
+        impact: 'moderate',
+        description: '<p> elements styled to look like headings should use an actual heading element',
+        check: () => {
+            const getCssPath = (el) => {
+                if (el.id)
+                    return '#' + el.id;
+                const parts = [];
+                let node = el;
+                while (node && node.tagName !== 'BODY') {
+                    const parent = node.parentElement;
+                    if (!parent)
+                        break;
+                    const tag = node.tagName.toLowerCase();
+                    const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                    parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                    if (parent.id) {
+                        parts.unshift('#' + parent.id);
+                        break;
+                    }
+                    node = parent;
+                }
+                return parts.join(' > ') || el.tagName.toLowerCase();
+            };
+            const paras = Array.from(document.querySelectorAll('p'));
+            return paras
+                .filter((p) => {
+                if (!p.textContent?.trim())
+                    return false;
+                const style = window.getComputedStyle(p);
+                const fontSize = parseFloat(style.fontSize);
+                const fontWeight = parseInt(style.fontWeight) || 400;
+                // Flag <p> that is visually heading-sized (>= 18px) and bold, or >= 24px
+                return (fontSize >= 24) || (fontSize >= 18 && fontWeight >= 700);
+            })
+                .map((p) => ({ selector: getCssPath(p), html: p.outerHTML.slice(0, 200) }));
+        },
+    },
+];

package/dist/engine/rules/tables.js

@@ -0,0 +1,159 @@
+export const tableRules = [
+    {
+        id: 'table-headers',
+        wcag: '1.3.1',
+        level: 'A',
+        impact: 'serious',
+        description: 'Data tables must use <th> or role="columnheader"/"rowheader" to identify headers',
+        check: () => {
+            const getCssPath = (el) => {
+                if (el.id)
+                    return '#' + el.id;
+                const parts = [];
+                let node = el;
+                while (node && node.tagName !== 'BODY') {
+                    const parent = node.parentElement;
+                    if (!parent)
+                        break;
+                    const tag = node.tagName.toLowerCase();
+                    const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                    parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                    if (parent.id) {
+                        parts.unshift('#' + parent.id);
+                        break;
+                    }
+                    node = parent;
+                }
+                return parts.join(' > ') || el.tagName.toLowerCase();
+            };
+            const tables = Array.from(document.querySelectorAll('table'));
+            return tables
+                .filter((table) => {
+                const role = table.getAttribute('role');
+                if (role === 'presentation' || role === 'none')
+                    return false;
+                const hasDataCells = table.querySelector('td') !== null;
+                if (!hasDataCells)
+                    return false;
+                const hasHeaders = table.querySelector('th') !== null ||
+                    table.querySelector('[scope]') !== null ||
+                    table.querySelector('[role="columnheader"], [role="rowheader"]') !== null;
+                return !hasHeaders;
+            })
+                .map((table) => ({ selector: getCssPath(table), html: table.outerHTML.slice(0, 200) }));
+        },
+    },
+    {
+        id: 'table-scope-valid',
+        wcag: '1.3.1',
+        level: 'A',
+        impact: 'moderate',
+        description: 'The scope attribute on <th> must have a valid value: col, row, colgroup, or rowgroup',
+        check: () => {
+            const getCssPath = (el) => {
+                if (el.id)
+                    return '#' + el.id;
+                const parts = [];
+                let node = el;
+                while (node && node.tagName !== 'BODY') {
+                    const parent = node.parentElement;
+                    if (!parent)
+                        break;
+                    const tag = node.tagName.toLowerCase();
+                    const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                    parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                    if (parent.id) {
+                        parts.unshift('#' + parent.id);
+                        break;
+                    }
+                    node = parent;
+                }
+                return parts.join(' > ') || el.tagName.toLowerCase();
+            };
+            const validScopes = new Set(['col', 'row', 'colgroup', 'rowgroup']);
+            const ths = Array.from(document.querySelectorAll('th[scope]'));
+            return ths
+                .filter((th) => !validScopes.has(th.getAttribute('scope') ?? ''))
+                .map((th) => ({ selector: getCssPath(th), html: th.outerHTML.slice(0, 200) }));
+        },
+    },
+    {
+        id: 'td-headers-attr',
+        wcag: '1.3.1',
+        level: 'A',
+        impact: 'serious',
+        description: 'Table cells using the headers attribute must reference valid, non-empty <th> IDs',
+        check: () => {
+            const getCssPath = (el) => {
+                if (el.id)
+                    return '#' + el.id;
+                const parts = [];
+                let node = el;
+                while (node && node.tagName !== 'BODY') {
+                    const parent = node.parentElement;
+                    if (!parent)
+                        break;
+                    const tag = node.tagName.toLowerCase();
+                    const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                    parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                    if (parent.id) {
+                        parts.unshift('#' + parent.id);
+                        break;
+                    }
+                    node = parent;
+                }
+                return parts.join(' > ') || el.tagName.toLowerCase();
+            };
+            const cells = Array.from(document.querySelectorAll('td[headers], th[headers]'));
+            return cells
+                .filter((cell) => {
+                const ids = (cell.getAttribute('headers') ?? '').trim().split(/\s+/).filter(Boolean);
+                if (ids.length === 0)
+                    return false;
+                return ids.some((id) => {
+                    const target = document.getElementById(id);
+                    return !target || target.tagName.toLowerCase() !== 'th' || !target.textContent?.trim();
+                });
+            })
+                .map((cell) => ({ selector: getCssPath(cell), html: cell.outerHTML.slice(0, 200) }));
+        },
+    },
+    {
+        id: 'table-duplicate-name',
+        wcag: '1.3.1',
+        level: 'A',
+        impact: 'moderate',
+        description: 'Table summary and caption must not be identical',
+        check: () => {
+            const getCssPath = (el) => {
+                if (el.id)
+                    return '#' + el.id;
+                const parts = [];
+                let node = el;
+                while (node && node.tagName !== 'BODY') {
+                    const parent = node.parentElement;
+                    if (!parent)
+                        break;
+                    const tag = node.tagName.toLowerCase();
+                    const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                    parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                    if (parent.id) {
+                        parts.unshift('#' + parent.id);
+                        break;
+                    }
+                    node = parent;
+                }
+                return parts.join(' > ') || el.tagName.toLowerCase();
+            };
+            const tables = Array.from(document.querySelectorAll('table[summary]'));
+            return tables
+                .filter((table) => {
+                const summary = (table.getAttribute('summary') ?? '').trim().toLowerCase();
+                const caption = table.querySelector('caption');
+                const captionText = (caption?.textContent ?? '').trim().toLowerCase();
+                return summary && captionText && summary === captionText;
+            })
+                .map((table) => ({ selector: getCssPath(table), html: table.outerHTML.slice(0, 200) }));
+        },
+    },
+];

package/dist/engine/rules/text-alternatives.js

@@ -0,0 +1,202 @@
+export const textAlternativeRules = [
+    {
+        id: 'img-alt',
+        wcag: '1.1.1',
+        level: 'A',
+        impact: 'critical',
+        description: 'Images must have an alt attribute',
+        check: () => {
+            const images = Array.from(document.querySelectorAll('img'));
+            return images
+                .filter((img) => !img.hasAttribute('alt'))
+                .map((img) => ({
+                selector: img.id ? `#${img.id}` : `img[src="${img.getAttribute('src')}"]`,
+                html: img.outerHTML.slice(0, 200),
+            }));
+        },
+    },
+    {
+        id: 'input-image-alt',
+        wcag: '1.1.1',
+        level: 'A',
+        impact: 'critical',
+        description: '<input type="image"> must have an alt attribute',
+        check: () => {
+            const inputs = Array.from(document.querySelectorAll('input[type="image"]'));
+            return inputs
+                .filter((el) => !el.hasAttribute('alt'))
+                .map((el) => ({
+                selector: el.id ? `#${el.id}` : `input[type="image"]`,
+                html: el.outerHTML.slice(0, 200),
+            }));
+        },
+    },
+    {
+        id: 'svg-title',
+        wcag: '1.1.1',
+        level: 'A',
+        impact: 'serious',
+        description: 'Inline SVGs must have a <title> or aria-label for screen readers',
+        check: () => {
+            const svgs = Array.from(document.querySelectorAll('svg'));
+            return svgs
+                .filter((svg) => {
+                const hasTitle = svg.querySelector('title') !== null;
+                const hasAriaLabel = svg.hasAttribute('aria-label') || svg.hasAttribute('aria-labelledby');
+                const isDecorative = svg.getAttribute('aria-hidden') === 'true';
+                return !hasTitle && !hasAriaLabel && !isDecorative;
+            })
+                .map((svg) => {
+                const getCssPath = (el) => {
+                    if (el.id)
+                        return '#' + el.id;
+                    const parts = [];
+                    let node = el;
+                    while (node && node.tagName !== 'BODY') {
+                        const parent = node.parentElement;
+                        if (!parent)
+                            break;
+                        const tag = node.tagName.toLowerCase();
+                        const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                        parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                        if (parent.id) {
+                            parts.unshift('#' + parent.id);
+                            break;
+                        }
+                        node = parent;
+                    }
+                    return parts.join(' > ') || el.tagName.toLowerCase();
+                };
+                return { selector: getCssPath(svg), html: svg.outerHTML.slice(0, 200) };
+            });
+        },
+    },
+    {
+        id: 'object-alt',
+        wcag: '1.1.1',
+        level: 'A',
+        impact: 'serious',
+        description: '<object> elements must have fallback text content',
+        check: () => {
+            const objects = Array.from(document.querySelectorAll('object'));
+            return objects
+                .filter((obj) => !obj.textContent?.trim())
+                .map((obj) => {
+                const getCssPath = (el) => {
+                    if (el.id)
+                        return '#' + el.id;
+                    const parts = [];
+                    let node = el;
+                    while (node && node.tagName !== 'BODY') {
+                        const parent = node.parentElement;
+                        if (!parent)
+                            break;
+                        const tag = node.tagName.toLowerCase();
+                        const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                        parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                        if (parent.id) {
+                            parts.unshift('#' + parent.id);
+                            break;
+                        }
+                        node = parent;
+                    }
+                    return parts.join(' > ') || el.tagName.toLowerCase();
+                };
+                return { selector: getCssPath(obj), html: obj.outerHTML.slice(0, 200) };
+            });
+        },
+    },
+    {
+        id: 'role-img-alt',
+        wcag: '1.1.1',
+        level: 'A',
+        impact: 'serious',
+        description: 'Elements with role="img" must have an accessible name',
+        check: () => {
+            const getCssPath = (el) => {
+                if (el.id)
+                    return '#' + el.id;
+                const parts = [];
+                let node = el;
+                while (node && node.tagName !== 'BODY') {
+                    const parent = node.parentElement;
+                    if (!parent)
+                        break;
+                    const tag = node.tagName.toLowerCase();
+                    const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                    parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                    if (parent.id) {
+                        parts.unshift('#' + parent.id);
+                        break;
+                    }
+                    node = parent;
+                }
+                return parts.join(' > ') || el.tagName.toLowerCase();
+            };
+            const els = Array.from(document.querySelectorAll('[role="img"]'));
+            return els
+                .filter((el) => {
+                if (el.getAttribute('aria-hidden') === 'true')
+                    return false;
+                const ariaLabel = el.getAttribute('aria-label')?.trim() ?? '';
+                const ariaLabelledby = el.getAttribute('aria-labelledby');
+                const labelledEl = ariaLabelledby ? document.getElementById(ariaLabelledby) : null;
+                return !ariaLabel && !labelledEl?.textContent?.trim();
+            })
+                .map((el) => ({ selector: getCssPath(el), html: el.outerHTML.slice(0, 200) }));
+        },
+    },
+    {
+        id: 'image-redundant-alt',
+        wcag: '1.1.1',
+        level: 'A',
+        impact: 'minor',
+        description: 'Image alt text must not duplicate text that is already visible nearby',
+        check: () => {
+            const getCssPath = (el) => {
+                if (el.id)
+                    return '#' + el.id;
+                const parts = [];
+                let node = el;
+                while (node && node.tagName !== 'BODY') {
+                    const parent = node.parentElement;
+                    if (!parent)
+                        break;
+                    const tag = node.tagName.toLowerCase();
+                    const sibs = Array.from(parent.children).filter((c) => c.tagName === node.tagName);
+                    parts.unshift(sibs.length === 1 ? tag : tag + ':nth-of-type(' + (sibs.indexOf(node) + 1) + ')');
+                    if (parent.id) {
+                        parts.unshift('#' + parent.id);
+                        break;
+                    }
+                    node = parent;
+                }
+                return parts.join(' > ') || el.tagName.toLowerCase();
+            };
+            const images = Array.from(document.querySelectorAll('img[alt]'));
+            return images
+                .filter((img) => {
+                const alt = (img.getAttribute('alt') ?? '').trim().toLowerCase();
+                if (!alt)
+                    return false;
+                const parent = img.parentElement;
+                if (!parent)
+                    return false;
+                // Get sibling/adjacent text, excluding the img alt itself
+                const siblingText = Array.from(parent.childNodes)
+                    .filter((n) => n !== img && n.nodeType === Node.TEXT_NODE)
+                    .map((n) => n.textContent ?? '')
+                    .join(' ')
+                    .trim()
+                    .toLowerCase();
+                const adjacentLabel = parent.querySelector('figcaption, caption');
+                const captionText = (adjacentLabel?.textContent ?? '').trim().toLowerCase();
+                return siblingText.includes(alt) || captionText.includes(alt);
+            })
+                .map((img) => ({
+                selector: getCssPath(img),
+                html: img.outerHTML.slice(0, 200),
+            }));
+        },
+    },
+];

package/dist/engine/types.js

@@ -0,0 +1 @@
+export {};