zemdomu 1.0.0

package/README.md

@@ -0,0 +1,112 @@
+ZemDomu
+
+Semantic HTML linting engine for clean, accessible, and SEO-friendly markup. This package provides the shared core logic used by the ZemDomu VS Code extension and upcoming GitHub Action.
+
+
+
+🧠 What is ZemDomu Core?
+
+ZemDomu is a semantic-first linter that helps developers write better HTML and JSX by catching accessibility and structural issues. This package contains the framework-agnostic linting engine used by other tools in the ZemDomu ecosystem.
+
+It parses .html, .jsx, and .tsx content and exposes a simple lint() function that returns semantic violations.
+
+🚀 Installation
+
+npm install zemdomu
+# or
+yarn add zemdomu
+
+✨ Features
+
+✅ Lint semantic issues in HTML, JSX, and TSX
+
+📦 Works in Node.js, CI, or any JS runtime
+
+⚙️ Extensible rule system
+
+📚 Shared by extension and GitHub Action
+
+🧪 Simple API: lint(content, options)
+
+⚙️ Usage Example
+
+import { lint } from 'zemdomu';
+
+const html = '<img>';
+const results = lint(html, { rules: { requireAltText: true } });
+
+console.log(results);
+// [
+//   {
+//     line: 0,
+//     column: 0,
+//     message: '<img> tag missing alt attribute',
+//     rule: 'requireAltText'
+//   }
+// ]
+
+// Custom rules can be supplied via the `customRules` option
+// const myRule = { name: 'demo', checkHtml: () => [] };
+// lint(html, { customRules: [myRule] });
+
+📖 API
+
+lint(content: string, options?: LinterOptions): LintResult[]
+
+Parameters:
+
+content — HTML, JSX, or TSX string input
+
+options.rules — toggles for built-in rules
+options.customRules — array of additional rules
+
+Example LinterOptions
+
+interface LinterOptions {
+  rules: {
+    requireAltText: boolean;
+    // ...more rules to come
+  };
+  customRules?: Rule[];
+}
+
+Example LintResult
+
+interface LintResult {
+  line: number;
+  column: number;
+  message: string;
+  rule: string;
+}
+
+🔗 Related Tools
+
+ZemDomu VS Code Extension
+
+ZemDomu GitHub Action (coming soon)
+
+🛠 Development
+
+git clone https://github.com/Zemdomu/ZemDomu-core.git
+cd ZemDomu-core
+npm install
+npm run build
+
+Tests and coverage support coming soon.
+
+🤝 Contributing
+
+We welcome contributions! If you'd like to add rules, improve parsing, or integrate new consumers:
+
+Fork this repo
+
+Add your logic inside src/rules or src/linter.ts
+
+Write or update tests (if applicable)
+
+Submit a pull request!
+
+📄 License
+
+MIT © 2025 Zacharias Eryd Berlin
+

package/out/index.js

@@ -0,0 +1,6 @@
+"use strict";
+// Exposes the core lint function and types
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lint = void 0;
+var linter_1 = require("./linter");
+Object.defineProperty(exports, "lint", { enumerable: true, get: function () { return linter_1.lint; } });

package/out/linter.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lint = lint;
+const simpleHtmlParser_1 = require("./simpleHtmlParser");
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const requireAltText_1 = __importDefault(require("./rules/requireAltText"));
+const requireSectionHeading_1 = __importDefault(require("./rules/requireSectionHeading"));
+const enforceHeadingOrder_1 = __importDefault(require("./rules/enforceHeadingOrder"));
+const singleH1_1 = __importDefault(require("./rules/singleH1"));
+const requireLabelForFormControls_1 = __importDefault(require("./rules/requireLabelForFormControls"));
+const enforceListNesting_1 = __importDefault(require("./rules/enforceListNesting"));
+const requireLinkText_1 = __importDefault(require("./rules/requireLinkText"));
+const requireTableCaption_1 = __importDefault(require("./rules/requireTableCaption"));
+const preventEmptyInlineTags_1 = __importDefault(require("./rules/preventEmptyInlineTags"));
+const requireHrefOnAnchors_1 = __importDefault(require("./rules/requireHrefOnAnchors"));
+const requireButtonText_1 = __importDefault(require("./rules/requireButtonText"));
+const requireIframeTitle_1 = __importDefault(require("./rules/requireIframeTitle"));
+const requireHtmlLang_1 = __importDefault(require("./rules/requireHtmlLang"));
+const requireImageInputAlt_1 = __importDefault(require("./rules/requireImageInputAlt"));
+const requireNavLinks_1 = __importDefault(require("./rules/requireNavLinks"));
+const uniqueIds_1 = __importDefault(require("./rules/uniqueIds"));
+const builtInRules = {
+    requireSectionHeading: requireSectionHeading_1.default,
+    enforceHeadingOrder: enforceHeadingOrder_1.default,
+    singleH1: singleH1_1.default,
+    requireAltText: requireAltText_1.default,
+    requireLabelForFormControls: requireLabelForFormControls_1.default,
+    enforceListNesting: enforceListNesting_1.default,
+    requireLinkText: requireLinkText_1.default,
+    requireTableCaption: requireTableCaption_1.default,
+    preventEmptyInlineTags: preventEmptyInlineTags_1.default,
+    requireHrefOnAnchors: requireHrefOnAnchors_1.default,
+    requireButtonText: requireButtonText_1.default,
+    requireIframeTitle: requireIframeTitle_1.default,
+    requireHtmlLang: requireHtmlLang_1.default,
+    requireImageInputAlt: requireImageInputAlt_1.default,
+    requireNavLinks: requireNavLinks_1.default,
+    uniqueIds: uniqueIds_1.default,
+};
+const defaultOptions = {
+    rules: {
+        requireSectionHeading: true,
+        enforceHeadingOrder: true,
+        singleH1: true,
+        requireAltText: true,
+        requireLabelForFormControls: true,
+        enforceListNesting: true,
+        requireLinkText: true,
+        requireTableCaption: true,
+        preventEmptyInlineTags: true,
+        requireHrefOnAnchors: true,
+        requireButtonText: true,
+        requireIframeTitle: true,
+        requireHtmlLang: true,
+        requireImageInputAlt: true,
+        requireNavLinks: true,
+        uniqueIds: true,
+    },
+    customRules: [],
+};
+/**
+ * Lint HTML/JSX/TSX content.
+ */
+function lint(content, options = defaultOptions) {
+    var _a;
+    const opts = {
+        rules: { ...defaultOptions.rules, ...(options.rules || {}) },
+        customRules: (_a = options.customRules) !== null && _a !== void 0 ? _a : defaultOptions.customRules,
+    };
+    const results = [];
+    const activeRules = [];
+    for (const name in opts.rules) {
+        const enabled = opts.rules[name];
+        if (enabled && builtInRules[name]) {
+            activeRules.push(builtInRules[name]());
+        }
+    }
+    if (opts.customRules)
+        activeRules.push(...opts.customRules);
+    activeRules.forEach(r => r.init && r.init());
+    let ast = null;
+    try {
+        ast = (0, parser_1.parse)(content, {
+            sourceType: 'module',
+            plugins: ['typescript', 'jsx'],
+        });
+    }
+    catch {
+        ast = null;
+    }
+    if (ast) {
+        (0, traverse_1.default)(ast, {
+            JSXElement: {
+                enter(path) {
+                    for (const rule of activeRules) {
+                        if (rule.enterJsx) {
+                            results.push(...rule.enterJsx(path));
+                        }
+                    }
+                },
+                exit(path) {
+                    for (const rule of activeRules) {
+                        if (rule.exitJsx) {
+                            results.push(...rule.exitJsx(path));
+                        }
+                    }
+                },
+            },
+        });
+        activeRules.forEach(r => r.end && results.push(...r.end()));
+        return results;
+    }
+    const root = (0, simpleHtmlParser_1.parse)(content);
+    const walk = (node) => {
+        for (const rule of activeRules) {
+            if (rule.enterHtml) {
+                results.push(...rule.enterHtml(node));
+            }
+        }
+        if (node.children) {
+            for (const child of node.children) {
+                walk(child);
+            }
+        }
+        for (const rule of activeRules) {
+            if (rule.exitHtml) {
+                results.push(...rule.exitHtml(node));
+            }
+        }
+    };
+    walk(root);
+    activeRules.forEach(r => r.end && results.push(...r.end()));
+    return results;
+}

package/out/rules/enforceHeadingOrder.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = enforceHeadingOrder;
+const utils_1 = require("./utils");
+function enforceHeadingOrder() {
+    let last = 0;
+    return {
+        name: 'enforceHeadingOrder',
+        init() { last = 0; },
+        enterHtml(node) {
+            if (node.type === 'element' && /^h[1-6]$/.test(node.tagName)) {
+                const lvl = parseInt(node.tagName.charAt(1), 10);
+                if (last && lvl > last + 1) {
+                    const message = `Heading level skipped: <${node.tagName}> after <h${last}>`;
+                    last = lvl;
+                    return [{ line: 0, column: 0, message, rule: 'enforceHeadingOrder' }];
+                }
+                last = lvl;
+            }
+            return [];
+        },
+        enterJsx(path) {
+            var _a, _b, _c, _d;
+            const tag = (0, utils_1.getTag)(path);
+            if (/^h[1-6]$/.test(tag)) {
+                const lvl = parseInt(tag.charAt(1), 10);
+                if (last && lvl > last + 1) {
+                    const message = `Heading level skipped: <${tag}> after <h${last}>`;
+                    last = lvl;
+                    const line = ((_b = (_a = path.node.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _b !== void 0 ? _b : 1) - 1;
+                    const column = (_d = (_c = path.node.loc) === null || _c === void 0 ? void 0 : _c.start.column) !== null && _d !== void 0 ? _d : 0;
+                    return [{ line, column, message, rule: 'enforceHeadingOrder' }];
+                }
+                last = lvl;
+            }
+            return [];
+        },
+    };
+}

package/out/rules/enforceListNesting.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = enforceListNesting;
+const t = __importStar(require("@babel/types"));
+const utils_1 = require("./utils");
+function enforceListNesting() {
+    const stack = [];
+    return {
+        name: 'enforceListNesting',
+        enterHtml(node) {
+            if (node.type === 'element') {
+                stack.push(node.tagName);
+                if (node.tagName === 'li') {
+                    const parent = stack[stack.length - 2];
+                    if (!parent || !['ul', 'ol'].includes(parent)) {
+                        return [{ line: 0, column: 0, message: '<li> must be inside a <ul> or <ol>', rule: 'enforceListNesting' }];
+                    }
+                }
+            }
+            return [];
+        },
+        exitHtml(node) {
+            if (node.type === 'element') {
+                stack.pop();
+            }
+            return [];
+        },
+        enterJsx(path) {
+            var _a, _b, _c, _d, _e, _f;
+            const tag = (0, utils_1.getTag)(path);
+            if (tag === 'li') {
+                const parent = (_b = (_a = path.parentPath) === null || _a === void 0 ? void 0 : _a.parentPath) === null || _b === void 0 ? void 0 : _b.node;
+                if (parent) {
+                    const pTag = t.isJSXIdentifier(parent.openingElement.name) ? parent.openingElement.name.name.toLowerCase() : '';
+                    if (!['ul', 'ol'].includes(pTag)) {
+                        const line = ((_d = (_c = path.node.loc) === null || _c === void 0 ? void 0 : _c.start.line) !== null && _d !== void 0 ? _d : 1) - 1;
+                        const column = (_f = (_e = path.node.loc) === null || _e === void 0 ? void 0 : _e.start.column) !== null && _f !== void 0 ? _f : 0;
+                        return [{ line, column, message: '<li> must be inside a <ul> or <ol>', rule: 'enforceListNesting' }];
+                    }
+                }
+            }
+            return [];
+        },
+    };
+}

package/out/rules/preventEmptyInlineTags.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = preventEmptyInlineTags;
+const t = __importStar(require("@babel/types"));
+const utils_1 = require("./utils");
+const inlineTags = new Set(['strong', 'em', 'b', 'i', 'u', 'small', 'mark', 'del', 'ins']);
+function preventEmptyInlineTags() {
+    const stack = [];
+    return {
+        name: 'preventEmptyInlineTags',
+        enterHtml(node) {
+            if (node.type === 'element' && inlineTags.has(node.tagName)) {
+                stack.push({ tag: node.tagName, found: false });
+            }
+            else if (node.type === 'text') {
+                if (stack.length && node.text.trim())
+                    stack[stack.length - 1].found = true;
+            }
+            return [];
+        },
+        exitHtml(node) {
+            if (node.type === 'element' && inlineTags.has(node.tagName)) {
+                const e = stack.pop();
+                if (e && !e.found)
+                    return [{ line: 0, column: 0, message: `<${e.tag}> tag should not be empty`, rule: 'preventEmptyInlineTags' }];
+            }
+            return [];
+        },
+        enterJsx(path) {
+            const tag = (0, utils_1.getTag)(path);
+            if (inlineTags.has(tag))
+                stack.push({ tag, found: false });
+            return [];
+        },
+        exitJsx(path) {
+            var _a, _b, _c, _d, _e;
+            const tag = (0, utils_1.getTag)(path);
+            if (inlineTags.has(tag)) {
+                const e = stack.pop();
+                const hasText = ((_a = path.parentPath) === null || _a === void 0 ? void 0 : _a.node).children.some(c => (t.isJSXText(c) && c.value.trim()) || t.isJSXExpressionContainer(c));
+                if (e && !(e.found || hasText)) {
+                    const line = ((_c = (_b = path.node.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _c !== void 0 ? _c : 1) - 1;
+                    const column = (_e = (_d = path.node.loc) === null || _d === void 0 ? void 0 : _d.start.column) !== null && _e !== void 0 ? _e : 0;
+                    return [{ line, column, message: `<${tag}> tag should not be empty`, rule: 'preventEmptyInlineTags' }];
+                }
+            }
+            return [];
+        },
+    };
+}

package/out/rules/requireAltText.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = requireAltText;
+const t = __importStar(require("@babel/types"));
+function requireAltText() {
+    return {
+        name: 'requireAltText',
+        enterHtml(node) {
+            if (node.type === 'element' &&
+                node.tagName === 'img' &&
+                (!('alt' in node.attrs) || !node.attrs.alt.trim())) {
+                return [
+                    {
+                        line: 0, // line/column handling omitted for brevity
+                        column: 0,
+                        message: '<img> tag missing alt attribute',
+                        rule: 'requireAltText',
+                    },
+                ];
+            }
+            return [];
+        },
+        enterJsx(path) {
+            const opening = path.node.openingElement;
+            const name = t.isJSXIdentifier(opening.name) ? opening.name.name : '';
+            if (name !== 'img')
+                return [];
+            const altAttr = opening.attributes.find((a) => t.isJSXAttribute(a) &&
+                t.isJSXIdentifier(a.name) &&
+                a.name.name === 'alt');
+            if (!altAttr || !t.isStringLiteral(altAttr.value) || altAttr.value.value.trim() === '') {
+                const loc = opening.loc.start;
+                return [
+                    {
+                        line: loc.line - 1,
+                        column: loc.column,
+                        message: '<img> tag missing alt attribute',
+                        rule: 'requireAltText',
+                    },
+                ];
+            }
+            return [];
+        },
+    };
+}

package/out/rules/requireAltTextJSX.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = requireAltTextJSX;
+const t = __importStar(require("@babel/types"));
+function requireAltTextJSX(path) {
+    var _a, _b, _c, _d;
+    const opening = path.node.openingElement;
+    const name = t.isJSXIdentifier(opening.name) ? opening.name.name : '';
+    if (name !== 'img') {
+        return [];
+    }
+    const altAttr = opening.attributes.find((a) => t.isJSXAttribute(a) &&
+        t.isJSXIdentifier(a.name) &&
+        a.name.name === 'alt');
+    if (!altAttr ||
+        !t.isStringLiteral(altAttr.value) ||
+        altAttr.value.value.trim() === '') {
+        const line = ((_b = (_a = opening.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _b !== void 0 ? _b : 1) - 1;
+        const column = (_d = (_c = opening.loc) === null || _c === void 0 ? void 0 : _c.start.column) !== null && _d !== void 0 ? _d : 0;
+        return [
+            {
+                line,
+                column,
+                message: '<img> tag missing alt attribute',
+                rule: 'requireAltText',
+            },
+        ];
+    }
+    return [];
+}

package/out/rules/requireButtonText.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = requireButtonText;
+const t = __importStar(require("@babel/types"));
+const utils_1 = require("./utils");
+function requireButtonText() {
+    const stack = [];
+    return {
+        name: 'requireButtonText',
+        enterHtml(node) {
+            if (node.type === 'element' && node.tagName === 'button') {
+                const aria = node.attrs['aria-label'];
+                stack.push({ found: !!(aria && aria.trim()), hadEmptyAria: aria !== undefined && !String(aria).trim() });
+            }
+            else if (node.type === 'text') {
+                if (stack.length && node.text.trim())
+                    stack[stack.length - 1].found = true;
+            }
+            return [];
+        },
+        exitHtml(node) {
+            if (node.type === 'element' && node.tagName === 'button') {
+                const info = stack.pop();
+                if (info && !info.found) {
+                    return [{ line: 0, column: 0, message: '<button> missing accessible text', rule: 'requireButtonText' }];
+                }
+            }
+            return [];
+        },
+        enterJsx(path) {
+            var _a, _b, _c, _d;
+            const opening = path.node.openingElement;
+            const tag = t.isJSXIdentifier(opening.name) ? opening.name.name.toLowerCase() : '';
+            if (tag === 'button') {
+                const aria = (0, utils_1.getJsxAttr)(opening, 'aria-label');
+                if (!aria || !aria.trim()) {
+                    const line = ((_b = (_a = opening.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _b !== void 0 ? _b : 1) - 1;
+                    const column = (_d = (_c = opening.loc) === null || _c === void 0 ? void 0 : _c.start.column) !== null && _d !== void 0 ? _d : 0;
+                    return [{ line, column, message: '<button> missing accessible text', rule: 'requireButtonText' }];
+                }
+            }
+            return [];
+        },
+    };
+}