001///////////////////////////////////////////////////////////////////////////////////////////////
002// checkstyle: Checks Java source code and other text files for adherence to a set of rules.
003// Copyright (C) 2001-2025 the original author or authors.
004//
005// This library is free software; you can redistribute it and/or
006// modify it under the terms of the GNU Lesser General Public
007// License as published by the Free Software Foundation; either
008// version 2.1 of the License, or (at your option) any later version.
009//
010// This library is distributed in the hope that it will be useful,
011// but WITHOUT ANY WARRANTY; without even the implied warranty of
012// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
013// Lesser General Public License for more details.
014//
015// You should have received a copy of the GNU Lesser General Public
016// License along with this library; if not, write to the Free Software
017// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
018///////////////////////////////////////////////////////////////////////////////////////////////
019
020package com.puppycrawl.tools.checkstyle.api;
021
022import com.puppycrawl.tools.checkstyle.grammar.javadoc.JavadocParser;
023
024/**
025 * Contains the constants for all the tokens contained in the Abstract
026 * Syntax Tree for the javadoc grammar.
027 *
028 * @see <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html">
029 *     javadoc - The Java API Documentation Generator</a>
030 */
031public final class JavadocTokenTypes {
032
033    // ------------------------------------------------------------------------------------------ //
034    // -----------------        JAVADOC TAGS          ------------------------------------------- //
035    // ------------------------------------------------------------------------------------------ //
036
037    /**
038     * '@return' literal in {@code @return} Javadoc tag.
039     *
040     * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
041     *
042     * <p><b>Example:</b></p>
043     * <pre>{@code @return true if file exists}</pre>
044     * <b>Tree:</b>
045     * <pre>{@code
046     * JAVADOC_TAG -> JAVADOC_TAG
047     *  |--RETURN_LITERAL -> @return
048     *  |--WS ->
049     *  `--DESCRIPTION -> DESCRIPTION
050     *      |--TEXT -> true if file exists
051     * }</pre>
052     *
053     * @see
054     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCDBGG">
055     *     Oracle Docs</a>
056     * @see #JAVADOC_TAG
057     */
058    public static final int RETURN_LITERAL = JavadocParser.RETURN_LITERAL;
059
060    /**
061     * '{@literal @}deprecated' literal in {@literal @}deprecated Javadoc tag.
062     *
063     * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
064     *
065     * <p><b>Example:</b></p>
066     * <pre>{@code @deprecated It is deprecated method}</pre>
067     * <b>Tree:</b>
068     * <pre>{@code
069     * JAVADOC_TAG -> JAVADOC_TAG
070     *  |--DEPRECATED_LITERAL -> @deprecated
071     *  |--WS ->
072     *  `--DESCRIPTION -> DESCRIPTION
073     *      |--TEXT -> It is deprecated method
074     * }</pre>
075     *
076     * @see
077     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#deprecated">
078     *     Oracle Docs</a>
079     * @see #JAVADOC_TAG
080     */
081    public static final int DEPRECATED_LITERAL = JavadocParser.DEPRECATED_LITERAL;
082
083    /**
084     * '@since' literal in {@code @since} Javadoc tag.
085     *
086     * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
087     *
088     * <p><b>Example:</b></p>
089     * <pre>{@code @since 3.4 RELEASE}</pre>
090     * <b>Tree:</b>
091     * <pre>{@code
092     * JAVADOC_TAG -> JAVADOC_TAG
093     *  |--SINCE_LITERAL -> @since
094     *  |--WS ->
095     *  `--DESCRIPTION -> DESCRIPTION
096     *      |--TEXT -> 3.4 RELEASE
097     * }</pre>
098     *
099     * @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>{&#64;code Comparable&lt;E&gt;}</code></pre>
376     * <b>Tree:</b>
377     * <pre>
378     * <code> JAVADOC_INLINE_TAG --&gt; JAVADOC_INLINE_TAG
379     *         |--JAVADOC_INLINE_TAG_START --&gt; {
380     *         |--CODE_LITERAL --&gt; @code
381     *         |--WS --&gt;
382     *         |--TEXT --&gt; Comparable&lt;E&gt;
383     *         `--JAVADOC_INLINE_TAG_END --&gt; }
384     * </code>
385     * </pre>
386     *
387     * @noinspection HtmlTagCanBeJavadocTag
388     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
389     *      replaced with Javadoc tag
390     */
391    public static final int JAVADOC_INLINE_TAG_START = JavadocParser.JAVADOC_INLINE_TAG_START;
392
393    /**
394     * Last child of {@link #JAVADOC_INLINE_TAG} that represents right curly brace '}'.
395     *
396     * <p><b>Example:</b></p>
397     * <pre><code>{&#64;code Comparable&lt;E&gt;}</code></pre>
398     * <b>Tree:</b>
399     * <pre>
400     * <code>JAVADOC_INLINE_TAG --&gt; JAVADOC_INLINE_TAG
401     *        |--JAVADOC_INLINE_TAG_START --&gt; {
402     *        |--CODE_LITERAL --&gt; @code
403     *        |--WS --&gt;
404     *        |--TEXT --&gt; Comparable&lt;E&gt;
405     *        `--JAVADOC_INLINE_TAG_END --&gt; }
406     *
407     * </code>
408     * </pre>
409     *
410     * @noinspection HtmlTagCanBeJavadocTag
411     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
412     *      replaced with Javadoc tag
413     */
414    public static final int JAVADOC_INLINE_TAG_END = JavadocParser.JAVADOC_INLINE_TAG_END;
415
416    /**
417     * '@code' literal in {&#64;code} Javadoc inline tag.
418     *
419     * <p>Such Javadoc inline tag can have such child nodes:</p>
420     * <ul>
421     * <li>{@link #NEWLINE}</li>
422     * <li>{@link #WS}</li>
423     * <li>{@link #TEXT}</li>
424     * </ul>
425     *
426     * <p><b>Example:</b></p>
427     * <pre><code>{&#64;code Comparable&lt;E&gt;}</code></pre>
428     * <b>Tree:</b>
429     * <pre>
430     * <code>JAVADOC_TAG -&gt; JAVADOC_TAG
431     *        |--CUSTOM_NAME -&gt; @code
432     *        |--WS -&gt;
433     *        `--DESCRIPTION -&gt; DESCRIPTION
434     *            |--TEXT -&gt; Comparable&lt;E&gt;
435     * </code>
436     * </pre>
437     *
438     * @see
439     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDFHHBB">
440     *     Oracle Docs</a>
441     * @see #JAVADOC_INLINE_TAG
442     * @noinspection HtmlTagCanBeJavadocTag
443     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
444     *      replaced with Javadoc tag
445     */
446    public static final int CODE_LITERAL = JavadocParser.CODE_LITERAL;
447
448    /**
449     * '@docRoot' literal in {&#64;docRoot} Javadoc inline tag.
450     *
451     * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p>
452     * <ul>
453     * <li>{@link #NEWLINE}</li>
454     * <li>{@link #WS}</li>
455     * </ul>
456     *
457     * <p><b>Example:</b></p>
458     * <pre><code>{&#64;docRoot}</code></pre>
459     * <b>Tree:</b>
460     * <pre>
461     * <code>
462     * |--JAVADOC_INLINE_TAG -&gt; JAVADOC_INLINE_TAG
463     *      |--JAVADOC_INLINE_TAG_START -&gt; {
464     *      |--DOC_ROOT_LITERAL -&gt; @docRoot
465     *      `--JAVADOC_INLINE_TAG_END -&gt; }
466     * </code>
467     * </pre>
468     *
469     * <pre><code>Example :{&#64;docRoot
470     * } in a Javadoc comment.
471     * </code></pre>
472     * <b>Tree:</b>
473     * <pre>
474     * <code>
475     *   |--JAVADOC_INLINE_TAG -&gt; JAVADOC_INLINE_TAG
476     *     |--JAVADOC_INLINE_TAG_START -&gt; {
477     *     |--DOC_ROOT_LITERAL -&gt; @docRoot
478     *     |--NEWLINE -&gt; \r\n
479     *     |--LEADING_ASTERISK -&gt;       *
480     *     |--WS -&gt;
481     *     `--JAVADOC_INLINE_TAG_END -&gt; }
482     * </code>
483     * </pre>
484     *
485     * @see
486     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDBACBF">
487     *     Oracle Docs</a>
488     * @see #JAVADOC_INLINE_TAG
489     * @noinspection HtmlTagCanBeJavadocTag
490     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
491     *      replaced with Javadoc tag
492     */
493    public static final int DOC_ROOT_LITERAL = JavadocParser.DOC_ROOT_LITERAL;
494
495    /**
496     * '@link' literal in {&#64;link} Javadoc inline tag.
497     *
498     * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p>
499     *
500     * <p><b>Example:</b></p>
501     *
502     * <pre><code>{&#64;link org.apache.utils.Lists.Comparator#compare(Object)}</code></pre>
503     *
504     * <p><b>Tree:</b></p>
505     *
506     * <pre>
507     * <code>
508     *   JAVADOC_INLINE_TAG -&gt; JAVADOC_INLINE_TAG
509     *    |--JAVADOC_INLINE_TAG_START -&gt; {
510     *    |--LINK_LITERAL -&gt; @link
511     *    |--WS -&gt;
512     *    |--REFERENCE -&gt; REFERENCE
513     *    |   |--PACKAGE_CLASS -&gt; org.apache.utils.Lists.Comparator
514     *    |   |--HASH -&gt; #
515     *    |   |--MEMBER -&gt; compare
516     *    |   `--PARAMETERS -&gt; PARAMETERS
517     *    |       |--LEFT_BRACE -&gt; (
518     *    |       |--ARGUMENT -&gt; Object
519     *    |       `--RIGHT_BRACE -&gt; )
520     *    `--JAVADOC_INLINE_TAG_END -&gt; }
521     * </code>
522     * </pre>
523     *
524     * @see
525     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDIECH">
526     *     Oracle Docs</a>
527     * @see #JAVADOC_INLINE_TAG
528     * @noinspection HtmlTagCanBeJavadocTag
529     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
530     *      replaced with Javadoc tag
531     */
532    public static final int LINK_LITERAL = JavadocParser.LINK_LITERAL;
533
534    /**
535     * '@inheritDoc' literal in {&#64;inheritDoc} Javadoc inline tag.
536     *
537     * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p>
538     * <ul>
539     * <li>{@link #NEWLINE}</li>
540     * <li>{@link #WS}</li>
541     * </ul>
542     *
543     * <p><b>Example:</b></p>
544     * <pre><code>{&#64;inheritDoc}</code></pre>
545     * <b>Tree:</b>
546     * <pre>{@code
547     *   JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
548     *    |--JAVADOC_INLINE_TAG_START -> {
549     *    |--INHERIT_DOC_LITERAL -> @inheritDoc
550     *    |--JAVADOC_INLINE_TAG_END -> }
551     * }</pre>
552     *
553     * @see
554     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGJCHC">
555     *     Oracle Docs</a>
556     * @see #JAVADOC_INLINE_TAG
557     * @noinspection HtmlTagCanBeJavadocTag
558     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
559     *      replaced with Javadoc tag
560     */
561    public static final int INHERIT_DOC_LITERAL = JavadocParser.INHERIT_DOC_LITERAL;
562
563    /**
564     * '@linkplain' literal in {&#64;linkplain} Javadoc inline tag.
565     *
566     * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p>
567     *
568     * <p><b>Example:</b></p>
569     * <pre><code>{&#64;linkplain org.apache.utils.Lists.Comparator#compare(Object) compare}</code>
570     * </pre>
571     * <b>Tree:</b>
572     * <pre>{@code
573     *   JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
574     *    |--JAVADOC_INLINE_TAG_START -> {
575     *    |--LINKPLAIN_LITERAL -> @linkplain
576     *    |--WS ->
577     *    |--REFERENCE -> org.apache.utils.Lists.Comparator#compare(Object)
578     *        |--PACKAGE_CLASS -> org.apache.utils
579     *        |--DOT -> .
580     *        |--CLASS -> Lists
581     *        |--DOT -> .
582     *        |--CLASS -> Comparator
583     *        |--HASH -> #
584     *        |--MEMBER -> compare
585     *        |--PARAMETERS -> (Object)
586     *            |--LEFT_BRACE -> (
587     *            |--ARGUMENT -> Object
588     *            |--RIGHT_BRACE -> )
589     *     |--DESCRIPTION -> compare
590     *         |--TEXT -> compare
591     *     |--JAVADOC_INLINE_TAG_END -> }
592     * }</pre>
593     *
594     * @see
595     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGBICD">
596     *     Oracle Docs</a>
597     * @see #JAVADOC_INLINE_TAG
598     * @noinspection HtmlTagCanBeJavadocTag
599     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
600     *      replaced with Javadoc tag
601     */
602    public static final int LINKPLAIN_LITERAL = JavadocParser.LINKPLAIN_LITERAL;
603
604    /**
605     * '@literal' literal in {&#64;literal} Javadoc inline tag.
606     *
607     * <p>Such Javadoc inline tag can have such child nodes:</p>
608     * <ul>
609     * <li>{@link #NEWLINE}</li>
610     * <li>{@link #WS}</li>
611     * <li>{@link #TEXT}</li>
612     * </ul>
613     *
614     * <p><b>Example:</b></p>
615     * <pre><code>{&#64;literal #compare(Object)}</code></pre>
616     * <b>Tree:</b>
617     * <pre>
618     * <code>
619     *     |--JAVADOC_INLINE_TAG -&gt; JAVADOC_INLINE_TAG
620     *        |--JAVADOC_INLINE_TAG_START -&gt; {
621     *        |--LITERAL_LITERAL -&gt; @literal
622     *        |--WS -&gt;
623     *        |--TEXT -&gt; #compare(Object)
624     *        `--JAVADOC_INLINE_TAG_END -&gt; }
625     * </code>
626     * </pre>
627     *
628     * @see
629     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCFJDG">
630     *     Oracle Docs</a>
631     * @see #JAVADOC_INLINE_TAG
632     * @noinspection HtmlTagCanBeJavadocTag
633     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
634     *      replaced with Javadoc tag
635     */
636    public static final int LITERAL_LITERAL = JavadocParser.LITERAL_LITERAL;
637
638    /**
639     * '@value' literal in {&#64;value} Javadoc inline tag.
640     *
641     * <p>Such Javadoc inline tag has one argument {@link #REFERENCE}
642     * and can have such child nodes:</p>
643     * <ul>
644     * <li>{@link #NEWLINE}</li>
645     * <li>{@link #WS}</li>
646     * </ul>
647     *
648     * <p><b>Example:</b></p>
649     * <pre><code>{&#64;value Integer#MAX_VALUE}</code></pre>
650     * <b>Tree:</b>
651     * <pre>
652     * <code> JAVADOC_INLINE_TAG --&gt; JAVADOC_INLINE_TAG
653     *         |--JAVADOC_INLINE_TAG_START --&gt; {
654     *         |--VALUE_LITERAL --&gt; @value
655     *         |--WS --&gt;
656     *         |--REFERENCE --&gt; REFERENCE
657     *         |   |--PACKAGE_CLASS --&gt; Integer
658     *         |   |--HASH --&gt; #
659     *         |   `--MEMBER --&gt; MAX_VALUE
660     *         `--JAVADOC_INLINE_TAG_END --&gt; }
661     * </code>
662     * </pre>
663     *
664     * @see
665     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDCDHH">
666     *     Oracle Docs</a>
667     * @see #JAVADOC_INLINE_TAG
668     * @noinspection HtmlTagCanBeJavadocTag
669     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
670     *      replaced with Javadoc tag
671     */
672    public static final int VALUE_LITERAL = JavadocParser.VALUE_LITERAL;
673
674    /**
675     * PACKAGE_CLASS represents the package or class which has been referenced in the `@see`,
676     * `@link`, `@linkplain` or `@value` javadoc tags. In the javadoc tree it shall be a child
677     * of {@link #REFERENCE}.
678     * <br>
679     * <strong>IMPORTANT:</strong> Constructs like
680     * {@code package.Class.NestedClassAtDepth1.NestedClassAtDepth2#member} are recognized by
681     * the javadoc tool from oracle, and no assumptions like, package names wouldn't consist of
682     * uppercase characters or class names begin with an uppercase character, are made.
683     * Also, <i>the reference</i> in a javadoc tag can consist just a package name or a
684     * simple class name or even a full class name. Thus, PACKAGE_CLASS can represent a
685     * package name or a simple class name or a full class name i.e. checkstyle doesn't
686     * resolve references at present.
687     *
688     * <p><b>Example:</b></p>
689     * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
690     * <b>Tree:</b>
691     * <pre>
692     * {@code
693     * JAVADOC_TAG -&gt JAVADOC_TAG
694     *  |--SEE_LITERAL -&gt @see
695     *  |--WS -&gt
696     *  |--REFERENCE -&gt REFERENCE
697     *  |   |--PACKAGE_CLASS -&gt org.apache.utils.Lists.Comparator
698     *  |   |--HASH -&gt #
699     *  |   |--MEMBER -&gt compare
700     *  |   `--PARAMETERS -&gt PARAMETERS
701     *  |       |--LEFT_BRACE -&gt (
702     *  |       |--ARGUMENT -&gt Object
703     *  |       `--RIGHT_BRACE -&gt )
704     *  |--NEWLINE -&gt \r\n
705     *  `--WS -&gt
706     * }
707     * </pre>
708     */
709    public static final int PACKAGE_CLASS = JavadocParser.PACKAGE_CLASS;
710
711    /**
712     * Hash character in {@link #REFERENCE}.
713     * Hash character is used before specifying a class member.
714     *
715     * <p><b>Example:</b></p>
716     * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
717     * <b>Tree:</b>
718     * <pre>
719     * {@code
720     * JAVADOC_TAG -&gt JAVADOC_TAG
721     *  |--SEE_LITERAL -&gt @see
722     *  |--WS -&gt
723     *  |--REFERENCE -&gt REFERENCE
724     *      |--PACKAGE_CLASS -&gt org.apache.utils.Lists.Comparator
725     *      |--HASH -&gt #
726     *      |--MEMBER -&gt compare
727     *      `--PARAMETERS -&gt PARAMETERS
728     *          |--LEFT_BRACE -&gt (
729     *          |--ARGUMENT -&gt Object
730     *          `--RIGHT_BRACE -&gt )
731     * }
732     * </pre>
733     */
734    public static final int HASH = JavadocParser.HASH;
735
736    /**
737     * A class member in {@link #REFERENCE}.
738     * Class member is specified after {@link #HASH} symbol.
739     *
740     * <p><b>Example:</b></p>
741     * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
742     * <b>Tree:</b>
743     * <pre>
744     * {@code
745     * JAVADOC_TAG -> JAVADOC_TAG
746     *  |--SEE_LITERAL -> @see
747     *  |--WS ->
748     *  |--REFERENCE -> REFERENCE
749     *      |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator
750     *      |--HASH -> #
751     *      |--MEMBER -> compare
752     *      `--PARAMETERS -> PARAMETERS
753     *          |--LEFT_BRACE -> (
754     *          |--ARGUMENT -> Object
755     *          `--RIGHT_BRACE -> )
756     * }
757     * </pre>
758     */
759    public static final int MEMBER = JavadocParser.MEMBER;
760
761    /**
762     * Left brace in {@link #PARAMETERS} part of {@link #REFERENCE}.
763     *
764     * <p><b>Example:</b></p>
765     * <pre>{@code @see #method(Processor, String)}</pre>
766     * <b>Tree:</b>
767     * <pre>
768     * {@code JAVADOC_TAG -&gt JAVADOC_TAG
769     *         |--SEE_LITERAL -&gt @see
770     *         |--WS -&gt
771     *         |--REFERENCE -&gt REFERENCE
772     *         |   |--HASH -&gt #
773     *         |   |--MEMBER -&gt method
774     *         |   `--PARAMETERS -&gt PARAMETERS
775     *         |       |--LEFT_BRACE -&gt (
776     *         |       |--ARGUMENT -&gt Processor
777     *         |       |--COMMA -&gt ,
778     *         |       |--WS -&gt
779     *         |       |--ARGUMENT -&gt String
780     *         |       `--RIGHT_BRACE -&gt )
781     * }
782     * </pre>
783     */
784    public static final int LEFT_BRACE = JavadocParser.LEFT_BRACE;
785
786    /**
787     * Right brace in {@link #PARAMETERS} part of {@link #REFERENCE}.
788     *
789     * <p><b>Example:</b></p>
790     * <pre>{@code @see #method(Processor, String)}</pre>
791     * <b>Tree:</b>
792     * <pre>
793     * {@code JAVADOC_TAG -&gt JAVADOC_TAG
794     *         |--SEE_LITERAL -&gt @see
795     *         |--WS -&gt
796     *         |--REFERENCE -&gt REFERENCE
797     *         |   |--HASH -&gt #
798     *         |   |--MEMBER -&gt method
799     *         |   `--PARAMETERS -&gt PARAMETERS
800     *         |       |--LEFT_BRACE -&gt (
801     *         |       |--ARGUMENT -&gt Processor
802     *         |       |--COMMA -&gt ,
803     *         |       |--WS -&gt
804     *         |       |--ARGUMENT -&gt String
805     *         |       `--RIGHT_BRACE -&gt )
806     * }
807     * </pre>
808     */
809    public static final int RIGHT_BRACE = JavadocParser.RIGHT_BRACE;
810
811    /**
812     * Argument definition in {@link #PARAMETERS} part of {@link #REFERENCE}.
813     *
814     * <p><b>Example:</b></p>
815     * <pre>{@code @see #method(Processor, String)}</pre>
816     * <b>Tree:</b>
817     * <pre>
818     * {@code JAVADOC_TAG -&gt JAVADOC_TAG
819     *         |--SEE_LITERAL -&gt @see
820     *         |--WS -&gt
821     *         |--REFERENCE -&gt REFERENCE
822     *         |   |--HASH -&gt #
823     *         |   |--MEMBER -&gt method
824     *         |   `--PARAMETERS -&gt PARAMETERS
825     *         |       |--LEFT_BRACE -&gt (
826     *         |       |--ARGUMENT -&gt Processor
827     *         |       |--COMMA -&gt ,
828     *         |       |--WS -&gt
829     *         |       |--ARGUMENT -&gt String
830     *         |       `--RIGHT_BRACE -&gt )
831     *         `--NEWLINE -&gt \n
832     * }
833     * </pre>
834     */
835    public static final int ARGUMENT = JavadocParser.ARGUMENT;
836
837    /**
838     * Comma separator between parameters in {@link #PARAMETERS} part of {@link #REFERENCE}.
839     *
840     * <p><b>Example:</b></p>
841     * <pre>{@code @see #method(Processor, String)}</pre>
842     * <b>Tree:</b>
843     * <pre>
844     * {@code
845     * JAVADOC_TAG -&gt JAVADOC_TAG
846     *  |--SEE_LITERAL -&gt @see
847     *  |--WS -&gt
848     *  |--REFERENCE -&gt REFERENCE
849     *  |   |--HASH -&gt #
850     *  |   |--MEMBER -&gt method
851     *  |   `--PARAMETERS -&gt PARAMETERS
852     *  |       |--LEFT_BRACE -&gt (
853     *  |       |--ARGUMENT -&gt Processor
854     *  |       |--COMMA -&gt ,
855     *  |       |--WS -&gt
856     *  |       |--ARGUMENT -&gt String
857     *  |       `--RIGHT_BRACE -&gt )
858     *  |--NEWLINE -&gt \r\n
859     *  `--WS -&gt
860     * }
861     * </pre>
862     *
863     * @see #PARAMETERS
864     * @see #REFERENCE
865     * @see #ARGUMENT
866     */
867    public static final int COMMA = JavadocParser.COMMA;
868
869    /**
870     * Quoted text.
871     * One of possible {@code @see} tag arguments.
872     *
873     * <p><b>Example:</b></p>
874     * <pre>{@code @see "Spring Framework"}</pre>
875     * <b>Tree:</b>
876     * <pre>
877     * {@code
878     * JAVADOC_TAG -> JAVADOC_TAG
879     *  |--SEE_LITERAL -> @see
880     *  |--WS ->
881     *  |--STRING -> "Spring Framework"
882     *  |--NEWLINE -> \r\n
883     *  `--WS ->
884     * }
885     * </pre>
886     *
887     * @see #SEE_LITERAL
888     */
889    public static final int STRING = JavadocParser.STRING;
890
891    /**
892     * Exception class name. First argument in {@link #THROWS_LITERAL @throws} and
893     * {@link #EXCEPTION_LITERAL @exception} Javadoc tags.
894     *
895     * <p><b>Example:</b></p>
896     * <pre>{@code @throws IOException connection problems}</pre>
897     * <b>Tree:</b>
898     * <pre>
899     * {@code
900     * JAVADOC_TAG -> JAVADOC_TAG
901     *  |--THROWS_LITERAL -> @throws
902     *  |--WS ->
903     *  |--CLASS_NAME -> IOException
904     *  |--WS ->
905     *  `--DESCRIPTION -> DESCRIPTION
906     *      |--TEXT -> connection problems
907     *      |--NEWLINE -> \r\n
908     *      `--TEXT ->
909     * }
910     * </pre>
911     *
912     * @see #EXCEPTION_LITERAL
913     * @see #THROWS_LITERAL
914     */
915    public static final int CLASS_NAME = JavadocParser.CLASS_NAME;
916
917    /**
918     * First argument in {@link #PARAM_LITERAL @param} Javadoc tag.
919     *
920     * <p><b>Example:</b></p>
921     * <pre>{@code @param T The bar.}</pre>
922     * <b>Tree:</b>
923     * <pre>
924     * {@code
925     *   --JAVADOC_TAG -> JAVADOC_TAG
926     *      |--PARAM_LITERAL -> @param
927     *      |--WS ->
928     *      |--PARAMETER_NAME -> T
929     *      |--WS ->
930     *      `--DESCRIPTION -> DESCRIPTION
931     *          |--TEXT -> The bar.
932     *          |--NEWLINE -> \r\n
933     *          `--TEXT ->
934     * }
935     * </pre>
936     *
937     * @see
938     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHJECF">
939     *     Oracle Docs</a>
940     * @see #PARAM_LITERAL
941     */
942    public static final int PARAMETER_NAME = JavadocParser.PARAMETER_NAME;
943
944    /**
945     * 'exclude' literal.
946     * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments.
947     *
948     * <p><b>Example:</b></p>
949     * <pre>{@code @serial exclude}</pre>
950     * <b>Tree:</b>
951     * <pre>
952     * {@code
953     *   JAVADOC_TAG -> JAVADOC_TAG
954     *    |--SERIAL_LITERAL -> @serial
955     *    |--WS ->
956     *    `--DESCRIPTION -> DESCRIPTION
957     *        |--TEXT -> serialized company name
958     *        |--NEWLINE -> \r\n
959     *        `--TEXT ->
960     * }
961     * </pre>
962     *
963     * @see
964     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
965     *     Oracle Docs</a>
966     * @see #SERIAL_LITERAL
967     */
968    public static final int LITERAL_EXCLUDE = JavadocParser.LITERAL_EXCLUDE;
969
970    /**
971     * 'include' literal.
972     * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments.
973     *
974     * <p><b>Example:</b></p>
975     * <pre>{@code @serial include}</pre>
976     * <b>Tree:</b>
977     * <pre>
978     * {@code
979     * JAVADOC_TAG -> JAVADOC_TAG
980     *  |--SERIAL_LITERAL -> @serial
981     *  |--WS ->
982     *  |--LITERAL_INCLUDE -> include
983     *  |--NEWLINE -> \r\n
984     *  `--WS ->
985     * }
986     * </pre>
987     *
988     * @see
989     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
990     *     Oracle Docs</a>
991     * @see #SERIAL_LITERAL
992     */
993    public static final int LITERAL_INCLUDE = JavadocParser.LITERAL_INCLUDE;
994
995    /**
996     * Field name. First argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag.
997     *
998     * <p><b>Example:</b></p>
999     * <pre>{@code @serialField counter Integer objects counter}</pre>
1000     * <b>Tree:</b>
1001     * <pre>
1002     * {@code
1003     *   --JAVADOC_TAG -> JAVADOC_TAG
1004     *   |--SERIAL_FIELD_LITERAL -> @serialField
1005     *   |--WS ->
1006     *   |--LITERAL_INCLUDE -> include
1007     *   |--NEWLINE -> \r\n
1008     *   `--WS ->
1009     *    `--DESCRIPTION -> DESCRIPTION
1010     *        |--TEXT -> objects counter
1011     *        |--NEWLINE -> \r\n
1012     *        `--TEXT ->
1013     * }</pre>
1014     *
1015     * @see
1016     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
1017     *     Oracle Docs</a>
1018     * @see #SERIAL_FIELD_LITERAL
1019     */
1020    public static final int FIELD_NAME = JavadocParser.FIELD_NAME;
1021
1022    /**
1023     * Field type. Second argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag.
1024     *
1025     * <p><b>Example:</b></p>
1026     * <pre>{@code @serialField counter Integer objects counter}</pre>
1027     * <b>Tree:</b>
1028     * <pre>
1029     * {@code
1030     *   --JAVADOC_TAG -> JAVADOC_TAG
1031     *      |--SERIAL_FIELD_LITERAL -> @serialField
1032     *      |--WS ->
1033     *      |--FIELD_NAME -> counter
1034     *      |--WS ->
1035     *      |--FIELD_TYPE -> Integer
1036     *      |--WS ->
1037     *      `--DESCRIPTION -> DESCRIPTION
1038     *          |--TEXT -> objects counter
1039     *          |--NEWLINE -> \r\n
1040     *          `--TEXT ->
1041     * }
1042     * </pre>
1043     *
1044     * @see
1045     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
1046     *     Oracle Docs</a>
1047     * @see #SERIAL_FIELD_LITERAL
1048     */
1049    public static final int FIELD_TYPE = JavadocParser.FIELD_TYPE;
1050
1051    // ------------------------------------------------------------------------------------------ //
1052    // -----------------        HTML TAGS          ---------------------------------------------- //
1053    // ------------------------------------------------------------------------------------------ //
1054
1055    /**
1056     * Identifier inside HTML tag: tag name or attribute name.
1057     */
1058    public static final int HTML_TAG_NAME = JavadocParser.HTML_TAG_NAME;
1059
1060    // HTML tag components
1061
1062    /**
1063     * Start html tag component: {@code '<'}.
1064     */
1065    public static final int START = JavadocParser.START;
1066
1067    /**
1068     * Slash html tag component: {@code '/'}.
1069     */
1070    public static final int SLASH = JavadocParser.SLASH;
1071
1072    /**
1073     * End html tag component: {@code '>'}.
1074     */
1075    public static final int END = JavadocParser.END;
1076
1077    /**
1078     * Slash close html tag component: {@code '/>'}.
1079     */
1080    public static final int SLASH_END = JavadocParser.SLASH_END;
1081
1082    /**
1083     * Equals html tag component: {@code '='}.
1084     */
1085    public static final int EQUALS = JavadocParser.EQUALS;
1086
1087    /**
1088     * Attribute value HTML tag component.
1089     *
1090     * <p><b>Example:</b></p>
1091     *
1092     * <pre>{@code
1093     * &lt;tag_name attr_name="attr_value">Content&lt;/tag_name&gt;
1094     * }</pre>
1095     *
1096     * <p><b>Tree:</b></p>
1097     * <pre>{@code
1098     * JAVADOC -> JAVADOC
1099     *  |--NEWLINE -> \r\n
1100     *  |--LEADING_ASTERISK ->  *
1101     *  |--TEXT ->
1102     *  |--HTML_ELEMENT -> HTML_ELEMENT
1103     *  |   `--HTML_TAG -> HTML_TAG
1104     *  |       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
1105     *  |       |   |--START -> <
1106     *  |       |   |--HTML_TAG_NAME -> tag_name
1107     *  |       |   |--WS ->
1108     *  |       |   |--ATTRIBUTE -> ATTRIBUTE
1109     *  |       |   |   |--HTML_TAG_NAME -> attr_name
1110     *  |       |   |   |--EQUALS -> =
1111     *  |       |   |   `--ATTR_VALUE -> "attr_value"
1112     *  |       |   `--END -> >
1113     *  |       |--TEXT -> Content
1114     *  |       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
1115     *  |           |--START -> <
1116     *  |           |--SLASH -> /
1117     *  |           |--HTML_TAG_NAME -> tag_name
1118     *  |           `--END -> >
1119     * }</pre>
1120     */
1121    public static final int ATTR_VALUE = JavadocParser.ATTR_VALUE;
1122
1123    /////////////////////// HTML TAGS WITH OPTIONAL END TAG /////////////////////////////////////
1124
1125    /**
1126     * Paragraph tag name.
1127     *
1128     * <p><b>Example:</b></p>
1129     * <pre>{@code <p>Paragraph Tag.</p>}</pre>
1130     * <b>Tree:</b>
1131     * <pre>
1132     * {@code
1133     *      `--HTML_ELEMENT -> HTML_ELEMENT
1134     *          `--PARAGRAPH -> PARAGRAPH
1135     *              |--P_TAG_START -> P_TAG_START
1136     *              |   |--START -> <
1137     *              |   |--P_HTML_TAG_NAME -> p
1138     *              |   `--END -> >
1139     *              |--TEXT -> Paragraph Tag.
1140     *              `--P_TAG_END -> P_TAG_END
1141     *                  |--START -> <
1142     *                  |--SLASH -> /
1143     *                  |--P_HTML_TAG_NAME -> p
1144     *                  `--END -> >
1145     * }
1146     * </pre>
1147     *
1148     * @see
1149     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1150     *     Comments are written in HTML</a>
1151     * @see #P_HTML_TAG_NAME
1152     */
1153    public static final int P_HTML_TAG_NAME = JavadocParser.P_HTML_TAG_NAME;
1154
1155    /**
1156     * List item tag name.
1157     *
1158     * <p><b>Example:</b></p>
1159     * <pre>{@code
1160     *  <ol>
1161     *    <li>banana</li>
1162     *  </ol>
1163     *  }</pre>
1164     *  <b>Tree:</b>
1165     *  <pre>
1166     *  {@code
1167     *   HTML_ELEMENT -> HTML_ELEMENT
1168     *    `--HTML_TAG -> HTML_TAG
1169     *       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
1170     *       |   |--START -> <
1171     *       |   |--HTML_TAG_NAME -> ol
1172     *       |   `--END -> >
1173     *       |--NEWLINE -> \r\n
1174     *       |--LEADING_ASTERISK ->  *
1175     *       |--TEXT ->
1176     *       |--HTML_ELEMENT -> HTML_ELEMENT
1177     *       |   `--LI -> LI
1178     *       |       |--LI_TAG_START -> LI_TAG_START
1179     *       |       |   |--START -> <
1180     *       |       |   |--LI_HTML_TAG_NAME -> li
1181     *       |       |   `--END -> >
1182     *       |       |--TEXT -> banana
1183     *       |       `--LI_TAG_END -> LI_TAG_END
1184     *       |           |--START -> <
1185     *       |           |--SLASH -> /
1186     *       |           |--LI_HTML_TAG_NAME -> li
1187     *       |           `--END -> >
1188     *       |--NEWLINE -> \r\n
1189     *       |--LEADING_ASTERISK ->  *
1190     *       |--TEXT ->
1191     *       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
1192     *           |--START -> <
1193     *           |--SLASH -> /
1194     *           |--HTML_TAG_NAME -> ol
1195     *           `--END -> >
1196     *  }
1197     *  </pre>
1198     *
1199     * @see
1200     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1201     *     comments are written in HTML</a>
1202     * @see #LI_HTML_TAG_NAME
1203     */
1204    public static final int LI_HTML_TAG_NAME = JavadocParser.LI_HTML_TAG_NAME;
1205
1206    /**
1207     * Table row tag name.
1208     *
1209     *  <p><b>Example:</b></p>
1210     *  <pre>{@code
1211     *  <table>
1212     *     <tr>Table Row</tr>
1213     *  </table>
1214     *  }</pre>
1215     *  <b>Tree:</b>
1216     *  <pre>
1217     *  {@code
1218     *  HTML_ELEMENT -> HTML_ELEMENT
1219     *   `--HTML_TAG -> HTML_TAG
1220     *       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
1221     *       |   |--START -> <
1222     *       |   |--HTML_TAG_NAME -> table
1223     *       |   `--END -> >
1224     *       |--NEWLINE -> \r\n
1225     *       |--LEADING_ASTERISK ->  *
1226     *       |--TEXT ->
1227     *       |--HTML_ELEMENT -> HTML_ELEMENT
1228     *       |   `--TR -> TR
1229     *       |       |--TR_TAG_START -> TR_TAG_START
1230     *       |       |   |--START -> <
1231     *       |       |   |--TR_HTML_TAG_NAME -> tr
1232     *       |       |   `--END -> >
1233     *       |       |--TEXT -> Table Row
1234     *       |       `--TR_TAG_END -> TR_TAG_END
1235     *       |           |--START -> <
1236     *       |           |--SLASH -> /
1237     *       |           |--TR_HTML_TAG_NAME -> tr
1238     *       |           `--END -> >
1239     *       |--NEWLINE -> \r\n
1240     *       |--LEADING_ASTERISK ->  *
1241     *       |--TEXT ->
1242     *       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
1243     *           |--START -> <
1244     *           |--SLASH -> /
1245     *           |--HTML_TAG_NAME -> table
1246     *           `--END -> >
1247     *  }
1248     *  </pre>
1249     *
1250     *  @see
1251     *  <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1252     *      comments are written in HTML</a>
1253     *  @see #TR_HTML_TAG_NAME
1254     */
1255    public static final int TR_HTML_TAG_NAME = JavadocParser.TR_HTML_TAG_NAME;
1256
1257    /**
1258     * Table cell tag name.
1259     *
1260     *  <p><b>Example:</b></p>
1261     *  <pre>{@code
1262     *  <tr>
1263     *     <td>Cell 1</td>
1264     *  </tr>
1265     *  }</pre>
1266     *  <b>Tree:</b>
1267     *  <pre>
1268     *  {@code
1269     *  HTML_ELEMENT -> HTML_ELEMENT
1270     *   `--TR -> TR
1271     *       |--TR_TAG_START -> TR_TAG_START
1272     *       |   |--START -> <
1273     *       |   |--TR_HTML_TAG_NAME -> tr
1274     *       |   `--END -> >
1275     *       |--NEWLINE -> \r\n
1276     *       |--LEADING_ASTERISK ->  *
1277     *       |--TEXT ->
1278     *       |--TD -> TD
1279     *       |   |--TD_TAG_START -> TD_TAG_START
1280     *       |   |   |--START -> <
1281     *       |   |   |--TD_HTML_TAG_NAME -> td
1282     *       |   |   `--END -> >
1283     *       |   |--TEXT -> Cell 1
1284     *       |   `--TD_TAG_END -> TD_TAG_END
1285     *       |       |--START -> <
1286     *       |       |--SLASH -> /
1287     *       |       |--TD_HTML_TAG_NAME -> td
1288     *       |       `--END -> >
1289     *       |--NEWLINE -> \r\n
1290     *       |--LEADING_ASTERISK ->  *
1291     *       |--TEXT ->
1292     *       `--TR_TAG_END -> TR_TAG_END
1293     *           |--START -> <
1294     *           |--SLASH -> /
1295     *           |--TR_HTML_TAG_NAME -> tr
1296     *           `--END -> >
1297     *  }
1298     *  </pre>
1299     *
1300     *  @see
1301     *  <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1302     *      comments are written in HTML</a>
1303     *  @see #TD_HTML_TAG_NAME
1304     */
1305    public static final int TD_HTML_TAG_NAME = JavadocParser.TD_HTML_TAG_NAME;
1306
1307    /**
1308     * Table header cell tag name.
1309     *
1310     * <p><b>Example:</b></p>
1311     * <pre>{@code
1312     * <tr>
1313     *     <th>Table Head</th>
1314     * </tr>
1315     * }</pre>
1316     * <b>Tree:</b>
1317     * <pre>
1318     * {@code
1319     *  HTML_ELEMENT -> HTML_ELEMENT
1320     *   `--TR -> TR
1321     *       |--TR_TAG_START -> TR_TAG_START
1322     *       |   |--START -> <
1323     *       |   |--TR_HTML_TAG_NAME -> tr
1324     *       |   `--END -> >
1325     *       |--NEWLINE -> \r\n
1326     *       |--LEADING_ASTERISK ->  *
1327     *       |--TEXT ->
1328     *       |--TH -> TH
1329     *       |   |--TH_TAG_START -> TH_TAG_START
1330     *       |   |   |--START -> <
1331     *       |   |   |--TH_HTML_TAG_NAME -> th
1332     *       |   |   `--END -> >
1333     *       |   |--TEXT -> Table Head
1334     *       |   `--TH_TAG_END -> TH_TAG_END
1335     *       |       |--START -> <
1336     *       |       |--SLASH -> /
1337     *       |       |--TH_HTML_TAG_NAME -> th
1338     *       |       `--END -> >
1339     *       |--NEWLINE -> \r\n
1340     *       |--LEADING_ASTERISK ->  *
1341     *       |--TEXT ->
1342     *       `--TR_TAG_END -> TR_TAG_END
1343     *           |--START -> <
1344     *           |--SLASH -> /
1345     *           |--TR_HTML_TAG_NAME -> tr
1346     *           `--END -> >
1347     *  }
1348     *  </pre>
1349     *
1350     *  @see
1351     *  <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1352     *      comments are written in HTML</a>
1353     *  @see #TH_HTML_TAG_NAME
1354     */
1355    public static final int TH_HTML_TAG_NAME = JavadocParser.TH_HTML_TAG_NAME;
1356
1357    /** Body tag name. */
1358    public static final int BODY_HTML_TAG_NAME = JavadocParser.BODY_HTML_TAG_NAME;
1359
1360    /**
1361     * Colgroup tag name.
1362     *
1363     * <p><b>Example:</b></p>
1364     * <pre>{@code <colgroup><col span="2"></colgroup>}</pre>
1365     * <b>Tree:</b>
1366     * <pre>
1367     * {@code
1368     *   |--HTML_ELEMENT -> HTML_ELEMENT
1369     *   |   `--COLGROUP -> COLGROUP
1370     *   |       |--COLGROUP_TAG_START -> COLGROUP_TAG_START
1371     *   |       |   |--START -> <
1372     *   |       |   |--COLGROUP_HTML_TAG_NAME -> colgroup
1373     *   |       |   `--END -> >
1374     *   |       |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1375     *   |       |   `--COL_TAG -> COL_TAG
1376     *   |       |       |--START -> <
1377     *   |       |       |--COL_HTML_TAG_NAME -> col
1378     *   |       |       |--WS ->
1379     *   |       |       |--ATTRIBUTE -> ATTRIBUTE
1380     *   |       |       |   |--HTML_TAG_NAME -> span
1381     *   |       |       |   |--EQUALS -> =
1382     *   |       |       |   `--ATTR_VALUE -> "2"
1383     *   |       |       `--END -> >
1384     *   |       `--COLGROUP_TAG_END -> COLGROUP_TAG_END
1385     *   |           |--START -> <
1386     *   |           |--SLASH -> /
1387     *   |           |--COLGROUP_HTML_TAG_NAME -> colgroup
1388     *   |           `--END -> >
1389     *   |--TEXT ->
1390     *   `--EOF -> <EOF>
1391     * }
1392     * </pre>
1393     *
1394     * @see #COLGROUP_HTML_TAG_NAME
1395     */
1396    public static final int COLGROUP_HTML_TAG_NAME = JavadocParser.COLGROUP_HTML_TAG_NAME;
1397
1398    /**
1399     * Description of a term tag name.
1400     *
1401     * <p><b>Example:</b></p>
1402     * <pre>{@code
1403     * <dl>
1404     *     <dt>Java</dt>
1405     *     <dd>A high-level programming language.</dd>
1406     * </dl>
1407     * }</pre>
1408     * <b>Tree:</b>
1409     * <pre>
1410     * {@code
1411     *  HTML_ELEMENT -> HTML_ELEMENT
1412     *   `--HTML_TAG -> HTML_TAG
1413     *       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
1414     *       |   |--START -> <
1415     *       |   |--HTML_TAG_NAME -> dl
1416     *       |   `--END -> >
1417     *       |--NEWLINE -> \r\n
1418     *       |--LEADING_ASTERISK ->  *
1419     *       |--TEXT ->
1420     *       |--HTML_ELEMENT -> HTML_ELEMENT
1421     *       |   `--DT -> DT
1422     *       |       |--DT_TAG_START -> DT_TAG_START
1423     *       |       |   |--START -> <
1424     *       |       |   |--DT_HTML_TAG_NAME -> dt
1425     *       |       |   `--END -> >
1426     *       |       |--TEXT -> Java
1427     *       |       `--DT_TAG_END -> DT_TAG_END
1428     *       |           |--START -> <
1429     *       |           |--SLASH -> /
1430     *       |           |--DT_HTML_TAG_NAME -> dt
1431     *       |           `--END -> >
1432     *       |--NEWLINE -> \r\n
1433     *       |--LEADING_ASTERISK ->  *
1434     *       |--TEXT ->
1435     *       |--HTML_ELEMENT -> HTML_ELEMENT
1436     *       |   `--DD -> DD
1437     *       |       |--DD_TAG_START -> DD_TAG_START
1438     *       |       |   |--START -> <
1439     *       |       |   |--DD_HTML_TAG_NAME -> dd
1440     *       |       |   `--END -> >
1441     *       |       |--TEXT -> A high-level programming language.
1442     *       |       `--DD_TAG_END -> DD_TAG_END
1443     *       |           |--START -> <
1444     *       |           |--SLASH -> /
1445     *       |           |--DD_HTML_TAG_NAME -> dd
1446     *       |           `--END -> >
1447     *       |--NEWLINE -> \r\n
1448     *       |--LEADING_ASTERISK ->  *
1449     *       |--TEXT ->
1450     *       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
1451     *           |--START -> <
1452     *           |--SLASH -> /
1453     *           |--HTML_TAG_NAME -> dl
1454     *           `--END -> >
1455     * }
1456     * </pre>
1457     *
1458     * @see #DD_HTML_TAG_NAME
1459     */
1460    public static final int DD_HTML_TAG_NAME = JavadocParser.DD_HTML_TAG_NAME;
1461
1462    /**
1463     * Description term tag name.
1464     *
1465     * <p><b>Example:</b></p>
1466     * <pre>{@code
1467     * <dl>
1468     *     <dt>Java</dt>
1469     * </dl>
1470     * }</pre>
1471     * <b>Tree:</b>
1472     * <pre>
1473     * {@code
1474     *  HTML_ELEMENT -> HTML_ELEMENT
1475     *   `--HTML_TAG -> HTML_TAG
1476     *       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
1477     *       |   |--START -> <
1478     *       |   |--HTML_TAG_NAME -> dl
1479     *       |   `--END -> >
1480     *       |--NEWLINE -> \r\n
1481     *       |--LEADING_ASTERISK ->  *
1482     *       |--TEXT ->
1483     *       |--HTML_ELEMENT -> HTML_ELEMENT
1484     *       |   `--DT -> DT
1485     *       |       |--DT_TAG_START -> DT_TAG_START
1486     *       |       |   |--START -> <
1487     *       |       |   |--DT_HTML_TAG_NAME -> dt
1488     *       |       |   `--END -> >
1489     *       |       |--TEXT -> Java
1490     *       |       `--DT_TAG_END -> DT_TAG_END
1491     *       |           |--START -> <
1492     *       |           |--SLASH -> /
1493     *       |           |--DT_HTML_TAG_NAME -> dt
1494     *       |           `--END -> >
1495     *       |--NEWLINE -> \r\n
1496     *       |--LEADING_ASTERISK ->  *
1497     *       |--TEXT ->
1498     *       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
1499     *           |--START -> <
1500     *           |--SLASH -> /
1501     *           |--HTML_TAG_NAME -> dl
1502     *           `--END -> >
1503     * }
1504     * </pre>
1505     *
1506     * @see #DT_HTML_TAG_NAME
1507     */
1508    public static final int DT_HTML_TAG_NAME = JavadocParser.DT_HTML_TAG_NAME;
1509
1510    /** Head tag name. */
1511    public static final int HEAD_HTML_TAG_NAME = JavadocParser.HEAD_HTML_TAG_NAME;
1512
1513    /** Html tag name. */
1514    public static final int HTML_HTML_TAG_NAME = JavadocParser.HTML_HTML_TAG_NAME;
1515
1516    /** Option tag name. */
1517    public static final int OPTION_HTML_TAG_NAME = JavadocParser.OPTION_HTML_TAG_NAME;
1518
1519    /** Table body tag name. */
1520    public static final int TBODY_HTML_TAG_NAME = JavadocParser.TBODY_HTML_TAG_NAME;
1521
1522    /** Table foot tag name. */
1523    public static final int TFOOT_HTML_TAG_NAME = JavadocParser.TFOOT_HTML_TAG_NAME;
1524
1525    /** Table head tag name. */
1526    public static final int THEAD_HTML_TAG_NAME = JavadocParser.THEAD_HTML_TAG_NAME;
1527
1528    /** `optgroup` tag name. */
1529    public static final int OPTGROUP_HTML_TAG_NAME = JavadocParser.OPTGROUP_HTML_TAG_NAME;
1530
1531    /** `rb` tag name. */
1532    public static final int RB_HTML_TAG_NAME = JavadocParser.RB_HTML_TAG_NAME;
1533
1534    /** `rt` tag name. */
1535    public static final int RT_HTML_TAG_NAME = JavadocParser.RT_HTML_TAG_NAME;
1536
1537    /** `rtc` tag name. */
1538    public static final int RTC_HTML_TAG_NAME = JavadocParser.RTC_HTML_TAG_NAME;
1539
1540    /** `rp` tag name. */
1541    public static final int RP_HTML_TAG_NAME = JavadocParser.RP_HTML_TAG_NAME;
1542    ///////////////////////////////////////////////////////////////////////////////////////////////
1543
1544    /////////////////////// SINGLETON HTML TAGS  //////////////////////////////////////////////////
1545    /**
1546     * Area tag name.
1547     *
1548     * <p><b>Example:</b></p>
1549     * <pre>{@code &lt area shape="rect" &gt}</pre>
1550     * <b>Tree:</b>
1551     * <pre>
1552     * {@code
1553     *   JAVADOC -> JAVADOC
1554     *        |--NEWLINE -> \n
1555     *        |--LEADING_ASTERISK ->  *
1556     *        |--TEXT ->
1557     *        |--HTML_ELEMENT -> HTML_ELEMENT
1558     *        |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1559     *        |       `--AREA_TAG -> AREA_TAG
1560     *        |           |--START -> <
1561     *        |           |--AREA_HTML_TAG_NAME -> area
1562     *        |           |--WS ->
1563     *        |           |--ATTRIBUTE -> ATTRIBUTE
1564     *        |           |   |--HTML_TAG_NAME -> shape
1565     *        |           |   |--EQUALS -> =
1566     *        |           |   `--ATTR_VALUE -> "rect"
1567     *        |           `--END -> >
1568     *        |--TEXT ->
1569     *        |--NEWLINE -> \n
1570     *        |--TEXT ->
1571     * }
1572     * </pre>
1573     */
1574
1575    public static final int AREA_HTML_TAG_NAME = JavadocParser.AREA_HTML_TAG_NAME;
1576
1577    /** Base tag name. */
1578    public static final int BASE_HTML_TAG_NAME = JavadocParser.BASE_HTML_TAG_NAME;
1579
1580    /** Basefont tag name. */
1581    public static final int BASEFONT_HTML_TAG_NAME = JavadocParser.BASEFONT_HTML_TAG_NAME;
1582
1583    /**
1584     * Br tag name.
1585     *
1586     * <p><b>Example:</b></p>
1587     * <pre>{@code text before break < br > text after break}</pre>
1588     * <b>Tree:</b>
1589     * <pre>
1590     * {@code
1591     *   `--JAVADOC -> JAVADOC
1592     *       |--NEWLINE -> \r\n
1593     *       |--LEADING_ASTERISK ->  *
1594     *       |--TEXT ->  text before break
1595     *       |--HTML_ELEMENT -> HTML_ELEMENT
1596     *       |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1597     *       |       `--BR_TAG -> BR_TAG
1598     *       |           |--START -> <
1599     *       |           |--BR_HTML_TAG_NAME -> br
1600     *       |           `--END -> >
1601     *       |--TEXT ->  text after break
1602     *       |--NEWLINE -> \r\n
1603     *       |--TEXT ->
1604     * }
1605     * </pre>
1606     */
1607
1608    public static final int BR_HTML_TAG_NAME = JavadocParser.BR_HTML_TAG_NAME;
1609
1610    /** Col tag name. */
1611    public static final int COL_HTML_TAG_NAME = JavadocParser.COL_HTML_TAG_NAME;
1612
1613    /** Frame tag name. */
1614    public static final int FRAME_HTML_TAG_NAME = JavadocParser.FRAME_HTML_TAG_NAME;
1615
1616    /**
1617     * Hr tag name.
1618     *
1619     * <p><b>Example:</b></p>
1620     * <pre>{@code text before horizontal rule < hr > text after horizontal rule}</pre>
1621     * <b>Tree:</b>
1622     * <pre>
1623     * {@code
1624     *  |--TEXT ->  text before horizontal rule
1625     *  |--HTML_ELEMENT -> HTML_ELEMENT
1626     *  |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1627     *  |       `--HR_TAG -> HR_TAG
1628     *  |           |--START -> <
1629     *  |           |--HR_HTML_TAG_NAME -> hr
1630     *  |           `--END -> >
1631     *  |--TEXT ->  text after horizontal rule
1632     *  |--NEWLINE -> \r\n
1633     * }
1634     * </pre>
1635     */
1636
1637    public static final int HR_HTML_TAG_NAME = JavadocParser.HR_HTML_TAG_NAME;
1638
1639    /** Img tag name. */
1640    public static final int IMG_HTML_TAG_NAME = JavadocParser.IMG_HTML_TAG_NAME;
1641
1642    /**
1643     * Input tag name.
1644     *
1645     *  <p><b>Example:</b></p>
1646     *  <pre>{@code <input name="Name" type="text" placeholder="Enter your name"/>}</pre>
1647     *  <b>Tree:</b>
1648     *  <pre>
1649     *  {@code
1650     *    HTML_ELEMENT -> HTML_ELEMENT
1651     *       `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1652     *         `--INPUT_TAG -> INPUT_TAG
1653     *             |--START -> <
1654     *             |--INPUT_HTML_TAG_NAME -> input
1655     *             |--WS ->
1656     *             |--ATTRIBUTE -> ATTRIBUTE
1657     *             |   |--HTML_TAG_NAME -> name
1658     *             |   |--EQUALS -> =
1659     *             |   `--ATTR_VALUE -> "Name"
1660     *             |--WS ->
1661     *             |--ATTRIBUTE -> ATTRIBUTE
1662     *             |   |--HTML_TAG_NAME -> type
1663     *             |   |--EQUALS -> =
1664     *             |   `--ATTR_VALUE -> "text"
1665     *             |--WS ->
1666     *             |--ATTRIBUTE -> ATTRIBUTE
1667     *             |   |--HTML_TAG_NAME -> placeholder
1668     *             |   |--EQUALS -> =
1669     *             |   `--ATTR_VALUE -> "Enter your name"
1670     *              `--SLASH_END -> />
1671     *  }
1672     *  </pre>
1673     *
1674     *   @see
1675     *   <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1676     *      comments are written in HTML</a>
1677     *     @see #INPUT_HTML_TAG_NAME
1678     */
1679    public static final int INPUT_HTML_TAG_NAME = JavadocParser.INPUT_HTML_TAG_NAME;
1680
1681    /** Isindex tag name. */
1682    public static final int ISINDEX_HTML_TAG_NAME = JavadocParser.ISINDEX_HTML_TAG_NAME;
1683
1684    /**
1685     *  Link tag name.
1686     *
1687     *  <p><b>Example:</b></p>
1688     *  <pre>{@code <link rel="stylesheet" href="Style.css">}</pre>
1689     *  <b>Tree:</b>
1690     *  <pre>
1691     *  {@code
1692     *  HTML_ELEMENT -> HTML_ELEMENT
1693     *  `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
1694     *      `--LINK_TAG -> LINK_TAG
1695     *          |--START -> <
1696     *          |--LINK_HTML_TAG_NAME -> link
1697     *          |--WS ->
1698     *          |--ATTRIBUTE -> ATTRIBUTE
1699     *          |   |--HTML_TAG_NAME -> rel
1700     *          |   |--EQUALS -> =
1701     *          |   `--ATTR_VALUE -> "stylesheet"
1702     *          |--WS ->
1703     *          |--ATTRIBUTE -> ATTRIBUTE
1704     *          |   |--HTML_TAG_NAME -> href
1705     *          |   |--EQUALS -> =
1706     *          |   `--ATTR_VALUE -> "Style.css"
1707     *          `--END -> >
1708     *  }
1709     *  </pre>
1710     *
1711     *  @see
1712     *  <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647">
1713     *      comments are written in HTML</a>
1714     *  @see #LINK_HTML_TAG_NAME
1715     */
1716    public static final int LINK_HTML_TAG_NAME = JavadocParser.LINK_HTML_TAG_NAME;
1717
1718    /** Meta tag name. */
1719    public static final int META_HTML_TAG_NAME = JavadocParser.META_HTML_TAG_NAME;
1720
1721    /** Param tag name. */
1722    public static final int PARAM_HTML_TAG_NAME = JavadocParser.PARAM_HTML_TAG_NAME;
1723    /** "embed" tag name. */
1724    public static final int EMBED_HTML_TAG_NAME = JavadocParser.EMBED_HTML_TAG_NAME;
1725    /** "keygen" tag name. */
1726    public static final int KEYGEN_HTML_TAG_NAME = JavadocParser.KEYGEN_HTML_TAG_NAME;
1727    /** "source" tag name. */
1728    public static final int SOURCE_HTML_TAG_NAME = JavadocParser.SOURCE_HTML_TAG_NAME;
1729    /** "track" tag name. */
1730    public static final int TRACK_HTML_TAG_NAME = JavadocParser.TRACK_HTML_TAG_NAME;
1731    /** "wbr" tag name. */
1732    public static final int WBR_HTML_TAG_NAME = JavadocParser.WBR_HTML_TAG_NAME;
1733    ///////////////////////////////////////////////////////////////////////////////////////////////
1734
1735    /**
1736     * HTML comment start symbol '&lt;&#33;--'.
1737     *
1738     * <p><b>Example:</b></p>
1739     * <pre>{@code
1740     * &lt;!--
1741     * This is an HTML multi-line comment:
1742     * This is another comment
1743     * --&gt;
1744     * }</pre>
1745     * <b>Tree:</b>
1746     * <pre>
1747     * {@code
1748     * HTML_COMMENT -> HTML_COMMENT
1749     *    |--HTML_COMMENT_START -> <!--
1750     *    |--NEWLINE -> \n
1751     *    |--LEADING_ASTERISK ->  *
1752     *    |--TEXT ->  This is an HTML multi-line comment:
1753     *    |--NEWLINE -> \n
1754     *    |--LEADING_ASTERISK ->  *
1755     *    |--TEXT ->  This is another comment
1756     *    |--NEWLINE -> \n
1757     *    |--LEADING_ASTERISK ->  *
1758     *    |--TEXT ->
1759     *    `--HTML_COMMENT_END -> -->
1760     * }
1761     * </pre>
1762     */
1763    public static final int HTML_COMMENT_START = JavadocParser.HTML_COMMENT_START;
1764
1765    /**
1766     * HTML comment end symbol '--&gt;'.
1767     *
1768     * <p><b>Example:</b></p>
1769     * <pre>{@code
1770     * &lt;!--
1771     * This is an HTML multi-line comment:
1772     * This is another comment
1773     * --&gt;
1774     * }</pre>
1775     * <b>Tree:</b>
1776     * <pre>
1777     * {@code
1778     * HTML_COMMENT -> HTML_COMMENT
1779     *    |--HTML_COMMENT_START -> <!--
1780     *    |--NEWLINE -> \n
1781     *    |--LEADING_ASTERISK ->  *
1782     *    |--TEXT ->  This is an HTML multi-line comment:
1783     *    |--NEWLINE -> \n
1784     *    |--LEADING_ASTERISK ->  *
1785     *    |--TEXT ->  This is another comment
1786     *    |--NEWLINE -> \n
1787     *    |--LEADING_ASTERISK ->  *
1788     *    |--TEXT ->
1789     *    `--HTML_COMMENT_END -> -->
1790     * }
1791     * </pre>
1792     */
1793    public static final int HTML_COMMENT_END = JavadocParser.HTML_COMMENT_END;
1794
1795    // ------------------------------------------------------------------------------------------ //
1796    // -----------------        OTHER          -------------------------------------------------- //
1797    // ------------------------------------------------------------------------------------------ //
1798
1799    /** Leading asterisk. */
1800    public static final int LEADING_ASTERISK = JavadocParser.LEADING_ASTERISK;
1801
1802    /**
1803     * Newline symbol - '\n'.
1804     */
1805    public static final int NEWLINE = JavadocParser.NEWLINE;
1806
1807    /**
1808     * Any other symbol.
1809     */
1810    public static final int CHAR = JavadocParser.CHAR;
1811
1812    /**
1813     * Whitespace or tab ('\t') symbol.
1814     */
1815    public static final int WS = JavadocParser.WS;
1816
1817    /**
1818     * End Of File symbol. Copied from
1819     * {@link org.antlr.v4.runtime.Recognizer#EOF} to avoid ANTLR dependency in
1820     * API.
1821     */
1822    public static final int EOF = -1;
1823
1824    // ------------------------------------------------------------------------------------------ //
1825    // ------ JAVADOC TAGS DEPENDING ON RULE TYPES OFFSET --------------------------------------- //
1826    // ------------------------------------------------------------------------------------------ //
1827
1828    /**
1829     * Rule types offset.
1830     * RULE_TYPES_OFFSET constant is used to split lexer tokens types and parser rules types.
1831     * We need unique numbers for all tokens,
1832     * ANTLR do not need this and that is why these types are mixed by used values.
1833     * All values we can take a look at
1834     * target/generated-sources/antlr/com/puppycrawl/tools/checkstyle/grammar/javadoc/JavadocParser.java
1835     * For example: LEADING_ASTERISK=1 and RULE_htmlElement = 1.
1836     * RULE_TYPES_OFFSET required to shift parser rules,
1837     * to let them not overlap with types that have prefix "RULE_".
1838     */
1839    private static final int RULE_TYPES_OFFSET = 10000;
1840
1841    /**
1842     * Root node of any Javadoc comment.
1843     * Last child is always {@link #EOF}.
1844     *
1845     * <p><b>Tree for example:</b></p>
1846     * <pre>{@code
1847     * JAVADOC -> JAVADOC
1848     *  |--NEWLINE -> \n
1849     *  |--LEADING_ASTERISK ->  *
1850     *  |--WS ->
1851     *  |--JAVADOC_TAG -> JAVADOC_TAG
1852     *  |   |--PARAM_LITERAL -> @param
1853     *  |   |--WS ->
1854     *  |   |--PARAMETER_NAME -> T
1855     *  |   |--WS ->
1856     *  |   `--DESCRIPTION -> DESCRIPTION
1857     *  |       |--TEXT -> The bar.
1858     *  |       |--NEWLINE -> \n
1859     *  |       `--TEXT ->
1860     *  `--EOF -> <EOF>
1861     * }</pre>
1862     */
1863    public static final int JAVADOC = JavadocParser.RULE_javadoc + RULE_TYPES_OFFSET;
1864
1865    /**
1866     * Javadoc tag.
1867     *
1868     * <p>Type of Javadoc tag is resolved by literal node that is first child of this node.</p>
1869     *
1870     * <p>As literal could be:</p>
1871     * <ul>
1872     * <li>{@link #RETURN_LITERAL}</li>
1873     * <li>{@link #DEPRECATED_LITERAL}</li>
1874     * <li>{@link #SINCE_LITERAL}</li>
1875     * <li>{@link #SERIAL_DATA_LITERAL}</li>
1876     * <li>{@link #SERIAL_FIELD_LITERAL}</li>
1877     * <li>{@link #PARAM_LITERAL}</li>
1878     * <li>{@link #SEE_LITERAL}</li>
1879     * <li>{@link #SERIAL_LITERAL}</li>
1880     * <li>{@link #VERSION_LITERAL}</li>
1881     * <li>{@link #EXCEPTION_LITERAL}</li>
1882     * <li>{@link #THROWS_LITERAL}</li>
1883     * <li>{@link #AUTHOR_LITERAL}</li>
1884     * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc tag.</li>
1885     * </ul>
1886     *
1887     * <p><b>Example</b></p>
1888     * <pre>{@code &#64;param T The bar.}</pre>
1889     * <b>Tree</b>
1890     * <pre>{@code
1891     * JAVADOC_TAG -> JAVADOC_TAG
1892     *  |--PARAM_LITERAL -> @param
1893     *  |--WS ->
1894     *  |--PARAMETER_NAME -> T
1895     *  |--WS ->
1896     *  `--DESCRIPTION -> DESCRIPTION
1897     *      |--TEXT -> The bar.
1898     *      |--NEWLINE -> \r\n
1899     *      `--TEXT ->
1900     * }</pre>
1901     */
1902
1903    public static final int JAVADOC_TAG = JavadocParser.RULE_javadocTag + RULE_TYPES_OFFSET;
1904    /**
1905     * Javadoc inline tag.
1906     *
1907     * <p>Type of Javadoc inline tag is resolved by literal node that is second child of this node.
1908     * First child is always {@link #JAVADOC_INLINE_TAG_START} and last node is always
1909     * {@link #JAVADOC_INLINE_TAG_END}.</p>
1910     *
1911     * <p>As literal could be:</p>
1912     * <ul>
1913     * <li>{@link #CODE_LITERAL}</li>
1914     * <li>{@link #DOC_ROOT_LITERAL}</li>
1915     * <li>{@link #LINK_LITERAL}</li>
1916     * <li>{@link #INHERIT_DOC_LITERAL}</li>
1917     * <li>{@link #LINKPLAIN_LITERAL}</li>
1918     * <li>{@link #LITERAL_LITERAL}</li>
1919     * <li>{@link #VALUE_LITERAL}</li>
1920     * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc inline tag.</li>
1921     * </ul>
1922     *
1923     * <p><b>Example:</b></p>
1924     * <pre><code>{&#64;link String}</code></pre>
1925     * <b>Tree:</b>
1926     * <pre>
1927     * {@code
1928     *  JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
1929     *      |--JAVADOC_INLINE_TAG_START -> {
1930     *      |--LINK_LITERAL -> @link
1931     *      |--WS ->
1932     *      |--REFERENCE -> REFERENCE
1933     *          `--PACKAGE_CLASS -> String
1934     *      `--JAVADOC_INLINE_TAG_END -> }
1935     * }
1936     * </pre>
1937     *
1938     * @noinspection HtmlTagCanBeJavadocTag
1939     * @noinspection HtmlTagCanBeJavadocTag
1940     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
1941     *      replaced with Javadoc tag
1942     */
1943    public static final int JAVADOC_INLINE_TAG = JavadocParser.RULE_javadocInlineTag
1944            + RULE_TYPES_OFFSET;
1945
1946    /**
1947     * Parameter of the Javadoc tags listed below.
1948     * <ul>
1949     * <li>{@link #SEE_LITERAL @see}</li>
1950     * <li>{@link #LINK_LITERAL &#123;&#64;link&#125;}</li>
1951     * <li>{@link #LINKPLAIN_LITERAL &#123;&#64;linkplain&#125;}</li>
1952     * <li>{@link #VALUE_LITERAL &#123;&#64;value&#125;}</li>
1953     * </ul>
1954     */
1955    public static final int REFERENCE = JavadocParser.RULE_reference + RULE_TYPES_OFFSET;
1956
1957    /**
1958     * Parameters part in {@link #REFERENCE}.
1959     * It is used to specify parameters for {@link #MEMBER method}.
1960     * Always contains {@link #LEFT_BRACE} as first child and {@link #RIGHT_BRACE} as last child.
1961     * Each parameter is represented by {@link #ARGUMENT} node.
1962     * Arguments in braces are separated by {@link #COMMA} (and optional {@link #WS}).
1963     *
1964     * <p><b>Example:</b></p>
1965     * <pre>{@code @see #method(Processor, String)}</pre>
1966     * <b>Tree:</b>
1967     * <pre>
1968     * {@code
1969     *      JAVADOC_TAG -> JAVADOC_TAG
1970     *          |--SEE_LITERAL -> @see
1971     *          |--WS ->
1972     *          |--REFERENCE -> REFERENCE
1973     *              |--HASH -> #
1974     *              |--MEMBER -> method
1975     *              `--PARAMETERS -> PARAMETERS
1976     *                  |--LEFT_BRACE -> (
1977     *                  |--ARGUMENT -> Processor
1978     *                  |--COMMA -> ,
1979     *                  |--WS ->
1980     *                  |--ARGUMENT -> String
1981     *                  `--RIGHT_BRACE -> )
1982     * }
1983     * </pre>
1984     */
1985    public static final int PARAMETERS = JavadocParser.RULE_parameters + RULE_TYPES_OFFSET;
1986
1987    /**
1988     * Description node. It contains:
1989     * <ul>
1990     * <li>{@link #TEXT}</li>
1991     * <li>{@link #WS}</li>
1992     * <li>{@link #NEWLINE}</li>
1993     * <li>{@link #HTML_ELEMENT}</li>
1994     * </ul>
1995     *
1996     * <p>It is argument for many Javadoc tags and inline tags.</p>
1997     *
1998     * <p><b>Example:</b></p>
1999     * <pre>{@code @throws IOException if <b>connection</b> problems occur}</pre>
2000     * <b>Tree:</b>
2001     * <pre>
2002     * {@code
2003     *   --JAVADOC_TAG -> JAVADOC_TAG
2004     *      |--THROWS_LITERAL -> @throws
2005     *      |--WS ->
2006     *      |--CLASS_NAME -> IOException
2007     *      |--WS ->
2008     *      `--DESCRIPTION -> DESCRIPTION
2009     *          |--TEXT -> if
2010     *          |--HTML_ELEMENT -> HTML_ELEMENT
2011     *          |   `--HTML_TAG -> HTML_TAG
2012     *          |       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
2013     *          |       |   |--START -> <
2014     *          |       |   |--HTML_TAG_NAME -> b
2015     *          |       |   `--END -> >
2016     *          |       |--TEXT -> connection
2017     *          |       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
2018     *          |           |--START -> <
2019     *          |           |--SLASH -> /
2020     *          |           |--HTML_TAG_NAME -> b
2021     *          |           `--END -> >
2022     *          |--TEXT ->  problems occur
2023     * }
2024     * </pre>
2025     */
2026    public static final int DESCRIPTION = JavadocParser.RULE_description + RULE_TYPES_OFFSET;
2027
2028    // ------------------------------------------------------------------------------------------ //
2029    // -------- HTML TAGS DEPENDING ON RULE TYPES OFFSET ---------------------------------------- //
2030    // ------------------------------------------------------------------------------------------ //
2031
2032    /**
2033     * Parent node for all html tags.
2034     */
2035    public static final int HTML_ELEMENT = JavadocParser.RULE_htmlElement
2036            + RULE_TYPES_OFFSET;
2037
2038    /**
2039     * Start html tag: &lt;XXXX&gt;.
2040     */
2041    public static final int HTML_ELEMENT_START = JavadocParser.RULE_htmlElementStart
2042            + RULE_TYPES_OFFSET;
2043
2044    /**
2045     * End html tag: &lt;XXXX&gt;.
2046     */
2047    public static final int HTML_ELEMENT_END = JavadocParser.RULE_htmlElementEnd
2048            + RULE_TYPES_OFFSET;
2049
2050    /**
2051     * Non-special HTML tag.
2052     */
2053    public static final int HTML_TAG = JavadocParser.RULE_htmlTag + RULE_TYPES_OFFSET;
2054
2055    /**
2056     * Html tag attribute. Parent node for: {@code HTML_TAG_IDENT, EQUALS, ATTR_VALUE}.
2057     *
2058     * <p><b>Example</b></p>
2059     * <pre>{@code <p class="highlight">Sample text</p>}</pre>
2060     * <b>Tree</b>
2061     * <pre>
2062     * {@code
2063     *   HTML_ELEMENT -> HTML_ELEMENT
2064     *      `--PARAGRAPH -> PARAGRAPH
2065     *          |--P_TAG_START -> P_TAG_START
2066     *          |   |--START -> <
2067     *          |   |--P_HTML_TAG_NAME -> p
2068     *          |   |--WS ->
2069     *          |   |--ATTRIBUTE -> ATTRIBUTE
2070     *          |   |   |--HTML_TAG_NAME -> class
2071     *          |   |   |--EQUALS -> =
2072     *          |   |   `--ATTR_VALUE -> "highlight"
2073     *          |   `--END -> >
2074     *          |--TEXT -> Sample text
2075     *          `--P_TAG_END -> P_TAG_END
2076     *              |--START -> <
2077     *              |--SLASH -> /
2078     *              |--P_HTML_TAG_NAME -> p
2079     *              `--END -> >
2080     * }
2081     * </pre>
2082     */
2083    public static final int ATTRIBUTE = JavadocParser.RULE_attribute
2084            + RULE_TYPES_OFFSET;
2085
2086    /////////////////////// HTML TAGS WITH OPTIONAL END TAG /////////////////////////////////////
2087    /**
2088     * Paragraph html tag.
2089     *
2090     * <p><b>Example:</b></p>
2091     * <pre>{@code <p>Sample text</p>}</pre>
2092     * <b>Tree:</b>
2093     * <pre>
2094     * {@code
2095     *   `--JAVADOC -> JAVADOC
2096     *       |--NEWLINE -> \r\n
2097     *       |--LEADING_ASTERISK ->  *
2098     *       |--TEXT ->
2099     *       |--HTML_ELEMENT -> HTML_ELEMENT
2100     *       |   `--PARAGRAPH -> PARAGRAPH
2101     *       |       |--P_TAG_START -> P_TAG_START
2102     *       |       |   |--START -> <
2103     *       |       |   |--P_HTML_TAG_NAME -> p
2104     *       |       |   `--END -> >
2105     *       |       |--TEXT -> Sample text
2106     *       |       `--P_TAG_END -> P_TAG_END
2107     *       |           |--START -> <
2108     *       |           |--SLASH -> /
2109     *       |           |--P_HTML_TAG_NAME -> p
2110     *       |           `--END -> >
2111     *       |--NEWLINE -> \r\n
2112     *       |--TEXT ->
2113     * }
2114     * </pre>
2115     */
2116    public static final int PARAGRAPH = JavadocParser.RULE_paragraph + RULE_TYPES_OFFSET;
2117    /** Start paragraph tag. */
2118    public static final int P_TAG_START = JavadocParser.RULE_pTagStart + RULE_TYPES_OFFSET;
2119    /** End paragraph tag. */
2120    public static final int P_TAG_END = JavadocParser.RULE_pTagEnd + RULE_TYPES_OFFSET;
2121
2122    /**
2123     * List items html tag.
2124     *
2125     * <p><b>Example:</b></p>
2126     * <pre>{@code
2127     * <ul>
2128     *      <li>Item 1</li>
2129     * </ul>
2130     * }</pre>
2131     * <b>Tree:</b>
2132     * <pre>
2133     * {@code
2134     *   --JAVADOC -> JAVADOC
2135     *     |--NEWLINE -> \n
2136     *     |--LEADING_ASTERISK ->  *
2137     *     |--TEXT ->
2138     *     |--HTML_ELEMENT -> HTML_ELEMENT
2139     *     |   `--HTML_TAG -> HTML_TAG
2140     *     |       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
2141     *     |       |   |--START -> <
2142     *     |       |   |--HTML_TAG_NAME -> ul
2143     *     |       |   `--END -> >
2144     *     |       |--NEWLINE -> \n
2145     *     |       |--LEADING_ASTERISK ->  *
2146     *     |       |--TEXT ->
2147     *     |       |--HTML_ELEMENT -> HTML_ELEMENT
2148     *     |       |   `--LI -> LI
2149     *     |       |       |--LI_TAG_START -> LI_TAG_START
2150     *     |       |       |   |--START -> <
2151     *     |       |       |   |--LI_HTML_TAG_NAME -> li
2152     *     |       |       |   `--END -> >
2153     *     |       |       |--TEXT -> Item 1
2154     *     |       |       `--LI_TAG_END -> LI_TAG_END
2155     *     |       |           |--START -> <
2156     *     |       |           |--SLASH -> /
2157     *     |       |           |--LI_HTML_TAG_NAME -> li
2158     *     |       |           `--END -> >
2159     *     |       |--NEWLINE -> \n
2160     *     |       |--LEADING_ASTERISK ->  *
2161     *     |       |--TEXT ->
2162     *     |       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
2163     *     |           |--START -> <
2164     *     |           |--SLASH -> /
2165     *     |           |--HTML_TAG_NAME -> ul
2166     *     |           `--END -> >
2167     *     |--NEWLINE -> \n
2168     *     |--TEXT ->
2169     * }
2170     * </pre>
2171     */
2172    public static final int LI = JavadocParser.RULE_li + RULE_TYPES_OFFSET;
2173    /** Start list item tag. */
2174    public static final int LI_TAG_START = JavadocParser.RULE_liTagStart + RULE_TYPES_OFFSET;
2175    /** End list item tag. */
2176    public static final int LI_TAG_END = JavadocParser.RULE_liTagEnd + RULE_TYPES_OFFSET;
2177
2178    /**
2179     * Table row html tag.
2180     *
2181     * <p><b>Example:</b></p>
2182     * <pre>{@code <tr></tr>}</pre>
2183     * <b>Tree:</b>
2184     * <pre>
2185     * {@code
2186     *   JAVADOC -> JAVADOC
2187     *        |--NEWLINE -> \r\n
2188     *        |--LEADING_ASTERISK ->  *
2189     *        |--TEXT ->
2190     *        |--HTML_ELEMENT -> HTML_ELEMENT
2191     *        |   `--TR -> TR
2192     *        |       |--TR_TAG_START -> TR_TAG_START
2193     *        |       |   |--START -> <
2194     *        |       |   |--TR_HTML_TAG_NAME -> tr
2195     *        |       |   `--END -> >
2196     *        |       `--TR_TAG_END -> TR_TAG_END
2197     *        |           |--START -> <
2198     *        |           |--SLASH -> /
2199     *        |           |--TR_HTML_TAG_NAME -> tr
2200     *        |           `--END -> >
2201     *        |--NEWLINE -> \r\n
2202     *        |--TEXT ->
2203     * }
2204     * </pre>
2205     */
2206    public static final int TR = JavadocParser.RULE_tr + RULE_TYPES_OFFSET;
2207    /** Start table row tag. */
2208    public static final int TR_TAG_START = JavadocParser.RULE_trTagStart + RULE_TYPES_OFFSET;
2209    /** End table row tag. */
2210    public static final int TR_TAG_END = JavadocParser.RULE_trTagEnd + RULE_TYPES_OFFSET;
2211
2212    /**
2213     * Table cell HTML tag.
2214     *
2215     * <p><b>Example:</b></p>
2216     * <pre>{@code <td>Cell Content</td>}</pre>
2217     * <b>Tree:</b>
2218     * <pre>
2219     * {@code
2220     * HTML_ELEMENT -> HTML_ELEMENT
2221     *    `--TD -> TD
2222     *        |--TD_TAG_START -> TD_TAG_START
2223     *        |   |--START -> <
2224     *        |   |--TD_HTML_TAG_NAME -> td
2225     *        |   `--END -> >
2226     *        |--TEXT -> Cell Content
2227     *        `--TD_TAG_END -> TD_TAG_END
2228     *            |--START -> <
2229     *            |--SLASH -> /
2230     *            |--TD_HTML_TAG_NAME -> td
2231     *            `--END -> >
2232     * }
2233     * </pre>
2234     */
2235    public static final int TD = JavadocParser.RULE_td + RULE_TYPES_OFFSET;
2236    /** Start table cell tag. */
2237    public static final int TD_TAG_START = JavadocParser.RULE_tdTagStart + RULE_TYPES_OFFSET;
2238    /** End table cell tag. */
2239    public static final int TD_TAG_END = JavadocParser.RULE_tdTagEnd + RULE_TYPES_OFFSET;
2240
2241    /** Table header cell html tag: {@code <th></th>}. */
2242    public static final int TH = JavadocParser.RULE_th + RULE_TYPES_OFFSET;
2243    /** Start table header cell tag. */
2244    public static final int TH_TAG_START = JavadocParser.RULE_thTagStart + RULE_TYPES_OFFSET;
2245    /** End table header cell tag. */
2246    public static final int TH_TAG_END = JavadocParser.RULE_thTagEnd + RULE_TYPES_OFFSET;
2247
2248    /** Body html tag. */
2249    public static final int BODY = JavadocParser.RULE_body + RULE_TYPES_OFFSET;
2250
2251    /**
2252     * Start body tag.
2253     *
2254     * <p><b>Example:</b></p>
2255     * <pre>{@code
2256     * &lt;body&gt;
2257     * This is a test
2258     * &lt;/body&gt;
2259     * }</pre>
2260     * <b>Tree:</b>
2261     * <pre>
2262     * {@code
2263     *   JAVADOC -> JAVADOC
2264     *        |--TEXT -> /**
2265     *        |--NEWLINE -> \n
2266     *        |--LEADING_ASTERISK ->  *
2267     *        |--TEXT ->
2268     *        |--HTML_ELEMENT -> HTML_ELEMENT
2269     *        |    `--BODY -> BODY
2270     *        |         |--BODY_TAG_START -> BODY_TAG_START
2271     *        |         |    |--START -> <
2272     *        |         |    |--BODY_HTML_TAG_NAME -> body
2273     *        |         |    `--END -> >
2274     *        |         |--NEWLINE -> \n
2275     *        |         |--LEADING_ASTERISK ->  *
2276     *        |         |--TEXT ->  This is inside the body tag.
2277     *        |         |--NEWLINE -> \n
2278     *        |         |--LEADING_ASTERISK ->  *
2279     *        |         |--TEXT ->
2280     *        |         `--BODY_TAG_END -> BODY_TAG_END
2281     *        |             |--START -> <
2282     *        |             |--SLASH -> /
2283     *        |             |--BODY_HTML_TAG_NAME -> body
2284     *        |             `--END -> >
2285     *          |--NEWLINE -> \n
2286     *          |--LEADING_ASTERISK ->  *
2287     *          |--TEXT -> /
2288     *          |--NEWLINE -> \n
2289     *          |--TEXT -> public class Test {
2290     *          |--NEWLINE -> \n
2291     *          |--TEXT -> }
2292     *          |--NEWLINE -> \n
2293     * }
2294     * </pre>
2295     */
2296    public static final int BODY_TAG_START = JavadocParser.RULE_bodyTagStart + RULE_TYPES_OFFSET;
2297
2298    /**
2299     * End body tag.
2300     *
2301     * <p><b>Example:</b></p>
2302     * <pre>{@code
2303     *  &lt;body&gt;
2304     *     This is a test
2305     * &lt;/body&gt;
2306     * }</pre>
2307     * <b>Tree:</b>
2308     * <pre>
2309     * {@code
2310     *   JAVADOC -> JAVADOC
2311     *        |--TEXT -> /**
2312     *        |--NEWLINE -> \n
2313     *        |--LEADING_ASTERISK ->  *
2314     *        |--TEXT ->
2315     *        |--HTML_ELEMENT -> HTML_ELEMENT
2316     *        |    `--BODY -> BODY
2317     *        |         |--BODY_TAG_START -> BODY_TAG_START
2318     *        |         |    |--START -> <
2319     *        |         |    |--BODY_HTML_TAG_NAME -> body
2320     *        |         |    `--END -> >
2321     *        |         |--NEWLINE -> \n
2322     *        |         |--LEADING_ASTERISK ->  *
2323     *        |         |--TEXT ->  This is inside the body tag.
2324     *        |         |--NEWLINE -> \n
2325     *        |         |--LEADING_ASTERISK ->  *
2326     *        |         |--TEXT ->
2327     *        |         `--BODY_TAG_END -> BODY_TAG_END
2328     *        |             |--START -> <
2329     *        |             |--SLASH -> /
2330     *        |             |--BODY_HTML_TAG_NAME -> body
2331     *        |             `--END -> >
2332     *        |--NEWLINE -> \n
2333     *        |--LEADING_ASTERISK ->  *
2334     *        |--TEXT -> /
2335     *        |--NEWLINE -> \n
2336     *        |--TEXT -> public class Test {
2337     *        |--NEWLINE -> \n
2338     *        |--TEXT -> }
2339     *        |--NEWLINE -> \n
2340     * }
2341     * </pre>
2342     */
2343    public static final int BODY_TAG_END = JavadocParser.RULE_bodyTagEnd + RULE_TYPES_OFFSET;
2344
2345    /**
2346     * Colgroup html tag.
2347     *
2348     * <p><b>Example:</b></p>
2349     * <pre>{@code
2350     * <colgroup>
2351     *     <col />
2352     *     <col span="2" class="batman" />
2353     * </colgroup>
2354     * }</pre>
2355     * <b>Tree:</b>
2356     * <pre>
2357     * {@code
2358     *   --JAVADOC -> JAVADOC
2359     *       |--NEWLINE -> \n
2360     *       |--LEADING_ASTERISK ->  *
2361     *       |--TEXT ->
2362     *       |--HTML_ELEMENT -> HTML_ELEMENT
2363     *       |   `--COLGROUP -> COLGROUP
2364     *       |       |--COLGROUP_TAG_START -> COLGROUP_TAG_START
2365     *       |       |   |--START -> <
2366     *       |       |   |--COLGROUP_HTML_TAG_NAME -> colgroup
2367     *       |       |   |   `--END -> >
2368     *       |       |--NEWLINE -> \n
2369     *       |       |--LEADING_ASTERISK ->  *
2370     *       |       |--TEXT ->
2371     *       |       |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2372     *       |       |   `--COL_TAG -> COL_TAG
2373     *       |       |       |--START -> <
2374     *       |       |       |--COL_HTML_TAG_NAME -> col
2375     *       |       |       |--WS ->
2376     *       |       |       `--SLASH_END -> />
2377     *       |       |--NEWLINE -> \n
2378     *       |       |--LEADING_ASTERISK ->  *
2379     *       |       |--TEXT ->
2380     *       |       |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2381     *       |       |   `--COL_TAG -> COL_TAG
2382     *       |       |       |--START -> <
2383     *       |       |       |--COL_HTML_TAG_NAME -> col
2384     *       |       |       |--WS ->
2385     *       |       |       |--ATTRIBUTE -> ATTRIBUTE
2386     *       |       |       |   |--HTML_TAG_NAME -> span
2387     *       |       |       |   |--EQUALS -> =
2388     *       |       |       |   `--ATTR_VALUE -> "2"
2389     *       |       |       |--WS ->
2390     *       |       |       |--ATTRIBUTE -> ATTRIBUTE
2391     *       |       |       |   |--HTML_TAG_NAME -> class
2392     *       |       |       |   |--EQUALS -> =
2393     *       |       |       |   `--ATTR_VALUE -> "batman"
2394     *       |       |       |--WS ->
2395     *       |       |       `--SLASH_END -> />
2396     *       |       |--NEWLINE -> \n
2397     *       |       |--LEADING_ASTERISK ->  *
2398     *       |       |--TEXT ->
2399     *       |       `--COLGROUP_TAG_END -> COLGROUP_TAG_END
2400     *       |       |       |--START -> <
2401     *       |       |       |--SLASH -> /
2402     *       |       |       |--COLGROUP_HTML_TAG_NAME -> colgroup
2403     *       |       |       `--END -> >
2404     *       |--NEWLINE -> \n
2405     *       |--TEXT ->
2406     * }
2407     * </pre>
2408     */
2409    public static final int COLGROUP = JavadocParser.RULE_colgroup + RULE_TYPES_OFFSET;
2410    /** Start colgroup tag. */
2411    public static final int COLGROUP_TAG_START = JavadocParser.RULE_colgroupTagStart
2412            + RULE_TYPES_OFFSET;
2413    /** End colgroup tag. */
2414    public static final int COLGROUP_TAG_END = JavadocParser.RULE_colgroupTagEnd
2415            + RULE_TYPES_OFFSET;
2416
2417    /**
2418     * DD html tag.
2419     *
2420     * <p><b>Example AST:</b></p>
2421     * <pre>{@code <dd>Description content</dd>}</pre>
2422     * <pre>
2423     * {@code
2424     *   --HTML_ELEMENT -> HTML_ELEMENT
2425     *      `--DD -> DD
2426     *          |--DD_TAG_START -> DD_TAG_START
2427     *          |   |--START -> <
2428     *          |   |--DD_HTML_TAG_NAME -> dd
2429     *          |   `--END -> >
2430     *          |--TEXT -> "Description content"
2431     *          `--DD_TAG_END -> DD_TAG_END
2432     *              |--START -> <
2433     *              |--SLASH -> /
2434     *              |--DD_HTML_TAG_NAME -> dd
2435     *              `--END -> >
2436     * }
2437     * </pre>
2438     */
2439    public static final int DD = JavadocParser.RULE_dd + RULE_TYPES_OFFSET;
2440    /** Start description of a term tag. */
2441    public static final int DD_TAG_START = JavadocParser.RULE_ddTagStart + RULE_TYPES_OFFSET;
2442    /** End description of a term tag. */
2443    public static final int DD_TAG_END = JavadocParser.RULE_ddTagEnd + RULE_TYPES_OFFSET;
2444
2445    /** Description term html tag: {@code <dt></dt>}. */
2446    public static final int DT = JavadocParser.RULE_dt + RULE_TYPES_OFFSET;
2447    /** Start description term tag. */
2448    public static final int DT_TAG_START = JavadocParser.RULE_dtTagStart + RULE_TYPES_OFFSET;
2449    /** End description term tag. */
2450    public static final int DT_TAG_END = JavadocParser.RULE_dtTagEnd + RULE_TYPES_OFFSET;
2451
2452    /** Head html tag. */
2453    public static final int HEAD = JavadocParser.RULE_head + RULE_TYPES_OFFSET;
2454    /** Start head tag. */
2455    public static final int HEAD_TAG_START = JavadocParser.RULE_headTagStart + RULE_TYPES_OFFSET;
2456    /** End head tag. */
2457    public static final int HEAD_TAG_END = JavadocParser.RULE_headTagEnd + RULE_TYPES_OFFSET;
2458
2459    /** Html html tag. */
2460    public static final int HTML = JavadocParser.RULE_html + RULE_TYPES_OFFSET;
2461    /** Start html tag. */
2462    public static final int HTML_TAG_START = JavadocParser.RULE_htmlTagStart + RULE_TYPES_OFFSET;
2463    /** End html tag. */
2464    public static final int HTML_TAG_END = JavadocParser.RULE_htmlTagEnd + RULE_TYPES_OFFSET;
2465
2466    /** Option html tag. */
2467    public static final int OPTION = JavadocParser.RULE_option + RULE_TYPES_OFFSET;
2468    /** Start option tag. */
2469    public static final int OPTION_TAG_START =
2470            JavadocParser.RULE_optionTagStart + RULE_TYPES_OFFSET;
2471    /** End option tag. */
2472    public static final int OPTION_TAG_END = JavadocParser.RULE_optionTagEnd
2473            + RULE_TYPES_OFFSET;
2474
2475    /**
2476     * Table body html tag.
2477     *
2478     * <p><b>Example:</b></p>
2479     * <pre>{@code <table><tbody></tbody></table>}</pre>
2480     * <b>Tree:</b>
2481     * <pre>
2482     * {@code
2483     *    JAVADOC -> JAVADOC
2484     *      |--NEWLINE -> \r\n
2485     *      |--LEADING_ASTERISK ->  *
2486     *      |--TEXT ->
2487     *      |--HTML_ELEMENT -> HTML_ELEMENT
2488     *      |   `--HTML_TAG -> HTML_TAG
2489     *      |       |--HTML_ELEMENT_START -> HTML_ELEMENT_START
2490     *      |       |   |--START -> <
2491     *      |       |   |--HTML_TAG_NAME -> table
2492     *      |       |   `--END -> >
2493     *      |       |--HTML_ELEMENT -> HTML_ELEMENT
2494     *      |       |   `--TBODY -> TBODY
2495     *      |       |       |--TBODY_TAG_START -> TBODY_TAG_START
2496     *      |       |       |   |--START -> <
2497     *      |       |       |   |--TBODY_HTML_TAG_NAME -> tbody
2498     *      |       |       |   `--END -> >
2499     *      |       |       `--TBODY_TAG_END -> TBODY_TAG_END
2500     *      |       |           |--START -> <
2501     *      |       |           |--SLASH -> /
2502     *      |       |           |--TBODY_HTML_TAG_NAME -> tbody
2503     *      |       |           `--END -> >
2504     *      |       `--HTML_ELEMENT_END -> HTML_ELEMENT_END
2505     *      |           |--START -> <
2506     *      |           |--SLASH -> /
2507     *      |           |--HTML_TAG_NAME -> table
2508     *      |           `--END -> >
2509     *      |--NEWLINE -> \r\n
2510     * }
2511     * </pre>
2512     */
2513    public static final int TBODY = JavadocParser.RULE_tbody + RULE_TYPES_OFFSET;
2514    /** Start table body tag. */
2515    public static final int TBODY_TAG_START = JavadocParser.RULE_tbodyTagStart + RULE_TYPES_OFFSET;
2516    /** End table body tag. */
2517    public static final int TBODY_TAG_END = JavadocParser.RULE_tbodyTagEnd + RULE_TYPES_OFFSET;
2518
2519    /** Table foot html tag. */
2520    public static final int TFOOT = JavadocParser.RULE_tfoot + RULE_TYPES_OFFSET;
2521    /** Start table foot tag. */
2522    public static final int TFOOT_TAG_START = JavadocParser.RULE_tfootTagStart + RULE_TYPES_OFFSET;
2523    /** End table foot tag. */
2524    public static final int TFOOT_TAG_END = JavadocParser.RULE_tfootTagEnd + RULE_TYPES_OFFSET;
2525
2526    /** Table head html tag. */
2527    public static final int THEAD = JavadocParser.RULE_thead + RULE_TYPES_OFFSET;
2528    /** Start table head tag. */
2529    public static final int THEAD_TAG_START = JavadocParser.RULE_theadTagStart + RULE_TYPES_OFFSET;
2530    /** End table head tag. */
2531    public static final int THEAD_TAG_END = JavadocParser.RULE_theadTagEnd + RULE_TYPES_OFFSET;
2532
2533    /** `optgroup` html tag. */
2534    public static final int OPTGROUP = JavadocParser.RULE_optgroup + RULE_TYPES_OFFSET;
2535    /** `optgroup` tag start. */
2536    public static final int OPTGROUP_TAG_START =
2537            JavadocParser.RULE_optgroupTagStart + RULE_TYPES_OFFSET;
2538    /** `optgroup` tag end. */
2539    public static final int OPTGROUP_TAG_END =
2540            JavadocParser.RULE_optgroupTagEnd + RULE_TYPES_OFFSET;
2541
2542    /** `rb` html tag. */
2543    public static final int RB = JavadocParser.RULE_rb + RULE_TYPES_OFFSET;
2544    /** `rb` tag start. */
2545    public static final int RB_TAG_START =
2546            JavadocParser.RULE_rbTagStart + RULE_TYPES_OFFSET;
2547    /** `rb` tag end. */
2548    public static final int RB_TAG_END =
2549            JavadocParser.RULE_rbTagEnd + RULE_TYPES_OFFSET;
2550
2551    /** `rt` html tag. */
2552    public static final int RT = JavadocParser.RULE_rt + RULE_TYPES_OFFSET;
2553    /** `rt` tag start. */
2554    public static final int RT_TAG_START =
2555            JavadocParser.RULE_rtTagStart + RULE_TYPES_OFFSET;
2556    /** `rt` tag end. */
2557    public static final int RT_TAG_END =
2558            JavadocParser.RULE_rtTagEnd + RULE_TYPES_OFFSET;
2559
2560    /** `rtc` html tag. */
2561    public static final int RTC = JavadocParser.RULE_rtc + RULE_TYPES_OFFSET;
2562    /** `rtc` tag start. */
2563    public static final int RTC_TAG_START =
2564            JavadocParser.RULE_rtcTagStart + RULE_TYPES_OFFSET;
2565    /** `rtc` tag end. */
2566    public static final int RTC_TAG_END =
2567            JavadocParser.RULE_rtcTagEnd + RULE_TYPES_OFFSET;
2568
2569    /** `rp` html tag. */
2570    public static final int RP = JavadocParser.RULE_rp + RULE_TYPES_OFFSET;
2571    /** `rp` tag start. */
2572    public static final int RP_TAG_START =
2573            JavadocParser.RULE_rpTagStart + RULE_TYPES_OFFSET;
2574    /** `rp` tag end. */
2575    public static final int RP_TAG_END =
2576            JavadocParser.RULE_rpTagEnd + RULE_TYPES_OFFSET;
2577
2578    /////////////////////// SINGLETON HTML TAGS  //////////////////////////////////////////////////
2579    /**
2580     * Parent node for all singleton html tags.
2581     */
2582    public static final int SINGLETON_ELEMENT = JavadocParser.RULE_singletonElement
2583            + RULE_TYPES_OFFSET;
2584
2585    /**
2586     * Non-special empty html tag.
2587     */
2588    public static final int EMPTY_TAG = JavadocParser.RULE_emptyTag
2589            + RULE_TYPES_OFFSET;
2590
2591    /**
2592     * Area html tag.
2593     *
2594     * <p><b>Example:</b></p>
2595     * <pre>{@code &lt area shape="rect" &gt}</pre>
2596     * <b>Tree:</b>
2597     * <pre>
2598     * {@code
2599     *   JAVADOC -> JAVADOC
2600     *        |--NEWLINE -> \n
2601     *        |--LEADING_ASTERISK ->  *
2602     *        |--TEXT ->
2603     *        |--HTML_ELEMENT -> HTML_ELEMENT
2604     *        |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2605     *        |       `--AREA_TAG -> AREA_TAG
2606     *        |           |--START -> <
2607     *        |           |--AREA_HTML_TAG_NAME -> area
2608     *        |           |--WS ->
2609     *        |           |--ATTRIBUTE -> ATTRIBUTE
2610     *        |           |   |--HTML_TAG_NAME -> shape
2611     *        |           |   |--EQUALS -> =
2612     *        |           |   `--ATTR_VALUE -> "rect"
2613     *        |           `--END -> >
2614     *        |--TEXT ->
2615     *        |--NEWLINE -> \n
2616     *        |--TEXT ->
2617     * }
2618     * </pre>
2619     */
2620    public static final int AREA_TAG = JavadocParser.RULE_areaTag + RULE_TYPES_OFFSET;
2621
2622    /** Base html tag. */
2623    public static final int BASE_TAG = JavadocParser.RULE_baseTag + RULE_TYPES_OFFSET;
2624
2625    /** Basefont html tag. */
2626    public static final int BASEFONT_TAG = JavadocParser.RULE_basefontTag + RULE_TYPES_OFFSET;
2627
2628    /** Br html tag. */
2629    public static final int BR_TAG = JavadocParser.RULE_brTag + RULE_TYPES_OFFSET;
2630
2631    /** Col html tag. */
2632    public static final int COL_TAG = JavadocParser.RULE_colTag + RULE_TYPES_OFFSET;
2633
2634    /** Frame html tag. */
2635    public static final int FRAME_TAG = JavadocParser.RULE_frameTag + RULE_TYPES_OFFSET;
2636
2637    /**
2638     * Hr html tag.
2639     *
2640     * <p><b>Example:</b></p>
2641     * <pre>{@code text above line<hr> test after line}</pre>
2642     * <b>Tree:</b>
2643     * <pre>
2644     * {@code
2645     *   |--LEADING_ASTERISK ->  *
2646     *   |--TEXT ->  text above line
2647     *   |--HTML_ELEMENT -> HTML_ELEMENT
2648     *   |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2649     *   |       `--HR_TAG -> HR_TAG
2650     *   |           |--START -> <
2651     *   |           |--HR_HTML_TAG_NAME -> hr
2652     *   |           `--END -> >
2653     *   |--TEXT ->  test after line
2654     *   |--NEWLINE -> \r\n
2655     *   |--TEXT ->
2656     * }
2657     * </pre>
2658     */
2659    public static final int HR_TAG = JavadocParser.RULE_hrTag + RULE_TYPES_OFFSET;
2660
2661    /**
2662     * Img html tag.
2663     *
2664     * <p><b>Example:</b></p>
2665     * <pre>{@code <img src="./image.png" alt="image description" width="200" height="100"> }</pre>
2666     * <b>Tree:</b>
2667     * <pre>
2668     * {@code
2669     *   `--JAVADOC -> JAVADOC
2670     *        |--NEWLINE -> \r\n
2671     *        |--LEADING_ASTERISK ->  *
2672     *        |--TEXT ->
2673     *        |--HTML_ELEMENT -> HTML_ELEMENT
2674     *        |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2675     *        |       `--IMG_TAG -> IMG_TAG
2676     *        |           |--START -> <
2677     *        |           |--IMG_HTML_TAG_NAME -> img
2678     *        |           |--WS ->
2679     *        |           |--ATTRIBUTE -> ATTRIBUTE
2680     *        |           |   |--HTML_TAG_NAME -> src
2681     *        |           |   |--EQUALS -> =
2682     *        |           |   `--ATTR_VALUE -> "./image.png"
2683     *        |           |--WS ->
2684     *        |           |--ATTRIBUTE -> ATTRIBUTE
2685     *        |           |   |--HTML_TAG_NAME -> alt
2686     *        |           |   |--EQUALS -> =
2687     *        |           |   `--ATTR_VALUE -> "image description"
2688     *        |           |--WS ->
2689     *        |           |--ATTRIBUTE -> ATTRIBUTE
2690     *        |           |   |--HTML_TAG_NAME -> width
2691     *        |           |   |--EQUALS -> =
2692     *        |           |   `--ATTR_VALUE -> "200"
2693     *        |           |--WS ->
2694     *        |           |--ATTRIBUTE -> ATTRIBUTE
2695     *        |           |   |--HTML_TAG_NAME -> height
2696     *        |           |   |--EQUALS -> =
2697     *        |           |   `--ATTR_VALUE -> "100"
2698     *        |           `--END -> >
2699     *        |--NEWLINE -> \r\n
2700     *        |--TEXT ->
2701     * }
2702     * </pre>
2703     */
2704    public static final int IMG_TAG = JavadocParser.RULE_imgTag + RULE_TYPES_OFFSET;
2705
2706    /**
2707     * Input html tag.
2708     *
2709     * <p><b>Example:</b></p>
2710     * <pre>{@code Type here: <input type="text" id="id" name="name"> }</pre>
2711     * <b>Tree:</b>
2712     * <pre>
2713     * {@code
2714     *   JAVADOC -> JAVADOC
2715     *        |--NEWLINE -> \r\n
2716     *        |--LEADING_ASTERISK ->  *
2717     *        |--TEXT ->   Type here:
2718     *        |--HTML_ELEMENT -> HTML_ELEMENT
2719     *        |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2720     *        |       `--INPUT_TAG -> INPUT_TAG
2721     *        |           |--START -> <
2722     *        |           |--INPUT_HTML_TAG_NAME -> input
2723     *        |           |--WS ->
2724     *        |           |--ATTRIBUTE -> ATTRIBUTE
2725     *        |           |   |--HTML_TAG_NAME -> type
2726     *        |           |   |--EQUALS -> =
2727     *        |           |   `--ATTR_VALUE -> "text"
2728     *        |           |--WS ->
2729     *        |           |--ATTRIBUTE -> ATTRIBUTE
2730     *        |           |   |--HTML_TAG_NAME -> id
2731     *        |           |   |--EQUALS -> =
2732     *        |           |   `--ATTR_VALUE -> "id"
2733     *        |           |--WS ->
2734     *        |           |--ATTRIBUTE -> ATTRIBUTE
2735     *        |           |   |--HTML_TAG_NAME -> name
2736     *        |           |   |--EQUALS -> =
2737     *        |           |   `--ATTR_VALUE -> "name"
2738     *        |           `--END -> >
2739     *        |--NEWLINE -> \r\n
2740     *        |--TEXT ->
2741     * }
2742     * </pre>
2743     */
2744    public static final int INPUT_TAG = JavadocParser.RULE_inputTag + RULE_TYPES_OFFSET;
2745
2746    /** Isindex html tag. */
2747    public static final int ISINDEX_TAG = JavadocParser.RULE_isindexTag + RULE_TYPES_OFFSET;
2748
2749    /** Link html tag. */
2750    public static final int LINK_TAG = JavadocParser.RULE_linkTag + RULE_TYPES_OFFSET;
2751
2752    /**
2753     * Meta html tag.
2754     *
2755     * <p><b>Example:</b></p>
2756     * <pre>{@code <meta charset="UTF-8"> }</pre>
2757     * <b>Tree:</b>
2758     * <pre>
2759     * {@code
2760     *   `--JAVADOC -> JAVADOC
2761     *        |--NEWLINE -> \r\n
2762     *        |--LEADING_ASTERISK ->  *
2763     *        |--TEXT ->
2764     *        |--HTML_ELEMENT -> HTML_ELEMENT
2765     *        |   `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT
2766     *        |       `--META_TAG -> META_TAG
2767     *        |           |--START -> <
2768     *        |           |--META_HTML_TAG_NAME -> meta
2769     *        |           |--WS ->
2770     *        |           |--ATTRIBUTE -> ATTRIBUTE
2771     *        |           |   |--HTML_TAG_NAME -> charset
2772     *        |           |   |--EQUALS -> =
2773     *        |           |   `--ATTR_VALUE -> "UTF-8"
2774     *        |           `--END -> >
2775     *        |--NEWLINE -> \r\n
2776     *        |--TEXT ->
2777     * }
2778     * </pre>
2779     */
2780    public static final int META_TAG = JavadocParser.RULE_metaTag + RULE_TYPES_OFFSET;
2781
2782    /** Param html tag. */
2783    public static final int PARAM_TAG = JavadocParser.RULE_paramTag + RULE_TYPES_OFFSET;
2784
2785    /**
2786     * HTML void element {@code <embed>}.
2787     *
2788     * @see #SINGLETON_ELEMENT
2789     * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-embed">
2790     *     W3 docs</a>
2791     */
2792    public static final int EMBED_TAG = JavadocParser.RULE_embedTag + RULE_TYPES_OFFSET;
2793
2794    /**
2795     * HTML void element {@code <keygen>}.
2796     *
2797     * @see #SINGLETON_ELEMENT
2798     * @see <a href="https://www.w3.org/TR/html51/sec-forms.html#elementdef-keygen">
2799     *     W3 docs</a>
2800     */
2801    public static final int KEYGEN_TAG = JavadocParser.RULE_keygenTag + RULE_TYPES_OFFSET;
2802
2803    /**
2804     * HTML void element {@code <source>}.
2805     *
2806     * @see #SINGLETON_ELEMENT
2807     * @see <a href=
2808     *     "https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-media-source">
2809     *     W3 docs</a>
2810     */
2811    public static final int SOURCE_TAG = JavadocParser.RULE_sourceTag + RULE_TYPES_OFFSET;
2812
2813    /**
2814     * HTML void element {@code <track>}.
2815     *
2816     * @see #SINGLETON_ELEMENT
2817     * @see <a
2818     *     href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-track">
2819     *     W3 docs</a>
2820     */
2821    public static final int TRACK_TAG = JavadocParser.RULE_trackTag + RULE_TYPES_OFFSET;
2822
2823    /**
2824     * HTML void element {@code <wbr>}.
2825     *
2826     * @see #SINGLETON_ELEMENT
2827     * @see <a href="https://www.w3.org/TR/html51/textlevel-semantics.html#elementdef-wbr">
2828     *     W3 docs</a>
2829     */
2830    public static final int WBR_TAG = JavadocParser.RULE_wbrTag + RULE_TYPES_OFFSET;
2831
2832    ///////////////////////////////////////////////////////////////////////////////////////////////
2833
2834    /**
2835     * Html comment: <code>&lt;&#33;-- --&gt;</code>.
2836     *
2837     * @noinspection HtmlTagCanBeJavadocTag
2838     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
2839     *      replaced with Javadoc tag
2840     */
2841    public static final int HTML_COMMENT = JavadocParser.RULE_htmlComment
2842            + RULE_TYPES_OFFSET;
2843    /**
2844     * CHAR and WS sequence.
2845     */
2846    public static final int TEXT = JavadocParser.RULE_text + RULE_TYPES_OFFSET;
2847
2848    /** Empty private constructor of the current class. */
2849    private JavadocTokenTypes() {
2850    }
2851
2852}