View Javadoc
1   ///////////////////////////////////////////////////////////////////////////////////////////////
2   // checkstyle: Checks Java source code and other text files for adherence to a set of rules.
3   // Copyright (C) 2001-2025 the original author or authors.
4   //
5   // This library is free software; you can redistribute it and/or
6   // modify it under the terms of the GNU Lesser General Public
7   // License as published by the Free Software Foundation; either
8   // version 2.1 of the License, or (at your option) any later version.
9   //
10  // This library is distributed in the hope that it will be useful,
11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  // Lesser General Public License for more details.
14  //
15  // You should have received a copy of the GNU Lesser General Public
16  // License along with this library; if not, write to the Free Software
17  // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  ///////////////////////////////////////////////////////////////////////////////////////////////
19  
20  package com.puppycrawl.tools.checkstyle.api;
21  
22  import com.puppycrawl.tools.checkstyle.grammar.javadoc.JavadocParser;
23  
24  /**
25   * Contains the constants for all the tokens contained in the Abstract
26   * Syntax Tree for the javadoc grammar.
27   *
28   * @see <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html">
29   *     javadoc - The Java API Documentation Generator</a>
30   */
31  public final class JavadocTokenTypes {
32  
33      // ------------------------------------------------------------------------------------------ //
34      // -----------------        JAVADOC TAGS          ------------------------------------------- //
35      // ------------------------------------------------------------------------------------------ //
36  
37      /**
38       * '@return' literal in {@code @return} Javadoc tag.
39       *
40       * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
41       *
42       * <p><b>Example:</b></p>
43       * <pre>{@code @return true if file exists}</pre>
44       * <b>Tree:</b>
45       * <pre>{@code
46       * JAVADOC_TAG -> JAVADOC_TAG
47       *  |--RETURN_LITERAL -> @return
48       *  |--WS ->
49       *  `--DESCRIPTION -> DESCRIPTION
50       *      |--TEXT -> true if file exists
51       * }</pre>
52       *
53       * @see
54       * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCDBGG">
55       *     Oracle Docs</a>
56       * @see #JAVADOC_TAG
57       */
58      public static final int RETURN_LITERAL = JavadocParser.RETURN_LITERAL;
59  
60      /**
61       * '{@literal @}deprecated' literal in {@literal @}deprecated Javadoc tag.
62       *
63       * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
64       *
65       * <p><b>Example:</b></p>
66       * <pre>{@code @deprecated It is deprecated method}</pre>
67       * <b>Tree:</b>
68       * <pre>{@code
69       * JAVADOC_TAG -> JAVADOC_TAG
70       *  |--DEPRECATED_LITERAL -> @deprecated
71       *  |--WS ->
72       *  `--DESCRIPTION -> DESCRIPTION
73       *      |--TEXT -> It is deprecated method
74       * }</pre>
75       *
76       * @see
77       * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#deprecated">
78       *     Oracle Docs</a>
79       * @see #JAVADOC_TAG
80       */
81      public static final int DEPRECATED_LITERAL = JavadocParser.DEPRECATED_LITERAL;
82  
83      /**
84       * '@since' literal in {@code @since} Javadoc tag.
85       *
86       * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
87       *
88       * <p><b>Example:</b></p>
89       * <pre>{@code @since 3.4 RELEASE}</pre>
90       * <b>Tree:</b>
91       * <pre>{@code
92       * JAVADOC_TAG -> JAVADOC_TAG
93       *  |--SINCE_LITERAL -> @since
94       *  |--WS ->
95       *  `--DESCRIPTION -> DESCRIPTION
96       *      |--TEXT -> 3.4 RELEASE
97       * }</pre>
98       *
99       * @see
100      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHGJGD">
101      *     Oracle Docs</a>
102      * @see #JAVADOC_TAG
103      */
104     public static final int SINCE_LITERAL = JavadocParser.SINCE_LITERAL;
105 
106     /**
107      * '@serialData' literal in {@code @serialData} Javadoc tag.
108      *
109      * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
110      *
111      * <p><b>Example:</b></p>
112      * <pre>{@code @serialData Two values of Integer type}</pre>
113      * <b>Tree:</b>
114      * <pre>{@code
115      * JAVADOC_TAG -> JAVADOC_TAG
116      *  |--SERIAL_DATA_LITERAL -> @serialData
117      *  |--WS ->
118      *  `--DESCRIPTION -> DESCRIPTION
119      *      |--TEXT -> Two values of Integer type
120      * }
121      * </pre>
122      *
123      * @see
124      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDJBFDB">
125      *     Oracle Docs</a>
126      * @see #JAVADOC_TAG
127      */
128     public static final int SERIAL_DATA_LITERAL = JavadocParser.SERIAL_DATA_LITERAL;
129 
130     /**
131      * '@serialField' literal in {@code @serialField} Javadoc tag.
132      *
133      * <p>Such Javadoc tag can have three arguments:</p>
134      * <ol>
135      * <li>{@link #FIELD_NAME}</li>
136      * <li>{@link #FIELD_TYPE}</li>
137      * <li>{@link #DESCRIPTION}</li>
138      * </ol>
139      *
140      * <p><b>Example:</b></p>
141      * <pre>{@code @serialField counter Integer objects counter}</pre>
142      * <b>Tree:</b>
143      * <pre>{@code
144      * JAVADOC_TAG -> JAVADOC_TAG
145      *  |--SERIAL_FIELD_LITERAL -> @serialField
146      *  |--WS ->
147      *  |--FIELD_NAME -> counter
148      *  |--WS ->
149      *  |--FIELD_TYPE -> Integer
150      *  |--WS ->
151      *  `--DESCRIPTION -> DESCRIPTION
152      *      |--TEXT -> objects counter
153      * }</pre>
154      *
155      * @see
156      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGHIDG">
157      *     Oracle Docs</a>
158      * @see #JAVADOC_TAG
159      */
160     public static final int SERIAL_FIELD_LITERAL = JavadocParser.SERIAL_FIELD_LITERAL;
161 
162     /**
163      * '@param' literal in {@code @param} Javadoc tag.
164      *
165      * <p>Such Javadoc tag can have two arguments:</p>
166      * <ol>
167      * <li>{@link #PARAMETER_NAME}</li>
168      * <li>{@link #DESCRIPTION}</li>
169      * </ol>
170      *
171      * <p><b>Example:</b></p>
172      * <pre>{@code @param value The parameter of method.}</pre>
173      * <b>Tree:</b>
174      * <pre>{@code
175      * JAVADOC_TAG -> JAVADOC_TAG
176      *  |--PARAM_LITERAL -> @param
177      *  |--WS ->
178      *  |--PARAMETER_NAME -> value
179      *  |--WS ->
180      *  `--DESCRIPTION -> DESCRIPTION
181      *      |--TEXT -> The parameter of method.
182      * }</pre>
183      *
184      * @see
185      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHJECF">
186      *     Oracle Docs</a>
187      * @see #JAVADOC_TAG
188      */
189     public static final int PARAM_LITERAL = JavadocParser.PARAM_LITERAL;
190 
191     /**
192      * '@see' literal in {@code @see} Javadoc tag.
193      *
194      * <p>Such Javadoc tag can have one argument - {@link #REFERENCE}</p>
195      *
196      * <p><b>Example:</b></p>
197      * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
198      * <b>Tree:</b>
199      * <pre>{@code
200      *   JAVADOC_TAG -> JAVADOC_TAG
201      *    |--SEE_LITERAL -> @see
202      *    |--WS ->
203      *    |--REFERENCE -> REFERENCE
204      *        |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator
205      *        |--HASH -> #
206      *        |--MEMBER -> compare
207      *        `--PARAMETERS -> PARAMETERS
208      *            |--LEFT_BRACE -> (
209      *            |--ARGUMENT -> Object
210      *            `--RIGHT_BRACE -> )
211      * }</pre>
212      *
213      * @see
214      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDIEDI">
215      *     Oracle Docs</a>
216      * @see #JAVADOC_TAG
217      */
218     public static final int SEE_LITERAL = JavadocParser.SEE_LITERAL;
219 
220     /**
221      * '@serial' literal in {@code @serial} Javadoc tag.
222      *
223      * <p>Such Javadoc tag can have one argument - {@link #REFERENCE} or {@link #LITERAL_EXCLUDE}
224      * or {@link #LITERAL_INCLUDE}</p>
225      *
226      * <p><b>Example:</b></p>
227      * <pre>{@code @serial include}</pre>
228      * <b>Tree:</b>
229      * <pre>{@code
230      *   |--JAVADOC_TAG -> JAVADOC_TAG
231      *       |--SERIAL_LITERAL -> @serial
232      *       |--WS
233      *       |--LITERAL_INCLUDE -> include
234      * }</pre>
235      *
236      * <p><b>Example:</b></p>
237      * <pre>{@code @serial serialized company name}</pre>
238      * <b>Tree:</b>
239      * <pre>{@code
240      *   |--JAVADOC_TAG-> JAVADOC_TAG
241      *       |--SERIAL_LITERAL -> @serial
242      *       |--WS
243      *       |--DESCRIPTION -> DESCRIPTION
244      *           |--TEXT -> serialized company name
245      * }</pre>
246      *
247      * @see
248      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
249      *     Oracle Docs</a>
250      * @see #JAVADOC_TAG
251      */
252     public static final int SERIAL_LITERAL = JavadocParser.SERIAL_LITERAL;
253 
254     /**
255      * '@version' literal in {@code @version} Javadoc tag.
256      *
257      * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
258      *
259      * <p><b>Example:</b></p>
260      * <pre>{@code @version 1.3}</pre>
261      * <b>Tree:</b>
262      * <pre>{@code
263      *   JAVADOC_TAG -> JAVADOC_TAG
264      *    |--VERSION_LITERAL -> @version
265      *    |--WS ->
266      *    `--DESCRIPTION -> DESCRIPTION
267      *        |--TEXT -> 1.3
268      * }</pre>
269      *
270      * @see
271      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCHBAE">
272      *     Oracle Docs</a>
273      * @see #JAVADOC_TAG
274      */
275     public static final int VERSION_LITERAL = JavadocParser.VERSION_LITERAL;
276 
277     /**
278      * '@exception' literal in {@code @exception} Javadoc tag.
279      *
280      * <p>Such Javadoc tag can have two argument - {@link #CLASS_NAME} and {@link #DESCRIPTION}</p>
281      *
282      * <p><b>Example:</b></p>
283      * <pre>{@code @exception SQLException if query is not correct}</pre>
284      * <b>Tree:</b>
285      * <pre>{@code
286      *   JAVADOC_TAG -> JAVADOC_TAG
287      *    |--EXCEPTION_LITERAL -> @exception
288      *    |--WS ->
289      *    |--CLASS_NAME -> SQLException
290      *    |--WS ->
291      *    `--DESCRIPTION -> DESCRIPTION
292      *        `--TEXT -> if query is not correct
293      * }</pre>
294      *
295      * @see
296      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCEAHH">
297      *     Oracle Docs</a>
298      * @see #JAVADOC_TAG
299      */
300     public static final int EXCEPTION_LITERAL = JavadocParser.EXCEPTION_LITERAL;
301 
302     /**
303      * '@throws' literal in {@code @throws} Javadoc tag.
304      *
305      * <p>Such Javadoc tag can have two argument - {@link #CLASS_NAME} and {@link #DESCRIPTION}</p>
306      *
307      * <p><b>Example:</b></p>
308      * <pre>{@code @throws SQLException if query is not correct}</pre>
309      * <b>Tree:</b>
310      * <pre>{@code
311      *   JAVADOC_TAG -> JAVADOC_TAG
312      *      |--THROWS_LITERAL -> @throws
313      *      |--WS ->
314      *      |--CLASS_NAME -> SQLException
315      *      |--WS ->
316      *      `--DESCRIPTION -> DESCRIPTION
317      *          |--TEXT -> if query is not correct
318      *          |--NEWLINE -> \r\n
319      *          `--TEXT ->
320      * }</pre>
321      *
322      * @see
323      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCHAHD">
324      *     Oracle Docs</a>
325      * @see #JAVADOC_TAG
326      */
327     public static final int THROWS_LITERAL = JavadocParser.THROWS_LITERAL;
328 
329     /**
330      * '@author' literal in {@code @author} Javadoc tag.
331      *
332      * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
333      *
334      * <p><b>Example:</b></p>
335      * <pre>{@code @author Baratali Izmailov}</pre>
336      * <b>Tree:</b>
337      * <pre>{@code
338      *   JAVADOC_TAG -> JAVADOC_TAG
339      *      |--AUTHOR_LITERAL -> @author
340      *      |--WS ->
341      *      `--DESCRIPTION -> DESCRIPTION
342      *          |--TEXT -> Baratali Izmailov
343      *          |--NEWLINE -> \r\n
344      * }</pre>
345      *
346      * @see
347      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCBAHA">
348      *     Oracle Docs</a>
349      * @see #JAVADOC_TAG
350      */
351     public static final int AUTHOR_LITERAL = JavadocParser.AUTHOR_LITERAL;
352 
353     /**
354      * Name of custom Javadoc tag (or Javadoc inline tag).
355      *
356      * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
357      *
358      * <p><b>Example:</b></p>
359      * <pre>{@code @myJavadocTag some magic}</pre>
360      * <b>Tree:</b>
361      * <pre>{@code
362      *   JAVADOC_TAG --> JAVADOC_TAG
363      *       |--CUSTOM_NAME --> @myJavadocTag
364      *       |--WS -->
365      *       `--DESCRIPTION --> DESCRIPTION
366      *           |--TEXT --> some magic
367      * }</pre>
368      */
369     public static final int CUSTOM_NAME = JavadocParser.CUSTOM_NAME;
370 
371     /**
372      * First child of {@link #JAVADOC_INLINE_TAG} that represents left curly brace '{'.
373      *
374      * <p><b>Example:</b></p>
375      * <pre>{@code Comparable<E>}</pre>
376      * <b>Tree:</b>
377      * <pre>{@code
378      *    JAVADOC_INLINE_TAG --> JAVADOC_INLINE_TAG
379      *     |--JAVADOC_INLINE_TAG_START --> {
380      *     |--CODE_LITERAL --> @code
381      *     |--WS -->
382      *     |--TEXT --> Comparable<E>
383      *     `--JAVADOC_INLINE_TAG_END --> }
384      * }</pre>
385      */
386     public static final int JAVADOC_INLINE_TAG_START = JavadocParser.JAVADOC_INLINE_TAG_START;
387 
388     /**
389      * Last child of {@link #JAVADOC_INLINE_TAG} that represents right curly brace '}'.
390      *
391      * <p><b>Example:</b></p>
392      * <pre>{@code Comparable<E>}</pre>
393      * <b>Tree:</b>
394      * <pre>{@code
395      *   JAVADOC_INLINE_TAG --> JAVADOC_INLINE_TAG
396      *    |--JAVADOC_INLINE_TAG_START --> {
397      *    |--CODE_LITERAL --> @code
398      *    |--WS -->
399      *    |--TEXT --> Comparable<E>
400      *    `--JAVADOC_INLINE_TAG_END --> }
401      * }</pre>
402      */
403     public static final int JAVADOC_INLINE_TAG_END = JavadocParser.JAVADOC_INLINE_TAG_END;
404 
405     /**
406      * '@code' literal in {&#64;code} Javadoc inline tag.
407      *
408      * <p>Such Javadoc inline tag can have such child nodes:</p>
409      * <ul>
410      * <li>{@link #NEWLINE}</li>
411      * <li>{@link #WS}</li>
412      * <li>{@link #TEXT}</li>
413      * </ul>
414      *
415      * <p><b>Example:</b></p>
416      * <pre>{@code Comparable<E>}</pre>
417      * <b>Tree:</b>
418      * <pre>{@code
419      *   JAVADOC_TAG -> JAVADOC_TAG
420      *    |--CUSTOM_NAME -> @code
421      *    |--WS ->
422      *    `--DESCRIPTION -> DESCRIPTION
423      *        |--TEXT -> Comparable<E>
424      * }</pre>
425      *
426      * @see
427      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDFHHBB">
428      *     Oracle Docs</a>
429      * @see #JAVADOC_INLINE_TAG
430      */
431     public static final int CODE_LITERAL = JavadocParser.CODE_LITERAL;
432 
433     /**
434      * '@docRoot' literal in {&#64;docRoot} Javadoc inline tag.
435      *
436      * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p>
437      * <ul>
438      * <li>{@link #NEWLINE}</li>
439      * <li>{@link #WS}</li>
440      * </ul>
441      *
442      * <p><b>Example:</b></p>
443      * <pre>{@code @docRoot}</pre>
444      * <b>Tree:</b>
445      * <pre>
446      * {@code
447      * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
448      *      |--JAVADOC_INLINE_TAG_START -> {
449      *      |--DOC_ROOT_LITERAL -> @docRoot
450      *      `--JAVADOC_INLINE_TAG_END -> }
451      * }</pre>
452      *
453      * <pre>{@code Example :{@docRoot
454      * } in a Javadoc comment.
455      * }</pre>
456      * <b>Tree:</b>
457      * <pre>
458      * {@code
459      *   |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
460      *     |--JAVADOC_INLINE_TAG_START -> {
461      *     |--DOC_ROOT_LITERAL -> @docRoot
462      *     |--NEWLINE -> \r\n
463      *     |--LEADING_ASTERISK ->       *
464      *     |--WS ->
465      *     `--JAVADOC_INLINE_TAG_END -> }
466      * }</pre>
467      *
468      * @see
469      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDBACBF">
470      *     Oracle Docs</a>
471      * @see #JAVADOC_INLINE_TAG
472      */
473     public static final int DOC_ROOT_LITERAL = JavadocParser.DOC_ROOT_LITERAL;
474 
475     /**
476      * '@link' literal in {&#64;link} Javadoc inline tag.
477      *
478      * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p>
479      *
480      * <p><b>Example:</b></p>
481      *
482      * <pre><code>{&#64;link org.apache.utils.Lists.Comparator#compare(Object)}</code></pre>
483      *
484      * <p><b>Tree:</b></p>
485      *
486      * <pre>
487      * {@code
488      *   JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
489      *    |--JAVADOC_INLINE_TAG_START -> {
490      *    |--LINK_LITERAL -> @link
491      *    |--WS ->
492      *    |--REFERENCE -> REFERENCE
493      *    |   |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator
494      *    |   |--HASH -> #
495      *    |   |--MEMBER -> compare
496      *    |   `--PARAMETERS -> PARAMETERS
497      *    |       |--LEFT_BRACE -> (
498      *    |       |--ARGUMENT -> Object
499      *    |       `--RIGHT_BRACE -> )
500      *    `--JAVADOC_INLINE_TAG_END -> }
501      * }</pre>
502      *
503      * @see
504      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDIECH">
505      *     Oracle Docs</a>
506      * @see #JAVADOC_INLINE_TAG
507      * @noinspection HtmlTagCanBeJavadocTag
508      * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
509      *      replaced with Javadoc tag
510      */
511     public static final int LINK_LITERAL = JavadocParser.LINK_LITERAL;
512 
513     /**
514      * '@inheritDoc' literal in {&#64;inheritDoc} Javadoc inline tag.
515      *
516      * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p>
517      * <ul>
518      * <li>{@link #NEWLINE}</li>
519      * <li>{@link #WS}</li>
520      * </ul>
521      *
522      * <p><b>Example:</b></p>
523      * <pre>{@code {@inheritDoc} }</pre>
524      * <b>Tree:</b>
525      * <pre>{@code
526      *   JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
527      *    |--JAVADOC_INLINE_TAG_START -> {
528      *    |--INHERIT_DOC_LITERAL -> @inheritDoc
529      *    |--JAVADOC_INLINE_TAG_END -> }
530      * }</pre>
531      *
532      * @see
533      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGJCHC">
534      *     Oracle Docs</a>
535      * @see #JAVADOC_INLINE_TAG
536      */
537     public static final int INHERIT_DOC_LITERAL = JavadocParser.INHERIT_DOC_LITERAL;
538 
539     /**
540      * '@linkplain' literal in {&#64;linkplain} Javadoc inline tag.
541      *
542      * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p>
543      *
544      * <p><b>Example:</b></p>
545      * <pre><code>{&#64;linkplain org.apache.utils.Lists.Comparator#compare(Object) compare}</code>
546      * </pre>
547      * <b>Tree:</b>
548      * <pre>{@code
549      *   JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
550      *    |--JAVADOC_INLINE_TAG_START -> {
551      *    |--LINKPLAIN_LITERAL -> @linkplain
552      *    |--WS ->
553      *    |--REFERENCE -> org.apache.utils.Lists.Comparator#compare(Object)
554      *        |--PACKAGE_CLASS -> org.apache.utils
555      *        |--DOT -> .
556      *        |--CLASS -> Lists
557      *        |--DOT -> .
558      *        |--CLASS -> Comparator
559      *        |--HASH -> #
560      *        |--MEMBER -> compare
561      *        |--PARAMETERS -> (Object)
562      *            |--LEFT_BRACE -> (
563      *            |--ARGUMENT -> Object
564      *            |--RIGHT_BRACE -> )
565      *     |--DESCRIPTION -> compare
566      *         |--TEXT -> compare
567      *     |--JAVADOC_INLINE_TAG_END -> }
568      * }</pre>
569      *
570      * @see
571      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGBICD">
572      *     Oracle Docs</a>
573      * @see #JAVADOC_INLINE_TAG
574      * @noinspection HtmlTagCanBeJavadocTag
575      * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
576      *      replaced with Javadoc tag
577      */
578     public static final int LINKPLAIN_LITERAL = JavadocParser.LINKPLAIN_LITERAL;
579 
580     /**
581      * '@literal' literal in {&#64;literal} Javadoc inline tag.
582      *
583      * <p>Such Javadoc inline tag can have such child nodes:</p>
584      * <ul>
585      * <li>{@link #NEWLINE}</li>
586      * <li>{@link #WS}</li>
587      * <li>{@link #TEXT}</li>
588      * </ul>
589      *
590      * <p><b>Example:</b></p>
591      * <pre>{@code {@literal #compare(Object)} }</pre>
592      * <b>Tree:</b>
593      * <pre>
594      * {@code
595      *     |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
596      *        |--JAVADOC_INLINE_TAG_START -> {
597      *        |--LITERAL_LITERAL -> @literal
598      *        |--WS ->
599      *        |--TEXT -> #compare(Object)
600      *        `--JAVADOC_INLINE_TAG_END -> }
601      * }</pre>
602      *
603      * @see
604      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCFJDG">
605      *     Oracle Docs</a>
606      * @see #JAVADOC_INLINE_TAG
607      */
608     public static final int LITERAL_LITERAL = JavadocParser.LITERAL_LITERAL;
609 
610     /**
611      * '@value' literal in {&#64;value} Javadoc inline tag.
612      *
613      * <p>Such Javadoc inline tag has one argument {@link #REFERENCE}
614      * and can have such child nodes:</p>
615      * <ul>
616      * <li>{@link #NEWLINE}</li>
617      * <li>{@link #WS}</li>
618      * </ul>
619      *
620      * <p><b>Example:</b></p>
621      * <pre>{@code {@value Integer#MAX_VALUE} }</pre>
622      * <b>Tree:</b>
623      * <pre>{@code
624      *   JAVADOC_INLINE_TAG --> JAVADOC_INLINE_TAG
625      *    |--JAVADOC_INLINE_TAG_START --> {
626      *    |--VALUE_LITERAL --> @value
627      *    |--WS -->
628      *    |--REFERENCE --> REFERENCE
629      *    |   |--PACKAGE_CLASS --> Integer
630      *    |   |--HASH --> #
631      *    |   `--MEMBER --> MAX_VALUE
632      *    `--JAVADOC_INLINE_TAG_END --> }
633      * }</pre>
634      *
635      * @see
636      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDCDHH">
637      *     Oracle Docs</a>
638      * @see #JAVADOC_INLINE_TAG
639      */
640     public static final int VALUE_LITERAL = JavadocParser.VALUE_LITERAL;
641 
642     /**
643      * PACKAGE_CLASS represents the package or class which has been referenced in the `@see`,
644      * `@link`, `@linkplain` or `@value` javadoc tags. In the javadoc tree it shall be a child
645      * of {@link #REFERENCE}.
646      * <br>
647      * <strong>IMPORTANT:</strong> Constructs like
648      * {@code package.Class.NestedClassAtDepth1.NestedClassAtDepth2#member} are recognized by
649      * the javadoc tool from oracle, and no assumptions like, package names wouldn't consist of
650      * uppercase characters or class names begin with an uppercase character, are made.
651      * Also, <i>the reference</i> in a javadoc tag can consist just a package name or a
652      * simple class name or even a full class name. Thus, PACKAGE_CLASS can represent a
653      * package name or a simple class name or a full class name i.e. checkstyle doesn't
654      * resolve references at present.
655      *
656      * <p><b>Example:</b></p>
657      * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
658      * <b>Tree:</b>
659      * <pre>
660      * {@code
661      * JAVADOC_TAG -> JAVADOC_TAG
662      *  |--SEE_LITERAL -> @see
663      *  |--WS ->
664      *  |--REFERENCE -> REFERENCE
665      *  |   |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator
666      *  |   |--HASH -> #
667      *  |   |--MEMBER -> compare
668      *  |   `--PARAMETERS -> PARAMETERS
669      *  |       |--LEFT_BRACE -> (
670      *  |       |--ARGUMENT -> Object
671      *  |       `--RIGHT_BRACE -> )
672      *  |--NEWLINE -> \r\n
673      *  `--WS ->
674      * }
675      * </pre>
676      */
677     public static final int PACKAGE_CLASS = JavadocParser.PACKAGE_CLASS;
678 
679     /**
680      * Hash character in {@link #REFERENCE}.
681      * Hash character is used before specifying a class member.
682      *
683      * <p><b>Example:</b></p>
684      * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
685      * <b>Tree:</b>
686      * <pre>
687      * {@code
688      * JAVADOC_TAG -> JAVADOC_TAG
689      *  |--SEE_LITERAL -> @see
690      *  |--WS ->
691      *  |--REFERENCE -> REFERENCE
692      *      |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator
693      *      |--HASH -> #
694      *      |--MEMBER -> compare
695      *      `--PARAMETERS -> PARAMETERS
696      *          |--LEFT_BRACE -> (
697      *          |--ARGUMENT -> Object
698      *          `--RIGHT_BRACE -> )
699      * }
700      * </pre>
701      */
702     public static final int HASH = JavadocParser.HASH;
703 
704     /**
705      * A class member in {@link #REFERENCE}.
706      * Class member is specified after {@link #HASH} symbol.
707      *
708      * <p><b>Example:</b></p>
709      * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
710      * <b>Tree:</b>
711      * <pre>
712      * {@code
713      * JAVADOC_TAG -> JAVADOC_TAG
714      *  |--SEE_LITERAL -> @see
715      *  |--WS ->
716      *  |--REFERENCE -> REFERENCE
717      *      |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator
718      *      |--HASH -> #
719      *      |--MEMBER -> compare
720      *      `--PARAMETERS -> PARAMETERS
721      *          |--LEFT_BRACE -> (
722      *          |--ARGUMENT -> Object
723      *          `--RIGHT_BRACE -> )
724      * }
725      * </pre>
726      */
727     public static final int MEMBER = JavadocParser.MEMBER;
728 
729     /**
730      * Left brace in {@link #PARAMETERS} part of {@link #REFERENCE}.
731      *
732      * <p><b>Example:</b></p>
733      * <pre>{@code @see #method(Processor, String)}</pre>
734      * <b>Tree:</b>
735      * <pre>
736      * {@code JAVADOC_TAG -> JAVADOC_TAG
737      *         |--SEE_LITERAL -> @see
738      *         |--WS ->
739      *         |--REFERENCE -> REFERENCE
740      *         |   |--HASH -> #
741      *         |   |--MEMBER -> method
742      *         |   `--PARAMETERS -> PARAMETERS
743      *         |       |--LEFT_BRACE -> (
744      *         |       |--ARGUMENT -> Processor
745      *         |       |--COMMA -> ,
746      *         |       |--WS ->
747      *         |       |--ARGUMENT -> String
748      *         |       `--RIGHT_BRACE -> )
749      * }
750      * </pre>
751      */
752     public static final int LEFT_BRACE = JavadocParser.LEFT_BRACE;
753 
754     /**
755      * Right brace in {@link #PARAMETERS} part of {@link #REFERENCE}.
756      *
757      * <p><b>Example:</b></p>
758      * <pre>{@code @see #method(Processor, String)}</pre>
759      * <b>Tree:</b>
760      * <pre>
761      * {@code JAVADOC_TAG -> JAVADOC_TAG
762      *         |--SEE_LITERAL -> @see
763      *         |--WS ->
764      *         |--REFERENCE -> REFERENCE
765      *         |   |--HASH -> #
766      *         |   |--MEMBER -> method
767      *         |   `--PARAMETERS -> PARAMETERS
768      *         |       |--LEFT_BRACE -> (
769      *         |       |--ARGUMENT -> Processor
770      *         |       |--COMMA -> ,
771      *         |       |--WS ->
772      *         |       |--ARGUMENT -> String
773      *         |       `--RIGHT_BRACE -> )
774      * }
775      * </pre>
776      */
777     public static final int RIGHT_BRACE = JavadocParser.RIGHT_BRACE;
778 
779     /**
780      * Argument definition in {@link #PARAMETERS} part of {@link #REFERENCE}.
781      *
782      * <p><b>Example:</b></p>
783      * <pre>{@code @see #method(Processor, String)}</pre>
784      * <b>Tree:</b>
785      * <pre>
786      * {@code JAVADOC_TAG -> JAVADOC_TAG
787      *         |--SEE_LITERAL -> @see
788      *         |--WS ->
789      *         |--REFERENCE -> REFERENCE
790      *         |   |--HASH -> #
791      *         |   |--MEMBER -> method
792      *         |   `--PARAMETERS -> PARAMETERS
793      *         |       |--LEFT_BRACE -> (
794      *         |       |--ARGUMENT -> Processor
795      *         |       |--COMMA -> ,
796      *         |       |--WS ->
797      *         |       |--ARGUMENT -> String
798      *         |       `--RIGHT_BRACE -> )
799      *         `--NEWLINE -> \n
800      * }
801      * </pre>
802      */
803     public static final int ARGUMENT = JavadocParser.ARGUMENT;
804 
805     /**
806      * Comma separator between parameters in {@link #PARAMETERS} part of {@link #REFERENCE}.
807      *
808      * <p><b>Example:</b></p>
809      * <pre>{@code @see #method(Processor, String)}</pre>
810      * <b>Tree:</b>
811      * <pre>
812      * {@code
813      * JAVADOC_TAG -> JAVADOC_TAG
814      *  |--SEE_LITERAL -> @see
815      *  |--WS ->
816      *  |--REFERENCE -> REFERENCE
817      *  |   |--HASH -> #
818      *  |   |--MEMBER -> method
819      *  |   `--PARAMETERS -> PARAMETERS
820      *  |       |--LEFT_BRACE -> (
821      *  |       |--ARGUMENT -> Processor
822      *  |       |--COMMA -> ,
823      *  |       |--WS ->
824      *  |       |--ARGUMENT -> String
825      *  |       `--RIGHT_BRACE -> )
826      *  |--NEWLINE -> \r\n
827      *  `--WS ->
828      * }
829      * </pre>
830      *
831      * @see #PARAMETERS
832      * @see #REFERENCE
833      * @see #ARGUMENT
834      */
835     public static final int COMMA = JavadocParser.COMMA;
836 
837     /**
838      * Quoted text.
839      * One of possible {@code @see} tag arguments.
840      *
841      * <p><b>Example:</b></p>
842      * <pre>{@code @see "Spring Framework"}</pre>
843      * <b>Tree:</b>
844      * <pre>
845      * {@code
846      * JAVADOC_TAG -> JAVADOC_TAG
847      *  |--SEE_LITERAL -> @see
848      *  |--WS ->
849      *  |--STRING -> "Spring Framework"
850      *  |--NEWLINE -> \r\n
851      *  `--WS ->
852      * }
853      * </pre>
854      *
855      * @see #SEE_LITERAL
856      */
857     public static final int STRING = JavadocParser.STRING;
858 
859     /**
860      * Exception class name. First argument in {@link #THROWS_LITERAL @throws} and
861      * {@link #EXCEPTION_LITERAL @exception} Javadoc tags.
862      *
863      * <p><b>Example:</b></p>
864      * <pre>{@code @throws IOException connection problems}</pre>
865      * <b>Tree:</b>
866      * <pre>
867      * {@code
868      * JAVADOC_TAG -> JAVADOC_TAG
869      *  |--THROWS_LITERAL -> @throws
870      *  |--WS ->
871      *  |--CLASS_NAME -> IOException
872      *  |--WS ->
873      *  `--DESCRIPTION -> DESCRIPTION
874      *      |--TEXT -> connection problems
875      *      |--NEWLINE -> \r\n
876      *      `--TEXT ->
877      * }
878      * </pre>
879      *
880      * @see #EXCEPTION_LITERAL
881      * @see #THROWS_LITERAL
882      */
883     public static final int CLASS_NAME = JavadocParser.CLASS_NAME;
884 
885     /**
886      * First argument in {@link #PARAM_LITERAL @param} Javadoc tag.
887      *
888      * <p><b>Example:</b></p>
889      * <pre>{@code @param T The bar.}</pre>
890      * <b>Tree:</b>
891      * <pre>
892      * {@code
893      *   --JAVADOC_TAG -> JAVADOC_TAG
894      *      |--PARAM_LITERAL -> @param
895      *      |--WS ->
896      *      |--PARAMETER_NAME -> T
897      *      |--WS ->
898      *      `--DESCRIPTION -> DESCRIPTION
899      *          |--TEXT -> The bar.
900      *          |--NEWLINE -> \r\n
901      *          `--TEXT ->
902      * }
903      * </pre>
904      *
905      * @see
906      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHJECF">
907      *     Oracle Docs</a>
908      * @see #PARAM_LITERAL
909      */
910     public static final int PARAMETER_NAME = JavadocParser.PARAMETER_NAME;
911 
912     /**
913      * 'exclude' literal.
914      * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments.
915      *
916      * <p><b>Example:</b></p>
917      * <pre>{@code @serial exclude}</pre>
918      * <b>Tree:</b>
919      * <pre>
920      * {@code
921      *   JAVADOC_TAG -> JAVADOC_TAG
922      *    |--SERIAL_LITERAL -> @serial
923      *    |--WS ->
924      *    `--DESCRIPTION -> DESCRIPTION
925      *        |--TEXT -> serialized company name
926      *        |--NEWLINE -> \r\n
927      *        `--TEXT ->
928      * }
929      * </pre>
930      *
931      * @see
932      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
933      *     Oracle Docs</a>
934      * @see #SERIAL_LITERAL
935      */
936     public static final int LITERAL_EXCLUDE = JavadocParser.LITERAL_EXCLUDE;
937 
938     /**
939      * 'include' literal.
940      * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments.
941      *
942      * <p><b>Example:</b></p>
943      * <pre>{@code @serial include}</pre>
944      * <b>Tree:</b>
945      * <pre>
946      * {@code
947      * JAVADOC_TAG -> JAVADOC_TAG
948      *  |--SERIAL_LITERAL -> @serial
949      *  |--WS ->
950      *  |--LITERAL_INCLUDE -> include
951      *  |--NEWLINE -> \r\n
952      *  `--WS ->
953      * }
954      * </pre>
955      *
956      * @see
957      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
958      *     Oracle Docs</a>
959      * @see #SERIAL_LITERAL
960      */
961     public static final int LITERAL_INCLUDE = JavadocParser.LITERAL_INCLUDE;
962 
963     /**
964      * Field name. First argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag.
965      *
966      * <p><b>Example:</b></p>
967      * <pre>{@code @serialField counter Integer objects counter}</pre>
968      * <b>Tree:</b>
969      * <pre>
970      * {@code
971      *   --JAVADOC_TAG -> JAVADOC_TAG
972      *   |--SERIAL_FIELD_LITERAL -> @serialField
973      *   |--WS ->
974      *   |--LITERAL_INCLUDE -> include
975      *   |--NEWLINE -> \r\n
976      *   `--WS ->
977      *    `--DESCRIPTION -> DESCRIPTION
978      *        |--TEXT -> objects counter
979      *        |--NEWLINE -> \r\n
980      *        `--TEXT ->
981      * }</pre>
982      *
983      * @see
984      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
985      *     Oracle Docs</a>
986      * @see #SERIAL_FIELD_LITERAL
987      */
988     public static final int FIELD_NAME = JavadocParser.FIELD_NAME;
989 
990     /**
991      * Field type. Second argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag.
992      *
993      * <p><b>Example:</b></p>
994      * <pre>{@code @serialField counter Integer objects counter}</pre>
995      * <b>Tree:</b>
996      * <pre>
997      * {@code
998      *   --JAVADOC_TAG -> JAVADOC_TAG
999      *      |--SERIAL_FIELD_LITERAL -> @serialField
1000      *      |--WS ->
1001      *      |--FIELD_NAME -> counter
1002      *      |--WS ->
1003      *      |--FIELD_TYPE -> Integer
1004      *      |--WS ->
1005      *      `--DESCRIPTION -> DESCRIPTION
1006      *          |--TEXT -> objects counter
1007      *          |--NEWLINE -> \r\n
1008      *          `--TEXT ->
1009      * }
1010      * </pre>
1011      *
1012      * @see
1013      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
1014      *     Oracle Docs</a>
1015      * @see #SERIAL_FIELD_LITERAL
1016      */
1017     public static final int FIELD_TYPE = JavadocParser.FIELD_TYPE;
1018 
1019     // ------------------------------------------------------------------------------------------ //
1020     // -----------------        HTML TAGS          ---------------------------------------------- //
1021     // ------------------------------------------------------------------------------------------ //
1022 
1023     /**
1024      * Identifier inside HTML tag: tag name or attribute name.
1025      */
1026     public static final int HTML_TAG_NAME = JavadocParser.HTML_TAG_NAME;
1027 
1028     // HTML tag components
1029 
1030     /**
1031      * Start html tag component: {@code '<'}.
1032      */
1033     public static final int START = JavadocParser.START;
1034 
1035     /**
1036      * Slash html tag component: {@code '/'}.
1037      */
1038     public static final int SLASH = JavadocParser.SLASH;
1039 
1040     /**
1041      * End html tag component: {@code '>'}.
1042      */
1043     public static final int END = JavadocParser.END;
1044 
1045     /**
1046      * Slash close html tag component: {@code '/>'}.
1047      */
1048     public static final int SLASH_END = JavadocParser.SLASH_END;
1049 
1050     /**
1051      * Equals html tag component: {@code '='}.
1052      */
1053     public static final int EQUALS = JavadocParser.EQUALS;
1054 
1055     /**
1056      * Attribute value HTML tag component.
1057      *
1058      * <p><b>Example:</b></p>
1059      *
1060      * <pre>
1061      * &lt;tag_name attr_name="attr_value">Content&lt;/tag_name&gt;
1062      * </pre>
1063      *
1064      * <p><b>Tree:</b></p>
1065      * <pre>{@code
1066      * JAVADOC -> JAVADOC
1067      *  |--NEWLINE -> \r\n
1068      *  |--LEADING_ASTERISK ->  *
1069      *  |--TEXT ->
1070      *  |--HTML_ELEMENT -> HTML_ELEMENT
1071      *  |   `--HTML_TAG -> HTML_TAG
1072      *  |       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
1073      *  |       |   |--START -> <
1074      *  |       |   |--HTML_TAG_NAME -> tag_name
1075      *  |       |   |--WS ->
1076      *  |       |   |--ATTRIBUTE -> ATTRIBUTE
1077      *  |       |   |   |--HTML_TAG_NAME -> attr_name
1078      *  |       |   |   |--EQUALS -> =
1079      *  |       |   |   `--ATTR_VALUE -> "attr_value"
1080      *  |       |   `--END -> >
1081      *  |       |--TEXT -> Content
1082      *  |       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
1083      *  |           |--START -> <
1084      *  |           |--SLASH -> /
1085      *  |           |--HTML_TAG_NAME -> tag_name
1086      *  |           `--END -> >
1087      * }</pre>
1088      */
1089     public static final int ATTR_VALUE = JavadocParser.ATTR_VALUE;
1090 
1091     /////////////////////// HTML TAGS WITH OPTIONAL END TAG /////////////////////////////////////
1092 
1093     /**
1094      * Paragraph tag name.
1095      *
1096      * <p><b>Example:</b></p>
1097      * <pre>{@code <p>Paragraph Tag.</p>}</pre>
1098      * <b>Tree:</b>
1099      * <pre>
1100      * {@code
1101      *      `--HTML_ELEMENT -> HTML_ELEMENT
1102      *          `--PARAGRAPH -> PARAGRAPH
1103      *              |--P_TAG_START -> P_TAG_START
1104      *              |   |--START -> <
1105      *              |   |--P_HTML_TAG_NAME -> p
1106      *              |   `--END -> >
1107      *              |--TEXT -> Paragraph Tag.
1108      *              `--P_TAG_END -> P_TAG_END
1109      *                  |--START -> <
1110      *                  |--SLASH -> /
1111      *                  |--P_HTML_TAG_NAME -> p
1112      *                  `--END -> >
1113      * }
1114      * </pre>
1115      *
1116      * @see
1117      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1118      *     Comments are written in HTML</a>
1119      * @see #P_HTML_TAG_NAME
1120      */
1121     public static final int P_HTML_TAG_NAME = JavadocParser.P_HTML_TAG_NAME;
1122 
1123     /**
1124      * List item tag name.
1125      *
1126      * <p><b>Example:</b></p>
1127      * <pre>{@code
1128      *  <ol>
1129      *    <li>banana</li>
1130      *  </ol>
1131      *  }</pre>
1132      *  <b>Tree:</b>
1133      *  <pre>
1134      *  {@code
1135      *   HTML_ELEMENT -> HTML_ELEMENT
1136      *    `--HTML_TAG -> HTML_TAG
1137      *       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
1138      *       |   |--START -> <
1139      *       |   |--HTML_TAG_NAME -> ol
1140      *       |   `--END -> >
1141      *       |--NEWLINE -> \r\n
1142      *       |--LEADING_ASTERISK ->  *
1143      *       |--TEXT ->
1144      *       |--HTML_ELEMENT -> HTML_ELEMENT
1145      *       |   `--LI -> LI
1146      *       |       |--LI_TAG_START -> LI_TAG_START
1147      *       |       |   |--START -> <
1148      *       |       |   |--LI_HTML_TAG_NAME -> li
1149      *       |       |   `--END -> >
1150      *       |       |--TEXT -> banana
1151      *       |       `--LI_TAG_END -> LI_TAG_END
1152      *       |           |--START -> <
1153      *       |           |--SLASH -> /
1154      *       |           |--LI_HTML_TAG_NAME -> li
1155      *       |           `--END -> >
1156      *       |--NEWLINE -> \r\n
1157      *       |--LEADING_ASTERISK ->  *
1158      *       |--TEXT ->
1159      *       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
1160      *           |--START -> <
1161      *           |--SLASH -> /
1162      *           |--HTML_TAG_NAME -> ol
1163      *           `--END -> >
1164      *  }
1165      *  </pre>
1166      *
1167      * @see
1168      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1169      *     comments are written in HTML</a>
1170      * @see #LI_HTML_TAG_NAME
1171      */
1172     public static final int LI_HTML_TAG_NAME = JavadocParser.LI_HTML_TAG_NAME;
1173 
1174     /**
1175      * Table row tag name.
1176      *
1177      *  <p><b>Example:</b></p>
1178      *  <pre>{@code
1179      *  <table>
1180      *     <tr>Table Row</tr>
1181      *  </table>
1182      *  }</pre>
1183      *  <b>Tree:</b>
1184      *  <pre>
1185      *  {@code
1186      *  HTML_ELEMENT -> HTML_ELEMENT
1187      *   `--HTML_TAG -> HTML_TAG
1188      *       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
1189      *       |   |--START -> <
1190      *       |   |--HTML_TAG_NAME -> table
1191      *       |   `--END -> >
1192      *       |--NEWLINE -> \r\n
1193      *       |--LEADING_ASTERISK ->  *
1194      *       |--TEXT ->
1195      *       |--HTML_ELEMENT -> HTML_ELEMENT
1196      *       |   `--TR -> TR
1197      *       |       |--TR_TAG_START -> TR_TAG_START
1198      *       |       |   |--START -> <
1199      *       |       |   |--TR_HTML_TAG_NAME -> tr
1200      *       |       |   `--END -> >
1201      *       |       |--TEXT -> Table Row
1202      *       |       `--TR_TAG_END -> TR_TAG_END
1203      *       |           |--START -> <
1204      *       |           |--SLASH -> /
1205      *       |           |--TR_HTML_TAG_NAME -> tr
1206      *       |           `--END -> >
1207      *       |--NEWLINE -> \r\n
1208      *       |--LEADING_ASTERISK ->  *
1209      *       |--TEXT ->
1210      *       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
1211      *           |--START -> <
1212      *           |--SLASH -> /
1213      *           |--HTML_TAG_NAME -> table
1214      *           `--END -> >
1215      *  }
1216      *  </pre>
1217      *
1218      *  @see
1219      *  <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1220      *      comments are written in HTML</a>
1221      *  @see #TR_HTML_TAG_NAME
1222      */
1223     public static final int TR_HTML_TAG_NAME = JavadocParser.TR_HTML_TAG_NAME;
1224 
1225     /**
1226      * Table cell tag name.
1227      *
1228      *  <p><b>Example:</b></p>
1229      *  <pre>{@code
1230      *  <tr>
1231      *     <td>Cell 1</td>
1232      *  </tr>
1233      *  }</pre>
1234      *  <b>Tree:</b>
1235      *  <pre>
1236      *  {@code
1237      *  HTML_ELEMENT -> HTML_ELEMENT
1238      *   `--TR -> TR
1239      *       |--TR_TAG_START -> TR_TAG_START
1240      *       |   |--START -> <
1241      *       |   |--TR_HTML_TAG_NAME -> tr
1242      *       |   `--END -> >
1243      *       |--NEWLINE -> \r\n
1244      *       |--LEADING_ASTERISK ->  *
1245      *       |--TEXT ->
1246      *       |--TD -> TD
1247      *       |   |--TD_TAG_START -> TD_TAG_START
1248      *       |   |   |--START -> <
1249      *       |   |   |--TD_HTML_TAG_NAME -> td
1250      *       |   |   `--END -> >
1251      *       |   |--TEXT -> Cell 1
1252      *       |   `--TD_TAG_END -> TD_TAG_END
1253      *       |       |--START -> <
1254      *       |       |--SLASH -> /
1255      *       |       |--TD_HTML_TAG_NAME -> td
1256      *       |       `--END -> >
1257      *       |--NEWLINE -> \r\n
1258      *       |--LEADING_ASTERISK ->  *
1259      *       |--TEXT ->
1260      *       `--TR_TAG_END -> TR_TAG_END
1261      *           |--START -> <
1262      *           |--SLASH -> /
1263      *           |--TR_HTML_TAG_NAME -> tr
1264      *           `--END -> >
1265      *  }
1266      *  </pre>
1267      *
1268      *  @see
1269      *  <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1270      *      comments are written in HTML</a>
1271      *  @see #TD_HTML_TAG_NAME
1272      */
1273     public static final int TD_HTML_TAG_NAME = JavadocParser.TD_HTML_TAG_NAME;
1274 
1275     /**
1276      * Table header cell tag name.
1277      *
1278      * <p><b>Example:</b></p>
1279      * <pre>{@code
1280      * <tr>
1281      *     <th>Table Head</th>
1282      * </tr>
1283      * }</pre>
1284      * <b>Tree:</b>
1285      * <pre>
1286      * {@code
1287      *  HTML_ELEMENT -> HTML_ELEMENT
1288      *   `--TR -> TR
1289      *       |--TR_TAG_START -> TR_TAG_START
1290      *       |   |--START -> <
1291      *       |   |--TR_HTML_TAG_NAME -> tr
1292      *       |   `--END -> >
1293      *       |--NEWLINE -> \r\n
1294      *       |--LEADING_ASTERISK ->  *
1295      *       |--TEXT ->
1296      *       |--TH -> TH
1297      *       |   |--TH_TAG_START -> TH_TAG_START
1298      *       |   |   |--START -> <
1299      *       |   |   |--TH_HTML_TAG_NAME -> th
1300      *       |   |   `--END -> >
1301      *       |   |--TEXT -> Table Head
1302      *       |   `--TH_TAG_END -> TH_TAG_END
1303      *       |       |--START -> <
1304      *       |       |--SLASH -> /
1305      *       |       |--TH_HTML_TAG_NAME -> th
1306      *       |       `--END -> >
1307      *       |--NEWLINE -> \r\n
1308      *       |--LEADING_ASTERISK ->  *
1309      *       |--TEXT ->
1310      *       `--TR_TAG_END -> TR_TAG_END
1311      *           |--START -> <
1312      *           |--SLASH -> /
1313      *           |--TR_HTML_TAG_NAME -> tr
1314      *           `--END -> >
1315      *  }
1316      *  </pre>
1317      *
1318      *  @see
1319      *  <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1320      *      comments are written in HTML</a>
1321      *  @see #TH_HTML_TAG_NAME
1322      */
1323     public static final int TH_HTML_TAG_NAME = JavadocParser.TH_HTML_TAG_NAME;
1324 
1325     /**
1326      * Body tag name.
1327      *
1328      *  <p><b>Example:</b></p>
1329      *  <pre>
1330      *  &lt;body&gt;
1331      *     &lt;p&gt;Body Content&lt;/p&gt;
1332      *  &lt;/body&gt;
1333      *  </pre>
1334      *  <b>Tree:</b>
1335      *  <pre>
1336      *  {@code
1337      *  HTML_ELEMENT -> HTML_ELEMENT
1338      *   `--BODY -> BODY
1339      *       |--BODY_TAG_START -> BODY_TAG_START
1340      *       |   |--START -> <
1341      *       |   |--BODY_HTML_TAG_NAME -> body
1342      *       |   `--END -> >
1343      *       |--NEWLINE -> \r\n
1344      *       |--LEADING_ASTERISK ->  *
1345      *       |--TEXT ->
1346      *       |--PARAGRAPH -> PARAGRAPH
1347      *       |   |--P_TAG_START -> P_TAG_START
1348      *       |   |   |--START -> <
1349      *       |   |   |--P_HTML_TAG_NAME -> p
1350      *       |   |   `--END -> >
1351      *       |   |--TEXT -> Body Content
1352      *       |   `--P_TAG_END -> P_TAG_END
1353      *       |       |--START -> <
1354      *       |       |--SLASH -> /
1355      *       |       |--P_HTML_TAG_NAME -> p
1356      *       |       `--END -> >
1357      *       |--NEWLINE -> \r\n
1358      *       |--LEADING_ASTERISK ->  *
1359      *       |--TEXT ->
1360      *       `--BODY_TAG_END -> BODY_TAG_END
1361      *           |--START -> <
1362      *           |--SLASH -> /
1363      *           |--BODY_HTML_TAG_NAME -> body
1364      *           `--END -> >
1365      *  }
1366      *  </pre>
1367      *
1368      *  @see
1369      *  <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1370      *      comments are written in HTML</a>
1371      *  @see #BODY_HTML_TAG_NAME
1372      */
1373     public static final int BODY_HTML_TAG_NAME = JavadocParser.BODY_HTML_TAG_NAME;
1374 
1375     /**
1376      * Colgroup tag name.
1377      *
1378      * <p><b>Example:</b></p>
1379      * <pre>{@code <colgroup><col span="2"></colgroup>}</pre>
1380      * <b>Tree:</b>
1381      * <pre>
1382      * {@code
1383      *   |--HTML_ELEMENT -> HTML_ELEMENT
1384      *   |   `--COLGROUP -> COLGROUP
1385      *   |       |--COLGROUP_TAG_START -> COLGROUP_TAG_START
1386      *   |       |   |--START -> <
1387      *   |       |   |--COLGROUP_HTML_TAG_NAME -> colgroup
1388      *   |       |   `--END -> >
1389      *   |       |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1390      *   |       |   `--COL_TAG -> COL_TAG
1391      *   |       |       |--START -> <
1392      *   |       |       |--COL_HTML_TAG_NAME -> col
1393      *   |       |       |--WS ->
1394      *   |       |       |--ATTRIBUTE -> ATTRIBUTE
1395      *   |       |       |   |--HTML_TAG_NAME -> span
1396      *   |       |       |   |--EQUALS -> =
1397      *   |       |       |   `--ATTR_VALUE -> "2"
1398      *   |       |       `--END -> >
1399      *   |       `--COLGROUP_TAG_END -> COLGROUP_TAG_END
1400      *   |           |--START -> <
1401      *   |           |--SLASH -> /
1402      *   |           |--COLGROUP_HTML_TAG_NAME -> colgroup
1403      *   |           `--END -> >
1404      *   |--TEXT ->
1405      *   `--EOF -> <EOF>
1406      * }
1407      * </pre>
1408      *
1409      * @see #COLGROUP_HTML_TAG_NAME
1410      */
1411     public static final int COLGROUP_HTML_TAG_NAME = JavadocParser.COLGROUP_HTML_TAG_NAME;
1412 
1413     /**
1414      * Description of a term tag name.
1415      *
1416      * <p><b>Example:</b></p>
1417      * <pre>{@code
1418      * <dl>
1419      *     <dt>Java</dt>
1420      *     <dd>A high-level programming language.</dd>
1421      * </dl>
1422      * }</pre>
1423      * <b>Tree:</b>
1424      * <pre>
1425      * {@code
1426      *  HTML_ELEMENT -> HTML_ELEMENT
1427      *   `--HTML_TAG -> HTML_TAG
1428      *       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
1429      *       |   |--START -> <
1430      *       |   |--HTML_TAG_NAME -> dl
1431      *       |   `--END -> >
1432      *       |--NEWLINE -> \r\n
1433      *       |--LEADING_ASTERISK ->  *
1434      *       |--TEXT ->
1435      *       |--HTML_ELEMENT -> HTML_ELEMENT
1436      *       |   `--DT -> DT
1437      *       |       |--DT_TAG_START -> DT_TAG_START
1438      *       |       |   |--START -> <
1439      *       |       |   |--DT_HTML_TAG_NAME -> dt
1440      *       |       |   `--END -> >
1441      *       |       |--TEXT -> Java
1442      *       |       `--DT_TAG_END -> DT_TAG_END
1443      *       |           |--START -> <
1444      *       |           |--SLASH -> /
1445      *       |           |--DT_HTML_TAG_NAME -> dt
1446      *       |           `--END -> >
1447      *       |--NEWLINE -> \r\n
1448      *       |--LEADING_ASTERISK ->  *
1449      *       |--TEXT ->
1450      *       |--HTML_ELEMENT -> HTML_ELEMENT
1451      *       |   `--DD -> DD
1452      *       |       |--DD_TAG_START -> DD_TAG_START
1453      *       |       |   |--START -> <
1454      *       |       |   |--DD_HTML_TAG_NAME -> dd
1455      *       |       |   `--END -> >
1456      *       |       |--TEXT -> A high-level programming language.
1457      *       |       `--DD_TAG_END -> DD_TAG_END
1458      *       |           |--START -> <
1459      *       |           |--SLASH -> /
1460      *       |           |--DD_HTML_TAG_NAME -> dd
1461      *       |           `--END -> >
1462      *       |--NEWLINE -> \r\n
1463      *       |--LEADING_ASTERISK ->  *
1464      *       |--TEXT ->
1465      *       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
1466      *           |--START -> <
1467      *           |--SLASH -> /
1468      *           |--HTML_TAG_NAME -> dl
1469      *           `--END -> >
1470      * }
1471      * </pre>
1472      *
1473      * @see #DD_HTML_TAG_NAME
1474      */
1475     public static final int DD_HTML_TAG_NAME = JavadocParser.DD_HTML_TAG_NAME;
1476 
1477     /**
1478      * Description term tag name.
1479      *
1480      * <p><b>Example:</b></p>
1481      * <pre>{@code
1482      * <dl>
1483      *     <dt>Java</dt>
1484      * </dl>
1485      * }</pre>
1486      * <b>Tree:</b>
1487      * <pre>
1488      * {@code
1489      *  HTML_ELEMENT -> HTML_ELEMENT
1490      *   `--HTML_TAG -> HTML_TAG
1491      *       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
1492      *       |   |--START -> <
1493      *       |   |--HTML_TAG_NAME -> dl
1494      *       |   `--END -> >
1495      *       |--NEWLINE -> \r\n
1496      *       |--LEADING_ASTERISK ->  *
1497      *       |--TEXT ->
1498      *       |--HTML_ELEMENT -> HTML_ELEMENT
1499      *       |   `--DT -> DT
1500      *       |       |--DT_TAG_START -> DT_TAG_START
1501      *       |       |   |--START -> <
1502      *       |       |   |--DT_HTML_TAG_NAME -> dt
1503      *       |       |   `--END -> >
1504      *       |       |--TEXT -> Java
1505      *       |       `--DT_TAG_END -> DT_TAG_END
1506      *       |           |--START -> <
1507      *       |           |--SLASH -> /
1508      *       |           |--DT_HTML_TAG_NAME -> dt
1509      *       |           `--END -> >
1510      *       |--NEWLINE -> \r\n
1511      *       |--LEADING_ASTERISK ->  *
1512      *       |--TEXT ->
1513      *       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
1514      *           |--START -> <
1515      *           |--SLASH -> /
1516      *           |--HTML_TAG_NAME -> dl
1517      *           `--END -> >
1518      * }
1519      * </pre>
1520      *
1521      * @see #DT_HTML_TAG_NAME
1522      */
1523     public static final int DT_HTML_TAG_NAME = JavadocParser.DT_HTML_TAG_NAME;
1524 
1525     /**
1526      * Head tag name.
1527      *
1528      * <p><b>Example:</b></p>
1529      * <pre>
1530      * &lt;head&gt;
1531      *   &lt;title&gt;Page Title&lt;/title&gt;
1532      *   &lt;meta charset="UTF-8"&gt;
1533      * &lt;/head&gt;
1534      * </pre>
1535      * <b>Tree:</b>
1536      * <pre>{@code
1537      *  HEAD -> HEAD
1538      *   |--HEAD_TAG_START -> HEAD_TAG_START
1539      *   |   |--START -> <
1540      *   |   |--HEAD_HTML_TAG_NAME -> head
1541      *   |   `--END -> >
1542      *   |--NEWLINE -> \r\n
1543      *   |--LEADING_ASTERISK ->  *
1544      *   |--TEXT ->
1545      *   |--HTML_TAG -> HTML_TAG
1546      *   |   |--HTML_ELEMENT_START -> HTML_ELEMENT_START
1547      *   |   |   |--START -> <
1548      *   |   |   |--HTML_TAG_NAME -> title
1549      *   |   |   `--END -> >
1550      *   |   |--TEXT -> Page Title
1551      *   |   `--HTML_ELEMENT_END -> HTML_ELEMENT_END
1552      *   |       |--START -> <
1553      *   |       |--SLASH -> /
1554      *   |       |--HTML_TAG_NAME -> title
1555      *   |       `--END -> >
1556      *   |--NEWLINE -> \r\n
1557      *   |--LEADING_ASTERISK ->  *
1558      *   |--TEXT ->
1559      *   |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1560      *   |   `--META_TAG -> META_TAG
1561      *   |       |--START -> <
1562      *   |       |--META_HTML_TAG_NAME -> meta
1563      *   |       |--WS ->
1564      *   |       |--ATTRIBUTE -> ATTRIBUTE
1565      *   |       |   |--HTML_TAG_NAME -> charset
1566      *   |       |   |--EQUALS -> =
1567      *   |       |   `--ATTR_VALUE -> "UTF-8"
1568      *   |       `--END -> >
1569      *   |--NEWLINE -> \r\n
1570      *   |--LEADING_ASTERISK ->  *
1571      *   |--TEXT ->
1572      *   `--HEAD_TAG_END -> HEAD_TAG_END
1573      *       |--START -> <
1574      *       |--SLASH -> /
1575      *       |--HEAD_HTML_TAG_NAME -> head
1576      *       `--END -> >
1577      * }
1578      * </pre>
1579      *
1580      * @see #HEAD_HTML_TAG_NAME
1581      */
1582     public static final int HEAD_HTML_TAG_NAME = JavadocParser.HEAD_HTML_TAG_NAME;
1583 
1584     /** Html tag name. */
1585     public static final int HTML_HTML_TAG_NAME = JavadocParser.HTML_HTML_TAG_NAME;
1586 
1587     /**
1588      * Option tag name.
1589      *
1590      * <p><b>Example:</b></p>
1591      * <pre>&lt;option value="yes"&gt;Yes&lt;/option&gt;</pre>
1592      * <b>Tree:</b>
1593      * <pre>
1594      * {@code
1595      * JAVADOC -> JAVADOC
1596      * |--NEWLINE -> \r\n
1597      * |--LEADING_ASTERISK ->  *
1598      * |--HTML_ELEMENT -> HTML_ELEMENT
1599      * |   `--OPTION -> OPTION
1600      * |       |--OPTION_TAG_START -> OPTION_TAG_START
1601      * |       |   |--START -> <
1602      * |       |   |--OPTION_HTML_TAG_NAME -> option
1603      * |       |   |--WS ->
1604      * |       |   |--ATTRIBUTE -> ATTRIBUTE
1605      * |       |   |   |--HTML_TAG_NAME -> value
1606      * |       |   |   |--EQUALS -> =
1607      * |       |   |   `--ATTR_VALUE -> "yes"
1608      * |       |   `--END -> >
1609      * |       |--TEXT -> Yes
1610      * |       `--OPTION_TAG_END -> OPTION_TAG_END
1611      * |           |--START -> <
1612      * |           |--SLASH -> /
1613      * |           |--OPTION_HTML_TAG_NAME -> option
1614      * |           `--END -> >
1615      * |--NEWLINE -> \r\n
1616      * |--TEXT ->
1617      * |--EOF -> <EOF>
1618      * }
1619      * </pre>
1620      */
1621     public static final int OPTION_HTML_TAG_NAME = JavadocParser.OPTION_HTML_TAG_NAME;
1622 
1623     /**
1624      * Table body tag name.
1625      *
1626      * <p><b>Example:</b></p>
1627      * <pre>
1628      * &lt;tbody&gt;
1629      * &lt;tr&gt;
1630      * &lt;td&gt;Row1&lt;/td&gt;
1631      * &lt;/tr&gt;
1632      * &lt;/tbody&gt;
1633      * </pre>
1634      * <b>Tree:</b>
1635      * <pre>
1636      * {@code
1637      * JAVADOC -> JAVADOC
1638      * |--NEWLINE -> \n
1639      * |--LEADING_ASTERISK ->  *
1640      * |--TEXT ->
1641      * |--HTML_ELEMENT -> HTML_ELEMENT
1642      * |   `--TBODY -> TBODY
1643      * |       |--TBODY_TAG_START -> TBODY_TAG_START
1644      * |       |   |--START -> <
1645      * |       |   |--TBODY_HTML_TAG_NAME -> tbody
1646      * |       |   `--END -> >
1647      * |       |--NEWLINE -> \n
1648      * |       |--LEADING_ASTERISK ->  *
1649      * |       |--TEXT ->
1650      * |       |--TR -> TR
1651      * |       |   |--TR_TAG_START -> TR_TAG_START
1652      * |       |   |   |--START -> <
1653      * |       |   |   |--TR_HTML_TAG_NAME -> tr
1654      * |       |   |   `--END -> >
1655      * |       |   |--NEWLINE -> \n
1656      * |       |   |--LEADING_ASTERISK ->  *
1657      * |       |   |--TEXT ->
1658      * |       |   |--TD -> TD
1659      * |       |   |   |--TD_TAG_START -> TD_TAG_START
1660      * |       |   |   |   |--START -> <
1661      * |       |   |   |   |--TD_HTML_TAG_NAME -> td
1662      * |       |   |   |   `--END -> >
1663      * |       |   |   |--TEXT -> Row1
1664      * |       |   |   `--TD_TAG_END -> TD_TAG_END
1665      * |       |   |       |--START -> <
1666      * |       |   |       |--SLASH -> /
1667      * |       |   |       |--TD_HTML_TAG_NAME -> td
1668      * |       |   |       `--END -> >
1669      * |       |   |--NEWLINE -> \n
1670      * |       |   |--LEADING_ASTERISK ->  *
1671      * |       |   |--TEXT ->
1672      * |       |   `--TR_TAG_END -> TR_TAG_END
1673      * |       |       |--START -> <
1674      * |       |       |--SLASH -> /
1675      * |       |       |--TR_HTML_TAG_NAME -> tr
1676      * |       |       `--END -> >
1677      * |       |--NEWLINE -> \n
1678      * |       |--LEADING_ASTERISK ->  *
1679      * |       |--TEXT ->
1680      * |       `--TBODY_TAG_END -> TBODY_TAG_END
1681      * |           |--START -> <
1682      * |           |--SLASH -> /
1683      * |           |--TBODY_HTML_TAG_NAME -> tbody
1684      * |           `--END -> >
1685      * |--NEWLINE -> \n
1686      * |--TEXT ->
1687      * `--EOF -> <EOF>
1688      * }
1689      * </pre>
1690      */
1691     public static final int TBODY_HTML_TAG_NAME = JavadocParser.TBODY_HTML_TAG_NAME;
1692 
1693     /** Table foot tag name. */
1694     public static final int TFOOT_HTML_TAG_NAME = JavadocParser.TFOOT_HTML_TAG_NAME;
1695 
1696     /**
1697      * Table head tag name.
1698      *
1699      * <p><b>Example:</b></p>
1700      * <pre>
1701      * &lt;thead&gt;
1702      * &lt;tr&gt;
1703      * &lt;th&gt;Header&lt;/th&gt;
1704      * &lt;/tr&gt;
1705      * &lt;/thead&gt;
1706      * </pre>
1707      * <b>Tree:</b>
1708      * <pre>
1709      * {@code
1710      * JAVADOC -> JAVADOC
1711      * |--NEWLINE -> \n
1712      * |--LEADING_ASTERISK ->  *
1713      * |--TEXT ->
1714      * |--HTML_ELEMENT -> HTML_ELEMENT
1715      * |   `--THEAD -> THEAD
1716      * |       |--THEAD_TAG_START -> THEAD_TAG_START
1717      * |       |   |--START -> <
1718      * |       |   |--THEAD_HTML_TAG_NAME -> thead
1719      * |       |   `--END -> >
1720      * |       |--TR -> TR
1721      * |       |   |--TR_TAG_START -> TR_TAG_START
1722      * |       |   |   |--START -> <
1723      * |       |   |   |--TR_HTML_TAG_NAME -> tr
1724      * |       |   |   `--END -> >
1725      * |       |   |--TH -> TH
1726      * |       |   |   |--TH_TAG_START -> TH_TAG_START
1727      * |       |   |   |   |--START -> <
1728      * |       |   |   |   |--TH_HTML_TAG_NAME -> th
1729      * |       |   |   |   `--END -> >
1730      * |       |   |   |--TEXT -> Header
1731      * |       |   |   `--TH_TAG_END -> TH_TAG_END
1732      * |       |   |       |--START -> <
1733      * |       |   |       |--SLASH -> /
1734      * |       |   |       |--TH_HTML_TAG_NAME -> th
1735      * |       |   |       `--END -> >
1736      * |       |   `--TR_TAG_END -> TR_TAG_END
1737      * |       |       |--START -> <
1738      * |       |       |--SLASH -> /
1739      * |       |       |--TR_HTML_TAG_NAME -> tr
1740      * |       |       `--END -> >
1741      * |       `--THEAD_TAG_END -> THEAD_TAG_END
1742      * |           |--START -> <
1743      * |           |--SLASH -> /
1744      * |           |--THEAD_HTML_TAG_NAME -> thead
1745      * |           `--END -> >
1746      * |--NEWLINE -> \n
1747      * |--TEXT ->
1748      * `--EOF -> <EOF>
1749      * }
1750      * </pre>
1751      */
1752     public static final int THEAD_HTML_TAG_NAME = JavadocParser.THEAD_HTML_TAG_NAME;
1753 
1754     /** `optgroup` tag name. */
1755     public static final int OPTGROUP_HTML_TAG_NAME = JavadocParser.OPTGROUP_HTML_TAG_NAME;
1756 
1757     /** `rb` tag name. */
1758     public static final int RB_HTML_TAG_NAME = JavadocParser.RB_HTML_TAG_NAME;
1759 
1760     /** `rt` tag name. */
1761     public static final int RT_HTML_TAG_NAME = JavadocParser.RT_HTML_TAG_NAME;
1762 
1763     /** `rtc` tag name. */
1764     public static final int RTC_HTML_TAG_NAME = JavadocParser.RTC_HTML_TAG_NAME;
1765 
1766     /**
1767      * RP tag name.
1768      *
1769      * <p><b>Example:</b></p>
1770      * <pre>
1771      * &lt;rp&gt;Fallback&lt;/rp&gt;
1772      * </pre>
1773      *
1774      * <b>Tree:</b>
1775      * <pre>
1776      * {@code
1777      * HTML_ELEMENT -> HTML_ELEMENT
1778      *     `--RP -> RP
1779      *         |--RP_TAG_START -> RP_TAG_START
1780      *         |   |--START -> <
1781      *         |   |--RP_HTML_TAG_NAME -> rp
1782      *         |   `--END -> >
1783      *         |--TEXT -> Fallback
1784      *         `--RP_TAG_END -> RP_TAG_END
1785      *             |--START -> <
1786      *             |--SLASH -> /
1787      *             |--RP_HTML_TAG_NAME -> rp
1788      *             `--END -> >
1789      * }
1790      * </pre>
1791      */
1792     public static final int RP_HTML_TAG_NAME = JavadocParser.RP_HTML_TAG_NAME;
1793 
1794     ///////////////////////////////////////////////////////////////////////////////////////////////
1795 
1796     /////////////////////// SINGLETON HTML TAGS  //////////////////////////////////////////////////
1797     /**
1798      * Area tag name.
1799      *
1800      * <p><b>Example:</b></p>
1801      * <pre>{@code < area shape="rect" >}</pre>
1802      * <b>Tree:</b>
1803      * <pre>
1804      * {@code
1805      *   JAVADOC -> JAVADOC
1806      *        |--NEWLINE -> \n
1807      *        |--LEADING_ASTERISK ->  *
1808      *        |--TEXT ->
1809      *        |--HTML_ELEMENT -> HTML_ELEMENT
1810      *        |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1811      *        |       `--AREA_TAG -> AREA_TAG
1812      *        |           |--START -> <
1813      *        |           |--AREA_HTML_TAG_NAME -> area
1814      *        |           |--WS ->
1815      *        |           |--ATTRIBUTE -> ATTRIBUTE
1816      *        |           |   |--HTML_TAG_NAME -> shape
1817      *        |           |   |--EQUALS -> =
1818      *        |           |   `--ATTR_VALUE -> "rect"
1819      *        |           `--END -> >
1820      *        |--TEXT ->
1821      *        |--NEWLINE -> \n
1822      *        |--TEXT ->
1823      * }
1824      * </pre>
1825      */
1826 
1827     public static final int AREA_HTML_TAG_NAME = JavadocParser.AREA_HTML_TAG_NAME;
1828 
1829     /** Base tag name. */
1830     public static final int BASE_HTML_TAG_NAME = JavadocParser.BASE_HTML_TAG_NAME;
1831 
1832     /** Basefont tag name. */
1833     public static final int BASEFONT_HTML_TAG_NAME = JavadocParser.BASEFONT_HTML_TAG_NAME;
1834 
1835     /**
1836      * Br tag name.
1837      *
1838      * <p><b>Example:</b></p>
1839      * <pre>{@code text before break < br > text after break}</pre>
1840      * <b>Tree:</b>
1841      * <pre>
1842      * {@code
1843      *   `--JAVADOC -> JAVADOC
1844      *       |--NEWLINE -> \r\n
1845      *       |--LEADING_ASTERISK ->  *
1846      *       |--TEXT ->  text before break
1847      *       |--HTML_ELEMENT -> HTML_ELEMENT
1848      *       |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1849      *       |       `--BR_TAG -> BR_TAG
1850      *       |           |--START -> <
1851      *       |           |--BR_HTML_TAG_NAME -> br
1852      *       |           `--END -> >
1853      *       |--TEXT ->  text after break
1854      *       |--NEWLINE -> \r\n
1855      *       |--TEXT ->
1856      * }
1857      * </pre>
1858      */
1859 
1860     public static final int BR_HTML_TAG_NAME = JavadocParser.BR_HTML_TAG_NAME;
1861 
1862     /** Col tag name. */
1863     public static final int COL_HTML_TAG_NAME = JavadocParser.COL_HTML_TAG_NAME;
1864 
1865     /**
1866      * Frame tag name.
1867      *
1868      * <p><b>Example:</b></p>
1869      * <pre>{@code <frame src="frame_a.html">}</pre>
1870      *
1871      * <p><b>Tree:</b></p>
1872      * <pre>
1873      * {@code
1874      * |--HTML_ELEMENT -> HTML_ELEMENT
1875      * |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1876      * |       `--FRAME_TAG -> FRAME_TAG
1877      * |           |--START -> <
1878      * |           |--FRAME_HTML_TAG_NAME -> frame
1879      * |           |--WS ->
1880      * |           |--ATTRIBUTE -> ATTRIBUTE
1881      * |           |   |--HTML_TAG_NAME -> src
1882      * |           |   |--EQUALS -> =
1883      * |           |   `--ATTR_VALUE -> "frame_a.html"
1884      * |           `--END -> >
1885      * }
1886      * </pre>
1887      */
1888     public static final int FRAME_HTML_TAG_NAME = JavadocParser.FRAME_HTML_TAG_NAME;
1889 
1890     /**
1891      * Hr tag name.
1892      *
1893      * <p><b>Example:</b></p>
1894      * <pre>{@code text before horizontal rule < hr > text after horizontal rule}</pre>
1895      * <b>Tree:</b>
1896      * <pre>
1897      * {@code
1898      *  |--TEXT ->  text before horizontal rule
1899      *  |--HTML_ELEMENT -> HTML_ELEMENT
1900      *  |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1901      *  |       `--HR_TAG -> HR_TAG
1902      *  |           |--START -> <
1903      *  |           |--HR_HTML_TAG_NAME -> hr
1904      *  |           `--END -> >
1905      *  |--TEXT ->  text after horizontal rule
1906      *  |--NEWLINE -> \r\n
1907      * }
1908      * </pre>
1909      */
1910 
1911     public static final int HR_HTML_TAG_NAME = JavadocParser.HR_HTML_TAG_NAME;
1912 
1913     /** Img tag name. */
1914     public static final int IMG_HTML_TAG_NAME = JavadocParser.IMG_HTML_TAG_NAME;
1915 
1916     /**
1917      * Input tag name.
1918      *
1919      *  <p><b>Example:</b></p>
1920      *  <pre>{@code <input name="Name" type="text" placeholder="Enter your name"/>}</pre>
1921      *  <b>Tree:</b>
1922      *  <pre>
1923      *  {@code
1924      *    HTML_ELEMENT -> HTML_ELEMENT
1925      *       `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1926      *         `--INPUT_TAG -> INPUT_TAG
1927      *             |--START -> <
1928      *             |--INPUT_HTML_TAG_NAME -> input
1929      *             |--WS ->
1930      *             |--ATTRIBUTE -> ATTRIBUTE
1931      *             |   |--HTML_TAG_NAME -> name
1932      *             |   |--EQUALS -> =
1933      *             |   `--ATTR_VALUE -> "Name"
1934      *             |--WS ->
1935      *             |--ATTRIBUTE -> ATTRIBUTE
1936      *             |   |--HTML_TAG_NAME -> type
1937      *             |   |--EQUALS -> =
1938      *             |   `--ATTR_VALUE -> "text"
1939      *             |--WS ->
1940      *             |--ATTRIBUTE -> ATTRIBUTE
1941      *             |   |--HTML_TAG_NAME -> placeholder
1942      *             |   |--EQUALS -> =
1943      *             |   `--ATTR_VALUE -> "Enter your name"
1944      *              `--SLASH_END -> />
1945      *  }
1946      *  </pre>
1947      *
1948      *   @see
1949      *   <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1950      *      comments are written in HTML</a>
1951      *     @see #INPUT_HTML_TAG_NAME
1952      */
1953     public static final int INPUT_HTML_TAG_NAME = JavadocParser.INPUT_HTML_TAG_NAME;
1954 
1955     /** Isindex tag name. */
1956     public static final int ISINDEX_HTML_TAG_NAME = JavadocParser.ISINDEX_HTML_TAG_NAME;
1957 
1958     /**
1959      *  Link tag name.
1960      *
1961      *  <p><b>Example:</b></p>
1962      *  <pre>{@code <link rel="stylesheet" href="Style.css">}</pre>
1963      *  <b>Tree:</b>
1964      *  <pre>
1965      *  {@code
1966      *  HTML_ELEMENT -> HTML_ELEMENT
1967      *  `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1968      *      `--LINK_TAG -> LINK_TAG
1969      *          |--START -> <
1970      *          |--LINK_HTML_TAG_NAME -> link
1971      *          |--WS ->
1972      *          |--ATTRIBUTE -> ATTRIBUTE
1973      *          |   |--HTML_TAG_NAME -> rel
1974      *          |   |--EQUALS -> =
1975      *          |   `--ATTR_VALUE -> "stylesheet"
1976      *          |--WS ->
1977      *          |--ATTRIBUTE -> ATTRIBUTE
1978      *          |   |--HTML_TAG_NAME -> href
1979      *          |   |--EQUALS -> =
1980      *          |   `--ATTR_VALUE -> "Style.css"
1981      *          `--END -> >
1982      *  }
1983      *  </pre>
1984      *
1985      *  @see
1986      *  <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1987      *      comments are written in HTML</a>
1988      *  @see #LINK_HTML_TAG_NAME
1989      */
1990     public static final int LINK_HTML_TAG_NAME = JavadocParser.LINK_HTML_TAG_NAME;
1991 
1992     /**
1993      *  Meta tag name.
1994      *
1995      *   <p><b>Example:</b></p>
1996      *   <pre>{@code <meta charset="UTF-8">}</pre>
1997      *   <b>Tree:</b>
1998      *   <pre>
1999      *   {@code
2000      *   HTML_ELEMENT -> HTML_ELEMENT
2001      *    `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2002      *       `--META_TAG -> META_TAG
2003      *          |--START -> <
2004      *          |--META_HTML_TAG_NAME -> meta
2005      *          |--WS ->
2006      *          |--ATTRIBUTE -> ATTRIBUTE
2007      *          |   |--HTML_TAG_NAME -> charset
2008      *          |   |--EQUALS -> =
2009      *          |   `--ATTR_VALUE -> "UTF-8"
2010      *           `--END -> >
2011      *  }
2012      * </pre>
2013      */
2014     public static final int META_HTML_TAG_NAME = JavadocParser.META_HTML_TAG_NAME;
2015 
2016     /** Param tag name. */
2017     public static final int PARAM_HTML_TAG_NAME = JavadocParser.PARAM_HTML_TAG_NAME;
2018     /** "embed" tag name. */
2019     public static final int EMBED_HTML_TAG_NAME = JavadocParser.EMBED_HTML_TAG_NAME;
2020     /** "keygen" tag name. */
2021     public static final int KEYGEN_HTML_TAG_NAME = JavadocParser.KEYGEN_HTML_TAG_NAME;
2022     /** "source" tag name. */
2023     public static final int SOURCE_HTML_TAG_NAME = JavadocParser.SOURCE_HTML_TAG_NAME;
2024     /** "track" tag name. */
2025     public static final int TRACK_HTML_TAG_NAME = JavadocParser.TRACK_HTML_TAG_NAME;
2026     /** "wbr" tag name. */
2027     public static final int WBR_HTML_TAG_NAME = JavadocParser.WBR_HTML_TAG_NAME;
2028     ///////////////////////////////////////////////////////////////////////////////////////////////
2029 
2030     /**
2031      * HTML comment start symbol  '&lt;!--'.
2032      *
2033      * <p><b>Example:</b></p>
2034      * <pre>
2035      * &lt;!--
2036      * This is an HTML multi-line comment:
2037      * This is another comment
2038      * -->
2039      * </pre>
2040      * <b>Tree:</b>
2041      * <pre>
2042      * {@code
2043      * HTML_COMMENT -> HTML_COMMENT
2044      *    |--HTML_COMMENT_START -> <!--
2045      *    |--NEWLINE -> \n
2046      *    |--LEADING_ASTERISK ->  *
2047      *    |--TEXT ->  This is an HTML multi-line comment:
2048      *    |--NEWLINE -> \n
2049      *    |--LEADING_ASTERISK ->  *
2050      *    |--TEXT ->  This is another comment
2051      *    |--NEWLINE -> \n
2052      *    |--LEADING_ASTERISK ->  *
2053      *    |--TEXT ->
2054      *    `--HTML_COMMENT_END -> -->
2055      * }
2056      * </pre>
2057      */
2058     public static final int HTML_COMMENT_START = JavadocParser.HTML_COMMENT_START;
2059 
2060     /**
2061      * HTML comment end symbol {@code '-->'} .
2062      *
2063      * <p><b>Example:</b></p>
2064      * <pre>{@code
2065      * <!--
2066      * This is an HTML multi-line comment:
2067      * This is another comment
2068      * -->
2069      * }</pre>
2070      * <b>Tree:</b>
2071      * <pre>
2072      * {@code
2073      * HTML_COMMENT -> HTML_COMMENT
2074      *    |--HTML_COMMENT_START -> <!--
2075      *    |--NEWLINE -> \n
2076      *    |--LEADING_ASTERISK ->  *
2077      *    |--TEXT ->  This is an HTML multi-line comment:
2078      *    |--NEWLINE -> \n
2079      *    |--LEADING_ASTERISK ->  *
2080      *    |--TEXT ->  This is another comment
2081      *    |--NEWLINE -> \n
2082      *    |--LEADING_ASTERISK ->  *
2083      *    |--TEXT ->
2084      *    `--HTML_COMMENT_END -> -->
2085      * }
2086      * </pre>
2087      */
2088     public static final int HTML_COMMENT_END = JavadocParser.HTML_COMMENT_END;
2089 
2090     // ------------------------------------------------------------------------------------------ //
2091     // -----------------        OTHER          -------------------------------------------------- //
2092     // ------------------------------------------------------------------------------------------ //
2093 
2094     /** Leading asterisk. */
2095     public static final int LEADING_ASTERISK = JavadocParser.LEADING_ASTERISK;
2096 
2097     /**
2098      * Newline symbol - '\n'.
2099      */
2100     public static final int NEWLINE = JavadocParser.NEWLINE;
2101 
2102     /**
2103      * Any other symbol.
2104      */
2105     public static final int CHAR = JavadocParser.CHAR;
2106 
2107     /**
2108      * Whitespace or tab ('\t') symbol.
2109      */
2110     public static final int WS = JavadocParser.WS;
2111 
2112     /**
2113      * End Of File symbol. Copied from
2114      * {@link org.antlr.v4.runtime.Recognizer#EOF} to avoid ANTLR dependency in
2115      * API.
2116      */
2117     public static final int EOF = -1;
2118 
2119     // ------------------------------------------------------------------------------------------ //
2120     // ------ JAVADOC TAGS DEPENDING ON RULE TYPES OFFSET --------------------------------------- //
2121     // ------------------------------------------------------------------------------------------ //
2122 
2123     /**
2124      * Rule types offset.
2125      * RULE_TYPES_OFFSET constant is used to split lexer tokens types and parser rules types.
2126      * We need unique numbers for all tokens,
2127      * ANTLR do not need this and that is why these types are mixed by used values.
2128      * All values we can take a look at
2129      * target/generated-sources/antlr/com/puppycrawl/tools/checkstyle/grammar/javadoc/JavadocParser.java
2130      * For example: LEADING_ASTERISK=1 and RULE_htmlElement = 1.
2131      * RULE_TYPES_OFFSET required to shift parser rules,
2132      * to let them not overlap with types that have prefix "RULE_".
2133      */
2134     private static final int RULE_TYPES_OFFSET = 10000;
2135 
2136     /**
2137      * Root node of any Javadoc comment.
2138      * Last child is always {@link #EOF}.
2139      *
2140      * <p><b>Tree for example:</b></p>
2141      * <pre>{@code
2142      * JAVADOC -> JAVADOC
2143      *  |--NEWLINE -> \n
2144      *  |--LEADING_ASTERISK ->  *
2145      *  |--WS ->
2146      *  |--JAVADOC_TAG -> JAVADOC_TAG
2147      *  |   |--PARAM_LITERAL -> @param
2148      *  |   |--WS ->
2149      *  |   |--PARAMETER_NAME -> T
2150      *  |   |--WS ->
2151      *  |   `--DESCRIPTION -> DESCRIPTION
2152      *  |       |--TEXT -> The bar.
2153      *  |       |--NEWLINE -> \n
2154      *  |       `--TEXT ->
2155      *  `--EOF -> <EOF>
2156      * }</pre>
2157      */
2158     public static final int JAVADOC = JavadocParser.RULE_javadoc + RULE_TYPES_OFFSET;
2159 
2160     /**
2161      * Javadoc tag.
2162      *
2163      * <p>Type of Javadoc tag is resolved by literal node that is first child of this node.</p>
2164      *
2165      * <p>As literal could be:</p>
2166      * <ul>
2167      * <li>{@link #RETURN_LITERAL}</li>
2168      * <li>{@link #DEPRECATED_LITERAL}</li>
2169      * <li>{@link #SINCE_LITERAL}</li>
2170      * <li>{@link #SERIAL_DATA_LITERAL}</li>
2171      * <li>{@link #SERIAL_FIELD_LITERAL}</li>
2172      * <li>{@link #PARAM_LITERAL}</li>
2173      * <li>{@link #SEE_LITERAL}</li>
2174      * <li>{@link #SERIAL_LITERAL}</li>
2175      * <li>{@link #VERSION_LITERAL}</li>
2176      * <li>{@link #EXCEPTION_LITERAL}</li>
2177      * <li>{@link #THROWS_LITERAL}</li>
2178      * <li>{@link #AUTHOR_LITERAL}</li>
2179      * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc tag.</li>
2180      * </ul>
2181      *
2182      * <p><b>Example</b></p>
2183      * <pre>{@code @param T The bar.}</pre>
2184      * <b>Tree</b>
2185      * <pre>{@code
2186      * JAVADOC_TAG -> JAVADOC_TAG
2187      *  |--PARAM_LITERAL -> @param
2188      *  |--WS ->
2189      *  |--PARAMETER_NAME -> T
2190      *  |--WS ->
2191      *  `--DESCRIPTION -> DESCRIPTION
2192      *      |--TEXT -> The bar.
2193      *      |--NEWLINE -> \r\n
2194      *      `--TEXT ->
2195      * }</pre>
2196      */
2197 
2198     public static final int JAVADOC_TAG = JavadocParser.RULE_javadocTag + RULE_TYPES_OFFSET;
2199     /**
2200      * Javadoc inline tag.
2201      *
2202      * <p>Type of Javadoc inline tag is resolved by literal node that is second child of this node.
2203      * First child is always {@link #JAVADOC_INLINE_TAG_START} and last node is always
2204      * {@link #JAVADOC_INLINE_TAG_END}.</p>
2205      *
2206      * <p>As literal could be:</p>
2207      * <ul>
2208      * <li>{@link #CODE_LITERAL}</li>
2209      * <li>{@link #DOC_ROOT_LITERAL}</li>
2210      * <li>{@link #LINK_LITERAL}</li>
2211      * <li>{@link #INHERIT_DOC_LITERAL}</li>
2212      * <li>{@link #LINKPLAIN_LITERAL}</li>
2213      * <li>{@link #LITERAL_LITERAL}</li>
2214      * <li>{@link #VALUE_LITERAL}</li>
2215      * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc inline tag.</li>
2216      * </ul>
2217      *
2218      * <p><b>Example:</b></p>
2219      * <pre>{@literal {@link String} }</pre>
2220      * <b>Tree:</b>
2221      * <pre>
2222      * {@code
2223      *  JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
2224      *      |--JAVADOC_INLINE_TAG_START -> {
2225      *      |--LINK_LITERAL -> @link
2226      *      |--WS ->
2227      *      |--REFERENCE -> REFERENCE
2228      *          `--PACKAGE_CLASS -> String
2229      *      `--JAVADOC_INLINE_TAG_END -> }
2230      * }
2231      * </pre>
2232      */
2233     public static final int JAVADOC_INLINE_TAG = JavadocParser.RULE_javadocInlineTag
2234             + RULE_TYPES_OFFSET;
2235 
2236     /**
2237      * Parameter of the Javadoc tags listed below.
2238      * <ul>
2239      * <li>{@link #SEE_LITERAL @see}</li>
2240      * <li>{@link #LINK_LITERAL &#123;&#64;link&#125;}</li>
2241      * <li>{@link #LINKPLAIN_LITERAL &#123;&#64;linkplain&#125;}</li>
2242      * <li>{@link #VALUE_LITERAL &#123;&#64;value&#125;}</li>
2243      * </ul>
2244      */
2245     public static final int REFERENCE = JavadocParser.RULE_reference + RULE_TYPES_OFFSET;
2246 
2247     /**
2248      * Parameters part in {@link #REFERENCE}.
2249      * It is used to specify parameters for {@link #MEMBER method}.
2250      * Always contains {@link #LEFT_BRACE} as first child and {@link #RIGHT_BRACE} as last child.
2251      * Each parameter is represented by {@link #ARGUMENT} node.
2252      * Arguments in braces are separated by {@link #COMMA} (and optional {@link #WS}).
2253      *
2254      * <p><b>Example:</b></p>
2255      * <pre>{@code @see #method(Processor, String)}</pre>
2256      * <b>Tree:</b>
2257      * <pre>
2258      * {@code
2259      *      JAVADOC_TAG -> JAVADOC_TAG
2260      *          |--SEE_LITERAL -> @see
2261      *          |--WS ->
2262      *          |--REFERENCE -> REFERENCE
2263      *              |--HASH -> #
2264      *              |--MEMBER -> method
2265      *              `--PARAMETERS -> PARAMETERS
2266      *                  |--LEFT_BRACE -> (
2267      *                  |--ARGUMENT -> Processor
2268      *                  |--COMMA -> ,
2269      *                  |--WS ->
2270      *                  |--ARGUMENT -> String
2271      *                  `--RIGHT_BRACE -> )
2272      * }
2273      * </pre>
2274      */
2275     public static final int PARAMETERS = JavadocParser.RULE_parameters + RULE_TYPES_OFFSET;
2276 
2277     /**
2278      * Description node. It contains:
2279      * <ul>
2280      * <li>{@link #TEXT}</li>
2281      * <li>{@link #WS}</li>
2282      * <li>{@link #NEWLINE}</li>
2283      * <li>{@link #HTML_ELEMENT}</li>
2284      * </ul>
2285      *
2286      * <p>It is argument for many Javadoc tags and inline tags.</p>
2287      *
2288      * <p><b>Example:</b></p>
2289      * <pre>{@code @throws IOException if <b>connection</b> problems occur}</pre>
2290      * <b>Tree:</b>
2291      * <pre>
2292      * {@code
2293      *   --JAVADOC_TAG -> JAVADOC_TAG
2294      *      |--THROWS_LITERAL -> @throws
2295      *      |--WS ->
2296      *      |--CLASS_NAME -> IOException
2297      *      |--WS ->
2298      *      `--DESCRIPTION -> DESCRIPTION
2299      *          |--TEXT -> if
2300      *          |--HTML_ELEMENT -> HTML_ELEMENT
2301      *          |   `--HTML_TAG -> HTML_TAG
2302      *          |       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
2303      *          |       |   |--START -> <
2304      *          |       |   |--HTML_TAG_NAME -> b
2305      *          |       |   `--END -> >
2306      *          |       |--TEXT -> connection
2307      *          |       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
2308      *          |           |--START -> <
2309      *          |           |--SLASH -> /
2310      *          |           |--HTML_TAG_NAME -> b
2311      *          |           `--END -> >
2312      *          |--TEXT ->  problems occur
2313      * }
2314      * </pre>
2315      */
2316     public static final int DESCRIPTION = JavadocParser.RULE_description + RULE_TYPES_OFFSET;
2317 
2318     // ------------------------------------------------------------------------------------------ //
2319     // -------- HTML TAGS DEPENDING ON RULE TYPES OFFSET ---------------------------------------- //
2320     // ------------------------------------------------------------------------------------------ //
2321 
2322     /**
2323      * Parent node for all html tags.
2324      */
2325     public static final int HTML_ELEMENT = JavadocParser.RULE_htmlElement
2326             + RULE_TYPES_OFFSET;
2327 
2328     /**
2329      * Start html tag: {@code <XXXX>}.
2330      */
2331     public static final int HTML_ELEMENT_START = JavadocParser.RULE_htmlElementStart
2332             + RULE_TYPES_OFFSET;
2333 
2334     /**
2335      * End html tag: {@code <XXXX>}.
2336      */
2337     public static final int HTML_ELEMENT_END = JavadocParser.RULE_htmlElementEnd
2338             + RULE_TYPES_OFFSET;
2339 
2340     /**
2341      * Non-special HTML tag.
2342      */
2343     public static final int HTML_TAG = JavadocParser.RULE_htmlTag + RULE_TYPES_OFFSET;
2344 
2345     /**
2346      * Html tag attribute. Parent node for: {@code HTML_TAG_IDENT, EQUALS, ATTR_VALUE}.
2347      *
2348      * <p><b>Example</b></p>
2349      * <pre>{@code <p class="highlight">Sample text</p>}</pre>
2350      * <b>Tree</b>
2351      * <pre>
2352      * {@code
2353      *   HTML_ELEMENT -> HTML_ELEMENT
2354      *      `--PARAGRAPH -> PARAGRAPH
2355      *          |--P_TAG_START -> P_TAG_START
2356      *          |   |--START -> <
2357      *          |   |--P_HTML_TAG_NAME -> p
2358      *          |   |--WS ->
2359      *          |   |--ATTRIBUTE -> ATTRIBUTE
2360      *          |   |   |--HTML_TAG_NAME -> class
2361      *          |   |   |--EQUALS -> =
2362      *          |   |   `--ATTR_VALUE -> "highlight"
2363      *          |   `--END -> >
2364      *          |--TEXT -> Sample text
2365      *          `--P_TAG_END -> P_TAG_END
2366      *              |--START -> <
2367      *              |--SLASH -> /
2368      *              |--P_HTML_TAG_NAME -> p
2369      *              `--END -> >
2370      * }
2371      * </pre>
2372      */
2373     public static final int ATTRIBUTE = JavadocParser.RULE_attribute
2374             + RULE_TYPES_OFFSET;
2375 
2376     /////////////////////// HTML TAGS WITH OPTIONAL END TAG /////////////////////////////////////
2377     /**
2378      * Paragraph html tag.
2379      *
2380      * <p><b>Example:</b></p>
2381      * <pre>{@code <p>Sample text</p>}</pre>
2382      * <b>Tree:</b>
2383      * <pre>
2384      * {@code
2385      *   `--JAVADOC -> JAVADOC
2386      *       |--NEWLINE -> \r\n
2387      *       |--LEADING_ASTERISK ->  *
2388      *       |--TEXT ->
2389      *       |--HTML_ELEMENT -> HTML_ELEMENT
2390      *       |   `--PARAGRAPH -> PARAGRAPH
2391      *       |       |--P_TAG_START -> P_TAG_START
2392      *       |       |   |--START -> <
2393      *       |       |   |--P_HTML_TAG_NAME -> p
2394      *       |       |   `--END -> >
2395      *       |       |--TEXT -> Sample text
2396      *       |       `--P_TAG_END -> P_TAG_END
2397      *       |           |--START -> <
2398      *       |           |--SLASH -> /
2399      *       |           |--P_HTML_TAG_NAME -> p
2400      *       |           `--END -> >
2401      *       |--NEWLINE -> \r\n
2402      *       |--TEXT ->
2403      * }
2404      * </pre>
2405      */
2406     public static final int PARAGRAPH = JavadocParser.RULE_paragraph + RULE_TYPES_OFFSET;
2407     /** Start paragraph tag. */
2408     public static final int P_TAG_START = JavadocParser.RULE_pTagStart + RULE_TYPES_OFFSET;
2409     /** End paragraph tag. */
2410     public static final int P_TAG_END = JavadocParser.RULE_pTagEnd + RULE_TYPES_OFFSET;
2411 
2412     /**
2413      * List items html tag.
2414      *
2415      * <p><b>Example:</b></p>
2416      * <pre>{@code
2417      * <ul>
2418      *      <li>Item 1</li>
2419      * </ul>
2420      * }</pre>
2421      * <b>Tree:</b>
2422      * <pre>
2423      * {@code
2424      *   --JAVADOC -> JAVADOC
2425      *     |--NEWLINE -> \n
2426      *     |--LEADING_ASTERISK ->  *
2427      *     |--TEXT ->
2428      *     |--HTML_ELEMENT -> HTML_ELEMENT
2429      *     |   `--HTML_TAG -> HTML_TAG
2430      *     |       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
2431      *     |       |   |--START -> <
2432      *     |       |   |--HTML_TAG_NAME -> ul
2433      *     |       |   `--END -> >
2434      *     |       |--NEWLINE -> \n
2435      *     |       |--LEADING_ASTERISK ->  *
2436      *     |       |--TEXT ->
2437      *     |       |--HTML_ELEMENT -> HTML_ELEMENT
2438      *     |       |   `--LI -> LI
2439      *     |       |       |--LI_TAG_START -> LI_TAG_START
2440      *     |       |       |   |--START -> <
2441      *     |       |       |   |--LI_HTML_TAG_NAME -> li
2442      *     |       |       |   `--END -> >
2443      *     |       |       |--TEXT -> Item 1
2444      *     |       |       `--LI_TAG_END -> LI_TAG_END
2445      *     |       |           |--START -> <
2446      *     |       |           |--SLASH -> /
2447      *     |       |           |--LI_HTML_TAG_NAME -> li
2448      *     |       |           `--END -> >
2449      *     |       |--NEWLINE -> \n
2450      *     |       |--LEADING_ASTERISK ->  *
2451      *     |       |--TEXT ->
2452      *     |       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
2453      *     |           |--START -> <
2454      *     |           |--SLASH -> /
2455      *     |           |--HTML_TAG_NAME -> ul
2456      *     |           `--END -> >
2457      *     |--NEWLINE -> \n
2458      *     |--TEXT ->
2459      * }
2460      * </pre>
2461      */
2462     public static final int LI = JavadocParser.RULE_li + RULE_TYPES_OFFSET;
2463     /** Start list item tag. */
2464     public static final int LI_TAG_START = JavadocParser.RULE_liTagStart + RULE_TYPES_OFFSET;
2465     /** End list item tag. */
2466     public static final int LI_TAG_END = JavadocParser.RULE_liTagEnd + RULE_TYPES_OFFSET;
2467 
2468     /**
2469      * Table row html tag.
2470      *
2471      * <p><b>Example:</b></p>
2472      * <pre>{@code <tr></tr>}</pre>
2473      * <b>Tree:</b>
2474      * <pre>
2475      * {@code
2476      *   JAVADOC -> JAVADOC
2477      *        |--NEWLINE -> \r\n
2478      *        |--LEADING_ASTERISK ->  *
2479      *        |--TEXT ->
2480      *        |--HTML_ELEMENT -> HTML_ELEMENT
2481      *        |   `--TR -> TR
2482      *        |       |--TR_TAG_START -> TR_TAG_START
2483      *        |       |   |--START -> <
2484      *        |       |   |--TR_HTML_TAG_NAME -> tr
2485      *        |       |   `--END -> >
2486      *        |       `--TR_TAG_END -> TR_TAG_END
2487      *        |           |--START -> <
2488      *        |           |--SLASH -> /
2489      *        |           |--TR_HTML_TAG_NAME -> tr
2490      *        |           `--END -> >
2491      *        |--NEWLINE -> \r\n
2492      *        |--TEXT ->
2493      * }
2494      * </pre>
2495      */
2496     public static final int TR = JavadocParser.RULE_tr + RULE_TYPES_OFFSET;
2497     /** Start table row tag. */
2498     public static final int TR_TAG_START = JavadocParser.RULE_trTagStart + RULE_TYPES_OFFSET;
2499     /** End table row tag. */
2500     public static final int TR_TAG_END = JavadocParser.RULE_trTagEnd + RULE_TYPES_OFFSET;
2501 
2502     /**
2503      * Table cell HTML tag.
2504      *
2505      * <p><b>Example:</b></p>
2506      * <pre>{@code <td>Cell Content</td>}</pre>
2507      * <b>Tree:</b>
2508      * <pre>
2509      * {@code
2510      * HTML_ELEMENT -> HTML_ELEMENT
2511      *    `--TD -> TD
2512      *        |--TD_TAG_START -> TD_TAG_START
2513      *        |   |--START -> <
2514      *        |   |--TD_HTML_TAG_NAME -> td
2515      *        |   `--END -> >
2516      *        |--TEXT -> Cell Content
2517      *        `--TD_TAG_END -> TD_TAG_END
2518      *            |--START -> <
2519      *            |--SLASH -> /
2520      *            |--TD_HTML_TAG_NAME -> td
2521      *            `--END -> >
2522      * }
2523      * </pre>
2524      */
2525     public static final int TD = JavadocParser.RULE_td + RULE_TYPES_OFFSET;
2526     /** Start table cell tag. */
2527     public static final int TD_TAG_START = JavadocParser.RULE_tdTagStart + RULE_TYPES_OFFSET;
2528     /** End table cell tag. */
2529     public static final int TD_TAG_END = JavadocParser.RULE_tdTagEnd + RULE_TYPES_OFFSET;
2530 
2531     /** Table header cell html tag: {@code <th></th>}. */
2532     public static final int TH = JavadocParser.RULE_th + RULE_TYPES_OFFSET;
2533     /** Start table header cell tag. */
2534     public static final int TH_TAG_START = JavadocParser.RULE_thTagStart + RULE_TYPES_OFFSET;
2535     /** End table header cell tag. */
2536     public static final int TH_TAG_END = JavadocParser.RULE_thTagEnd + RULE_TYPES_OFFSET;
2537 
2538     /** Body html tag. */
2539     public static final int BODY = JavadocParser.RULE_body + RULE_TYPES_OFFSET;
2540 
2541     /**
2542      * Start body tag.
2543      *
2544      * <p><b>Example:</b></p>
2545      * <pre>
2546      * &lt;body&gt;
2547      * This is a test
2548      * &lt;/body&gt;
2549      * </pre>
2550      * <b>Tree:</b>
2551      * <pre>
2552      * {@code
2553      *   JAVADOC -> JAVADOC
2554      *        |--TEXT -> /**
2555      *        |--NEWLINE -> \n
2556      *        |--LEADING_ASTERISK ->  *
2557      *        |--TEXT ->
2558      *        |--HTML_ELEMENT -> HTML_ELEMENT
2559      *        |    `--BODY -> BODY
2560      *        |         |--BODY_TAG_START -> BODY_TAG_START
2561      *        |         |    |--START -> <
2562      *        |         |    |--BODY_HTML_TAG_NAME -> body
2563      *        |         |    `--END -> >
2564      *        |         |--NEWLINE -> \n
2565      *        |         |--LEADING_ASTERISK ->  *
2566      *        |         |--TEXT ->  This is inside the body tag.
2567      *        |         |--NEWLINE -> \n
2568      *        |         |--LEADING_ASTERISK ->  *
2569      *        |         |--TEXT ->
2570      *        |         `--BODY_TAG_END -> BODY_TAG_END
2571      *        |             |--START -> <
2572      *        |             |--SLASH -> /
2573      *        |             |--BODY_HTML_TAG_NAME -> body
2574      *        |             `--END -> >
2575      *        |--NEWLINE -> \n
2576      *        |--LEADING_ASTERISK ->  *
2577      *        |--TEXT -> /
2578      *        |--NEWLINE -> \n
2579      *        |--TEXT -> public class Test {
2580      *        |--NEWLINE -> \n
2581      *        |--TEXT -> }
2582      *        |--NEWLINE -> \n
2583      * }
2584      * </pre>
2585      */
2586     public static final int BODY_TAG_START = JavadocParser.RULE_bodyTagStart + RULE_TYPES_OFFSET;
2587 
2588     /**
2589      * End body tag.
2590      *
2591      * <p><b>Example:</b></p>
2592      * <pre>
2593      *  &lt;body&gt;
2594      *     This is a test
2595      * &lt;/body&gt;
2596      * </pre>
2597      * <b>Tree:</b>
2598      * <pre>
2599      * {@code
2600      *   JAVADOC -> JAVADOC
2601      *        |--TEXT -> /**
2602      *        |--NEWLINE -> \n
2603      *        |--LEADING_ASTERISK ->  *
2604      *        |--TEXT ->
2605      *        |--HTML_ELEMENT -> HTML_ELEMENT
2606      *        |    `--BODY -> BODY
2607      *        |         |--BODY_TAG_START -> BODY_TAG_START
2608      *        |         |    |--START -> <
2609      *        |         |    |--BODY_HTML_TAG_NAME -> body
2610      *        |         |    `--END -> >
2611      *        |         |--NEWLINE -> \n
2612      *        |         |--LEADING_ASTERISK ->  *
2613      *        |         |--TEXT ->  This is inside the body tag.
2614      *        |         |--NEWLINE -> \n
2615      *        |         |--LEADING_ASTERISK ->  *
2616      *        |         |--TEXT ->
2617      *        |         `--BODY_TAG_END -> BODY_TAG_END
2618      *        |             |--START -> <
2619      *        |             |--SLASH -> /
2620      *        |             |--BODY_HTML_TAG_NAME -> body
2621      *        |             `--END -> >
2622      *        |--NEWLINE -> \n
2623      *        |--LEADING_ASTERISK ->  *
2624      *        |--TEXT -> /
2625      *        |--NEWLINE -> \n
2626      *        |--TEXT -> public class Test {
2627      *        |--NEWLINE -> \n
2628      *        |--TEXT -> }
2629      *        |--NEWLINE -> \n
2630      * }
2631      * </pre>
2632      */
2633     public static final int BODY_TAG_END = JavadocParser.RULE_bodyTagEnd + RULE_TYPES_OFFSET;
2634 
2635     /**
2636      * Colgroup html tag.
2637      *
2638      * <p><b>Example:</b></p>
2639      * <pre>{@code
2640      * <colgroup>
2641      *     <col />
2642      *     <col span="2" class="batman" />
2643      * </colgroup>
2644      * }</pre>
2645      * <b>Tree:</b>
2646      * <pre>
2647      * {@code
2648      *   --JAVADOC -> JAVADOC
2649      *       |--NEWLINE -> \n
2650      *       |--LEADING_ASTERISK ->  *
2651      *       |--TEXT ->
2652      *       |--HTML_ELEMENT -> HTML_ELEMENT
2653      *       |   `--COLGROUP -> COLGROUP
2654      *       |       |--COLGROUP_TAG_START -> COLGROUP_TAG_START
2655      *       |       |   |--START -> <
2656      *       |       |   |--COLGROUP_HTML_TAG_NAME -> colgroup
2657      *       |       |   |   `--END -> >
2658      *       |       |--NEWLINE -> \n
2659      *       |       |--LEADING_ASTERISK ->  *
2660      *       |       |--TEXT ->
2661      *       |       |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2662      *       |       |   `--COL_TAG -> COL_TAG
2663      *       |       |       |--START -> <
2664      *       |       |       |--COL_HTML_TAG_NAME -> col
2665      *       |       |       |--WS ->
2666      *       |       |       `--SLASH_END -> />
2667      *       |       |--NEWLINE -> \n
2668      *       |       |--LEADING_ASTERISK ->  *
2669      *       |       |--TEXT ->
2670      *       |       |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2671      *       |       |   `--COL_TAG -> COL_TAG
2672      *       |       |       |--START -> <
2673      *       |       |       |--COL_HTML_TAG_NAME -> col
2674      *       |       |       |--WS ->
2675      *       |       |       |--ATTRIBUTE -> ATTRIBUTE
2676      *       |       |       |   |--HTML_TAG_NAME -> span
2677      *       |       |       |   |--EQUALS -> =
2678      *       |       |       |   `--ATTR_VALUE -> "2"
2679      *       |       |       |--WS ->
2680      *       |       |       |--ATTRIBUTE -> ATTRIBUTE
2681      *       |       |       |   |--HTML_TAG_NAME -> class
2682      *       |       |       |   |--EQUALS -> =
2683      *       |       |       |   `--ATTR_VALUE -> "batman"
2684      *       |       |       |--WS ->
2685      *       |       |       `--SLASH_END -> />
2686      *       |       |--NEWLINE -> \n
2687      *       |       |--LEADING_ASTERISK ->  *
2688      *       |       |--TEXT ->
2689      *       |       `--COLGROUP_TAG_END -> COLGROUP_TAG_END
2690      *       |       |       |--START -> <
2691      *       |       |       |--SLASH -> /
2692      *       |       |       |--COLGROUP_HTML_TAG_NAME -> colgroup
2693      *       |       |       `--END -> >
2694      *       |--NEWLINE -> \n
2695      *       |--TEXT ->
2696      * }
2697      * </pre>
2698      */
2699     public static final int COLGROUP = JavadocParser.RULE_colgroup + RULE_TYPES_OFFSET;
2700     /** Start colgroup tag. */
2701     public static final int COLGROUP_TAG_START = JavadocParser.RULE_colgroupTagStart
2702             + RULE_TYPES_OFFSET;
2703     /** End colgroup tag. */
2704     public static final int COLGROUP_TAG_END = JavadocParser.RULE_colgroupTagEnd
2705             + RULE_TYPES_OFFSET;
2706 
2707     /**
2708      * DD html tag.
2709      *
2710      * <p><b>Example AST:</b></p>
2711      * <pre>{@code <dd>Description content</dd>}</pre>
2712      * <pre>
2713      * {@code
2714      *   --HTML_ELEMENT -> HTML_ELEMENT
2715      *      `--DD -> DD
2716      *          |--DD_TAG_START -> DD_TAG_START
2717      *          |   |--START -> <
2718      *          |   |--DD_HTML_TAG_NAME -> dd
2719      *          |   `--END -> >
2720      *          |--TEXT -> "Description content"
2721      *          `--DD_TAG_END -> DD_TAG_END
2722      *              |--START -> <
2723      *              |--SLASH -> /
2724      *              |--DD_HTML_TAG_NAME -> dd
2725      *              `--END -> >
2726      * }
2727      * </pre>
2728      */
2729     public static final int DD = JavadocParser.RULE_dd + RULE_TYPES_OFFSET;
2730     /** Start description of a term tag. */
2731     public static final int DD_TAG_START = JavadocParser.RULE_ddTagStart + RULE_TYPES_OFFSET;
2732     /** End description of a term tag. */
2733     public static final int DD_TAG_END = JavadocParser.RULE_ddTagEnd + RULE_TYPES_OFFSET;
2734 
2735     /**
2736      * DT html tag.
2737      *
2738      * <p><b>Example AST:</b></p>
2739      * <pre>{@code <dd>Description Term</dd>}</pre>
2740      * <pre>
2741      * {@code
2742      *   --HTML_ELEMENT -> HTML_ELEMENT
2743      *      `--DT -> DT
2744      *          |--DT_TAG_START -> DT_TAG_START
2745      *          |   |--START -> <
2746      *          |   |--DT_HTML_TAG_NAME -> dt
2747      *          |   `--END -> >
2748      *          |--TEXT -> "Description term"
2749      *          `--DT_TAG_END -> DT_TAG_END
2750      *              |--START -> <
2751      *              |--SLASH -> /
2752      *              |--DT_HTML_TAG_NAME -> dt
2753      *              `--END -> >
2754      * }
2755      * </pre>
2756      */
2757     public static final int DT = JavadocParser.RULE_dt + RULE_TYPES_OFFSET;
2758     /** Start description term tag. */
2759     public static final int DT_TAG_START = JavadocParser.RULE_dtTagStart + RULE_TYPES_OFFSET;
2760     /** End description term tag. */
2761     public static final int DT_TAG_END = JavadocParser.RULE_dtTagEnd + RULE_TYPES_OFFSET;
2762 
2763     /** Head html tag. */
2764     public static final int HEAD = JavadocParser.RULE_head + RULE_TYPES_OFFSET;
2765     /** Start head tag. */
2766     public static final int HEAD_TAG_START = JavadocParser.RULE_headTagStart + RULE_TYPES_OFFSET;
2767     /** End head tag. */
2768     public static final int HEAD_TAG_END = JavadocParser.RULE_headTagEnd + RULE_TYPES_OFFSET;
2769 
2770     /** Html html tag. */
2771     public static final int HTML = JavadocParser.RULE_html + RULE_TYPES_OFFSET;
2772     /** Start html tag. */
2773     public static final int HTML_TAG_START = JavadocParser.RULE_htmlTagStart + RULE_TYPES_OFFSET;
2774     /** End html tag. */
2775     public static final int HTML_TAG_END = JavadocParser.RULE_htmlTagEnd + RULE_TYPES_OFFSET;
2776 
2777     /** Option html tag. */
2778     public static final int OPTION = JavadocParser.RULE_option + RULE_TYPES_OFFSET;
2779     /** Start option tag. */
2780     public static final int OPTION_TAG_START =
2781             JavadocParser.RULE_optionTagStart + RULE_TYPES_OFFSET;
2782     /** End option tag. */
2783     public static final int OPTION_TAG_END = JavadocParser.RULE_optionTagEnd
2784             + RULE_TYPES_OFFSET;
2785 
2786     /**
2787      * Table body html tag.
2788      *
2789      * <p><b>Example:</b></p>
2790      * <pre>{@code <table><tbody></tbody></table>}</pre>
2791      * <b>Tree:</b>
2792      * <pre>
2793      * {@code
2794      *    JAVADOC -> JAVADOC
2795      *      |--NEWLINE -> \r\n
2796      *      |--LEADING_ASTERISK ->  *
2797      *      |--TEXT ->
2798      *      |--HTML_ELEMENT -> HTML_ELEMENT
2799      *      |   `--HTML_TAG -> HTML_TAG
2800      *      |       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
2801      *      |       |   |--START -> <
2802      *      |       |   |--HTML_TAG_NAME -> table
2803      *      |       |   `--END -> >
2804      *      |       |--HTML_ELEMENT -> HTML_ELEMENT
2805      *      |       |   `--TBODY -> TBODY
2806      *      |       |       |--TBODY_TAG_START -> TBODY_TAG_START
2807      *      |       |       |   |--START -> <
2808      *      |       |       |   |--TBODY_HTML_TAG_NAME -> tbody
2809      *      |       |       |   `--END -> >
2810      *      |       |       `--TBODY_TAG_END -> TBODY_TAG_END
2811      *      |       |           |--START -> <
2812      *      |       |           |--SLASH -> /
2813      *      |       |           |--TBODY_HTML_TAG_NAME -> tbody
2814      *      |       |           `--END -> >
2815      *      |       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
2816      *      |           |--START -> <
2817      *      |           |--SLASH -> /
2818      *      |           |--HTML_TAG_NAME -> table
2819      *      |           `--END -> >
2820      *      |--NEWLINE -> \r\n
2821      * }
2822      * </pre>
2823      */
2824     public static final int TBODY = JavadocParser.RULE_tbody + RULE_TYPES_OFFSET;
2825     /** Start table body tag. */
2826     public static final int TBODY_TAG_START = JavadocParser.RULE_tbodyTagStart + RULE_TYPES_OFFSET;
2827     /** End table body tag. */
2828     public static final int TBODY_TAG_END = JavadocParser.RULE_tbodyTagEnd + RULE_TYPES_OFFSET;
2829 
2830     /** Table foot html tag. */
2831     public static final int TFOOT = JavadocParser.RULE_tfoot + RULE_TYPES_OFFSET;
2832     /** Start table foot tag. */
2833     public static final int TFOOT_TAG_START = JavadocParser.RULE_tfootTagStart + RULE_TYPES_OFFSET;
2834     /** End table foot tag. */
2835     public static final int TFOOT_TAG_END = JavadocParser.RULE_tfootTagEnd + RULE_TYPES_OFFSET;
2836 
2837     /** Table head html tag. */
2838     public static final int THEAD = JavadocParser.RULE_thead + RULE_TYPES_OFFSET;
2839     /** Start table head tag. */
2840     public static final int THEAD_TAG_START = JavadocParser.RULE_theadTagStart + RULE_TYPES_OFFSET;
2841     /** End table head tag. */
2842     public static final int THEAD_TAG_END = JavadocParser.RULE_theadTagEnd + RULE_TYPES_OFFSET;
2843 
2844     /** `optgroup` html tag. */
2845     public static final int OPTGROUP = JavadocParser.RULE_optgroup + RULE_TYPES_OFFSET;
2846     /** `optgroup` tag start. */
2847     public static final int OPTGROUP_TAG_START =
2848             JavadocParser.RULE_optgroupTagStart + RULE_TYPES_OFFSET;
2849     /** `optgroup` tag end. */
2850     public static final int OPTGROUP_TAG_END =
2851             JavadocParser.RULE_optgroupTagEnd + RULE_TYPES_OFFSET;
2852 
2853     /** `rb` html tag. */
2854     public static final int RB = JavadocParser.RULE_rb + RULE_TYPES_OFFSET;
2855     /** `rb` tag start. */
2856     public static final int RB_TAG_START =
2857             JavadocParser.RULE_rbTagStart + RULE_TYPES_OFFSET;
2858     /** `rb` tag end. */
2859     public static final int RB_TAG_END =
2860             JavadocParser.RULE_rbTagEnd + RULE_TYPES_OFFSET;
2861 
2862     /** `rt` html tag. */
2863     public static final int RT = JavadocParser.RULE_rt + RULE_TYPES_OFFSET;
2864     /** `rt` tag start. */
2865     public static final int RT_TAG_START =
2866             JavadocParser.RULE_rtTagStart + RULE_TYPES_OFFSET;
2867     /** `rt` tag end. */
2868     public static final int RT_TAG_END =
2869             JavadocParser.RULE_rtTagEnd + RULE_TYPES_OFFSET;
2870 
2871     /** `rtc` html tag. */
2872     public static final int RTC = JavadocParser.RULE_rtc + RULE_TYPES_OFFSET;
2873     /** `rtc` tag start. */
2874     public static final int RTC_TAG_START =
2875             JavadocParser.RULE_rtcTagStart + RULE_TYPES_OFFSET;
2876     /** `rtc` tag end. */
2877     public static final int RTC_TAG_END =
2878             JavadocParser.RULE_rtcTagEnd + RULE_TYPES_OFFSET;
2879 
2880     /** `rp` html tag. */
2881     public static final int RP = JavadocParser.RULE_rp + RULE_TYPES_OFFSET;
2882     /** `rp` tag start. */
2883     public static final int RP_TAG_START =
2884             JavadocParser.RULE_rpTagStart + RULE_TYPES_OFFSET;
2885     /** `rp` tag end. */
2886     public static final int RP_TAG_END =
2887             JavadocParser.RULE_rpTagEnd + RULE_TYPES_OFFSET;
2888 
2889     /////////////////////// SINGLETON HTML TAGS  //////////////////////////////////////////////////
2890     /**
2891      * Parent node for all singleton html tags.
2892      */
2893     public static final int SINGLETON_ELEMENT = JavadocParser.RULE_singletonElement
2894             + RULE_TYPES_OFFSET;
2895 
2896     /**
2897      * Represents an empty (self-closing) HTML tag in Javadoc comments,
2898      * such as {@code <justsometag />}.
2899      *
2900      * <p><b>Example:</b></p>
2901      * <pre>{@code <justsometag />}</pre>
2902      *
2903      * <p><b>AST Tree:</b></p>
2904      * <pre>{@code
2905      * --HTML_ELEMENT -> HTML_ELEMENT
2906      *   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2907      *     `--EMPTY_TAG -> EMPTY_TAG
2908      *       |--START -> <
2909      *       |--HTML_TAG_NAME -> justsometag
2910      *       |--WS
2911      *       `--SLASH_END -> >
2912      * }</pre>
2913      */
2914     public static final int EMPTY_TAG =
2915         JavadocParser.RULE_emptyTag + RULE_TYPES_OFFSET;
2916 
2917     /**
2918      * Area html tag.
2919      *
2920      * <p><b>Example:</b></p>
2921      * <pre>{@code < area shape="rect" >}</pre>
2922      * <b>Tree:</b>
2923      * <pre>
2924      * {@code
2925      *   JAVADOC -> JAVADOC
2926      *        |--NEWLINE -> \n
2927      *        |--LEADING_ASTERISK ->  *
2928      *        |--TEXT ->
2929      *        |--HTML_ELEMENT -> HTML_ELEMENT
2930      *        |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2931      *        |       `--AREA_TAG -> AREA_TAG
2932      *        |           |--START -> <
2933      *        |           |--AREA_HTML_TAG_NAME -> area
2934      *        |           |--WS ->
2935      *        |           |--ATTRIBUTE -> ATTRIBUTE
2936      *        |           |   |--HTML_TAG_NAME -> shape
2937      *        |           |   |--EQUALS -> =
2938      *        |           |   `--ATTR_VALUE -> "rect"
2939      *        |           `--END -> >
2940      *        |--TEXT ->
2941      *        |--NEWLINE -> \n
2942      *        |--TEXT ->
2943      * }
2944      * </pre>
2945      */
2946     public static final int AREA_TAG = JavadocParser.RULE_areaTag + RULE_TYPES_OFFSET;
2947 
2948     /** Base html tag. */
2949     public static final int BASE_TAG = JavadocParser.RULE_baseTag + RULE_TYPES_OFFSET;
2950 
2951     /** Basefont html tag. */
2952     public static final int BASEFONT_TAG = JavadocParser.RULE_basefontTag + RULE_TYPES_OFFSET;
2953 
2954     /**
2955      * Br html tag.
2956      *
2957      * <p><b>Example:</b></p>
2958      * <pre>{@code <br> line breaks<br/>}</pre>
2959      * <b>Tree:</b>
2960      * <pre>
2961      * {@code
2962      * JAVADOC -> JAVADOC
2963      * |--NEWLINE -> \r\n
2964      * |--LEADING_ASTERISK ->  *
2965      * |--TEXT ->
2966      * |--HTML_ELEMENT -> HTML_ELEMENT
2967      * |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2968      * |       `--BR_TAG -> BR_TAG
2969      * |           |--START -> <
2970      * |           |--BR_HTML_TAG_NAME -> br
2971      * |           `--END -> >
2972      * |--TEXT ->  line breaks
2973      * |--HTML_ELEMENT -> HTML_ELEMENT
2974      * |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2975      * |       `--BR_TAG -> BR_TAG
2976      * |           |--START -> <
2977      * |           |--BR_HTML_TAG_NAME -> br
2978      * |           `--SLASH_END -> />
2979      * }
2980      * </pre>
2981      */
2982     public static final int BR_TAG = JavadocParser.RULE_brTag + RULE_TYPES_OFFSET;
2983 
2984     /** Col html tag. */
2985     public static final int COL_TAG = JavadocParser.RULE_colTag + RULE_TYPES_OFFSET;
2986 
2987     /**
2988      * Frame html tag.
2989      *
2990      * <p><b>Example:</b></p>
2991      * <pre>
2992      * &lt;frameset cols="50%,50%"&gt;
2993      * &lt;frame src="page1.html"&gt;
2994      * &lt;/frameset&gt;
2995      * </pre>
2996      * <b>Tree:</b>
2997      * <pre>
2998      * {@code
2999      * HTML_ELEMENT -> HTML_ELEMENT
3000      *  `--HTML_TAG -> HTML_TAG
3001      *     |--HTML_ELEMENT_START -> HTML_ELEMENT_START
3002      *     |   |--START -> <
3003      *     |   |--HTML_TAG_NAME -> frameset
3004      *     |   |--WS ->
3005      *     |   |--ATTRIBUTE -> ATTRIBUTE
3006      *     |   |   |--HTML_TAG_NAME -> cols
3007      *     |   |   |--EQUALS -> =
3008      *     |   |   `--ATTR_VALUE -> "50%,50%"
3009      *     |   `--END -> >
3010      *     |--NEWLINE -> \r\n
3011      *     |--LEADING_ASTERISK ->  *
3012      *     |--TEXT ->
3013      *     |--HTML_ELEMENT -> HTML_ELEMENT
3014      *     |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
3015      *     |       `--FRAME_TAG -> FRAME_TAG
3016      *     |           |--START -> <
3017      *     |           |--FRAME_HTML_TAG_NAME -> frame
3018      *     |           |--WS ->
3019      *     |           |--ATTRIBUTE -> ATTRIBUTE
3020      *     |           |   |--HTML_TAG_NAME -> src
3021      *     |           |   |--EQUALS -> =
3022      *     |           |   `--ATTR_VALUE -> "page1.html"
3023      *     |           `--END -> >
3024      *     |--NEWLINE -> \r\n
3025      *     |--LEADING_ASTERISK ->  *
3026      *     |--TEXT ->
3027      *     `--HTML_ELEMENT_END -> HTML_ELEMENT_END
3028      *         |--START -> <
3029      *         |--SLASH -> /
3030      *         |--HTML_TAG_NAME -> frameset
3031      *         `--END -> >
3032      * }
3033      * </pre>
3034      */
3035     public static final int FRAME_TAG = JavadocParser.RULE_frameTag + RULE_TYPES_OFFSET;
3036 
3037     /**
3038      * Hr html tag.
3039      *
3040      * <p><b>Example:</b></p>
3041      * <pre>{@code text above line<hr> test after line}</pre>
3042      * <b>Tree:</b>
3043      * <pre>
3044      * {@code
3045      *   |--LEADING_ASTERISK ->  *
3046      *   |--TEXT ->  text above line
3047      *   |--HTML_ELEMENT -> HTML_ELEMENT
3048      *   |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
3049      *   |       `--HR_TAG -> HR_TAG
3050      *   |           |--START -> <
3051      *   |           |--HR_HTML_TAG_NAME -> hr
3052      *   |           `--END -> >
3053      *   |--TEXT ->  test after line
3054      *   |--NEWLINE -> \r\n
3055      *   |--TEXT ->
3056      * }
3057      * </pre>
3058      */
3059     public static final int HR_TAG = JavadocParser.RULE_hrTag + RULE_TYPES_OFFSET;
3060 
3061     /**
3062      * Img html tag.
3063      *
3064      * <p><b>Example:</b></p>
3065      * <pre>{@code <img src="./image.png" alt="image description" width="200" height="100"> }</pre>
3066      * <b>Tree:</b>
3067      * <pre>
3068      * {@code
3069      *   `--JAVADOC -> JAVADOC
3070      *        |--NEWLINE -> \r\n
3071      *        |--LEADING_ASTERISK ->  *
3072      *        |--TEXT ->
3073      *        |--HTML_ELEMENT -> HTML_ELEMENT
3074      *        |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
3075      *        |       `--IMG_TAG -> IMG_TAG
3076      *        |           |--START -> <
3077      *        |           |--IMG_HTML_TAG_NAME -> img
3078      *        |           |--WS ->
3079      *        |           |--ATTRIBUTE -> ATTRIBUTE
3080      *        |           |   |--HTML_TAG_NAME -> src
3081      *        |           |   |--EQUALS -> =
3082      *        |           |   `--ATTR_VALUE -> "./image.png"
3083      *        |           |--WS ->
3084      *        |           |--ATTRIBUTE -> ATTRIBUTE
3085      *        |           |   |--HTML_TAG_NAME -> alt
3086      *        |           |   |--EQUALS -> =
3087      *        |           |   `--ATTR_VALUE -> "image description"
3088      *        |           |--WS ->
3089      *        |           |--ATTRIBUTE -> ATTRIBUTE
3090      *        |           |   |--HTML_TAG_NAME -> width
3091      *        |           |   |--EQUALS -> =
3092      *        |           |   `--ATTR_VALUE -> "200"
3093      *        |           |--WS ->
3094      *        |           |--ATTRIBUTE -> ATTRIBUTE
3095      *        |           |   |--HTML_TAG_NAME -> height
3096      *        |           |   |--EQUALS -> =
3097      *        |           |   `--ATTR_VALUE -> "100"
3098      *        |           `--END -> >
3099      *        |--NEWLINE -> \r\n
3100      *        |--TEXT ->
3101      * }
3102      * </pre>
3103      */
3104     public static final int IMG_TAG = JavadocParser.RULE_imgTag + RULE_TYPES_OFFSET;
3105 
3106     /**
3107      * Input html tag.
3108      *
3109      * <p><b>Example:</b></p>
3110      * <pre>{@code Type here: <input type="text" id="id" name="name"> }</pre>
3111      * <b>Tree:</b>
3112      * <pre>
3113      * {@code
3114      *   JAVADOC -> JAVADOC
3115      *        |--NEWLINE -> \r\n
3116      *        |--LEADING_ASTERISK ->  *
3117      *        |--TEXT ->   Type here:
3118      *        |--HTML_ELEMENT -> HTML_ELEMENT
3119      *        |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
3120      *        |       `--INPUT_TAG -> INPUT_TAG
3121      *        |           |--START -> <
3122      *        |           |--INPUT_HTML_TAG_NAME -> input
3123      *        |           |--WS ->
3124      *        |           |--ATTRIBUTE -> ATTRIBUTE
3125      *        |           |   |--HTML_TAG_NAME -> type
3126      *        |           |   |--EQUALS -> =
3127      *        |           |   `--ATTR_VALUE -> "text"
3128      *        |           |--WS ->
3129      *        |           |--ATTRIBUTE -> ATTRIBUTE
3130      *        |           |   |--HTML_TAG_NAME -> id
3131      *        |           |   |--EQUALS -> =
3132      *        |           |   `--ATTR_VALUE -> "id"
3133      *        |           |--WS ->
3134      *        |           |--ATTRIBUTE -> ATTRIBUTE
3135      *        |           |   |--HTML_TAG_NAME -> name
3136      *        |           |   |--EQUALS -> =
3137      *        |           |   `--ATTR_VALUE -> "name"
3138      *        |           `--END -> >
3139      *        |--NEWLINE -> \r\n
3140      *        |--TEXT ->
3141      * }
3142      * </pre>
3143      */
3144     public static final int INPUT_TAG = JavadocParser.RULE_inputTag + RULE_TYPES_OFFSET;
3145 
3146     /**
3147      * Isindex tag name.
3148      *
3149      * <p><b>Example:</b></p>
3150      * <pre>
3151      * &lt;head&gt;
3152      *    &lt;isindex prompt="search"&gt;
3153      * &lt;/head&gt;
3154      * </pre>
3155      * <b>Tree:</b>
3156      * <pre>
3157      * {@code
3158      *   |--HTML_ELEMENT -> HTML_ELEMENT
3159      *   |   `--HEAD -> HEAD
3160      *   |       |--HEAD_TAG_START -> HEAD_TAG_START
3161      *   |       |   |--START -> <
3162      *   |       |   |--HEAD_HTML_TAG_NAME -> head
3163      *   |       |   `--END -> >
3164      *   |       |--NEWLINE -> \r\n
3165      *   |       |--LEADING_ASTERISK ->  *
3166      *   |       |--TEXT ->
3167      *   |       |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
3168      *   |       |   `--ISINDEX_TAG -> ISINDEX_TAG
3169      *   |       |       |--START -> <
3170      *   |       |       |--ISINDEX_HTML_TAG_NAME -> isindex
3171      *   |       |       |--WS ->
3172      *   |       |       |--ATTRIBUTE -> ATTRIBUTE
3173      *   |       |       |   |--HTML_TAG_NAME -> prompt
3174      *   |       |       |   |--EQUALS -> =
3175      *   |       |       |   `--ATTR_VALUE -> "search"
3176      *   |       |       `--END -> >
3177      *   |       |--NEWLINE -> \r\n
3178      *   |       |--LEADING_ASTERISK ->  *
3179      *   |       |--TEXT ->
3180      *   |       `--HEAD_TAG_END -> HEAD_TAG_END
3181      *   |           |--START -> <
3182      *   |           |--SLASH -> /
3183      *   |           |--HEAD_HTML_TAG_NAME -> head
3184      *   |           `--END -> >
3185      *   |--NEWLINE -> \r\n
3186      *   |--TEXT ->
3187      * }
3188      * </pre>
3189      */
3190     public static final int ISINDEX_TAG = JavadocParser.RULE_isindexTag + RULE_TYPES_OFFSET;
3191 
3192     /**
3193      * Link html tag.
3194      *
3195      * <p><b>Example:</b></p>
3196      * <pre>{@code <link rel="stylesheet" href="styles.css">}</pre>
3197      *
3198      * <b>Tree:</b>
3199      * <pre>
3200      * {@code
3201      * HTML_ELEMENT -> HTML_ELEMENT
3202      *     `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
3203      *      `--LINK_TAG -> LINK_TAG
3204      *          |--START -> <
3205      *          |--LINK_HTML_TAG_NAME -> link
3206      *          |--ATTRIBUTE -> ATTRIBUTE
3207      *          |   |--HTML_TAG_NAME -> rel
3208      *          |   |--EQUALS -> =
3209      *          |   `--ATTR_VALUE -> "stylesheet"
3210      *          |--ATTRIBUTE -> ATTRIBUTE
3211      *          |   |--HTML_TAG_NAME -> href
3212      *          |   |--EQUALS -> =
3213      *          |   `--ATTR_VALUE -> "styles.css"
3214      *          `--END -> >
3215      * }
3216      * </pre>
3217      */
3218     public static final int LINK_TAG = JavadocParser.RULE_linkTag + RULE_TYPES_OFFSET;
3219 
3220     /**
3221      * Meta html tag.
3222      *
3223      * <p><b>Example:</b></p>
3224      * <pre>{@code <meta charset="UTF-8"> }</pre>
3225      * <b>Tree:</b>
3226      * <pre>
3227      * {@code
3228      *   `--JAVADOC -> JAVADOC
3229      *        |--NEWLINE -> \r\n
3230      *        |--LEADING_ASTERISK ->  *
3231      *        |--TEXT ->
3232      *        |--HTML_ELEMENT -> HTML_ELEMENT
3233      *        |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
3234      *        |       `--META_TAG -> META_TAG
3235      *        |           |--START -> <
3236      *        |           |--META_HTML_TAG_NAME -> meta
3237      *        |           |--WS ->
3238      *        |           |--ATTRIBUTE -> ATTRIBUTE
3239      *        |           |   |--HTML_TAG_NAME -> charset
3240      *        |           |   |--EQUALS -> =
3241      *        |           |   `--ATTR_VALUE -> "UTF-8"
3242      *        |           `--END -> >
3243      *        |--NEWLINE -> \r\n
3244      *        |--TEXT ->
3245      * }
3246      * </pre>
3247      */
3248     public static final int META_TAG = JavadocParser.RULE_metaTag + RULE_TYPES_OFFSET;
3249 
3250     /** Param html tag. */
3251     public static final int PARAM_TAG = JavadocParser.RULE_paramTag + RULE_TYPES_OFFSET;
3252 
3253     /**
3254      * HTML void element.
3255      *
3256      * <p><b>Example:</b></p>
3257      * <pre>{@code
3258      * <embed src="URL" type="MIME_type">
3259      * }</pre>
3260      * <b>Tree:</b>
3261      * <pre>
3262      * {@code
3263      *    |--HTML_ELEMENT -> HTML_ELEMENT
3264      *    |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
3265      *    |       `--EMBED_TAG -> EMBED_TAG
3266      *    |           |--START -> <
3267      *    |           |--EMBED_HTML_TAG_NAME -> embed
3268      *    |           |--WS ->
3269      *    |           |--ATTRIBUTE -> ATTRIBUTE
3270      *    |           |   |--HTML_TAG_NAME -> src
3271      *    |           |   |--EQUALS -> =
3272      *    |           |   `--ATTR_VALUE -> "URL"
3273      *    |           |--WS ->
3274      *    |           |--ATTRIBUTE -> ATTRIBUTE
3275      *    |           |   |--HTML_TAG_NAME -> type
3276      *    |           |   |--EQUALS -> =
3277      *    |           |   `--ATTR_VALUE -> "MIME_type"
3278      *    |           `--END -> >
3279      *    |--NEWLINE -> \r\n
3280      *    |--TEXT ->
3281      * }
3282      * </pre>
3283      *
3284      * @see #EMBED_TAG
3285      * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-embed">
3286      *     W3 docs</a>
3287      */
3288     public static final int EMBED_TAG = JavadocParser.RULE_embedTag + RULE_TYPES_OFFSET;
3289 
3290     /**
3291      * HTML void element {@code <keygen>}.
3292      *
3293      * @see #SINGLETON_ELEMENT
3294      * @see <a href="https://www.w3.org/TR/html51/sec-forms.html#elementdef-keygen">
3295      *     W3 docs</a>
3296      */
3297     public static final int KEYGEN_TAG = JavadocParser.RULE_keygenTag + RULE_TYPES_OFFSET;
3298 
3299     /**
3300      * HTML void element {@code <source>}.
3301      *
3302      * @see #SINGLETON_ELEMENT
3303      * @see <a href=
3304      *     "https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-media-source">
3305      *     W3 docs</a>
3306      */
3307     public static final int SOURCE_TAG = JavadocParser.RULE_sourceTag + RULE_TYPES_OFFSET;
3308 
3309     /**
3310      * HTML void element {@code <track>}.
3311      *
3312      * <p><b>Example:</b></p>
3313      * <pre>{@code
3314      * <track kind="subtitles" src="subtitles_en.file" />
3315      * }</pre>
3316      * <b>Tree:</b>
3317      * <pre>
3318      * {@code
3319      *    |--HTML_ELEMENT -> HTML_ELEMENT
3320      *    |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
3321      *    |       `--TRACK_TAG -> TRACK_TAG
3322      *    |           |--START -> <
3323      *    |           |--TRACK_HTML_TAG_NAME -> track
3324      *    |           |--WS ->
3325      *    |           |--ATTRIBUTE -> ATTRIBUTE
3326      *    |           |   |--HTML_TAG_NAME -> kind
3327      *    |           |   |--EQUALS -> =
3328      *    |           |   `--ATTR_VALUE -> "subtitles"
3329      *    |           |--WS ->
3330      *    |           |--ATTRIBUTE -> ATTRIBUTE
3331      *    |           |   |--HTML_TAG_NAME -> src
3332      *    |           |   |--EQUALS -> =
3333      *    |           |   `--ATTR_VALUE -> "subtitles_en.file"
3334      *    |           `--END -> />
3335      *    |--NEWLINE -> \r\n
3336      *    |--TEXT ->
3337      * }
3338      * </pre>
3339      *
3340      * @see #TRACK_TAG
3341      * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-track">
3342      *     W3 docs</a>
3343      */
3344     public static final int TRACK_TAG = JavadocParser.RULE_trackTag + RULE_TYPES_OFFSET;
3345 
3346     /**
3347      * HTML void element {@code <wbr>}.
3348      *
3349      * @see #SINGLETON_ELEMENT
3350      * @see <a href="https://www.w3.org/TR/html51/textlevel-semantics.html#elementdef-wbr">
3351      *     W3 docs</a>
3352      */
3353     public static final int WBR_TAG = JavadocParser.RULE_wbrTag + RULE_TYPES_OFFSET;
3354 
3355     ///////////////////////////////////////////////////////////////////////////////////////////////
3356 
3357     /**
3358      * Html comment: {@code <!-- --> }.
3359      */
3360     public static final int HTML_COMMENT = JavadocParser.RULE_htmlComment
3361             + RULE_TYPES_OFFSET;
3362     /**
3363      * CHAR and WS sequence.
3364      */
3365     public static final int TEXT = JavadocParser.RULE_text + RULE_TYPES_OFFSET;
3366 
3367     /** Empty private constructor of the current class. */
3368     private JavadocTokenTypes() {
3369     }
3370 
3371 }