@html-eslint/eslint-plugin 0.24.1 → 0.26.0

package/lib/configs/recommended.js

@@ -6,6 +6,7 @@ module.exports = {
     "@html-eslint/require-title": "error",
     "@html-eslint/no-multiple-h1": "error",
     "@html-eslint/no-extra-spacing-attrs": "error",
+    "@html-eslint/attrs-newline": "error",
     "@html-eslint/element-newline": "error",
     "@html-eslint/no-duplicate-id": "error",
     "@html-eslint/indent": "error",

package/lib/rules/attrs-newline.js

@@ -0,0 +1,163 @@
+/**
+ * @typedef { import("../types").RuleFixer } RuleFixer
+ * @typedef { import("../types").RuleModule } RuleModule
+ * @typedef { import("../types").TagNode } TagNode
+ * @typedef {Object} MessageId
+ * @property {"closeStyleWrong"} CLOSE_STYLE_WRONG
+ * @property {"newlineMissing"} NEWLINE_MISSING
+ * @property {"newlineUnexpected"} NEWLINE_UNEXPECTED
+ */
+
+const { RULE_CATEGORY } = require("../constants");
+
+/**
+ * @type {MessageId}
+ */
+
+const MESSAGE_ID = {
+  CLOSE_STYLE_WRONG: "closeStyleWrong",
+  NEWLINE_MISSING: "newlineMissing",
+  NEWLINE_UNEXPECTED: "newlineUnexpected",
+};
+
+/**
+ * @type {RuleModule}
+ */
+module.exports = {
+  meta: {
+    type: "code",
+
+    docs: {
+      description: "Enforce newline between attributes",
+      category: RULE_CATEGORY.STYLE,
+      recommended: true,
+    },
+
+    fixable: true,
+    schema: [
+      {
+        type: "object",
+        properties: {
+          closeStyle: {
+            enum: ["newline", "sameline"],
+          },
+          ifAttrsMoreThan: {
+            type: "integer",
+          },
+        },
+      },
+    ],
+    messages: {
+      [MESSAGE_ID.CLOSE_STYLE_WRONG]:
+        "Closing bracket was on {{actual}}; expected {{expected}}",
+      [MESSAGE_ID.NEWLINE_MISSING]: "Newline expected before {{attrName}}",
+      [MESSAGE_ID.NEWLINE_UNEXPECTED]:
+        "Newlines not expected between attributes, since this tag has fewer than {{attrMin}} attributes",
+    },
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const attrMin = isNaN(options.ifAttrsMoreThan)
+      ? 2
+      : options.ifAttrsMoreThan;
+    const closeStyle = options.closeStyle || "newline";
+
+    return {
+      /**
+       * @param {TagNode} node
+       */
+      Tag(node) {
+        const shouldBeMultiline = node.attributes.length > attrMin;
+
+        /**
+         * This doesn't do any indentation, so the result will look silly. Indentation should be covered by the `indent` rule
+         * @param {RuleFixer} fixer
+         */
+        function fix(fixer) {
+          const spacer = shouldBeMultiline ? "\n" : " ";
+          let expected = node.openStart.value;
+          for (const attr of node.attributes) {
+            expected += `${spacer}${attr.key.value}`;
+            if (attr.startWrapper && attr.value && attr.endWrapper) {
+              expected += `=${attr.startWrapper.value}${attr.value.value}${attr.endWrapper.value}`;
+            }
+          }
+          if (shouldBeMultiline && closeStyle === "newline") {
+            expected += "\n";
+          } else if (node.selfClosing) {
+            expected += " ";
+          }
+          expected += node.openEnd.value;
+
+          return fixer.replaceTextRange(
+            [node.openStart.range[0], node.openEnd.range[1]],
+            expected
+          );
+        }
+
+        if (shouldBeMultiline) {
+          let index = 0;
+          for (const attr of node.attributes) {
+            const attrPrevious = node.attributes[index - 1];
+            const relativeToNode = attrPrevious || node.openStart;
+            if (attr.loc.start.line === relativeToNode.loc.end.line) {
+              return context.report({
+                node,
+                data: {
+                  attrName: attr.key.value,
+                },
+                fix,
+                messageId: MESSAGE_ID.NEWLINE_MISSING,
+              });
+            }
+            index += 1;
+          }
+
+          const attrLast = node.attributes[node.attributes.length - 1];
+          const closeStyleActual =
+            node.openEnd.loc.start.line === attrLast.loc.end.line
+              ? "sameline"
+              : "newline";
+          if (closeStyle !== closeStyleActual) {
+            return context.report({
+              node,
+              data: {
+                actual: closeStyleActual,
+                expected: closeStyle,
+              },
+              fix,
+              messageId: MESSAGE_ID.CLOSE_STYLE_WRONG,
+            });
+          }
+        } else {
+          let expectedLastLineNum = node.openStart.loc.start.line;
+          for (const attr of node.attributes) {
+            if (shouldBeMultiline) {
+              expectedLastLineNum += 1;
+            }
+            if (attr.value) {
+              const valueLineSpan =
+                attr.value.loc.end.line - attr.value.loc.start.line;
+              expectedLastLineNum += valueLineSpan;
+            }
+          }
+          if (shouldBeMultiline && closeStyle === "newline") {
+            expectedLastLineNum += 1;
+          }
+
+          if (node.openEnd.loc.end.line !== expectedLastLineNum) {
+            return context.report({
+              node,
+              data: {
+                attrMin,
+              },
+              fix,
+              messageId: MESSAGE_ID.NEWLINE_UNEXPECTED,
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/lib/rules/index.js

@@ -6,6 +6,7 @@ const noDuplicateId = require("./no-duplicate-id");
 const noInlineStyles = require("./no-inline-styles");
 const noMultipleH1 = require("./no-multiple-h1");
 const noExtraSpacingAttrs = require("./no-extra-spacing-attrs");
+const attrsNewline = require("./attrs-newline");
 const elementNewLine = require("./element-newline");
 const noSkipHeadingLevels = require("./no-skip-heading-levels");
 const indent = require("./indent");
@@ -45,6 +46,7 @@ module.exports = {
   "no-inline-styles": noInlineStyles,
   "no-multiple-h1": noMultipleH1,
   "no-extra-spacing-attrs": noExtraSpacingAttrs,
+  "attrs-newline": attrsNewline,
   "element-newline": elementNewLine,
   "no-skip-heading-levels": noSkipHeadingLevels,
   "require-li-container": requireLiContainer,

package/lib/rules/no-extra-spacing-attrs.js

@@ -20,9 +20,13 @@ const MESSAGE_IDS = {
   EXTRA_BETWEEN: "unexpectedBetween",
   EXTRA_AFTER: "unexpectedAfter",
   EXTRA_BEFORE: "unexpectedBefore",
+  EXTRA_BEFORE_CLOSE: "unexpectedBeforeClose",
   MISSING_BEFORE: "missingBefore",
   MISSING_BEFORE_SELF_CLOSE: "missingBeforeSelfClose",
   EXTRA_BEFORE_SELF_CLOSE: "unexpectedBeforeSelfClose",
+  EXTRA_TAB_BEFORE: "unexpectedTabBefore",
+  EXTRA_TAB_BEFORE_SELF_CLOSE: "unexpectedTabBeforeSelfClose",
+  EXTRA_TAB_BETWEEN: "unexpectedTabBetween",
 };
 
 /**
@@ -46,6 +50,9 @@ module.exports = {
           disallowMissing: {
             type: "boolean",
           },
+          disallowTabs: {
+            type: "boolean",
+          },
           enforceBeforeSelfClose: {
             type: "boolean",
           },
@@ -56,17 +63,27 @@ module.exports = {
       [MESSAGE_IDS.EXTRA_BETWEEN]: "Unexpected space between attributes",
       [MESSAGE_IDS.EXTRA_AFTER]: "Unexpected space after attribute",
       [MESSAGE_IDS.EXTRA_BEFORE]: "Unexpected space before attribute",
+      [MESSAGE_IDS.EXTRA_BEFORE_CLOSE]: "Unexpected space before closing",
       [MESSAGE_IDS.MISSING_BEFORE_SELF_CLOSE]:
         "Missing space before self closing",
       [MESSAGE_IDS.EXTRA_BEFORE_SELF_CLOSE]:
         "Unexpected extra spaces before self closing",
       [MESSAGE_IDS.MISSING_BEFORE]: "Missing space before attribute",
+      [MESSAGE_IDS.EXTRA_TAB_BEFORE]:
+        "Unexpected tab before attribute; use space instead",
+      [MESSAGE_IDS.EXTRA_TAB_BEFORE_SELF_CLOSE]:
+        "Unexpected tab before self closing; use space instead",
+      [MESSAGE_IDS.EXTRA_TAB_BETWEEN]:
+        "Unexpected tab between attributes; use space instead",
     },
   },
   create(context) {
     const enforceBeforeSelfClose = !!(context.options[0] || {})
       .enforceBeforeSelfClose;
     const disallowMissing = !!(context.options[0] || {}).disallowMissing;
+    const disallowTabs = !!(context.options[0] || {}).disallowTabs;
+
+    const sourceCode = context.getSourceCode().text;
 
     /**
      * @param {AttributeNode[]} attrs
@@ -98,48 +115,23 @@ module.exports = {
               return fixer.insertTextAfter(current, " ");
             },
           });
+        } else if (disallowTabs) {
+          if (sourceCode[current.range[1]] === `\t`) {
+            context.report({
+              loc: getLocBetween(current, after),
+              messageId: MESSAGE_IDS.EXTRA_TAB_BETWEEN,
+              fix(fixer) {
+                return fixer.replaceTextRange(
+                  [current.range[1], current.range[1] + 1],
+                  ` `
+                );
+              },
+            });
+          }
         }
       });
     }
 
-    /**
-     * @param {OpenTagEndNode | OpenScriptTagEndNode | OpenStyleTagEndNode} openEnd
-     * @param {AttributeNode} lastAttr
-     * @param {boolean} isSelfClosed
-     * @returns {void}
-     */
-    function checkExtraSpaceAfter(openEnd, lastAttr, isSelfClosed) {
-      if (openEnd.loc.end.line !== lastAttr.loc.end.line) {
-        // skip the attribute on the different line with the start tag
-        return;
-      }
-      const limit = isSelfClosed && enforceBeforeSelfClose ? 1 : 0;
-      const spacesBetween = openEnd.loc.start.column - lastAttr.loc.end.column;
-
-      if (spacesBetween > limit) {
-        context.report({
-          loc: getLocBetween(lastAttr, openEnd),
-          messageId: MESSAGE_IDS.EXTRA_AFTER,
-          fix(fixer) {
-            return fixer.removeRange([
-              lastAttr.range[1],
-              lastAttr.range[1] + spacesBetween - limit,
-            ]);
-          },
-        });
-      }
-
-      if (isSelfClosed && enforceBeforeSelfClose && spacesBetween < 1) {
-        context.report({
-          loc: getLocBetween(lastAttr, openEnd),
-          messageId: MESSAGE_IDS.MISSING_BEFORE_SELF_CLOSE,
-          fix(fixer) {
-            return fixer.insertTextAfter(lastAttr, " ");
-          },
-        });
-      }
-    }
-
     /**
      * @param {OpenScriptTagStartNode | OpenTagStartNode | OpenStyleTagStartNode} node
      * @param {AttributeNode} firstAttr
@@ -164,42 +156,19 @@ module.exports = {
             ]);
           },
         });
-      }
-    }
-
-    /**
-     * @param {AnyNode} beforeSelfClosing
-     * @param {OpenTagEndNode | OpenScriptTagEndNode | OpenStyleTagEndNode} openEnd
-     * @returns
-     */
-    function checkSpaceBeforeSelfClosing(beforeSelfClosing, openEnd) {
-      if (beforeSelfClosing.loc.start.line !== openEnd.loc.start.line) {
-        // skip the attribute on the different line with the start tag
-        return;
-      }
-      const spacesBetween =
-        openEnd.loc.start.column - beforeSelfClosing.loc.end.column;
-      const locBetween = getLocBetween(beforeSelfClosing, openEnd);
-
-      if (spacesBetween > 1) {
-        context.report({
-          loc: locBetween,
-          messageId: MESSAGE_IDS.EXTRA_BEFORE_SELF_CLOSE,
-          fix(fixer) {
-            return fixer.removeRange([
-              beforeSelfClosing.range[1] + 1,
-              openEnd.range[0],
-            ]);
-          },
-        });
-      } else if (spacesBetween < 1) {
-        context.report({
-          loc: locBetween,
-          messageId: MESSAGE_IDS.MISSING_BEFORE_SELF_CLOSE,
-          fix(fixer) {
-            return fixer.insertTextAfter(beforeSelfClosing, " ");
-          },
-        });
+      } else if (disallowTabs) {
+        if (sourceCode[firstAttr.range[0] - 1] === `\t`) {
+          context.report({
+            loc: firstAttr.loc,
+            messageId: MESSAGE_IDS.EXTRA_TAB_BEFORE,
+            fix(fixer) {
+              return fixer.replaceTextRange(
+                [firstAttr.range[0] - 1, firstAttr.range[0]],
+                ` `
+              );
+            },
+          });
+        }
       }
     }
 
@@ -216,24 +185,89 @@ module.exports = {
         if (node.attributes.length) {
           checkExtraSpaceBefore(node.openStart, node.attributes[0]);
         }
+
         if (node.openEnd) {
+          checkExtraSpacesBetweenAttrs(node.attributes);
+
+          const lastAttr = node.attributes[node.attributes.length - 1];
+          const nodeBeforeEnd =
+            node.attributes.length === 0 ? node.openStart : lastAttr;
+
+          if (nodeBeforeEnd.loc.end.line !== node.openEnd.loc.start.line) {
+            return;
+          }
+
           const isSelfClosing = node.openEnd.value === "/>";
 
-          if (node.attributes && node.attributes.length > 0) {
-            checkExtraSpaceAfter(
-              node.openEnd,
-              node.attributes[node.attributes.length - 1],
-              isSelfClosing
-            );
+          const spacesBetween =
+            node.openEnd.loc.start.column - nodeBeforeEnd.loc.end.column;
+          const locBetween = getLocBetween(nodeBeforeEnd, node.openEnd);
+
+          if (isSelfClosing && enforceBeforeSelfClose) {
+            if (spacesBetween < 1) {
+              context.report({
+                loc: locBetween,
+                messageId: MESSAGE_IDS.MISSING_BEFORE_SELF_CLOSE,
+                fix(fixer) {
+                  return fixer.insertTextAfter(nodeBeforeEnd, " ");
+                },
+              });
+            } else if (spacesBetween === 1) {
+              if (
+                disallowTabs &&
+                sourceCode[node.openEnd.range[0] - 1] === `\t`
+              ) {
+                context.report({
+                  loc: node.openEnd.loc,
+                  messageId: MESSAGE_IDS.EXTRA_TAB_BEFORE_SELF_CLOSE,
+                  fix(fixer) {
+                    return fixer.replaceTextRange(
+                      [node.openEnd.range[0] - 1, node.openEnd.range[0]],
+                      ` `
+                    );
+                  },
+                });
+              }
+            } else {
+              context.report({
+                loc: locBetween,
+                messageId: MESSAGE_IDS.EXTRA_BEFORE_SELF_CLOSE,
+                fix(fixer) {
+                  return fixer.removeRange([
+                    nodeBeforeEnd.range[1] + 1,
+                    node.openEnd.range[0],
+                  ]);
+                },
+              });
+            }
+
+            return;
           }
 
-          checkExtraSpacesBetweenAttrs(node.attributes);
-          if (
-            node.attributes.length === 0 &&
-            isSelfClosing &&
-            enforceBeforeSelfClose
-          ) {
-            checkSpaceBeforeSelfClosing(node.openStart, node.openEnd);
+          if (spacesBetween > 0) {
+            if (node.attributes.length > 0) {
+              context.report({
+                loc: locBetween,
+                messageId: MESSAGE_IDS.EXTRA_AFTER,
+                fix(fixer) {
+                  return fixer.removeRange([
+                    lastAttr.range[1],
+                    node.openEnd.range[0],
+                  ]);
+                },
+              });
+            } else {
+              context.report({
+                loc: locBetween,
+                messageId: MESSAGE_IDS.EXTRA_BEFORE_CLOSE,
+                fix(fixer) {
+                  return fixer.removeRange([
+                    node.openStart.range[1],
+                    node.openEnd.range[0],
+                  ]);
+                },
+              });
+            }
           }
         }
       },

package/lib/rules/require-closing-tags.js

@@ -34,8 +34,11 @@ module.exports = {
           selfClosing: {
             enum: ["always", "never"],
           },
-          allowSelfClosingCustom: {
-            type: "boolean",
+          selfClosingCustomPatterns: {
+            type: "array",
+            items: {
+              type: "string",
+            },
           },
         },
         additionalProperties: false,
@@ -49,14 +52,21 @@ module.exports = {
   },
 
   create(context) {
-    const shouldSelfClose =
+    /** @type {string[]} */
+    const foreignContext = [];
+    const shouldSelfCloseVoid =
       context.options && context.options.length
         ? context.options[0].selfClosing === "always"
         : false;
-    const allowSelfClosingCustom =
-      context.options && context.options.length
-        ? context.options[0].allowSelfClosingCustom === true
-        : false;
+    /** @type {string[]} */
+    const selfClosingCustomPatternsOption =
+      (context.options &&
+        context.options.length &&
+        context.options[0].selfClosingCustomPatterns) ||
+      [];
+    const selfClosingCustomPatterns = selfClosingCustomPatternsOption.map(
+      (i) => new RegExp(i)
+    );
 
     /**
      * @param {TagNode} node
@@ -91,7 +101,10 @@ module.exports = {
             if (!fixable) {
               return null;
             }
-            return fixer.replaceText(node.openEnd, " />");
+            const fixes = [];
+            fixes.push(fixer.replaceText(node.openEnd, " />"));
+            if (node.close) fixes.push(fixer.remove(node.close));
+            return fixes;
           },
         });
       }
@@ -115,17 +128,33 @@ module.exports = {
     return {
       Tag(node) {
         const isVoidElement = VOID_ELEMENTS_SET.has(node.name);
-        if (
-          node.selfClosing &&
-          allowSelfClosingCustom &&
-          node.name.indexOf("-") !== -1
-        ) {
-          checkVoidElement(node, true, false);
-        } else if (node.selfClosing || isVoidElement) {
-          checkVoidElement(node, shouldSelfClose, isVoidElement);
+        const isSelfClosingCustomElement = !!selfClosingCustomPatterns.some(
+          (i) => node.name.match(i)
+        );
+        const isForeign = foreignContext.length > 0;
+        const shouldSelfCloseCustom =
+          isSelfClosingCustomElement && !node.children.length;
+        const shouldSelfCloseForeign = node.selfClosing;
+        const shouldSelfClose =
+          (isVoidElement && shouldSelfCloseVoid) ||
+          (isSelfClosingCustomElement && shouldSelfCloseCustom) ||
+          (isForeign && shouldSelfCloseForeign);
+        const canSelfClose =
+          isVoidElement || isSelfClosingCustomElement || isForeign;
+        if (node.selfClosing || canSelfClose) {
+          checkVoidElement(node, shouldSelfClose, canSelfClose);
         } else if (node.openEnd.value !== "/>") {
           checkClosingTag(node);
         }
+        if (["svg", "math"].includes(node.name)) foreignContext.push(node.name);
+      },
+      /**
+       * @param {TagNode} node
+       */
+      "Tag:exit"(node) {
+        if (node.name === foreignContext[foreignContext.length - 1]) {
+          foreignContext.pop();
+        }
       },
     };
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@html-eslint/eslint-plugin",
-  "version": "0.24.1",
+  "version": "0.26.0",
   "description": "ESLint plugin for html",
   "author": "yeonjuan",
   "homepage": "https://github.com/yeonjuan/html-eslint#readme",
@@ -45,11 +45,11 @@
     "accessibility"
   ],
   "devDependencies": {
-    "@html-eslint/parser": "^0.24.1",
+    "@html-eslint/parser": "^0.26.0",
     "@types/eslint": "^8.56.2",
     "@types/estree": "^0.0.47",
     "es-html-parser": "^0.0.8",
     "typescript": "^4.4.4"
   },
-  "gitHead": "c9095f0738fea1688099937ebc0a93b1a26b7da9"
+  "gitHead": "34d55c3b5be5a29cc416063b4b4375cb89b3a519"
 }

package/types/configs/recommended.d.ts

@@ -0,0 +1,18 @@
+export const rules: {
+    "@html-eslint/require-lang": string;
+    "@html-eslint/require-img-alt": string;
+    "@html-eslint/require-doctype": string;
+    "@html-eslint/require-title": string;
+    "@html-eslint/no-multiple-h1": string;
+    "@html-eslint/no-extra-spacing-attrs": string;
+    "@html-eslint/attrs-newline": string;
+    "@html-eslint/element-newline": string;
+    "@html-eslint/no-duplicate-id": string;
+    "@html-eslint/indent": string;
+    "@html-eslint/require-li-container": string;
+    "@html-eslint/quotes": string;
+    "@html-eslint/no-obsolete-tags": string;
+    "@html-eslint/require-closing-tags": string;
+    "@html-eslint/no-duplicate-attrs": string;
+};
+//# sourceMappingURL=recommended.d.ts.map

package/types/configs/recommended.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommended.d.ts","sourceRoot":"","sources":["../../lib/configs/recommended.js"],"names":[],"mappings":""}

package/types/constants/index.d.ts

@@ -0,0 +1,5 @@
+import RULE_CATEGORY = require("./rule-category");
+import OBSOLETE_TAGS = require("./obsolete-tags");
+import VOID_ELEMENTS = require("./void-elements");
+export { RULE_CATEGORY, OBSOLETE_TAGS, VOID_ELEMENTS };
+//# sourceMappingURL=index.d.ts.map

package/types/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/constants/index.js"],"names":[],"mappings":""}

package/types/constants/obsolete-tags.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: string[];
+export = _exports;
+//# sourceMappingURL=obsolete-tags.d.ts.map

package/types/constants/obsolete-tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"obsolete-tags.d.ts","sourceRoot":"","sources":["../../lib/constants/obsolete-tags.js"],"names":[],"mappings":"wBACW,MAAM,EAAE"}

package/types/constants/rule-category.d.ts

@@ -0,0 +1,5 @@
+export const BEST_PRACTICE: string;
+export const SEO: string;
+export const ACCESSIBILITY: string;
+export const STYLE: string;
+//# sourceMappingURL=rule-category.d.ts.map

package/types/constants/rule-category.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-category.d.ts","sourceRoot":"","sources":["../../lib/constants/rule-category.js"],"names":[],"mappings":""}

package/types/constants/void-elements.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: string[];
+export = _exports;
+//# sourceMappingURL=void-elements.d.ts.map

package/types/constants/void-elements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"void-elements.d.ts","sourceRoot":"","sources":["../../lib/constants/void-elements.js"],"names":[],"mappings":"wBAAW,MAAM,EAAE"}

package/types/rules/attrs-newline.d.ts

@@ -0,0 +1,11 @@
+declare const _exports: RuleModule;
+export = _exports;
+export type RuleFixer = import("../types").RuleFixer;
+export type RuleModule = import("../types").RuleModule;
+export type TagNode = import("../types").TagNode;
+export type MessageId = {
+    CLOSE_STYLE_WRONG: "closeStyleWrong";
+    NEWLINE_MISSING: "newlineMissing";
+    NEWLINE_UNEXPECTED: "newlineUnexpected";
+};
+//# sourceMappingURL=attrs-newline.d.ts.map

package/types/rules/attrs-newline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attrs-newline.d.ts","sourceRoot":"","sources":["../../lib/rules/attrs-newline.js"],"names":[],"mappings":"wBAuBU,UAAU;;wBAtBN,OAAO,UAAU,EAAE,SAAS;yBAC5B,OAAO,UAAU,EAAE,UAAU;sBAC7B,OAAO,UAAU,EAAE,OAAO;;uBAE1B,iBAAiB;qBACjB,gBAAgB;wBAChB,mBAAmB"}

package/types/rules/element-newline.d.ts

@@ -0,0 +1,7 @@
+declare const _exports: RuleModule;
+export = _exports;
+export type RuleModule = import("../types").RuleModule;
+export type ProgramNode = import("../types").ProgramNode;
+export type TagNode = import("../types").TagNode;
+export type BaseNode = import("../types").BaseNode;
+//# sourceMappingURL=element-newline.d.ts.map

package/types/rules/element-newline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-newline.d.ts","sourceRoot":"","sources":["../../lib/rules/element-newline.js"],"names":[],"mappings":"wBAeU,UAAU;;yBAdN,OAAO,UAAU,EAAE,UAAU;0BAC7B,OAAO,UAAU,EAAE,WAAW;sBAC9B,OAAO,UAAU,EAAE,OAAO;uBAC1B,OAAO,UAAU,EAAE,QAAQ"}

package/types/rules/id-naming-convention.d.ts

@@ -0,0 +1,7 @@
+declare const _exports: RuleModule;
+export = _exports;
+export type RuleModule = import("../types").RuleModule;
+export type TagNode = import("../types").TagNode;
+export type ScriptTagNode = import("../types").ScriptTagNode;
+export type StyleTagNode = import("../types").StyleTagNode;
+//# sourceMappingURL=id-naming-convention.d.ts.map