zemdomu 1.3.14 → 1.3.15

package/out/rules/enforceListNesting.js

@@ -1,40 +1,6 @@
 "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 = [];
@@ -59,19 +25,15 @@ function enforceListNesting() {
             return [];
         },
         enterJsx(path) {
-            var _a, _b, _c, _d, _e, _f;
+            var _a, _b, _c, _d;
             const tag = (0, utils_1.getTag)(path);
             if (tag === 'li') {
-                const parentNode = (_b = (_a = path.parentPath) === null || _a === void 0 ? void 0 : _a.parentPath) === null || _b === void 0 ? void 0 : _b.node;
-                let inList = false;
-                if (parentNode && t.isJSXElement(parentNode)) {
-                    const open = parentNode.openingElement;
-                    const pTag = t.isJSXIdentifier(open.name) ? open.name.name.toLowerCase() : '';
-                    inList = ['ul', 'ol'].includes(pTag);
-                }
+                const parentElement = path.findParent((p) => p.isJSXElement());
+                const parentTag = parentElement ? (0, utils_1.getTag)(parentElement) : '';
+                const inList = parentTag === 'ul' || parentTag === 'ol';
                 if (!inList) {
-                    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;
+                    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: '<li> must be inside a <ul> or <ol>', rule: 'enforceListNesting' }];
                 }
             }

package/out/rules/requireAltText.js

@@ -35,21 +35,24 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = requireAltText;
 const t = __importStar(require("@babel/types"));
+const utils_1 = require("./utils");
 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',
-                    },
-                ];
+            var _a, _b;
+            if (node.type === 'element' && node.tagName === 'img') {
+                const alt = (_b = (_a = node.attrs.alt) !== null && _a !== void 0 ? _a : node.attrs[':alt']) !== null && _b !== void 0 ? _b : node.attrs['v-bind:alt'];
+                if (alt === undefined || !String(alt).trim()) {
+                    return [
+                        {
+                            line: 0, // line/column handling omitted for brevity
+                            column: 0,
+                            message: '<img> tag missing or empty alt attribute',
+                            rule: 'requireAltText',
+                        },
+                    ];
+                }
             }
             return [];
         },
@@ -58,16 +61,17 @@ function requireAltText() {
             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 altState = (0, utils_1.getJsxAttributeState)(opening, 'alt', true);
+            if (altState === 'missing' || altState === 'empty' || altState === 'possiblyEmpty') {
                 const loc = opening.loc.start;
+                const message = altState === 'possiblyEmpty'
+                    ? '<img> alt is possibly empty or undefined'
+                    : '<img> tag missing or empty alt attribute';
                 return [
                     {
                         line: loc.line - 1,
                         column: loc.column,
-                        message: '<img> tag missing alt attribute',
+                        message,
                         rule: 'requireAltText',
                     },
                 ];

package/out/rules/requireHrefOnAnchors.js

@@ -40,10 +40,18 @@ function requireHrefOnAnchors() {
     return {
         name: 'requireHrefOnAnchors',
         enterHtml(node) {
+            var _a, _b;
             if (node.type === 'element' && node.tagName === 'a') {
-                const href = node.attrs.href;
+                const href = (_b = (_a = node.attrs.href) !== null && _a !== void 0 ? _a : node.attrs[':href']) !== null && _b !== void 0 ? _b : node.attrs['v-bind:href'];
                 if (!href || !href.trim()) {
-                    return [{ line: 0, column: 0, message: '<a> tag missing non-empty href attribute', rule: 'requireHrefOnAnchors' }];
+                    return [
+                        {
+                            line: 0,
+                            column: 0,
+                            message: '<a> tag missing non-empty href attribute',
+                            rule: 'requireHrefOnAnchors',
+                        },
+                    ];
                 }
             }
             return [];
@@ -53,11 +61,14 @@ function requireHrefOnAnchors() {
             const opening = path.node.openingElement;
             const tag = t.isJSXIdentifier(opening.name) ? opening.name.name.toLowerCase() : '';
             if (tag === 'a') {
-                const href = (0, utils_1.getJsxAttr)(opening, 'href');
-                if (!href || !href.trim()) {
+                const hrefState = (0, utils_1.getJsxAttributeState)(opening, 'href', true);
+                if (hrefState === 'missing' || hrefState === 'empty' || hrefState === 'possiblyEmpty') {
                     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: '<a> tag missing non-empty href attribute', rule: 'requireHrefOnAnchors' }];
+                    const message = hrefState === 'possiblyEmpty'
+                        ? '<a> href is possibly empty or undefined'
+                        : '<a> tag missing non-empty href attribute';
+                    return [{ line, column, message, rule: 'requireHrefOnAnchors' }];
                 }
             }
             return [];

package/out/rules/requireLinkText.js

@@ -36,6 +36,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = requireLinkText;
 const t = __importStar(require("@babel/types"));
 const utils_1 = require("./utils");
+function mergeTextStates(states) {
+    if (states.some((s) => s === "present"))
+        return "present";
+    if (states.some((s) => s === "possiblyEmpty"))
+        return "possiblyEmpty";
+    return "empty";
+}
+function jsxChildTextState(child) {
+    if (t.isJSXText(child))
+        return child.value.trim().length > 0 ? "present" : "empty";
+    if (t.isJSXExpressionContainer(child)) {
+        const expr = child.expression;
+        if (t.isJSXElement(expr))
+            return jsxElementTextState(expr);
+        if (t.isJSXFragment(expr)) {
+            return mergeTextStates(expr.children.map(jsxChildTextState));
+        }
+        return (0, utils_1.getJsxExpressionState)(expr, true);
+    }
+    if (t.isJSXElement(child))
+        return jsxElementTextState(child);
+    if (t.isJSXFragment(child)) {
+        return mergeTextStates(child.children.map(jsxChildTextState));
+    }
+    if (t.isJSXSpreadChild(child))
+        return "present";
+    return "empty";
+}
+function jsxElementTextState(node) {
+    return mergeTextStates(node.children.map(jsxChildTextState));
+}
 function requireLinkText() {
     const stack = [];
     return {
@@ -65,31 +96,25 @@ function requireLinkText() {
             }
             return [];
         },
-        enterJsx(path) {
-            const tag = (0, utils_1.getTag)(path);
-            if (tag === "a")
-                stack.push({ found: false });
+        enterJsx(_) {
             return [];
         },
         exitJsx(path) {
-            var _a, _b, _c, _d, _e;
+            var _a, _b, _c, _d;
             const tag = (0, utils_1.getTag)(path);
             if (tag === "a") {
-                const entry = stack.pop();
-                let hasText = false;
-                const parentNode = (_a = path.parentPath) === null || _a === void 0 ? void 0 : _a.node;
-                if (t.isJSXElement(parentNode) && Array.isArray(parentNode.children)) {
-                    hasText = parentNode.children.some((c) => (t.isJSXText(c) && c.value.trim()) ||
-                        t.isJSXExpressionContainer(c));
-                }
-                if (entry && !(entry.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;
+                const textState = jsxElementTextState(path.node);
+                if (textState !== "present") {
+                    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;
+                    const message = textState === "possiblyEmpty"
+                        ? "<a> link text is possibly empty or undefined"
+                        : "<a> tag missing link text";
                     return [
                         {
                             line,
                             column,
-                            message: "<a> tag missing link text",
+                            message,
                             rule: "requireLinkText",
                         },
                     ];

package/out/rules/utils.d.ts

@@ -3,4 +3,10 @@ import { NodePath } from '@babel/traverse';
 import { ElementNode } from '../simpleHtmlParser';
 export declare function getAttr(node: ElementNode, name: string): string | undefined;
 export declare function getJsxAttr(opening: t.JSXOpeningElement, name: string): string | undefined;
+export declare function getJsxAttribute(opening: t.JSXOpeningElement, name: string): t.JSXAttribute | undefined;
+export type JsxValueState = 'missing' | 'empty' | 'possiblyEmpty' | 'present';
+export declare function getJsxExpressionState(expression: t.Expression | t.TSType | t.JSXEmptyExpression, trimText: boolean): JsxValueState;
+export declare function isJsxExpressionPossiblyEmpty(expression: t.Expression | t.JSXEmptyExpression, trimText: boolean): boolean;
+export declare function isJsxAttrValueEmpty(value: t.JSXAttribute['value'], trimText: boolean): boolean;
+export declare function getJsxAttributeState(opening: t.JSXOpeningElement, name: string, trimText: boolean): JsxValueState;
 export declare function getTag(path: NodePath<t.JSXElement>): string;

package/out/rules/utils.js

@@ -35,6 +35,11 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAttr = getAttr;
 exports.getJsxAttr = getJsxAttr;
+exports.getJsxAttribute = getJsxAttribute;
+exports.getJsxExpressionState = getJsxExpressionState;
+exports.isJsxExpressionPossiblyEmpty = isJsxExpressionPossiblyEmpty;
+exports.isJsxAttrValueEmpty = isJsxAttrValueEmpty;
+exports.getJsxAttributeState = getJsxAttributeState;
 exports.getTag = getTag;
 const t = __importStar(require("@babel/types"));
 function getAttr(node, name) {
@@ -44,6 +49,115 @@ function getJsxAttr(opening, name) {
     const attr = opening.attributes.find((a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name) && a.name.name === name);
     return attr && t.isStringLiteral(attr.value) ? attr.value.value : undefined;
 }
+function getJsxAttribute(opening, name) {
+    return opening.attributes.find((a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name) && a.name.name === name);
+}
+function isEmptyString(value, trimText) {
+    return trimText ? value.trim().length === 0 : value.length === 0;
+}
+function mergeConditionalStates(a, b) {
+    if (a === 'present' && b === 'present')
+        return 'present';
+    if (a === 'empty' && b === 'empty')
+        return 'empty';
+    return 'possiblyEmpty';
+}
+function mergeTemplateStates(states) {
+    if (states.some((s) => s === 'present'))
+        return 'present';
+    if (states.some((s) => s === 'possiblyEmpty'))
+        return 'possiblyEmpty';
+    return 'empty';
+}
+function getJsxExpressionState(expression, trimText) {
+    if (t.isTSType(expression))
+        return 'present';
+    if (t.isJSXEmptyExpression(expression))
+        return 'empty';
+    if (t.isNullLiteral(expression))
+        return 'empty';
+    if (t.isIdentifier(expression, { name: 'undefined' }))
+        return 'empty';
+    if (t.isBooleanLiteral(expression))
+        return 'empty';
+    if (t.isOptionalMemberExpression(expression) || t.isOptionalCallExpression(expression)) {
+        return 'possiblyEmpty';
+    }
+    if (t.isStringLiteral(expression)) {
+        return isEmptyString(expression.value, trimText) ? 'empty' : 'present';
+    }
+    if (t.isTemplateLiteral(expression)) {
+        if (expression.expressions.length === 0) {
+            const raw = expression.quasis
+                .map((q) => { var _a; return (_a = q.value.cooked) !== null && _a !== void 0 ? _a : q.value.raw; })
+                .join('');
+            return isEmptyString(raw, trimText) ? 'empty' : 'present';
+        }
+        const staticText = expression.quasis
+            .map((q) => { var _a; return (_a = q.value.cooked) !== null && _a !== void 0 ? _a : q.value.raw; })
+            .join('');
+        if (staticText.trim().length > 0)
+            return 'present';
+        const exprStates = expression.expressions.map((expr) => getJsxExpressionState(expr, trimText));
+        return mergeTemplateStates(exprStates);
+    }
+    if (t.isConditionalExpression(expression)) {
+        return mergeConditionalStates(getJsxExpressionState(expression.consequent, trimText), getJsxExpressionState(expression.alternate, trimText));
+    }
+    if (t.isLogicalExpression(expression)) {
+        const left = getJsxExpressionState(expression.left, trimText);
+        if (expression.operator === '&&') {
+            if (left === 'empty')
+                return 'empty';
+            if (left === 'present') {
+                return getJsxExpressionState(expression.right, trimText);
+            }
+            return 'possiblyEmpty';
+        }
+        if (expression.operator === '||' || expression.operator === '??') {
+            if (left === 'present')
+                return 'present';
+            if (left === 'empty') {
+                return getJsxExpressionState(expression.right, trimText);
+            }
+            const right = getJsxExpressionState(expression.right, trimText);
+            if (right === 'present')
+                return 'present';
+            return 'possiblyEmpty';
+        }
+    }
+    if (t.isUnaryExpression(expression) && expression.operator === 'void')
+        return 'empty';
+    return 'present';
+}
+function isJsxExpressionPossiblyEmpty(expression, trimText) {
+    return getJsxExpressionState(expression, trimText) !== 'present';
+}
+function isJsxAttrValueEmpty(value, trimText) {
+    if (!value)
+        return true;
+    if (t.isStringLiteral(value)) {
+        return isEmptyString(value.value, trimText);
+    }
+    if (t.isJSXExpressionContainer(value)) {
+        return isJsxExpressionPossiblyEmpty(value.expression, trimText);
+    }
+    return false;
+}
+function getJsxAttributeState(opening, name, trimText) {
+    const attr = getJsxAttribute(opening, name);
+    if (!attr)
+        return 'missing';
+    if (!attr.value)
+        return 'empty';
+    if (t.isStringLiteral(attr.value)) {
+        return isEmptyString(attr.value.value, trimText) ? 'empty' : 'present';
+    }
+    if (t.isJSXExpressionContainer(attr.value)) {
+        return getJsxExpressionState(attr.value.expression, trimText);
+    }
+    return 'present';
+}
 function getTag(path) {
     const opening = path.node.openingElement;
     return t.isJSXIdentifier(opening.name) ? opening.name.name.toLowerCase() : '';

package/out/tests/img-alt-dynamic.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const linter_1 = require("../src/linter");
+describe("img alt text with dynamic values", () => {
+    it("allows JSX expressions for alt when not explicitly empty", () => {
+        const jsx = `
+      const avatarUrl = "/avatar.png";
+      const displayLabel = "Avatar";
+      export default function Avatar() {
+        return <img src={avatarUrl} alt={displayLabel} />;
+      }
+    `;
+        const results = (0, linter_1.lint)(jsx);
+        assert_1.strict.ok(!results.some((r) => r.rule === "requireAltText"), "Did not expect alt warning for dynamic alt value");
+    });
+    it("flags explicitly empty JSX alt values", () => {
+        const jsx = `export default () => <img src="/avatar.png" alt={""} />;`;
+        const results = (0, linter_1.lint)(jsx);
+        assert_1.strict.ok(results.some((r) => r.rule === "requireAltText"), "Expected alt warning for empty JSX alt");
+    });
+    it("uses possible-empty messaging for conditional alt", () => {
+        const jsx = `
+      export default function Avatar({ user }) {
+        return <img src="/avatar.png" alt={user ? user.label : ""} />;
+      }
+    `;
+        const results = (0, linter_1.lint)(jsx);
+        const warning = results.find((r) => r.rule === "requireAltText");
+        assert_1.strict.ok(warning, "Expected alt warning for possibly empty alt");
+        assert_1.strict.ok(warning === null || warning === void 0 ? void 0 : warning.message.includes("possibly empty or undefined"), "Expected possible-empty alt message");
+    });
+    it("treats Vue-style bound alt as present in HTML mode unless empty", () => {
+        const html = `<img src="/avatar.png" :alt="displayLabel"><img src="/avatar.png" :alt="">`;
+        const results = (0, linter_1.lint)(html, { forceHtml: true });
+        const warnings = results.filter((r) => r.rule === "requireAltText");
+        assert_1.strict.strictEqual(warnings.length, 1, "Expected only the empty bound alt to warn");
+    });
+});

package/out/tests/link-href-text.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const linter_1 = require("../src/linter");
+describe("link href and text with dynamic values", () => {
+    it("allows JSX expressions for href and text when not explicitly empty", () => {
+        const jsx = `
+      const link = { url: "/docs" };
+      const text = "Docs";
+      export default function Nav() {
+        return <a href={link.url}>{text}</a>;
+      }
+    `;
+        const results = (0, linter_1.lint)(jsx);
+        assert_1.strict.ok(!results.some((r) => r.rule === "requireHrefOnAnchors"), "Did not expect href warning for dynamic href value");
+        assert_1.strict.ok(!results.some((r) => r.rule === "requireLinkText"), "Did not expect link text warning for dynamic text value");
+    });
+    it("flags explicitly empty JSX href values", () => {
+        const jsx = `export default () => <a href={""}>Text</a>;`;
+        const results = (0, linter_1.lint)(jsx);
+        assert_1.strict.ok(results.some((r) => r.rule === "requireHrefOnAnchors"), "Expected href warning for empty JSX href");
+    });
+    it("flags explicitly empty JSX text values", () => {
+        const jsx = `export default () => <a href="/docs">{undefined}</a>;`;
+        const results = (0, linter_1.lint)(jsx);
+        assert_1.strict.ok(results.some((r) => r.rule === "requireLinkText"), "Expected link text warning for undefined JSX text");
+    });
+    it("uses possible-empty messaging for conditional href/text", () => {
+        const jsx = `
+      export default function Nav({ ready, link }) {
+        return (
+          <a href={ready ? link.url : ""}>
+            {ready ? "Docs" : ""}
+          </a>
+        );
+      }
+    `;
+        const results = (0, linter_1.lint)(jsx);
+        const hrefWarning = results.find((r) => r.rule === "requireHrefOnAnchors");
+        const textWarning = results.find((r) => r.rule === "requireLinkText");
+        assert_1.strict.ok(hrefWarning, "Expected href warning for possibly empty href");
+        assert_1.strict.ok(textWarning, "Expected link text warning for possibly empty text");
+        assert_1.strict.ok(hrefWarning === null || hrefWarning === void 0 ? void 0 : hrefWarning.message.includes("possibly empty or undefined"), "Expected possible-empty href message");
+        assert_1.strict.ok(textWarning === null || textWarning === void 0 ? void 0 : textWarning.message.includes("possibly empty or undefined"), "Expected possible-empty text message");
+    });
+    it("treats Vue-style bound href and mustache text as present in HTML mode", () => {
+        const html = `<a :href="link.url">{{ text }}</a>`;
+        const results = (0, linter_1.lint)(html, { forceHtml: true });
+        assert_1.strict.ok(!results.some((r) => r.rule === "requireHrefOnAnchors"), "Did not expect href warning for bound Vue href");
+        assert_1.strict.ok(!results.some((r) => r.rule === "requireLinkText"), "Did not expect link text warning for mustache text");
+    });
+});

package/out/tests/list-nesting-dynamic.test.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const linter_1 = require("../src/linter");
+describe("list nesting with JSX expressions", () => {
+    it("allows <li> returned from map inside <ul>", () => {
+        const jsx = `
+      const holdings = [{ id: 1, asset: { id: "btc" } }];
+      export default function Holdings() {
+        return (
+          <ul className="mt-4 space-y-3">
+            {holdings.map((holding) => (
+              <li key={holding.asset.id}>{holding.asset.id}</li>
+            ))}
+          </ul>
+        );
+      }
+    `;
+        const results = (0, linter_1.lint)(jsx);
+        assert_1.strict.ok(!results.some((r) => r.rule === "enforceListNesting"), "Did not expect list nesting warning for mapped <li> inside <ul>");
+    });
+    it("still warns when <li> is not inside <ul> or <ol>", () => {
+        const jsx = `export default () => <li>Orphan</li>;`;
+        const results = (0, linter_1.lint)(jsx);
+        assert_1.strict.ok(results.some((r) => r.rule === "enforceListNesting"), "Expected list nesting warning for orphan <li>");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zemdomu",
-  "version": "1.3.14",
+  "version": "1.3.15",
   "description": "Semantic HTML linter for HTML, JSX, TSX, and Vue templates. Detects accessibility, SEO, and structure issues before deployment.",
   "main": "./out/index.js",
   "types": "./out/index.d.ts",