@html-eslint/eslint-plugin 0.31.1 → 0.32.0

package/lib/rules/utils/node.js

@@ -1,26 +1,26 @@
 /**
- * @typedef { import("es-html-parser").TagNode } TagNode
- * @typedef { import("es-html-parser").ScriptTagNode } ScriptTagNode
- * @typedef { import("es-html-parser").StyleTagNode } StyleTagNode
- * @typedef { import("es-html-parser").AttributeNode } AttributeNode
- * @typedef { import("es-html-parser").AttributeValueNode } AttributeValueNode
- * @typedef { import("es-html-parser").AnyNode } AnyNode
- * @typedef { import("es-html-parser").TextNode } TextNode
- * @typedef { import("es-html-parser").CommentContentNode } CommentContentNode
- * @typedef { import("es-html-parser").CommentNode } CommentNode
- * @typedef { import("es-html-parser").AnyToken} AnyToken
- * @typedef { import("../../types").LineNode } LineNode
- * @typedef { import("../../types").BaseNode } BaseNode
- * @typedef { import("../../types").Location } Location
- * @typedef { import("../../types").Range } Range
+ * @typedef { import("../../types").Attribute } Attribute
+ * @typedef { import("../../types").Tag } Tag
+ * @typedef { import("../../types").ScriptTag } ScriptTag
+ * @typedef { import("../../types").StyleTag } StyleTag
+ * @typedef { import("../../types").Line } Line
+ * @typedef { import("../../types").Text } Text
+ * @typedef { import("../../types").CommentContent } CommentContent
+ * @typedef { import("../../types").Comment } Comment
+ * @typedef { import("../../types").AnyNode } AnyNode
+ * @typedef { import("../../types").AttributeValue } AttributeValue
+ * @typedef { import("eslint").AST.Range } Range
+ * @typedef { import("eslint").AST.SourceLocation } SourceLocation
+ * @typedef { import("es-html-parser").AnyToken } AnyToken
+
  */
 
 const { NODE_TYPES } = require("@html-eslint/parser");
 
 /**
- * @param {TagNode | ScriptTagNode | StyleTagNode} node
+ * @param {Tag | ScriptTag | StyleTag} node
  * @param {string} key
- * @returns {AttributeNode | undefined}
+ * @returns {Attribute | undefined}
  */
 function findAttr(node, key) {
   return node.attributes.find(
@@ -30,7 +30,7 @@ function findAttr(node, key) {
 
 /**
  * Checks whether a node's attributes is empty or not.
- * @param {TagNode | ScriptTagNode | StyleTagNode} node
+ * @param {Tag | ScriptTag | StyleTag} node
  * @returns {boolean}
  */
 function isAttributesEmpty(node) {
@@ -57,7 +57,7 @@ function isRangesOverlap(rangeA, rangeB) {
 }
 
 /**
- * @param {(TextNode | CommentContentNode)['templates']} templates
+ * @param {(Text | CommentContent)['templates']} templates
  * @param {Range} range
  * @returns {boolean}
  */
@@ -69,21 +69,21 @@ function isOverlapWithTemplates(templates, range) {
 
 /**
  *
- * @param {TextNode | CommentContentNode} node
- * @returns {LineNode[]}
+ * @param {Text | CommentContent} node
+ * @returns {Line[]}
  */
 function splitToLineNodes(node) {
   let start = node.range[0];
   let line = node.loc.start.line;
   const startCol = node.loc.start.column;
   /**
-   * @type {LineNode[]}
+   * @type {Line[]}
    */
   const lineNodes = [];
   const templates = node.templates || [];
   /**
    *
-   * @param {import("../../types").Range} range
+   * @param {Range} range
    */
   function shouldSkipIndentCheck(range) {
     return templates.some(
@@ -95,7 +95,7 @@ function splitToLineNodes(node) {
   node.value.split("\n").forEach((value, index) => {
     const columnStart = index === 0 ? startCol : 0;
     /**
-     * @type {import("../../types").Range}
+     * @type {Range}
      */
     const range = [start, start + value.length];
     const loc = {
@@ -109,7 +109,7 @@ function splitToLineNodes(node) {
       },
     };
     /**
-     * @type {LineNode}
+     * @type {Line}
      */
     const lineNode = {
       type: "Line",
@@ -130,9 +130,9 @@ function splitToLineNodes(node) {
 
 /**
  * Get location between two nodes.
- * @param {BaseNode} before A node placed in before
- * @param {BaseNode} after A node placed in after
- * @returns {Location} location between two nodes.
+ * @param {{loc: SourceLocation}} before A node placed in before
+ * @param {{loc: SourceLocation}} after A node placed in after
+ * @returns {SourceLocation} location between two nodes.
  */
 function getLocBetween(before, after) {
   return {
@@ -142,7 +142,7 @@ function getLocBetween(before, after) {
 }
 
 /**
- * @param {AttributeValueNode} node
+ * @param {AttributeValue} node
  * @return {boolean}
  */
 function isExpressionInTemplate(node) {
@@ -154,7 +154,7 @@ function isExpressionInTemplate(node) {
 
 /**
  * @param {AnyNode} node
- * @returns {node is TagNode}
+ * @returns {node is Tag}
  */
 function isTag(node) {
   return node.type === NODE_TYPES.Tag;
@@ -162,7 +162,15 @@ function isTag(node) {
 
 /**
  * @param {AnyNode} node
- * @returns {node is CommentNode}
+ * @returns {node is ScriptTag}
+ */
+function isScript(node) {
+  return node.type === NODE_TYPES.ScriptTag;
+}
+
+/**
+ * @param {AnyNode} node
+ * @returns {node is Comment}
  */
 function isComment(node) {
   return node.type === NODE_TYPES.Comment;
@@ -170,12 +178,20 @@ function isComment(node) {
 
 /**
  * @param {AnyNode} node
- * @returns {node is TextNode}
+ * @returns {node is Text}
  */
 function isText(node) {
   return node.type === NODE_TYPES.Text;
 }
 
+/**
+ * @param {AnyNode | Line} node
+ * @returns {node is Line}
+ */
+function isLine(node) {
+  return node.type === "Line";
+}
+
 const lineBreakPattern = /\r\n|[\r\n\u2028\u2029]/u;
 const lineEndingPattern = new RegExp(lineBreakPattern.source, "gu");
 /**
@@ -186,10 +202,31 @@ function codeToLines(source) {
   return source.split(lineEndingPattern);
 }
 
+/**
+ * @param {Exclude<AnyNode, Line>} node
+ * @param {(node: AnyNode) => boolean} predicate
+ * @returns {null | AnyNode}
+ */
+function findParent(node, predicate) {
+  if (!node.parent) {
+    return null;
+  }
+  if (
+    node.type === "TaggedTemplateExpression" ||
+    node.type === "TemplateLiteral"
+  ) {
+    return null;
+  }
+  if (predicate(node.parent)) {
+    return node.parent;
+  }
+  return findParent(node.parent, predicate);
+}
+
 /**
  *
  * @param {AnyToken[]} tokens
- * @returns {((CommentContentNode | TextNode)['templates'][number])[]}
+ * @returns {((CommentContent | Text)['templates'][number])[]}
  */
 function getTemplateTokens(tokens) {
   return (
@@ -210,10 +247,13 @@ module.exports = {
   isNodeTokensOnSameLine,
   splitToLineNodes,
   getLocBetween,
+  findParent,
   isExpressionInTemplate,
   isTag,
   isComment,
   isText,
+  isLine,
+  isScript,
   isOverlapWithTemplates,
   codeToLines,
   isRangesOverlap,

package/lib/rules/utils/settings.js

@@ -2,8 +2,8 @@
  * @typedef {import("../../types").MaybeHTMLSettings} MaybeHTMLSettings
  * @typedef {import("../../types").HTMLSettings} HTMLSettings
  * @typedef {import("../../types").Context} Context
- * @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpression
- * @typedef {import("estree").TemplateLiteral} TemplateLiteral
+ * @typedef {import("../../types").TaggedTemplateExpression} TaggedTemplateExpression
+ * @typedef {import("../../types").TemplateLiteral} TemplateLiteral
  */
 
 const { getSourceCode } = require("../utils/source-code");

package/lib/rules/utils/visitors.js

@@ -1,6 +1,6 @@
 /**
- * @typedef { import("../../types").RuleListener } RuleListener
  * @typedef { import("../../types").Context } Context
+ * @typedef { import("../../types").RuleListener } RuleListener
  */
 
 const {

package/lib/types/ast.d.ts

@@ -0,0 +1,204 @@
+import * as Parser from "es-html-parser";
+import eslint from "eslint";
+import * as estree from "estree";
+
+export interface Document extends Parser.DocumentNode {
+  parent: null;
+  children: Array<Tag | Text | Comment | Doctype | ScriptTag | StyleTag>;
+}
+
+export interface Doctype extends Parser.DoctypeNode {
+  parent: Document | Tag;
+  open: DoctypeOpen;
+  close: DoctypeClose;
+  attributes: Array<DoctypeAttribute>;
+}
+
+export interface DoctypeOpen extends Parser.DoctypeOpenNode {
+  parent: Doctype;
+}
+
+export interface DoctypeClose extends Parser.DoctypeCloseNode {
+  parent: Doctype;
+}
+
+export interface DoctypeAttribute extends Parser.DoctypeAttributeNode {
+  parent: Doctype;
+}
+
+export interface Comment extends Parser.CommentNode {
+  parent: Tag | Document;
+  open: CommentOpen;
+  close: CommentClose;
+  value: CommentContent;
+}
+
+export interface CommentOpen extends Parser.CommentOpenNode {
+  parent: Comment;
+}
+
+export interface CommentClose extends Parser.CommentCloseNode {
+  parent: Comment;
+}
+
+export interface CommentContent extends Parser.CommentContentNode {
+  parent: Comment;
+}
+
+export interface Tag extends Parser.TagNode {
+  parent: Document | Tag;
+  openStart: OpenTagStart;
+  openEnd: OpenTagEnd;
+  attributes: Array<Attribute>;
+  close?: CloseTag;
+  children: Array<Tag | Text | StyleTag | ScriptTag>;
+}
+
+export interface OpenTagStart extends Parser.OpenTagStartNode {
+  parent: Tag;
+}
+
+export interface OpenTagEnd extends Parser.OpenTagEndNode {
+  parent: Tag;
+}
+
+export interface CloseTag extends Parser.CloseTagNode {
+  parent: Tag;
+}
+
+export interface ScriptTag extends Parser.ScriptTagNode {
+  parent: Document | Tag;
+  attributes: Array<Attribute>;
+  openStart: OpenScriptTagStart;
+  openEnd: OpenScriptTagEnd;
+  value?: ScriptTagContent;
+}
+
+export interface OpenScriptTagStart extends Parser.OpenScriptTagStartNode {
+  parent: ScriptTag;
+}
+
+export interface OpenScriptTagEnd extends Parser.OpenScriptTagEndNode {
+  parent: ScriptTag;
+}
+
+export interface CloseScriptTag extends Parser.CloseScriptTagNode {
+  parent: ScriptTag;
+}
+
+export interface ScriptTagContent extends Parser.ScriptTagContentNode {
+  parent: ScriptTag;
+}
+
+export interface StyleTag extends Parser.StyleTagNode {
+  parent: Document | Tag;
+  attributes: Array<Attribute>;
+  openStart: OpenStyleTagStart;
+  openEnd: OpenStyleTagEnd;
+  value?: StyleTagContent;
+}
+
+export interface OpenStyleTagStart extends Parser.OpenStyleTagStartNode {
+  parent: StyleTag;
+}
+
+export interface OpenStyleTagEnd extends Parser.OpenStyleTagEndNode {
+  parent: StyleTag;
+}
+
+export interface CloseStyleTag extends Parser.CloseStyleTagNode {
+  parent: StyleTag;
+}
+
+export interface StyleTagContent extends Parser.StyleTagContentNode {
+  parent: StyleTag;
+}
+
+export interface Attribute extends Parser.AttributeNode {
+  parent: Tag;
+  key: AttributeKey;
+  value?: AttributeValue;
+  startWrapper?: AttributeValueWrapperStart;
+  endWrapper?: AttributeValueWrapperEnd;
+}
+
+export interface AttributeKey extends Parser.AttributeKeyNode {
+  parent: Attribute;
+}
+
+export interface AttributeValue extends Parser.AttributeValueNode {
+  parent: Attribute;
+}
+
+export interface AttributeValueWrapperStart
+  extends Parser.AttributeValueWrapperStartNode {
+  parent: Attribute;
+}
+
+export interface AttributeValueWrapperEnd
+  extends Parser.AttributeValueWrapperEndNode {
+  parent: Attribute;
+}
+
+export interface Text extends Parser.TextNode {
+  parent: Document | Tag;
+}
+
+/**
+ *  This is not a node generated by es-html-parser; it is created by utils's splitToLineNodes.
+ */
+export interface Line {
+  type: "Line";
+  value: string;
+  skipIndentCheck: boolean;
+  range: eslint.AST.Range;
+  loc: eslint.AST.SourceLocation;
+}
+
+export interface TaggedTemplateExpression
+  extends estree.TaggedTemplateExpression {
+  parent: estree.Node | null;
+  loc: eslint.AST.SourceLocation;
+  range: eslint.AST.Range;
+  quasi: TemplateLiteral;
+}
+
+export interface TemplateLiteral extends estree.TemplateLiteral {
+  parent: estree.Node | null;
+  loc: eslint.AST.SourceLocation;
+  range: eslint.AST.Range;
+}
+
+export type AnyNode =
+  | Document
+  | Doctype
+  | DoctypeOpen
+  | DoctypeClose
+  | DoctypeAttribute
+  | Comment
+  | CommentOpen
+  | CommentClose
+  | CommentContent
+  | Tag
+  | OpenTagStart
+  | OpenTagEnd
+  | CloseTag
+  | ScriptTag
+  | OpenScriptTagStart
+  | OpenScriptTagEnd
+  | ScriptTagContent
+  | CloseScriptTag
+  | StyleTag
+  | OpenStyleTagStart
+  | OpenStyleTagEnd
+  | StyleTagContent
+  | CloseStyleTag
+  | Attribute
+  | AttributeKey
+  | AttributeValue
+  | AttributeValueWrapperEnd
+  | AttributeValueWrapperStart
+  | Text
+  | Line
+  | TaggedTemplateExpression
+  | TemplateLiteral;

package/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ast";
+export * from "./rule";
+export * from "./settings";

package/lib/types/rule.d.ts

@@ -0,0 +1,83 @@
+import eslint from "eslint";
+import * as AST from "./ast";
+
+type PostFix<T, S extends string> = {
+  [K in keyof T as `${K & string}${S}`]: T[K];
+};
+
+interface BaseRuleListener {
+  Document?: (node: AST.Document) => void;
+  AttributeKey?: (node: AST.AttributeKey) => void;
+  Text?: (node: AST.Text) => void;
+  Tag?: (node: AST.Tag) => void;
+  OpenTagStart?: (node: AST.OpenTagStart) => void;
+  OpenTagEnd?: (node: AST.OpenTagEnd) => void;
+  CloseTag?: (node: AST.CloseTag) => void;
+  Attribute?: (node: AST.Attribute) => void;
+  AttributeValue?: (node: AST.AttributeValue) => void;
+  AttributeValueWrapperEnd?: (node: AST.AttributeValueWrapperEnd) => void;
+  AttributeValueWrapperStart?: (node: AST.AttributeValueWrapperStart) => void;
+  ScriptTag?: (node: AST.ScriptTag) => void;
+  OpenScriptTagStart?: (node: AST.OpenScriptTagStart) => void;
+  CloseScriptTag?: (node: AST.CloseScriptTag) => void;
+  OpenScriptTagEnd?: (node: AST.OpenScriptTagEnd) => void;
+  ScriptTagContent?: (node: AST.ScriptTagContent) => void;
+  StyleTag?: (node: AST.StyleTag) => void;
+  OpenStyleTagStart?: (node: AST.OpenStyleTagStart) => void;
+  OpenStyleTagEnd?: (node: AST.OpenStyleTagEnd) => void;
+  StyleTagContent?: (node: AST.StyleTagContent) => void;
+  CloseStyleTag?: (node: AST.CloseStyleTag) => void;
+  Comment?: (node: AST.Comment) => void;
+  CommentOpen?: (node: AST.CommentOpen) => void;
+  CommentClose?: (node: AST.CommentClose) => void;
+  CommentContent?: (node: AST.CommentContent) => void;
+  Doctype?: (node: AST.Doctype) => void;
+  DoctypeOpen?: (node: AST.DoctypeOpen) => void;
+  DoctypeClose?: (node: AST.DoctypeClose) => void;
+  DoctypeAttribute?: (node: AST.DoctypeAttribute) => void;
+  DoctypeAttributeValue?: (node: AST.DoctypeAttributeValue) => void;
+  DoctypeAttributeWrapperStart?: (
+    node: AST.DoctypeAttributeWrapperStart
+  ) => void;
+  DoctypeAttributeWrapperEnd?: (node: AST.DoctypeAttributeWrapperEnd) => void;
+  TaggedTemplateExpression?: (node: AST.TaggedTemplateExpression) => void;
+  TemplateLiteral?: (node: AST.TemplateLiteral) => void;
+}
+
+interface ReportDescriptorOptionsBase {
+  data?: { [key: string]: string };
+
+  fix?:
+    | null
+    | ((fixer: RuleFixer) => null | Fix | IterableIterator<Fix> | Fix[]);
+}
+
+type SuggestionDescriptorMessage = { desc: string } | { messageId: string };
+type SuggestionReportDescriptor = SuggestionDescriptorMessage &
+  ReportDescriptorOptionsBase;
+
+interface ReportDescriptorOptions extends ReportDescriptorOptionsBase {
+  suggest?: SuggestionReportDescriptor[] | null;
+}
+
+type ReportDescriptor = ReportDescriptorMessage &
+  ReportDescriptorLocation &
+  ReportDescriptorOptions;
+type ReportDescriptorMessage = { message: string } | { messageId: string };
+type ReportDescriptorLocation = {
+  node?: BaseNode;
+  loc?: ESLint.AST.SourceLocation;
+  line?: number;
+  column?: number;
+};
+
+export interface Context extends Omit<ESLint.Rule.RuleContext, "report"> {
+  report(descriptor: ReportDescriptor): void;
+}
+
+export type RuleListener = BaseRuleListener &
+  PostFix<BaseRuleListener, ":exit">;
+
+export interface RuleModule extends eslint.Rule.RuleModule {
+  create(context: Context): RuleListener;
+}

package/lib/types/settings.ts

@@ -0,0 +1,13 @@
+export type MaybeHTMLSettings = {
+  templateLiterals?: {
+    tags?: string[];
+    comments?: string[];
+  };
+};
+
+export type HTMLSettings = {
+  templateLiterals: {
+    tags: RegExp[];
+    comments: RegExp[];
+  };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@html-eslint/eslint-plugin",
-  "version": "0.31.1",
+  "version": "0.32.0",
   "description": "ESLint plugin for html",
   "author": "yeonjuan",
   "homepage": "https://github.com/yeonjuan/html-eslint#readme",
@@ -45,15 +45,15 @@
     "accessibility"
   ],
   "dependencies": {
-    "@html-eslint/template-parser": "^0.31.0"
+    "@html-eslint/template-parser": "^0.32.0"
   },
   "devDependencies": {
-    "@html-eslint/parser": "^0.31.0",
+    "@html-eslint/parser": "^0.32.0",
     "@types/eslint": "^9.6.1",
     "@types/estree": "^0.0.47",
     "es-html-parser": "^1.0.0-alpha.4",
     "espree": "^10.3.0",
     "typescript": "^5.7.2"
   },
-  "gitHead": "96d3cb165f2d777d36e7efbba174e46f437faec0"
+  "gitHead": "ae0860389c4463a3e259d0ccae38992db46a20e5"
 }

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

@@ -1,11 +1,10 @@
 declare namespace _exports {
-    export { RuleFixer, RuleModule, TagNode, MessageId };
+    export { RuleFixer, RuleModule, MessageId };
 }
 declare const _exports: RuleModule;
 export = _exports;
-type RuleFixer = import("../types").RuleFixer;
+type RuleFixer = import("eslint").Rule.RuleFixer;
 type RuleModule = import("../types").RuleModule;
-type TagNode = import("../types").TagNode;
 type MessageId = {
     CLOSE_STYLE_WRONG: "closeStyleWrong";
     NEWLINE_MISSING: "newlineMissing";

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

@@ -1 +1 @@
-{"version":3,"file":"attrs-newline.d.ts","sourceRoot":"","sources":["../../lib/rules/attrs-newline.js"],"names":[],"mappings":";;;wBAyBU,UAAU;;iBAxBN,OAAO,UAAU,EAAE,SAAS;kBAC5B,OAAO,UAAU,EAAE,UAAU;eAC7B,OAAO,UAAU,EAAE,OAAO;;uBAG1B,iBAAiB;qBACjB,gBAAgB;wBAChB,mBAAmB"}
+{"version":3,"file":"attrs-newline.d.ts","sourceRoot":"","sources":["../../lib/rules/attrs-newline.js"],"names":[],"mappings":";;;wBAuBU,UAAU;;iBAtBN,OAAO,QAAQ,EAAE,IAAI,CAAC,SAAS;kBAC/B,OAAO,UAAU,EAAE,UAAU;;uBAG7B,iBAAiB;qBACjB,gBAAgB;wBAChB,mBAAmB"}

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

@@ -1,17 +1,16 @@
 declare namespace _exports {
-    export { RuleModule, TagNode, BaseNode, CommentNode, DoctypeNode, ScriptTagNode, StyleTagNode, TextNode, NewlineNode, NodeMeta };
+    export { RuleModule, Tag, Comment, Doctype, ScriptTag, StyleTag, Text, NewlineNode, NodeMeta };
 }
 declare const _exports: RuleModule;
 export = _exports;
 type RuleModule = import("../types").RuleModule;
-type TagNode = import("../types").TagNode;
-type BaseNode = import("../types").BaseNode;
-type CommentNode = import("../types").CommentNode;
-type DoctypeNode = import("../types").DoctypeNode;
-type ScriptTagNode = import("../types").ScriptTagNode;
-type StyleTagNode = import("../types").StyleTagNode;
-type TextNode = import("../types").TextNode;
-type NewlineNode = CommentNode | DoctypeNode | ScriptTagNode | StyleTagNode | TagNode | TextNode;
+type Tag = import("../types").Tag;
+type Comment = import("../types").Comment;
+type Doctype = import("../types").Doctype;
+type ScriptTag = import("../types").ScriptTag;
+type StyleTag = import("../types").StyleTag;
+type Text = import("../types").Text;
+type NewlineNode = Tag | Doctype | ScriptTag | StyleTag | Text;
 type NodeMeta = {
     childFirst: NewlineNode | null;
     childLast: NewlineNode | null;

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

@@ -1 +1 @@
-{"version":3,"file":"element-newline.d.ts","sourceRoot":"","sources":["../../lib/rules/element-newline.js"],"names":[],"mappings":";;;wBAoEU,UAAU;;kBAnEN,OAAO,UAAU,EAAE,UAAU;eAC7B,OAAO,UAAU,EAAE,OAAO;gBAC1B,OAAO,UAAU,EAAE,QAAQ;mBAC3B,OAAO,UAAU,EAAE,WAAW;mBAC9B,OAAO,UAAU,EAAE,WAAW;qBAC9B,OAAO,UAAU,EAAE,aAAa;oBAChC,OAAO,UAAU,EAAE,YAAY;gBAC/B,OAAO,UAAU,EAAE,QAAQ;mBAC3B,WAAW,GAAG,WAAW,GAAG,aAAa,GAAG,YAAY,GAAG,OAAO,GAAG,QAAQ;gBAC9E;IACR,UAAU,EAAE,WAAW,GAAG,IAAI,CAAC;IAC/B,SAAS,EAAE,WAAW,GAAG,IAAI,CAAC;IAC9B,eAAe,EAAE,OAAO,CAAC;CAC1B"}
+{"version":3,"file":"element-newline.d.ts","sourceRoot":"","sources":["../../lib/rules/element-newline.js"],"names":[],"mappings":";;;wBAmEU,UAAU;;kBAlEN,OAAO,UAAU,EAAE,UAAU;WAC7B,OAAO,UAAU,EAAE,GAAG;eACtB,OAAO,UAAU,EAAE,OAAO;eAC1B,OAAO,UAAU,EAAE,OAAO;iBAC1B,OAAO,UAAU,EAAE,SAAS;gBAC5B,OAAO,UAAU,EAAE,QAAQ;YAC3B,OAAO,UAAU,EAAE,IAAI;mBACvB,GAAG,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,IAAI;gBAC5C;IACR,UAAU,EAAE,WAAW,GAAG,IAAI,CAAC;IAC/B,SAAS,EAAE,WAAW,GAAG,IAAI,CAAC;IAC9B,eAAe,EAAE,OAAO,CAAC;CAC1B"}

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

@@ -1,10 +1,10 @@
 declare namespace _exports {
-    export { RuleModule, TagNode, ScriptTagNode, StyleTagNode };
+    export { RuleModule, Tag, ScriptTag, StyleTag };
 }
 declare const _exports: RuleModule;
 export = _exports;
 type RuleModule = import("../types").RuleModule;
-type TagNode = import("../types").TagNode;
-type ScriptTagNode = import("../types").ScriptTagNode;
-type StyleTagNode = import("../types").StyleTagNode;
+type Tag = import("../types").Tag;
+type ScriptTag = import("../types").ScriptTag;
+type StyleTag = import("../types").StyleTag;
 //# sourceMappingURL=id-naming-convention.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"id-naming-convention.d.ts","sourceRoot":"","sources":["../../lib/rules/id-naming-convention.js"],"names":[],"mappings":";;;wBAyCU,UAAU;;kBAxCN,OAAO,UAAU,EAAE,UAAU;eAC7B,OAAO,UAAU,EAAE,OAAO;qBAC1B,OAAO,UAAU,EAAE,aAAa;oBAChC,OAAO,UAAU,EAAE,YAAY"}
+{"version":3,"file":"id-naming-convention.d.ts","sourceRoot":"","sources":["../../lib/rules/id-naming-convention.js"],"names":[],"mappings":";;;wBAyCU,UAAU;;kBAxCN,OAAO,UAAU,EAAE,UAAU;WAC7B,OAAO,UAAU,EAAE,GAAG;iBACtB,OAAO,UAAU,EAAE,SAAS;gBAC5B,OAAO,UAAU,EAAE,QAAQ"}