# Generated from /home/sergey/PycharmProjects/idl2js/grammar/WebIDLParser.g4 by ANTLR 4.9.2
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\\")
        buf.write("\u0344\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
        buf.write("V\4W\tW\4X\tX\4Y\tY\3\2\5\2\u00b4\n\2\3\2\3\2\3\3\6\3")
        buf.write("\u00b9\n\3\r\3\16\3\u00ba\3\4\5\4\u00be\n\4\3\4\3\4\3")
        buf.write("\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5\u00c9\n\5\3\6\3\6\3\6\3")
        buf.write("\6\5\6\u00cf\n\6\3\7\3\7\5\7\u00d3\n\7\3\b\3\b\5\b\u00d7")
        buf.write("\n\b\3\b\3\b\7\b\u00db\n\b\f\b\16\b\u00de\13\b\3\b\3\b")
        buf.write("\3\b\3\t\3\t\3\t\3\t\3\n\3\n\5\n\u00e9\n\n\3\13\3\13\3")
        buf.write("\13\7\13\u00ee\n\13\f\13\16\13\u00f1\13\13\3\13\3\13\3")
        buf.write("\13\3\f\5\f\u00f7\n\f\3\f\3\f\3\r\3\r\5\r\u00fd\n\r\3")
        buf.write("\16\5\16\u0100\n\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17")
        buf.write("\3\17\3\17\3\17\3\17\3\17\5\17\u010e\n\17\3\20\3\20\3")
        buf.write("\20\3\21\3\21\3\21\3\21\7\21\u0117\n\21\f\21\16\21\u011a")
        buf.write("\13\21\3\21\3\21\3\21\3\22\5\22\u0120\n\22\3\22\3\22\3")
        buf.write("\23\3\23\3\23\3\23\5\23\u0128\n\23\3\23\5\23\u012b\n\23")
        buf.write("\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\7\25")
        buf.write("\u0137\n\25\f\25\16\25\u013a\13\25\3\25\3\25\5\25\u013e")
        buf.write("\n\25\3\26\5\26\u0141\n\26\3\26\3\26\3\27\3\27\5\27\u0147")
        buf.write("\n\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31")
        buf.write("\5\31\u0153\n\31\3\32\3\32\3\32\3\33\3\33\3\33\5\33\u015b")
        buf.write("\n\33\3\34\3\34\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36")
        buf.write("\3\37\3\37\5\37\u0169\n\37\3 \3 \3 \3 \3 \3 \3 \5 \u0172")
        buf.write("\n \3!\5!\u0175\n!\3!\3!\3\"\3\"\3\"\3#\5#\u017d\n#\3")
        buf.write("#\3#\5#\u0181\n#\3#\3#\3#\3$\3$\5$\u0188\n$\3%\3%\3&\3")
        buf.write("&\3&\7&\u018f\n&\f&\16&\u0192\13&\3\'\5\'\u0195\n\'\3")
        buf.write("\'\3\'\3(\3(\3(\3(\5(\u019d\n(\3(\3(\5(\u01a1\n(\3(\3")
        buf.write("(\5(\u01a5\n(\3)\3)\5)\u01a9\n)\3*\3*\3*\5*\u01ae\n*\3")
        buf.write("*\3*\3*\3+\3+\3+\5+\u01b6\n+\3,\5,\u01b9\n,\3,\3,\5,\u01bd")
        buf.write("\n,\3-\3-\3-\3.\5.\u01c3\n.\3.\3.\5.\u01c7\n.\3/\3/\3")
        buf.write("/\3/\3/\5/\u01ce\n/\3/\3/\3/\3/\3/\3/\3/\3/\3/\5/\u01d9")
        buf.write("\n/\3/\3/\5/\u01dd\n/\3/\3/\5/\u01e1\n/\3\60\3\60\5\60")
        buf.write("\u01e5\n\60\3\60\3\60\3\61\3\61\3\62\5\62\u01ec\n\62\3")
        buf.write("\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\63\3\63\3\64")
        buf.write("\5\64\u01f9\n\64\3\64\3\64\3\64\3\64\3\64\3\64\3\65\5")
        buf.write("\65\u0202\n\65\3\65\3\65\3\65\3\65\7\65\u0208\n\65\f\65")
        buf.write("\16\65\u020b\13\65\3\65\3\65\3\65\3\66\5\66\u0211\n\66")
        buf.write("\3\66\3\66\3\67\3\67\3\67\5\67\u0218\n\67\38\38\38\58")
        buf.write("\u021d\n8\38\38\78\u0221\n8\f8\168\u0224\138\38\38\38")
        buf.write("\38\38\38\38\78\u022d\n8\f8\168\u0230\138\38\38\58\u0234")
        buf.write("\n8\39\59\u0237\n9\39\39\3:\3:\3:\3:\3:\3:\3:\3:\5:\u0243")
        buf.write("\n:\3:\3:\5:\u0247\n:\3;\3;\3;\3<\3<\3<\3<\3<\3<\5<\u0252")
        buf.write("\n<\7<\u0254\n<\f<\16<\u0257\13<\3<\3<\3<\3=\3=\3=\3=")
        buf.write("\3=\5=\u0261\n=\3=\3=\3=\3>\3>\3>\3>\3>\3?\3?\3?\5?\u026e")
        buf.write("\n?\5?\u0270\n?\3@\5@\u0273\n@\3@\3@\3A\3A\3A\3A\7A\u027b")
        buf.write("\nA\fA\16A\u027e\13A\3A\3A\3B\3B\3B\3B\3B\3B\3B\3B\3B")
        buf.write("\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\5B\u0298\nB\3")
        buf.write("C\3C\3C\7C\u029d\nC\fC\16C\u02a0\13C\3D\3D\3E\3E\5E\u02a6")
        buf.write("\nE\3F\3F\5F\u02aa\nF\3F\3F\5F\u02ae\nF\3F\3F\5F\u02b2")
        buf.write("\nF\3G\3G\3G\3G\6G\u02b8\nG\rG\16G\u02b9\3G\3G\3H\5H\u02bf")
        buf.write("\nH\3H\3H\5H\u02c3\nH\3H\5H\u02c6\nH\3H\3H\5H\u02ca\n")
        buf.write("H\3H\3H\5H\u02ce\nH\5H\u02d0\nH\3I\3I\3I\3I\3I\3J\3J\3")
        buf.write("J\3J\3J\3J\3J\5J\u02de\nJ\3K\3K\3K\3K\3K\5K\u02e5\nK\3")
        buf.write("L\3L\5L\u02e9\nL\3M\3M\3M\3M\3M\3N\3N\3N\3N\3N\3N\3N\3")
        buf.write("O\5O\u02f8\nO\3O\3O\3P\3P\3Q\5Q\u02ff\nQ\3Q\3Q\3R\3R\3")
        buf.write("R\5R\u0306\nR\5R\u0308\nR\3S\3S\3T\3T\3U\3U\3V\3V\3W\3")
        buf.write("W\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3")
        buf.write("X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3")
        buf.write("X\3X\3X\3X\3X\3X\3X\3X\3X\5X\u0340\nX\3Y\3Y\3Y\2\2Z\2")
        buf.write("\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64")
        buf.write("\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084")
        buf.write("\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096")
        buf.write("\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8")
        buf.write("\u00aa\u00ac\u00ae\u00b0\2\13\4\2\26\26<<\5\2\36\36&&")
        buf.write("??\5\2%%\64\64==\4\2!!$$\5\2\32\32  HH\3\2JT\4\2##DD\6")
        buf.write("\2\'\'..\61\61VV\17\2\26\27\33\37\"\"&&(+--/\6088::<<")
        buf.write(">?ABEF\2\u038f\2\u00b3\3\2\2\2\4\u00b8\3\2\2\2\6\u00bd")
        buf.write("\3\2\2\2\b\u00c8\3\2\2\2\n\u00ce\3\2\2\2\f\u00d2\3\2\2")
        buf.write("\2\16\u00d4\3\2\2\2\20\u00e2\3\2\2\2\22\u00e8\3\2\2\2")
        buf.write("\24\u00ea\3\2\2\2\26\u00f6\3\2\2\2\30\u00fc\3\2\2\2\32")
        buf.write("\u00ff\3\2\2\2\34\u010d\3\2\2\2\36\u010f\3\2\2\2 \u0112")
        buf.write("\3\2\2\2\"\u011f\3\2\2\2$\u012a\3\2\2\2&\u012c\3\2\2\2")
        buf.write("(\u013d\3\2\2\2*\u0140\3\2\2\2,\u0146\3\2\2\2.\u0148\3")
        buf.write("\2\2\2\60\u0152\3\2\2\2\62\u0154\3\2\2\2\64\u015a\3\2")
        buf.write("\2\2\66\u015c\3\2\2\28\u015e\3\2\2\2:\u0161\3\2\2\2<\u0168")
        buf.write("\3\2\2\2>\u0171\3\2\2\2@\u0174\3\2\2\2B\u0178\3\2\2\2")
        buf.write("D\u017c\3\2\2\2F\u0187\3\2\2\2H\u0189\3\2\2\2J\u018b\3")
        buf.write("\2\2\2L\u0194\3\2\2\2N\u01a4\3\2\2\2P\u01a8\3\2\2\2R\u01aa")
        buf.write("\3\2\2\2T\u01b2\3\2\2\2V\u01bc\3\2\2\2X\u01be\3\2\2\2")
        buf.write("Z\u01c6\3\2\2\2\\\u01e0\3\2\2\2^\u01e2\3\2\2\2`\u01e8")
        buf.write("\3\2\2\2b\u01eb\3\2\2\2d\u01f5\3\2\2\2f\u01f8\3\2\2\2")
        buf.write("h\u0201\3\2\2\2j\u0210\3\2\2\2l\u0217\3\2\2\2n\u0233\3")
        buf.write("\2\2\2p\u0236\3\2\2\2r\u0246\3\2\2\2t\u0248\3\2\2\2v\u024b")
        buf.write("\3\2\2\2x\u025b\3\2\2\2z\u0265\3\2\2\2|\u026f\3\2\2\2")
        buf.write("~\u0272\3\2\2\2\u0080\u0276\3\2\2\2\u0082\u0297\3\2\2")
        buf.write("\2\u0084\u0299\3\2\2\2\u0086\u02a1\3\2\2\2\u0088\u02a5")
        buf.write("\3\2\2\2\u008a\u02b1\3\2\2\2\u008c\u02b3\3\2\2\2\u008e")
        buf.write("\u02cf\3\2\2\2\u0090\u02d1\3\2\2\2\u0092\u02dd\3\2\2\2")
        buf.write("\u0094\u02e4\3\2\2\2\u0096\u02e8\3\2\2\2\u0098\u02ea\3")
        buf.write("\2\2\2\u009a\u02ef\3\2\2\2\u009c\u02f7\3\2\2\2\u009e\u02fb")
        buf.write("\3\2\2\2\u00a0\u02fe\3\2\2\2\u00a2\u0307\3\2\2\2\u00a4")
        buf.write("\u0309\3\2\2\2\u00a6\u030b\3\2\2\2\u00a8\u030d\3\2\2\2")
        buf.write("\u00aa\u030f\3\2\2\2\u00ac\u0311\3\2\2\2\u00ae\u033f\3")
        buf.write("\2\2\2\u00b0\u0341\3\2\2\2\u00b2\u00b4\5\4\3\2\u00b3\u00b2")
        buf.write("\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5")
        buf.write("\u00b6\7\2\2\3\u00b6\3\3\2\2\2\u00b7\u00b9\5\6\4\2\u00b8")
        buf.write("\u00b7\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00b8\3\2\2\2")
        buf.write("\u00ba\u00bb\3\2\2\2\u00bb\5\3\2\2\2\u00bc\u00be\5\u0080")
        buf.write("A\2\u00bd\u00bc\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00bf")
        buf.write("\3\2\2\2\u00bf\u00c0\5\b\5\2\u00c0\7\3\2\2\2\u00c1\u00c9")
        buf.write("\5\n\6\2\u00c2\u00c9\5h\65\2\u00c3\u00c9\5\20\t\2\u00c4")
        buf.write("\u00c9\5n8\2\u00c5\u00c9\5v<\2\u00c6\u00c9\5z>\2\u00c7")
        buf.write("\u00c9\5&\24\2\u00c8\u00c1\3\2\2\2\u00c8\u00c2\3\2\2\2")
        buf.write("\u00c8\u00c3\3\2\2\2\u00c8\u00c4\3\2\2\2\u00c8\u00c5\3")
        buf.write("\2\2\2\u00c8\u00c6\3\2\2\2\u00c8\u00c7\3\2\2\2\u00c9\t")
        buf.write("\3\2\2\2\u00ca\u00cb\7\33\2\2\u00cb\u00cf\5(\25\2\u00cc")
        buf.write("\u00cd\7*\2\2\u00cd\u00cf\5\f\7\2\u00ce\u00ca\3\2\2\2")
        buf.write("\u00ce\u00cc\3\2\2\2\u00cf\13\3\2\2\2\u00d0\u00d3\5\16")
        buf.write("\b\2\u00d1\u00d3\5 \21\2\u00d2\u00d0\3\2\2\2\u00d2\u00d1")
        buf.write("\3\2\2\2\u00d3\r\3\2\2\2\u00d4\u00d6\7[\2\2\u00d5\u00d7")
        buf.write("\5\36\20\2\u00d6\u00d5\3\2\2\2\u00d6\u00d7\3\2\2\2\u00d7")
        buf.write("\u00d8\3\2\2\2\u00d8\u00dc\7\13\2\2\u00d9\u00db\5\26\f")
        buf.write("\2\u00da\u00d9\3\2\2\2\u00db\u00de\3\2\2\2\u00dc\u00da")
        buf.write("\3\2\2\2\u00dc\u00dd\3\2\2\2\u00dd\u00df\3\2\2\2\u00de")
        buf.write("\u00dc\3\2\2\2\u00df\u00e0\7\f\2\2\u00e0\u00e1\7\20\2")
        buf.write("\2\u00e1\17\3\2\2\2\u00e2\u00e3\78\2\2\u00e3\u00e4\7*")
        buf.write("\2\2\u00e4\u00e5\5\22\n\2\u00e5\21\3\2\2\2\u00e6\u00e9")
        buf.write("\5\24\13\2\u00e7\u00e9\5 \21\2\u00e8\u00e6\3\2\2\2\u00e8")
        buf.write("\u00e7\3\2\2\2\u00e9\23\3\2\2\2\u00ea\u00eb\7[\2\2\u00eb")
        buf.write("\u00ef\7\13\2\2\u00ec\u00ee\5\32\16\2\u00ed\u00ec\3\2")
        buf.write("\2\2\u00ee\u00f1\3\2\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0")
        buf.write("\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1\u00ef\3\2\2\2\u00f2")
        buf.write("\u00f3\7\f\2\2\u00f3\u00f4\7\20\2\2\u00f4\25\3\2\2\2\u00f5")
        buf.write("\u00f7\5\u0080A\2\u00f6\u00f5\3\2\2\2\u00f6\u00f7\3\2")
        buf.write("\2\2\u00f7\u00f8\3\2\2\2\u00f8\u00f9\5\30\r\2\u00f9\27")
        buf.write("\3\2\2\2\u00fa\u00fd\5\34\17\2\u00fb\u00fd\5R*\2\u00fc")
        buf.write("\u00fa\3\2\2\2\u00fc\u00fb\3\2\2\2\u00fd\31\3\2\2\2\u00fe")
        buf.write("\u0100\5\u0080A\2\u00ff\u00fe\3\2\2\2\u00ff\u0100\3\2")
        buf.write("\2\2\u0100\u0101\3\2\2\2\u0101\u0102\5\34\17\2\u0102\33")
        buf.write("\3\2\2\2\u0103\u010e\5.\30\2\u0104\u010e\5@!\2\u0105\u010e")
        buf.write("\5T+\2\u0106\u010e\5X-\2\u0107\u010e\5\\/\2\u0108\u010e")
        buf.write("\5\62\32\2\u0109\u010e\5\66\34\2\u010a\u010e\5`\61\2\u010b")
        buf.write("\u010e\5d\63\2\u010c\u010e\58\35\2\u010d\u0103\3\2\2\2")
        buf.write("\u010d\u0104\3\2\2\2\u010d\u0105\3\2\2\2\u010d\u0106\3")
        buf.write("\2\2\2\u010d\u0107\3\2\2\2\u010d\u0108\3\2\2\2\u010d\u0109")
        buf.write("\3\2\2\2\u010d\u010a\3\2\2\2\u010d\u010b\3\2\2\2\u010d")
        buf.write("\u010c\3\2\2\2\u010e\35\3\2\2\2\u010f\u0110\7\21\2\2\u0110")
        buf.write("\u0111\7[\2\2\u0111\37\3\2\2\2\u0112\u0113\7/\2\2\u0113")
        buf.write("\u0114\7[\2\2\u0114\u0118\7\13\2\2\u0115\u0117\5\"\22")
        buf.write("\2\u0116\u0115\3\2\2\2\u0117\u011a\3\2\2\2\u0118\u0116")
        buf.write("\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011b\3\2\2\2\u011a")
        buf.write("\u0118\3\2\2\2\u011b\u011c\7\f\2\2\u011c\u011d\7\20\2")
        buf.write("\2\u011d!\3\2\2\2\u011e\u0120\5\u0080A\2\u011f\u011e\3")
        buf.write("\2\2\2\u011f\u0120\3\2\2\2\u0120\u0121\3\2\2\2\u0121\u0122")
        buf.write("\5$\23\2\u0122#\3\2\2\2\u0123\u012b\5.\30\2\u0124\u012b")
        buf.write("\5B\"\2\u0125\u012b\5T+\2\u0126\u0128\7:\2\2\u0127\u0126")
        buf.write("\3\2\2\2\u0127\u0128\3\2\2\2\u0128\u0129\3\2\2\2\u0129")
        buf.write("\u012b\5:\36\2\u012a\u0123\3\2\2\2\u012a\u0124\3\2\2\2")
        buf.write("\u012a\u0125\3\2\2\2\u012a\u0127\3\2\2\2\u012b%\3\2\2")
        buf.write("\2\u012c\u012d\7[\2\2\u012d\u012e\7(\2\2\u012e\u012f\7")
        buf.write("[\2\2\u012f\u0130\7\20\2\2\u0130\'\3\2\2\2\u0131\u013e")
        buf.write("\5x=\2\u0132\u0133\7*\2\2\u0133\u0134\7[\2\2\u0134\u0138")
        buf.write("\7\13\2\2\u0135\u0137\5*\26\2\u0136\u0135\3\2\2\2\u0137")
        buf.write("\u013a\3\2\2\2\u0138\u0136\3\2\2\2\u0138\u0139\3\2\2\2")
        buf.write("\u0139\u013b\3\2\2\2\u013a\u0138\3\2\2\2\u013b\u013c\7")
        buf.write("\f\2\2\u013c\u013e\7\20\2\2\u013d\u0131\3\2\2\2\u013d")
        buf.write("\u0132\3\2\2\2\u013e)\3\2\2\2\u013f\u0141\5\u0080A\2\u0140")
        buf.write("\u013f\3\2\2\2\u0140\u0141\3\2\2\2\u0141\u0142\3\2\2\2")
        buf.write("\u0142\u0143\5,\27\2\u0143+\3\2\2\2\u0144\u0147\5.\30")
        buf.write("\2\u0145\u0147\5B\"\2\u0146\u0144\3\2\2\2\u0146\u0145")
        buf.write("\3\2\2\2\u0147-\3\2\2\2\u0148\u0149\7\34\2\2\u0149\u014a")
        buf.write("\5\u0096L\2\u014a\u014b\7[\2\2\u014b\u014c\7\5\2\2\u014c")
        buf.write("\u014d\5\60\31\2\u014d\u014e\7\20\2\2\u014e/\3\2\2\2\u014f")
        buf.write("\u0153\5\u00a8U\2\u0150\u0153\5\u00aaV\2\u0151\u0153\7")
        buf.write("U\2\2\u0152\u014f\3\2\2\2\u0152\u0150\3\2\2\2\u0152\u0151")
        buf.write("\3\2\2\2\u0153\61\3\2\2\2\u0154\u0155\7:\2\2\u0155\u0156")
        buf.write("\5\64\33\2\u0156\63\3\2\2\2\u0157\u015b\5:\36\2\u0158")
        buf.write("\u015b\5b\62\2\u0159\u015b\5f\64\2\u015a\u0157\3\2\2\2")
        buf.write("\u015a\u0158\3\2\2\2\u015a\u0159\3\2\2\2\u015b\65\3\2")
        buf.write("\2\2\u015c\u015d\5:\36\2\u015d\67\3\2\2\2\u015e\u015f")
        buf.write("\7)\2\2\u015f\u0160\5:\36\2\u01609\3\2\2\2\u0161\u0162")
        buf.write("\7\27\2\2\u0162\u0163\5~@\2\u0163\u0164\5<\37\2\u0164")
        buf.write("\u0165\7\20\2\2\u0165;\3\2\2\2\u0166\u0169\t\2\2\2\u0167")
        buf.write("\u0169\7[\2\2\u0168\u0166\3\2\2\2\u0168\u0167\3\2\2\2")
        buf.write("\u0169=\3\2\2\2\u016a\u0172\5\60\31\2\u016b\u0172\7W\2")
        buf.write("\2\u016c\u016d\7\t\2\2\u016d\u0172\7\n\2\2\u016e\u016f")
        buf.write("\7\13\2\2\u016f\u0172\7\f\2\2\u0170\u0172\7\62\2\2\u0171")
        buf.write("\u016a\3\2\2\2\u0171\u016b\3\2\2\2\u0171\u016c\3\2\2\2")
        buf.write("\u0171\u016e\3\2\2\2\u0171\u0170\3\2\2\2\u0172?\3\2\2")
        buf.write("\2\u0173\u0175\t\3\2\2\u0174\u0173\3\2\2\2\u0174\u0175")
        buf.write("\3\2\2\2\u0175\u0176\3\2\2\2\u0176\u0177\5B\"\2\u0177")
        buf.write("A\3\2\2\2\u0178\u0179\5\u0088E\2\u0179\u017a\5D#\2\u017a")
        buf.write("C\3\2\2\2\u017b\u017d\5F$\2\u017c\u017b\3\2\2\2\u017c")
        buf.write("\u017d\3\2\2\2\u017d\u017e\3\2\2\2\u017e\u0180\7\7\2\2")
        buf.write("\u017f\u0181\5J&\2\u0180\u017f\3\2\2\2\u0180\u0181\3\2")
        buf.write("\2\2\u0181\u0182\3\2\2\2\u0182\u0183\7\b\2\2\u0183\u0184")
        buf.write("\7\20\2\2\u0184E\3\2\2\2\u0185\u0188\5H%\2\u0186\u0188")
        buf.write("\7[\2\2\u0187\u0185\3\2\2\2\u0187\u0186\3\2\2\2\u0188")
        buf.write("G\3\2\2\2\u0189\u018a\7(\2\2\u018aI\3\2\2\2\u018b\u0190")
        buf.write("\5L\'\2\u018c\u018d\7\17\2\2\u018d\u018f\5L\'\2\u018e")
        buf.write("\u018c\3\2\2\2\u018f\u0192\3\2\2\2\u0190\u018e\3\2\2\2")
        buf.write("\u0190\u0191\3\2\2\2\u0191K\3\2\2\2\u0192\u0190\3\2\2")
        buf.write("\2\u0193\u0195\5\u0080A\2\u0194\u0193\3\2\2\2\u0194\u0195")
        buf.write("\3\2\2\2\u0195\u0196\3\2\2\2\u0196\u0197\5N(\2\u0197M")
        buf.write("\3\2\2\2\u0198\u0199\7\66\2\2\u0199\u019a\5~@\2\u019a")
        buf.write("\u019c\5P)\2\u019b\u019d\5t;\2\u019c\u019b\3\2\2\2\u019c")
        buf.write("\u019d\3\2\2\2\u019d\u01a5\3\2\2\2\u019e\u01a0\5|?\2\u019f")
        buf.write("\u01a1\7\23\2\2\u01a0\u019f\3\2\2\2\u01a0\u01a1\3\2\2")
        buf.write("\2\u01a1\u01a2\3\2\2\2\u01a2\u01a3\5P)\2\u01a3\u01a5\3")
        buf.write("\2\2\2\u01a4\u0198\3\2\2\2\u01a4\u019e\3\2\2\2\u01a5O")
        buf.write("\3\2\2\2\u01a6\u01a9\5\u00b0Y\2\u01a7\u01a9\7[\2\2\u01a8")
        buf.write("\u01a6\3\2\2\2\u01a8\u01a7\3\2\2\2\u01a9Q\3\2\2\2\u01aa")
        buf.write("\u01ab\7\35\2\2\u01ab\u01ad\7\7\2\2\u01ac\u01ae\5J&\2")
        buf.write("\u01ad\u01ac\3\2\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01af\3")
        buf.write("\2\2\2\u01af\u01b0\7\b\2\2\u01b0\u01b1\7\20\2\2\u01b1")
        buf.write("S\3\2\2\2\u01b2\u01b5\7B\2\2\u01b3\u01b6\5V,\2\u01b4\u01b6")
        buf.write("\7\20\2\2\u01b5\u01b3\3\2\2\2\u01b5\u01b4\3\2\2\2\u01b6")
        buf.write("U\3\2\2\2\u01b7\u01b9\7:\2\2\u01b8\u01b7\3\2\2\2\u01b8")
        buf.write("\u01b9\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bd\5:\36\2")
        buf.write("\u01bb\u01bd\5B\"\2\u01bc\u01b8\3\2\2\2\u01bc\u01bb\3")
        buf.write("\2\2\2\u01bdW\3\2\2\2\u01be\u01bf\7A\2\2\u01bf\u01c0\5")
        buf.write("Z.\2\u01c0Y\3\2\2\2\u01c1\u01c3\7:\2\2\u01c2\u01c1\3\2")
        buf.write("\2\2\u01c2\u01c3\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4\u01c7")
        buf.write("\5:\36\2\u01c5\u01c7\5B\"\2\u01c6\u01c2\3\2\2\2\u01c6")
        buf.write("\u01c5\3\2\2\2\u01c7[\3\2\2\2\u01c8\u01c9\7+\2\2\u01c9")
        buf.write("\u01ca\7\r\2\2\u01ca\u01cd\5~@\2\u01cb\u01cc\7\17\2\2")
        buf.write("\u01cc\u01ce\5~@\2\u01cd\u01cb\3\2\2\2\u01cd\u01ce\3\2")
        buf.write("\2\2\u01ce\u01cf\3\2\2\2\u01cf\u01d0\7\16\2\2\u01d0\u01d1")
        buf.write("\7\20\2\2\u01d1\u01e1\3\2\2\2\u01d2\u01d3\7\26\2\2\u01d3")
        buf.write("\u01d4\7+\2\2\u01d4\u01d5\7\r\2\2\u01d5\u01d8\5~@\2\u01d6")
        buf.write("\u01d7\7\17\2\2\u01d7\u01d9\5~@\2\u01d8\u01d6\3\2\2\2")
        buf.write("\u01d8\u01d9\3\2\2\2\u01d9\u01da\3\2\2\2\u01da\u01dc\7")
        buf.write("\16\2\2\u01db\u01dd\5^\60\2\u01dc\u01db\3\2\2\2\u01dc")
        buf.write("\u01dd\3\2\2\2\u01dd\u01de\3\2\2\2\u01de\u01df\7\20\2")
        buf.write("\2\u01df\u01e1\3\2\2\2\u01e0\u01c8\3\2\2\2\u01e0\u01d2")
        buf.write("\3\2\2\2\u01e1]\3\2\2\2\u01e2\u01e4\7\7\2\2\u01e3\u01e5")
        buf.write("\5J&\2\u01e4\u01e3\3\2\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e6")
        buf.write("\3\2\2\2\u01e6\u01e7\7\b\2\2\u01e7_\3\2\2\2\u01e8\u01e9")
        buf.write("\5b\62\2\u01e9a\3\2\2\2\u01ea\u01ec\7:\2\2\u01eb\u01ea")
        buf.write("\3\2\2\2\u01eb\u01ec\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed")
        buf.write("\u01ee\7-\2\2\u01ee\u01ef\7\r\2\2\u01ef\u01f0\5~@\2\u01f0")
        buf.write("\u01f1\7\17\2\2\u01f1\u01f2\5~@\2\u01f2\u01f3\7\16\2\2")
        buf.write("\u01f3\u01f4\7\20\2\2\u01f4c\3\2\2\2\u01f5\u01f6\5f\64")
        buf.write("\2\u01f6e\3\2\2\2\u01f7\u01f9\7:\2\2\u01f8\u01f7\3\2\2")
        buf.write("\2\u01f8\u01f9\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u01fb")
        buf.write("\7>\2\2\u01fb\u01fc\7\r\2\2\u01fc\u01fd\5~@\2\u01fd\u01fe")
        buf.write("\7\16\2\2\u01fe\u01ff\7\20\2\2\u01ffg\3\2\2\2\u0200\u0202")
        buf.write("\78\2\2\u0201\u0200\3\2\2\2\u0201\u0202\3\2\2\2\u0202")
        buf.write("\u0203\3\2\2\2\u0203\u0204\7\60\2\2\u0204\u0205\7[\2\2")
        buf.write("\u0205\u0209\7\13\2\2\u0206\u0208\5j\66\2\u0207\u0206")
        buf.write("\3\2\2\2\u0208\u020b\3\2\2\2\u0209\u0207\3\2\2\2\u0209")
        buf.write("\u020a\3\2\2\2\u020a\u020c\3\2\2\2\u020b\u0209\3\2\2\2")
        buf.write("\u020c\u020d\7\f\2\2\u020d\u020e\7\20\2\2\u020ei\3\2\2")
        buf.write("\2\u020f\u0211\5\u0080A\2\u0210\u020f\3\2\2\2\u0210\u0211")
        buf.write("\3\2\2\2\u0211\u0212\3\2\2\2\u0212\u0213\5l\67\2\u0213")
        buf.write("k\3\2\2\2\u0214\u0218\5B\"\2\u0215\u0216\7:\2\2\u0216")
        buf.write("\u0218\5:\36\2\u0217\u0214\3\2\2\2\u0217\u0215\3\2\2\2")
        buf.write("\u0218m\3\2\2\2\u0219\u021a\7\37\2\2\u021a\u021c\7[\2")
        buf.write("\2\u021b\u021d\5\36\20\2\u021c\u021b\3\2\2\2\u021c\u021d")
        buf.write("\3\2\2\2\u021d\u021e\3\2\2\2\u021e\u0222\7\13\2\2\u021f")
        buf.write("\u0221\5p9\2\u0220\u021f\3\2\2\2\u0221\u0224\3\2\2\2\u0222")
        buf.write("\u0220\3\2\2\2\u0222\u0223\3\2\2\2\u0223\u0225\3\2\2\2")
        buf.write("\u0224\u0222\3\2\2\2\u0225\u0226\7\f\2\2\u0226\u0234\7")
        buf.write("\20\2\2\u0227\u0228\78\2\2\u0228\u0229\7\37\2\2\u0229")
        buf.write("\u022a\7[\2\2\u022a\u022e\7\13\2\2\u022b\u022d\5p9\2\u022c")
        buf.write("\u022b\3\2\2\2\u022d\u0230\3\2\2\2\u022e\u022c\3\2\2\2")
        buf.write("\u022e\u022f\3\2\2\2\u022f\u0231\3\2\2\2\u0230\u022e\3")
        buf.write("\2\2\2\u0231\u0232\7\f\2\2\u0232\u0234\7\20\2\2\u0233")
        buf.write("\u0219\3\2\2\2\u0233\u0227\3\2\2\2\u0234o\3\2\2\2\u0235")
        buf.write("\u0237\5\u0080A\2\u0236\u0235\3\2\2\2\u0236\u0237\3\2")
        buf.write("\2\2\u0237\u0238\3\2\2\2\u0238\u0239\5r:\2\u0239q\3\2")
        buf.write("\2\2\u023a\u023b\7<\2\2\u023b\u023c\5~@\2\u023c\u023d")
        buf.write("\7[\2\2\u023d\u023e\7\20\2\2\u023e\u0247\3\2\2\2\u023f")
        buf.write("\u0240\5|?\2\u0240\u0242\7[\2\2\u0241\u0243\5t;\2\u0242")
        buf.write("\u0241\3\2\2\2\u0242\u0243\3\2\2\2\u0243\u0244\3\2\2\2")
        buf.write("\u0244\u0245\7\20\2\2\u0245\u0247\3\2\2\2\u0246\u023a")
        buf.write("\3\2\2\2\u0246\u023f\3\2\2\2\u0247s\3\2\2\2\u0248\u0249")
        buf.write("\7\5\2\2\u0249\u024a\5> \2\u024au\3\2\2\2\u024b\u024c")
        buf.write("\7\"\2\2\u024c\u024d\7[\2\2\u024d\u024e\7\13\2\2\u024e")
        buf.write("\u0255\7W\2\2\u024f\u0251\7\17\2\2\u0250\u0252\7W\2\2")
        buf.write("\u0251\u0250\3\2\2\2\u0251\u0252\3\2\2\2\u0252\u0254\3")
        buf.write("\2\2\2\u0253\u024f\3\2\2\2\u0254\u0257\3\2\2\2\u0255\u0253")
        buf.write("\3\2\2\2\u0255\u0256\3\2\2\2\u0256\u0258\3\2\2\2\u0257")
        buf.write("\u0255\3\2\2\2\u0258\u0259\7\f\2\2\u0259\u025a\7\20\2")
        buf.write("\2\u025aw\3\2\2\2\u025b\u025c\7[\2\2\u025c\u025d\7\5\2")
        buf.write("\2\u025d\u025e\5\u0088E\2\u025e\u0260\7\7\2\2\u025f\u0261")
        buf.write("\5J&\2\u0260\u025f\3\2\2\2\u0260\u0261\3\2\2\2\u0261\u0262")
        buf.write("\3\2\2\2\u0262\u0263\7\b\2\2\u0263\u0264\7\20\2\2\u0264")
        buf.write("y\3\2\2\2\u0265\u0266\7E\2\2\u0266\u0267\5~@\2\u0267\u0268")
        buf.write("\7[\2\2\u0268\u0269\7\20\2\2\u0269{\3\2\2\2\u026a\u0270")
        buf.write("\5\u008aF\2\u026b\u026d\5\u008cG\2\u026c\u026e\5\u00ac")
        buf.write("W\2\u026d\u026c\3\2\2\2\u026d\u026e\3\2\2\2\u026e\u0270")
        buf.write("\3\2\2\2\u026f\u026a\3\2\2\2\u026f\u026b\3\2\2\2\u0270")
        buf.write("}\3\2\2\2\u0271\u0273\5\u0080A\2\u0272\u0271\3\2\2\2\u0272")
        buf.write("\u0273\3\2\2\2\u0273\u0274\3\2\2\2\u0274\u0275\5|?\2\u0275")
        buf.write("\177\3\2\2\2\u0276\u0277\7\t\2\2\u0277\u027c\5\u0082B")
        buf.write("\2\u0278\u0279\7\17\2\2\u0279\u027b\5\u0082B\2\u027a\u0278")
        buf.write("\3\2\2\2\u027b\u027e\3\2\2\2\u027c\u027a\3\2\2\2\u027c")
        buf.write("\u027d\3\2\2\2\u027d\u027f\3\2\2\2\u027e\u027c\3\2\2\2")
        buf.write("\u027f\u0280\7\n\2\2\u0280\u0081\3\2\2\2\u0281\u0298\7")
        buf.write("[\2\2\u0282\u0283\7[\2\2\u0283\u0284\7\5\2\2\u0284\u0285")
        buf.write("\7\7\2\2\u0285\u0286\5\u0084C\2\u0286\u0287\7\b\2\2\u0287")
        buf.write("\u0298\3\2\2\2\u0288\u0289\7[\2\2\u0289\u028a\7\5\2\2")
        buf.write("\u028a\u028b\7[\2\2\u028b\u028c\7\7\2\2\u028c\u028d\5")
        buf.write("J&\2\u028d\u028e\7\b\2\2\u028e\u0298\3\2\2\2\u028f\u0290")
        buf.write("\7[\2\2\u0290\u0291\7\5\2\2\u0291\u0298\5\u0086D\2\u0292")
        buf.write("\u0293\7[\2\2\u0293\u0294\7\7\2\2\u0294\u0295\5J&\2\u0295")
        buf.write("\u0296\7\b\2\2\u0296\u0298\3\2\2\2\u0297\u0281\3\2\2\2")
        buf.write("\u0297\u0282\3\2\2\2\u0297\u0288\3\2\2\2\u0297\u028f\3")
        buf.write("\2\2\2\u0297\u0292\3\2\2\2\u0298\u0083\3\2\2\2\u0299\u029e")
        buf.write("\5\u0086D\2\u029a\u029b\7\17\2\2\u029b\u029d\5\u0086D")
        buf.write("\2\u029c\u029a\3\2\2\2\u029d\u02a0\3\2\2\2\u029e\u029c")
        buf.write("\3\2\2\2\u029e\u029f\3\2\2\2\u029f\u0085\3\2\2\2\u02a0")
        buf.write("\u029e\3\2\2\2\u02a1\u02a2\5\u00aeX\2\u02a2\u0087\3\2")
        buf.write("\2\2\u02a3\u02a6\5|?\2\u02a4\u02a6\7I\2\2\u02a5\u02a3")
        buf.write("\3\2\2\2\u02a5\u02a4\3\2\2\2\u02a6\u0089\3\2\2\2\u02a7")
        buf.write("\u02a9\5\u0092J\2\u02a8\u02aa\5\u00acW\2\u02a9\u02a8\3")
        buf.write("\2\2\2\u02a9\u02aa\3\2\2\2\u02aa\u02b2\3\2\2\2\u02ab\u02ad")
        buf.write("\5\u0090I\2\u02ac\u02ae\5\u00acW\2\u02ad\u02ac\3\2\2\2")
        buf.write("\u02ad\u02ae\3\2\2\2\u02ae\u02b2\3\2\2\2\u02af\u02b2\5")
        buf.write("\u0098M\2\u02b0\u02b2\7\25\2\2\u02b1\u02a7\3\2\2\2\u02b1")
        buf.write("\u02ab\3\2\2\2\u02b1\u02af\3\2\2\2\u02b1\u02b0\3\2\2\2")
        buf.write("\u02b2\u008b\3\2\2\2\u02b3\u02b4\7\7\2\2\u02b4\u02b7\5")
        buf.write("\u008eH\2\u02b5\u02b6\7\67\2\2\u02b6\u02b8\5\u008eH\2")
        buf.write("\u02b7\u02b5\3\2\2\2\u02b8\u02b9\3\2\2\2\u02b9\u02b7\3")
        buf.write("\2\2\2\u02b9\u02ba\3\2\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02bc")
        buf.write("\7\b\2\2\u02bc\u008d\3\2\2\2\u02bd\u02bf\5\u0080A\2\u02be")
        buf.write("\u02bd\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf\u02c0\3\2\2\2")
        buf.write("\u02c0\u02c2\5\u0092J\2\u02c1\u02c3\5\u00acW\2\u02c2\u02c1")
        buf.write("\3\2\2\2\u02c2\u02c3\3\2\2\2\u02c3\u02d0\3\2\2\2\u02c4")
        buf.write("\u02c6\5\u0080A\2\u02c5\u02c4\3\2\2\2\u02c5\u02c6\3\2")
        buf.write("\2\2\u02c6\u02c7\3\2\2\2\u02c7\u02c9\5\u0090I\2\u02c8")
        buf.write("\u02ca\5\u00acW\2\u02c9\u02c8\3\2\2\2\u02c9\u02ca\3\2")
        buf.write("\2\2\u02ca\u02d0\3\2\2\2\u02cb\u02cd\5\u008cG\2\u02cc")
        buf.write("\u02ce\5\u00acW\2\u02cd\u02cc\3\2\2\2\u02cd\u02ce\3\2")
        buf.write("\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02be\3\2\2\2\u02cf\u02c5")
        buf.write("\3\2\2\2\u02cf\u02cb\3\2\2\2\u02d0\u008f\3\2\2\2\u02d1")
        buf.write("\u02d2\t\4\2\2\u02d2\u02d3\7\r\2\2\u02d3\u02d4\5~@\2\u02d4")
        buf.write("\u02d5\7\16\2\2\u02d5\u0091\3\2\2\2\u02d6\u02de\5\u0094")
        buf.write("K\2\u02d7\u02de\5\u00a4S\2\u02d8\u02de\5\u00a6T\2\u02d9")
        buf.write("\u02de\5\u009aN\2\u02da\u02de\7[\2\2\u02db\u02de\7\63")
        buf.write("\2\2\u02dc\u02de\7C\2\2\u02dd\u02d6\3\2\2\2\u02dd\u02d7")
        buf.write("\3\2\2\2\u02dd\u02d8\3\2\2\2\u02dd\u02d9\3\2\2\2\u02dd")
        buf.write("\u02da\3\2\2\2\u02dd\u02db\3\2\2\2\u02dd\u02dc\3\2\2\2")
        buf.write("\u02de\u0093\3\2\2\2\u02df\u02e5\5\u00a0Q\2\u02e0\u02e5")
        buf.write("\5\u009cO\2\u02e1\u02e5\7\30\2\2\u02e2\u02e5\7\31\2\2")
        buf.write("\u02e3\u02e5\7\65\2\2\u02e4\u02df\3\2\2\2\u02e4\u02e0")
        buf.write("\3\2\2\2\u02e4\u02e1\3\2\2\2\u02e4\u02e2\3\2\2\2\u02e4")
        buf.write("\u02e3\3\2\2\2\u02e5\u0095\3\2\2\2\u02e6\u02e9\5\u0094")
        buf.write("K\2\u02e7\u02e9\7[\2\2\u02e8\u02e6\3\2\2\2\u02e8\u02e7")
        buf.write("\3\2\2\2\u02e9\u0097\3\2\2\2\u02ea\u02eb\79\2\2\u02eb")
        buf.write("\u02ec\7\r\2\2\u02ec\u02ed\5\u0088E\2\u02ed\u02ee\7\16")
        buf.write("\2\2\u02ee\u0099\3\2\2\2\u02ef\u02f0\7;\2\2\u02f0\u02f1")
        buf.write("\7\r\2\2\u02f1\u02f2\5\u00a4S\2\u02f2\u02f3\7\17\2\2\u02f3")
        buf.write("\u02f4\5~@\2\u02f4\u02f5\7\16\2\2\u02f5\u009b\3\2\2\2")
        buf.write("\u02f6\u02f8\7F\2\2\u02f7\u02f6\3\2\2\2\u02f7\u02f8\3")
        buf.write("\2\2\2\u02f8\u02f9\3\2\2\2\u02f9\u02fa\5\u009eP\2\u02fa")
        buf.write("\u009d\3\2\2\2\u02fb\u02fc\t\5\2\2\u02fc\u009f\3\2\2\2")
        buf.write("\u02fd\u02ff\7G\2\2\u02fe\u02fd\3\2\2\2\u02fe\u02ff\3")
        buf.write("\2\2\2\u02ff\u0300\3\2\2\2\u0300\u0301\5\u00a2R\2\u0301")
        buf.write("\u00a1\3\2\2\2\u0302\u0308\7@\2\2\u0303\u0305\7,\2\2\u0304")
        buf.write("\u0306\7,\2\2\u0305\u0304\3\2\2\2\u0305\u0306\3\2\2\2")
        buf.write("\u0306\u0308\3\2\2\2\u0307\u0302\3\2\2\2\u0307\u0303\3")
        buf.write("\2\2\2\u0308\u00a3\3\2\2\2\u0309\u030a\t\6\2\2\u030a\u00a5")
        buf.write("\3\2\2\2\u030b\u030c\t\7\2\2\u030c\u00a7\3\2\2\2\u030d")
        buf.write("\u030e\t\b\2\2\u030e\u00a9\3\2\2\2\u030f\u0310\t\t\2\2")
        buf.write("\u0310\u00ab\3\2\2\2\u0311\u0312\7\6\2\2\u0312\u00ad\3")
        buf.write("\2\2\2\u0313\u0340\7U\2\2\u0314\u0340\7V\2\2\u0315\u0340")
        buf.write("\7[\2\2\u0316\u0340\7W\2\2\u0317\u0340\7\\\2\2\u0318\u0340")
        buf.write("\7\22\2\2\u0319\u0340\7.\2\2\u031a\u0340\7\24\2\2\u031b")
        buf.write("\u0340\7\23\2\2\u031c\u0340\7\21\2\2\u031d\u0340\7\20")
        buf.write("\2\2\u031e\u0340\7\r\2\2\u031f\u0340\7\5\2\2\u0320\u0340")
        buf.write("\7\16\2\2\u0321\u0340\7\6\2\2\u0322\u0340\7\32\2\2\u0323")
        buf.write("\u0340\7 \2\2\u0324\u0340\7%\2\2\u0325\u0340\7\'\2\2\u0326")
        buf.write("\u0340\7\61\2\2\u0327\u0340\7\64\2\2\u0328\u0340\79\2")
        buf.write("\2\u0329\u0340\7H\2\2\u032a\u0340\7\25\2\2\u032b\u0340")
        buf.write("\7\30\2\2\u032c\u0340\7\31\2\2\u032d\u0340\7!\2\2\u032e")
        buf.write("\u0340\7#\2\2\u032f\u0340\7$\2\2\u0330\u0340\7,\2\2\u0331")
        buf.write("\u0340\7\62\2\2\u0332\u0340\7\63\2\2\u0333\u0340\7\65")
        buf.write("\2\2\u0334\u0340\7\67\2\2\u0335\u0340\7\66\2\2\u0336\u0340")
        buf.write("\7;\2\2\u0337\u0340\7=\2\2\u0338\u0340\7@\2\2\u0339\u0340")
        buf.write("\7C\2\2\u033a\u0340\7D\2\2\u033b\u0340\7G\2\2\u033c\u0340")
        buf.write("\7I\2\2\u033d\u0340\5\u00b0Y\2\u033e\u0340\5\u00a6T\2")
        buf.write("\u033f\u0313\3\2\2\2\u033f\u0314\3\2\2\2\u033f\u0315\3")
        buf.write("\2\2\2\u033f\u0316\3\2\2\2\u033f\u0317\3\2\2\2\u033f\u0318")
        buf.write("\3\2\2\2\u033f\u0319\3\2\2\2\u033f\u031a\3\2\2\2\u033f")
        buf.write("\u031b\3\2\2\2\u033f\u031c\3\2\2\2\u033f\u031d\3\2\2\2")
        buf.write("\u033f\u031e\3\2\2\2\u033f\u031f\3\2\2\2\u033f\u0320\3")
        buf.write("\2\2\2\u033f\u0321\3\2\2\2\u033f\u0322\3\2\2\2\u033f\u0323")
        buf.write("\3\2\2\2\u033f\u0324\3\2\2\2\u033f\u0325\3\2\2\2\u033f")
        buf.write("\u0326\3\2\2\2\u033f\u0327\3\2\2\2\u033f\u0328\3\2\2\2")
        buf.write("\u033f\u0329\3\2\2\2\u033f\u032a\3\2\2\2\u033f\u032b\3")
        buf.write("\2\2\2\u033f\u032c\3\2\2\2\u033f\u032d\3\2\2\2\u033f\u032e")
        buf.write("\3\2\2\2\u033f\u032f\3\2\2\2\u033f\u0330\3\2\2\2\u033f")
        buf.write("\u0331\3\2\2\2\u033f\u0332\3\2\2\2\u033f\u0333\3\2\2\2")
        buf.write("\u033f\u0334\3\2\2\2\u033f\u0335\3\2\2\2\u033f\u0336\3")
        buf.write("\2\2\2\u033f\u0337\3\2\2\2\u033f\u0338\3\2\2\2\u033f\u0339")
        buf.write("\3\2\2\2\u033f\u033a\3\2\2\2\u033f\u033b\3\2\2\2\u033f")
        buf.write("\u033c\3\2\2\2\u033f\u033d\3\2\2\2\u033f\u033e\3\2\2\2")
        buf.write("\u0340\u00af\3\2\2\2\u0341\u0342\t\n\2\2\u0342\u00b1\3")
        buf.write("\2\2\2Z\u00b3\u00ba\u00bd\u00c8\u00ce\u00d2\u00d6\u00dc")
        buf.write("\u00e8\u00ef\u00f6\u00fc\u00ff\u010d\u0118\u011f\u0127")
        buf.write("\u012a\u0138\u013d\u0140\u0146\u0152\u015a\u0168\u0171")
        buf.write("\u0174\u017c\u0180\u0187\u0190\u0194\u019c\u01a0\u01a4")
        buf.write("\u01a8\u01ad\u01b5\u01b8\u01bc\u01c2\u01c6\u01cd\u01d8")
        buf.write("\u01dc\u01e0\u01e4\u01eb\u01f8\u0201\u0209\u0210\u0217")
        buf.write("\u021c\u0222\u022e\u0233\u0236\u0242\u0246\u0251\u0255")
        buf.write("\u0260\u026d\u026f\u0272\u027c\u0297\u029e\u02a5\u02a9")
        buf.write("\u02ad\u02b1\u02b9\u02be\u02c2\u02c5\u02c9\u02cd\u02cf")
        buf.write("\u02dd\u02e4\u02e8\u02f7\u02fe\u0305\u0307\u033f")
        return buf.getvalue()


class WebIDLParser ( Parser ):

    grammarFileName = "WebIDLParser.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "'='", "'?'", 
                     "'('", "')'", "'['", "']'", "'{'", "'}'", "'<'", "'>'", 
                     "','", "';'", "':'", "'-'", "'...'", "'.'", "'any'", 
                     "'async'", "'attribute'", "'boolean'", "'byte'", "'ByteString'", 
                     "'callback'", "'const'", "'constructor'", "'deleter'", 
                     "'dictionary'", "'DOMString'", "'double'", "'enum'", 
                     "'false'", "'float'", "'FrozenArray'", "'getter'", 
                     "'Infinity'", "'includes'", "'inherit'", "'interface'", 
                     "'iterable'", "'long'", "'maplike'", "'-Infinity'", 
                     "'mixin'", "'namespace'", "'NaN'", "'null'", "'object'", 
                     "'ObservableArray'", "'octet'", "'optional'", "'or'", 
                     "'partial'", "'Promise'", "'readonly'", "'record'", 
                     "'required'", "'sequence'", "'setlike'", "'setter'", 
                     "'short'", "'static'", "'stringifier'", "'symbol'", 
                     "'true'", "'typedef'", "'unrestricted'", "'unsigned'", 
                     "'USVString'", "'void'", "'ArrayBuffer'", "'DataView'", 
                     "'Int8Array'", "'Int16Array'", "'Int32Array'", "'Uint8Array'", 
                     "'Uint16Array'", "'Uint32Array'", "'Uint8ClampedArray'", 
                     "'Float32Array'", "'Float64Array'" ]

    symbolicNames = [ "<INVALID>", "WHITESPACE", "COMMENT", "EQUAL_SYMBOL", 
                      "QUESTION_SYMBOL", "LEFT_PAREN", "RIGHT_PAREN", "LEFT_BRACKET", 
                      "RIGHT_BRACKET", "LEFT_BRACE", "RIGHT_BRACE", "LEFT_ANGLE", 
                      "RIGHT_ANGLE", "COMMA", "SEMI", "COLON", "MINUS", 
                      "ELLIPSIS", "DOT", "ANY", "ASYNC", "ATTRIBUTE", "BOOLEAN", 
                      "BYTE", "BYTE_STRING", "CALLBACK", "CONST", "CONSTRUCTOR", 
                      "DELETER", "DICTIONARY", "DOM_STRING", "DOUBLE", "ENUM", 
                      "FALSE", "FLOAT", "FROZEN_ARRAY", "GETTER", "INFINITY", 
                      "INCLUDES", "INHERIT", "INTERFACE", "ITERABLE", "LONG", 
                      "MAPLIKE", "MINUS_INFINITY", "MIXIN", "NAMESPACE", 
                      "NAN", "NULL", "OBJECT", "OBSERVABLE_ARRAY", "OCTET", 
                      "OPTIONAL", "OR", "PARTIAL", "PROMISE", "READONLY", 
                      "RECORD", "REQUIRED", "SEQUENCE", "SETLIKE", "SETTER", 
                      "SHORT", "STATIC", "STRINGIFIER", "SYMBOL", "TRUE", 
                      "TYPEDEF", "UNRESTRICTED", "UNSIGNED", "USV_STRING", 
                      "VOID", "ARRAY_BUFFER", "DATA_VIEW", "INT_8_ARRAY", 
                      "INT_16_ARRAY", "INT_32_ARRAY", "UINT_8_ARRAY", "UINT_16_ARRAY", 
                      "UINT_32_ARRAY", "UINT_8_CLAMPED_ARRAY", "FLOAT_32_ARRAY", 
                      "FLOAT_64_ARRAY", "IntegerLiteral", "DecimalLiteral", 
                      "StringLiteral", "HexIntegerLiteral", "OctalIntegerLiteral", 
                      "DecimalIntegerLiteral", "IDENTIFIER", "OTHER" ]

    RULE_webIDL = 0
    RULE_definitions = 1
    RULE_extendedDefinition = 2
    RULE_definition = 3
    RULE_callbackOrInterfaceOrMixin = 4
    RULE_interfaceOrMixin = 5
    RULE_interfaceRest = 6
    RULE_partial = 7
    RULE_partialInterfaceOrPartialMixin = 8
    RULE_partialInterfaceRest = 9
    RULE_interfaceMembers = 10
    RULE_interfaceMember = 11
    RULE_partialInterfaceMembers = 12
    RULE_partialInterfaceMember = 13
    RULE_inheritance = 14
    RULE_mixinRest = 15
    RULE_mixinMembers = 16
    RULE_mixinMember = 17
    RULE_includesStatement = 18
    RULE_callbackRestOrInterface = 19
    RULE_callbackInterfaceMembers = 20
    RULE_callbackInterfaceMember = 21
    RULE_const_ = 22
    RULE_constValue = 23
    RULE_readOnlyMember = 24
    RULE_readOnlyMemberRest = 25
    RULE_readWriteAttribute = 26
    RULE_inheritAttribute = 27
    RULE_attributeRest = 28
    RULE_attributeName = 29
    RULE_defaultValue = 30
    RULE_operation = 31
    RULE_regularOperation = 32
    RULE_operationRest = 33
    RULE_operationName = 34
    RULE_operationNameKeyword = 35
    RULE_argumentList = 36
    RULE_argument = 37
    RULE_argumentRest = 38
    RULE_argumentName = 39
    RULE_constructor = 40
    RULE_stringifier = 41
    RULE_stringifierRest = 42
    RULE_staticMember = 43
    RULE_staticMemberRest = 44
    RULE_iterable = 45
    RULE_optionalArgumentList = 46
    RULE_readWriteMaplike = 47
    RULE_maplikeRest = 48
    RULE_readWriteSetlike = 49
    RULE_setlikeRest = 50
    RULE_namespace = 51
    RULE_namespaceMembers = 52
    RULE_namespaceMember = 53
    RULE_dictionary = 54
    RULE_dictionaryMembers = 55
    RULE_dictionaryMember = 56
    RULE_default_ = 57
    RULE_enum_ = 58
    RULE_callbackRest = 59
    RULE_typedef = 60
    RULE_type_ = 61
    RULE_typeWithExtendedAttributes = 62
    RULE_extendedAttributeList = 63
    RULE_extendedAttribute = 64
    RULE_identifierList = 65
    RULE_identifier = 66
    RULE_returnType = 67
    RULE_singleType = 68
    RULE_unionType = 69
    RULE_unionMemberType = 70
    RULE_genericType = 71
    RULE_distinguishableType = 72
    RULE_primitiveType = 73
    RULE_constType = 74
    RULE_promiseType = 75
    RULE_recordType = 76
    RULE_unrestrictedFloatType = 77
    RULE_floatType = 78
    RULE_unsignedIntegerType = 79
    RULE_integerType = 80
    RULE_stringType = 81
    RULE_bufferRelatedType = 82
    RULE_booleanLiteral = 83
    RULE_floatLiteral = 84
    RULE_null_ = 85
    RULE_other = 86
    RULE_argumentNameKeyword = 87

    ruleNames =  [ "webIDL", "definitions", "extendedDefinition", "definition", 
                   "callbackOrInterfaceOrMixin", "interfaceOrMixin", "interfaceRest", 
                   "partial", "partialInterfaceOrPartialMixin", "partialInterfaceRest", 
                   "interfaceMembers", "interfaceMember", "partialInterfaceMembers", 
                   "partialInterfaceMember", "inheritance", "mixinRest", 
                   "mixinMembers", "mixinMember", "includesStatement", "callbackRestOrInterface", 
                   "callbackInterfaceMembers", "callbackInterfaceMember", 
                   "const_", "constValue", "readOnlyMember", "readOnlyMemberRest", 
                   "readWriteAttribute", "inheritAttribute", "attributeRest", 
                   "attributeName", "defaultValue", "operation", "regularOperation", 
                   "operationRest", "operationName", "operationNameKeyword", 
                   "argumentList", "argument", "argumentRest", "argumentName", 
                   "constructor", "stringifier", "stringifierRest", "staticMember", 
                   "staticMemberRest", "iterable", "optionalArgumentList", 
                   "readWriteMaplike", "maplikeRest", "readWriteSetlike", 
                   "setlikeRest", "namespace", "namespaceMembers", "namespaceMember", 
                   "dictionary", "dictionaryMembers", "dictionaryMember", 
                   "default_", "enum_", "callbackRest", "typedef", "type_", 
                   "typeWithExtendedAttributes", "extendedAttributeList", 
                   "extendedAttribute", "identifierList", "identifier", 
                   "returnType", "singleType", "unionType", "unionMemberType", 
                   "genericType", "distinguishableType", "primitiveType", 
                   "constType", "promiseType", "recordType", "unrestrictedFloatType", 
                   "floatType", "unsignedIntegerType", "integerType", "stringType", 
                   "bufferRelatedType", "booleanLiteral", "floatLiteral", 
                   "null_", "other", "argumentNameKeyword" ]

    EOF = Token.EOF
    WHITESPACE=1
    COMMENT=2
    EQUAL_SYMBOL=3
    QUESTION_SYMBOL=4
    LEFT_PAREN=5
    RIGHT_PAREN=6
    LEFT_BRACKET=7
    RIGHT_BRACKET=8
    LEFT_BRACE=9
    RIGHT_BRACE=10
    LEFT_ANGLE=11
    RIGHT_ANGLE=12
    COMMA=13
    SEMI=14
    COLON=15
    MINUS=16
    ELLIPSIS=17
    DOT=18
    ANY=19
    ASYNC=20
    ATTRIBUTE=21
    BOOLEAN=22
    BYTE=23
    BYTE_STRING=24
    CALLBACK=25
    CONST=26
    CONSTRUCTOR=27
    DELETER=28
    DICTIONARY=29
    DOM_STRING=30
    DOUBLE=31
    ENUM=32
    FALSE=33
    FLOAT=34
    FROZEN_ARRAY=35
    GETTER=36
    INFINITY=37
    INCLUDES=38
    INHERIT=39
    INTERFACE=40
    ITERABLE=41
    LONG=42
    MAPLIKE=43
    MINUS_INFINITY=44
    MIXIN=45
    NAMESPACE=46
    NAN=47
    NULL=48
    OBJECT=49
    OBSERVABLE_ARRAY=50
    OCTET=51
    OPTIONAL=52
    OR=53
    PARTIAL=54
    PROMISE=55
    READONLY=56
    RECORD=57
    REQUIRED=58
    SEQUENCE=59
    SETLIKE=60
    SETTER=61
    SHORT=62
    STATIC=63
    STRINGIFIER=64
    SYMBOL=65
    TRUE=66
    TYPEDEF=67
    UNRESTRICTED=68
    UNSIGNED=69
    USV_STRING=70
    VOID=71
    ARRAY_BUFFER=72
    DATA_VIEW=73
    INT_8_ARRAY=74
    INT_16_ARRAY=75
    INT_32_ARRAY=76
    UINT_8_ARRAY=77
    UINT_16_ARRAY=78
    UINT_32_ARRAY=79
    UINT_8_CLAMPED_ARRAY=80
    FLOAT_32_ARRAY=81
    FLOAT_64_ARRAY=82
    IntegerLiteral=83
    DecimalLiteral=84
    StringLiteral=85
    HexIntegerLiteral=86
    OctalIntegerLiteral=87
    DecimalIntegerLiteral=88
    IDENTIFIER=89
    OTHER=90

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.9.2")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class WebIDLContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EOF(self):
            return self.getToken(WebIDLParser.EOF, 0)

        def definitions(self):
            return self.getTypedRuleContext(WebIDLParser.DefinitionsContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_webIDL

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWebIDL" ):
                return visitor.visitWebIDL(self)
            else:
                return visitor.visitChildren(self)




    def webIDL(self):

        localctx = WebIDLParser.WebIDLContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_webIDL)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 177
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.LEFT_BRACKET) | (1 << WebIDLParser.CALLBACK) | (1 << WebIDLParser.DICTIONARY) | (1 << WebIDLParser.ENUM) | (1 << WebIDLParser.INTERFACE) | (1 << WebIDLParser.NAMESPACE) | (1 << WebIDLParser.PARTIAL))) != 0) or _la==WebIDLParser.TYPEDEF or _la==WebIDLParser.IDENTIFIER:
                self.state = 176
                self.definitions()


            self.state = 179
            self.match(WebIDLParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DefinitionsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def extendedDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(WebIDLParser.ExtendedDefinitionContext)
            else:
                return self.getTypedRuleContext(WebIDLParser.ExtendedDefinitionContext,i)


        def getRuleIndex(self):
            return WebIDLParser.RULE_definitions

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDefinitions" ):
                return visitor.visitDefinitions(self)
            else:
                return visitor.visitChildren(self)




    def definitions(self):

        localctx = WebIDLParser.DefinitionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_definitions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 182 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 181
                self.extendedDefinition()
                self.state = 184 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.LEFT_BRACKET) | (1 << WebIDLParser.CALLBACK) | (1 << WebIDLParser.DICTIONARY) | (1 << WebIDLParser.ENUM) | (1 << WebIDLParser.INTERFACE) | (1 << WebIDLParser.NAMESPACE) | (1 << WebIDLParser.PARTIAL))) != 0) or _la==WebIDLParser.TYPEDEF or _la==WebIDLParser.IDENTIFIER):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExtendedDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def definition(self):
            return self.getTypedRuleContext(WebIDLParser.DefinitionContext,0)


        def extendedAttributeList(self):
            return self.getTypedRuleContext(WebIDLParser.ExtendedAttributeListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_extendedDefinition

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExtendedDefinition" ):
                return visitor.visitExtendedDefinition(self)
            else:
                return visitor.visitChildren(self)




    def extendedDefinition(self):

        localctx = WebIDLParser.ExtendedDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_extendedDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 187
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.LEFT_BRACKET:
                self.state = 186
                self.extendedAttributeList()


            self.state = 189
            self.definition()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def callbackOrInterfaceOrMixin(self):
            return self.getTypedRuleContext(WebIDLParser.CallbackOrInterfaceOrMixinContext,0)


        def namespace(self):
            return self.getTypedRuleContext(WebIDLParser.NamespaceContext,0)


        def partial(self):
            return self.getTypedRuleContext(WebIDLParser.PartialContext,0)


        def dictionary(self):
            return self.getTypedRuleContext(WebIDLParser.DictionaryContext,0)


        def enum_(self):
            return self.getTypedRuleContext(WebIDLParser.Enum_Context,0)


        def typedef(self):
            return self.getTypedRuleContext(WebIDLParser.TypedefContext,0)


        def includesStatement(self):
            return self.getTypedRuleContext(WebIDLParser.IncludesStatementContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_definition

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDefinition" ):
                return visitor.visitDefinition(self)
            else:
                return visitor.visitChildren(self)




    def definition(self):

        localctx = WebIDLParser.DefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_definition)
        try:
            self.state = 198
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 191
                self.callbackOrInterfaceOrMixin()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 192
                self.namespace()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 193
                self.partial()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 194
                self.dictionary()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 195
                self.enum_()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 196
                self.typedef()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 197
                self.includesStatement()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CallbackOrInterfaceOrMixinContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CALLBACK(self):
            return self.getToken(WebIDLParser.CALLBACK, 0)

        def callbackRestOrInterface(self):
            return self.getTypedRuleContext(WebIDLParser.CallbackRestOrInterfaceContext,0)


        def INTERFACE(self):
            return self.getToken(WebIDLParser.INTERFACE, 0)

        def interfaceOrMixin(self):
            return self.getTypedRuleContext(WebIDLParser.InterfaceOrMixinContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_callbackOrInterfaceOrMixin

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCallbackOrInterfaceOrMixin" ):
                return visitor.visitCallbackOrInterfaceOrMixin(self)
            else:
                return visitor.visitChildren(self)




    def callbackOrInterfaceOrMixin(self):

        localctx = WebIDLParser.CallbackOrInterfaceOrMixinContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_callbackOrInterfaceOrMixin)
        try:
            self.state = 204
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.CALLBACK]:
                self.enterOuterAlt(localctx, 1)
                self.state = 200
                self.match(WebIDLParser.CALLBACK)
                self.state = 201
                self.callbackRestOrInterface()
                pass
            elif token in [WebIDLParser.INTERFACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 202
                self.match(WebIDLParser.INTERFACE)
                self.state = 203
                self.interfaceOrMixin()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InterfaceOrMixinContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def interfaceRest(self):
            return self.getTypedRuleContext(WebIDLParser.InterfaceRestContext,0)


        def mixinRest(self):
            return self.getTypedRuleContext(WebIDLParser.MixinRestContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_interfaceOrMixin

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInterfaceOrMixin" ):
                return visitor.visitInterfaceOrMixin(self)
            else:
                return visitor.visitChildren(self)




    def interfaceOrMixin(self):

        localctx = WebIDLParser.InterfaceOrMixinContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_interfaceOrMixin)
        try:
            self.state = 208
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 206
                self.interfaceRest()
                pass
            elif token in [WebIDLParser.MIXIN]:
                self.enterOuterAlt(localctx, 2)
                self.state = 207
                self.mixinRest()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InterfaceRestContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def LEFT_BRACE(self):
            return self.getToken(WebIDLParser.LEFT_BRACE, 0)

        def RIGHT_BRACE(self):
            return self.getToken(WebIDLParser.RIGHT_BRACE, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def inheritance(self):
            return self.getTypedRuleContext(WebIDLParser.InheritanceContext,0)


        def interfaceMembers(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(WebIDLParser.InterfaceMembersContext)
            else:
                return self.getTypedRuleContext(WebIDLParser.InterfaceMembersContext,i)


        def getRuleIndex(self):
            return WebIDLParser.RULE_interfaceRest

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInterfaceRest" ):
                return visitor.visitInterfaceRest(self)
            else:
                return visitor.visitChildren(self)




    def interfaceRest(self):

        localctx = WebIDLParser.InterfaceRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_interfaceRest)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 210
            self.match(WebIDLParser.IDENTIFIER)
            self.state = 212
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.COLON:
                self.state = 211
                self.inheritance()


            self.state = 214
            self.match(WebIDLParser.LEFT_BRACE)
            self.state = 218
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.LEFT_PAREN) | (1 << WebIDLParser.LEFT_BRACKET) | (1 << WebIDLParser.ANY) | (1 << WebIDLParser.ASYNC) | (1 << WebIDLParser.ATTRIBUTE) | (1 << WebIDLParser.BOOLEAN) | (1 << WebIDLParser.BYTE) | (1 << WebIDLParser.BYTE_STRING) | (1 << WebIDLParser.CONST) | (1 << WebIDLParser.CONSTRUCTOR) | (1 << WebIDLParser.DELETER) | (1 << WebIDLParser.DOM_STRING) | (1 << WebIDLParser.DOUBLE) | (1 << WebIDLParser.FLOAT) | (1 << WebIDLParser.FROZEN_ARRAY) | (1 << WebIDLParser.GETTER) | (1 << WebIDLParser.INHERIT) | (1 << WebIDLParser.ITERABLE) | (1 << WebIDLParser.LONG) | (1 << WebIDLParser.MAPLIKE) | (1 << WebIDLParser.OBJECT) | (1 << WebIDLParser.OBSERVABLE_ARRAY) | (1 << WebIDLParser.OCTET) | (1 << WebIDLParser.PROMISE) | (1 << WebIDLParser.READONLY) | (1 << WebIDLParser.RECORD) | (1 << WebIDLParser.SEQUENCE) | (1 << WebIDLParser.SETLIKE) | (1 << WebIDLParser.SETTER) | (1 << WebIDLParser.SHORT) | (1 << WebIDLParser.STATIC))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (WebIDLParser.STRINGIFIER - 64)) | (1 << (WebIDLParser.SYMBOL - 64)) | (1 << (WebIDLParser.UNRESTRICTED - 64)) | (1 << (WebIDLParser.UNSIGNED - 64)) | (1 << (WebIDLParser.USV_STRING - 64)) | (1 << (WebIDLParser.VOID - 64)) | (1 << (WebIDLParser.ARRAY_BUFFER - 64)) | (1 << (WebIDLParser.DATA_VIEW - 64)) | (1 << (WebIDLParser.INT_8_ARRAY - 64)) | (1 << (WebIDLParser.INT_16_ARRAY - 64)) | (1 << (WebIDLParser.INT_32_ARRAY - 64)) | (1 << (WebIDLParser.UINT_8_ARRAY - 64)) | (1 << (WebIDLParser.UINT_16_ARRAY - 64)) | (1 << (WebIDLParser.UINT_32_ARRAY - 64)) | (1 << (WebIDLParser.UINT_8_CLAMPED_ARRAY - 64)) | (1 << (WebIDLParser.FLOAT_32_ARRAY - 64)) | (1 << (WebIDLParser.FLOAT_64_ARRAY - 64)) | (1 << (WebIDLParser.IDENTIFIER - 64)))) != 0):
                self.state = 215
                self.interfaceMembers()
                self.state = 220
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 221
            self.match(WebIDLParser.RIGHT_BRACE)
            self.state = 222
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PartialContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PARTIAL(self):
            return self.getToken(WebIDLParser.PARTIAL, 0)

        def INTERFACE(self):
            return self.getToken(WebIDLParser.INTERFACE, 0)

        def partialInterfaceOrPartialMixin(self):
            return self.getTypedRuleContext(WebIDLParser.PartialInterfaceOrPartialMixinContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_partial

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPartial" ):
                return visitor.visitPartial(self)
            else:
                return visitor.visitChildren(self)




    def partial(self):

        localctx = WebIDLParser.PartialContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_partial)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 224
            self.match(WebIDLParser.PARTIAL)
            self.state = 225
            self.match(WebIDLParser.INTERFACE)
            self.state = 226
            self.partialInterfaceOrPartialMixin()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PartialInterfaceOrPartialMixinContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def partialInterfaceRest(self):
            return self.getTypedRuleContext(WebIDLParser.PartialInterfaceRestContext,0)


        def mixinRest(self):
            return self.getTypedRuleContext(WebIDLParser.MixinRestContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_partialInterfaceOrPartialMixin

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPartialInterfaceOrPartialMixin" ):
                return visitor.visitPartialInterfaceOrPartialMixin(self)
            else:
                return visitor.visitChildren(self)




    def partialInterfaceOrPartialMixin(self):

        localctx = WebIDLParser.PartialInterfaceOrPartialMixinContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_partialInterfaceOrPartialMixin)
        try:
            self.state = 230
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 228
                self.partialInterfaceRest()
                pass
            elif token in [WebIDLParser.MIXIN]:
                self.enterOuterAlt(localctx, 2)
                self.state = 229
                self.mixinRest()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PartialInterfaceRestContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def LEFT_BRACE(self):
            return self.getToken(WebIDLParser.LEFT_BRACE, 0)

        def RIGHT_BRACE(self):
            return self.getToken(WebIDLParser.RIGHT_BRACE, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def partialInterfaceMembers(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(WebIDLParser.PartialInterfaceMembersContext)
            else:
                return self.getTypedRuleContext(WebIDLParser.PartialInterfaceMembersContext,i)


        def getRuleIndex(self):
            return WebIDLParser.RULE_partialInterfaceRest

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPartialInterfaceRest" ):
                return visitor.visitPartialInterfaceRest(self)
            else:
                return visitor.visitChildren(self)




    def partialInterfaceRest(self):

        localctx = WebIDLParser.PartialInterfaceRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_partialInterfaceRest)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 232
            self.match(WebIDLParser.IDENTIFIER)
            self.state = 233
            self.match(WebIDLParser.LEFT_BRACE)
            self.state = 237
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.LEFT_PAREN) | (1 << WebIDLParser.LEFT_BRACKET) | (1 << WebIDLParser.ANY) | (1 << WebIDLParser.ASYNC) | (1 << WebIDLParser.ATTRIBUTE) | (1 << WebIDLParser.BOOLEAN) | (1 << WebIDLParser.BYTE) | (1 << WebIDLParser.BYTE_STRING) | (1 << WebIDLParser.CONST) | (1 << WebIDLParser.DELETER) | (1 << WebIDLParser.DOM_STRING) | (1 << WebIDLParser.DOUBLE) | (1 << WebIDLParser.FLOAT) | (1 << WebIDLParser.FROZEN_ARRAY) | (1 << WebIDLParser.GETTER) | (1 << WebIDLParser.INHERIT) | (1 << WebIDLParser.ITERABLE) | (1 << WebIDLParser.LONG) | (1 << WebIDLParser.MAPLIKE) | (1 << WebIDLParser.OBJECT) | (1 << WebIDLParser.OBSERVABLE_ARRAY) | (1 << WebIDLParser.OCTET) | (1 << WebIDLParser.PROMISE) | (1 << WebIDLParser.READONLY) | (1 << WebIDLParser.RECORD) | (1 << WebIDLParser.SEQUENCE) | (1 << WebIDLParser.SETLIKE) | (1 << WebIDLParser.SETTER) | (1 << WebIDLParser.SHORT) | (1 << WebIDLParser.STATIC))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (WebIDLParser.STRINGIFIER - 64)) | (1 << (WebIDLParser.SYMBOL - 64)) | (1 << (WebIDLParser.UNRESTRICTED - 64)) | (1 << (WebIDLParser.UNSIGNED - 64)) | (1 << (WebIDLParser.USV_STRING - 64)) | (1 << (WebIDLParser.VOID - 64)) | (1 << (WebIDLParser.ARRAY_BUFFER - 64)) | (1 << (WebIDLParser.DATA_VIEW - 64)) | (1 << (WebIDLParser.INT_8_ARRAY - 64)) | (1 << (WebIDLParser.INT_16_ARRAY - 64)) | (1 << (WebIDLParser.INT_32_ARRAY - 64)) | (1 << (WebIDLParser.UINT_8_ARRAY - 64)) | (1 << (WebIDLParser.UINT_16_ARRAY - 64)) | (1 << (WebIDLParser.UINT_32_ARRAY - 64)) | (1 << (WebIDLParser.UINT_8_CLAMPED_ARRAY - 64)) | (1 << (WebIDLParser.FLOAT_32_ARRAY - 64)) | (1 << (WebIDLParser.FLOAT_64_ARRAY - 64)) | (1 << (WebIDLParser.IDENTIFIER - 64)))) != 0):
                self.state = 234
                self.partialInterfaceMembers()
                self.state = 239
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 240
            self.match(WebIDLParser.RIGHT_BRACE)
            self.state = 241
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InterfaceMembersContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def interfaceMember(self):
            return self.getTypedRuleContext(WebIDLParser.InterfaceMemberContext,0)


        def extendedAttributeList(self):
            return self.getTypedRuleContext(WebIDLParser.ExtendedAttributeListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_interfaceMembers

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInterfaceMembers" ):
                return visitor.visitInterfaceMembers(self)
            else:
                return visitor.visitChildren(self)




    def interfaceMembers(self):

        localctx = WebIDLParser.InterfaceMembersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_interfaceMembers)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 244
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.LEFT_BRACKET:
                self.state = 243
                self.extendedAttributeList()


            self.state = 246
            self.interfaceMember()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InterfaceMemberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def partialInterfaceMember(self):
            return self.getTypedRuleContext(WebIDLParser.PartialInterfaceMemberContext,0)


        def constructor(self):
            return self.getTypedRuleContext(WebIDLParser.ConstructorContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_interfaceMember

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInterfaceMember" ):
                return visitor.visitInterfaceMember(self)
            else:
                return visitor.visitChildren(self)




    def interfaceMember(self):

        localctx = WebIDLParser.InterfaceMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_interfaceMember)
        try:
            self.state = 250
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.LEFT_PAREN, WebIDLParser.ANY, WebIDLParser.ASYNC, WebIDLParser.ATTRIBUTE, WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.BYTE_STRING, WebIDLParser.CONST, WebIDLParser.DELETER, WebIDLParser.DOM_STRING, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.FROZEN_ARRAY, WebIDLParser.GETTER, WebIDLParser.INHERIT, WebIDLParser.ITERABLE, WebIDLParser.LONG, WebIDLParser.MAPLIKE, WebIDLParser.OBJECT, WebIDLParser.OBSERVABLE_ARRAY, WebIDLParser.OCTET, WebIDLParser.PROMISE, WebIDLParser.READONLY, WebIDLParser.RECORD, WebIDLParser.SEQUENCE, WebIDLParser.SETLIKE, WebIDLParser.SETTER, WebIDLParser.SHORT, WebIDLParser.STATIC, WebIDLParser.STRINGIFIER, WebIDLParser.SYMBOL, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED, WebIDLParser.USV_STRING, WebIDLParser.VOID, WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY, WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 248
                self.partialInterfaceMember()
                pass
            elif token in [WebIDLParser.CONSTRUCTOR]:
                self.enterOuterAlt(localctx, 2)
                self.state = 249
                self.constructor()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PartialInterfaceMembersContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def partialInterfaceMember(self):
            return self.getTypedRuleContext(WebIDLParser.PartialInterfaceMemberContext,0)


        def extendedAttributeList(self):
            return self.getTypedRuleContext(WebIDLParser.ExtendedAttributeListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_partialInterfaceMembers

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPartialInterfaceMembers" ):
                return visitor.visitPartialInterfaceMembers(self)
            else:
                return visitor.visitChildren(self)




    def partialInterfaceMembers(self):

        localctx = WebIDLParser.PartialInterfaceMembersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_partialInterfaceMembers)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 253
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.LEFT_BRACKET:
                self.state = 252
                self.extendedAttributeList()


            self.state = 255
            self.partialInterfaceMember()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PartialInterfaceMemberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def const_(self):
            return self.getTypedRuleContext(WebIDLParser.Const_Context,0)


        def operation(self):
            return self.getTypedRuleContext(WebIDLParser.OperationContext,0)


        def stringifier(self):
            return self.getTypedRuleContext(WebIDLParser.StringifierContext,0)


        def staticMember(self):
            return self.getTypedRuleContext(WebIDLParser.StaticMemberContext,0)


        def iterable(self):
            return self.getTypedRuleContext(WebIDLParser.IterableContext,0)


        def readOnlyMember(self):
            return self.getTypedRuleContext(WebIDLParser.ReadOnlyMemberContext,0)


        def readWriteAttribute(self):
            return self.getTypedRuleContext(WebIDLParser.ReadWriteAttributeContext,0)


        def readWriteMaplike(self):
            return self.getTypedRuleContext(WebIDLParser.ReadWriteMaplikeContext,0)


        def readWriteSetlike(self):
            return self.getTypedRuleContext(WebIDLParser.ReadWriteSetlikeContext,0)


        def inheritAttribute(self):
            return self.getTypedRuleContext(WebIDLParser.InheritAttributeContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_partialInterfaceMember

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPartialInterfaceMember" ):
                return visitor.visitPartialInterfaceMember(self)
            else:
                return visitor.visitChildren(self)




    def partialInterfaceMember(self):

        localctx = WebIDLParser.PartialInterfaceMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_partialInterfaceMember)
        try:
            self.state = 267
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 257
                self.const_()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 258
                self.operation()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 259
                self.stringifier()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 260
                self.staticMember()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 261
                self.iterable()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 262
                self.readOnlyMember()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 263
                self.readWriteAttribute()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 264
                self.readWriteMaplike()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 265
                self.readWriteSetlike()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 266
                self.inheritAttribute()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InheritanceContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def COLON(self):
            return self.getToken(WebIDLParser.COLON, 0)

        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_inheritance

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInheritance" ):
                return visitor.visitInheritance(self)
            else:
                return visitor.visitChildren(self)




    def inheritance(self):

        localctx = WebIDLParser.InheritanceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_inheritance)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 269
            self.match(WebIDLParser.COLON)
            self.state = 270
            self.match(WebIDLParser.IDENTIFIER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MixinRestContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def MIXIN(self):
            return self.getToken(WebIDLParser.MIXIN, 0)

        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def LEFT_BRACE(self):
            return self.getToken(WebIDLParser.LEFT_BRACE, 0)

        def RIGHT_BRACE(self):
            return self.getToken(WebIDLParser.RIGHT_BRACE, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def mixinMembers(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(WebIDLParser.MixinMembersContext)
            else:
                return self.getTypedRuleContext(WebIDLParser.MixinMembersContext,i)


        def getRuleIndex(self):
            return WebIDLParser.RULE_mixinRest

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMixinRest" ):
                return visitor.visitMixinRest(self)
            else:
                return visitor.visitChildren(self)




    def mixinRest(self):

        localctx = WebIDLParser.MixinRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_mixinRest)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 272
            self.match(WebIDLParser.MIXIN)
            self.state = 273
            self.match(WebIDLParser.IDENTIFIER)
            self.state = 274
            self.match(WebIDLParser.LEFT_BRACE)
            self.state = 278
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.LEFT_PAREN) | (1 << WebIDLParser.LEFT_BRACKET) | (1 << WebIDLParser.ANY) | (1 << WebIDLParser.ATTRIBUTE) | (1 << WebIDLParser.BOOLEAN) | (1 << WebIDLParser.BYTE) | (1 << WebIDLParser.BYTE_STRING) | (1 << WebIDLParser.CONST) | (1 << WebIDLParser.DOM_STRING) | (1 << WebIDLParser.DOUBLE) | (1 << WebIDLParser.FLOAT) | (1 << WebIDLParser.FROZEN_ARRAY) | (1 << WebIDLParser.LONG) | (1 << WebIDLParser.OBJECT) | (1 << WebIDLParser.OBSERVABLE_ARRAY) | (1 << WebIDLParser.OCTET) | (1 << WebIDLParser.PROMISE) | (1 << WebIDLParser.READONLY) | (1 << WebIDLParser.RECORD) | (1 << WebIDLParser.SEQUENCE) | (1 << WebIDLParser.SHORT))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (WebIDLParser.STRINGIFIER - 64)) | (1 << (WebIDLParser.SYMBOL - 64)) | (1 << (WebIDLParser.UNRESTRICTED - 64)) | (1 << (WebIDLParser.UNSIGNED - 64)) | (1 << (WebIDLParser.USV_STRING - 64)) | (1 << (WebIDLParser.VOID - 64)) | (1 << (WebIDLParser.ARRAY_BUFFER - 64)) | (1 << (WebIDLParser.DATA_VIEW - 64)) | (1 << (WebIDLParser.INT_8_ARRAY - 64)) | (1 << (WebIDLParser.INT_16_ARRAY - 64)) | (1 << (WebIDLParser.INT_32_ARRAY - 64)) | (1 << (WebIDLParser.UINT_8_ARRAY - 64)) | (1 << (WebIDLParser.UINT_16_ARRAY - 64)) | (1 << (WebIDLParser.UINT_32_ARRAY - 64)) | (1 << (WebIDLParser.UINT_8_CLAMPED_ARRAY - 64)) | (1 << (WebIDLParser.FLOAT_32_ARRAY - 64)) | (1 << (WebIDLParser.FLOAT_64_ARRAY - 64)) | (1 << (WebIDLParser.IDENTIFIER - 64)))) != 0):
                self.state = 275
                self.mixinMembers()
                self.state = 280
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 281
            self.match(WebIDLParser.RIGHT_BRACE)
            self.state = 282
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MixinMembersContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def mixinMember(self):
            return self.getTypedRuleContext(WebIDLParser.MixinMemberContext,0)


        def extendedAttributeList(self):
            return self.getTypedRuleContext(WebIDLParser.ExtendedAttributeListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_mixinMembers

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMixinMembers" ):
                return visitor.visitMixinMembers(self)
            else:
                return visitor.visitChildren(self)




    def mixinMembers(self):

        localctx = WebIDLParser.MixinMembersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_mixinMembers)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 285
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.LEFT_BRACKET:
                self.state = 284
                self.extendedAttributeList()


            self.state = 287
            self.mixinMember()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MixinMemberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def const_(self):
            return self.getTypedRuleContext(WebIDLParser.Const_Context,0)


        def regularOperation(self):
            return self.getTypedRuleContext(WebIDLParser.RegularOperationContext,0)


        def stringifier(self):
            return self.getTypedRuleContext(WebIDLParser.StringifierContext,0)


        def attributeRest(self):
            return self.getTypedRuleContext(WebIDLParser.AttributeRestContext,0)


        def READONLY(self):
            return self.getToken(WebIDLParser.READONLY, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_mixinMember

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMixinMember" ):
                return visitor.visitMixinMember(self)
            else:
                return visitor.visitChildren(self)




    def mixinMember(self):

        localctx = WebIDLParser.MixinMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_mixinMember)
        self._la = 0 # Token type
        try:
            self.state = 296
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.CONST]:
                self.enterOuterAlt(localctx, 1)
                self.state = 289
                self.const_()
                pass
            elif token in [WebIDLParser.LEFT_PAREN, WebIDLParser.ANY, WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.BYTE_STRING, WebIDLParser.DOM_STRING, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.FROZEN_ARRAY, WebIDLParser.LONG, WebIDLParser.OBJECT, WebIDLParser.OBSERVABLE_ARRAY, WebIDLParser.OCTET, WebIDLParser.PROMISE, WebIDLParser.RECORD, WebIDLParser.SEQUENCE, WebIDLParser.SHORT, WebIDLParser.SYMBOL, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED, WebIDLParser.USV_STRING, WebIDLParser.VOID, WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY, WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 290
                self.regularOperation()
                pass
            elif token in [WebIDLParser.STRINGIFIER]:
                self.enterOuterAlt(localctx, 3)
                self.state = 291
                self.stringifier()
                pass
            elif token in [WebIDLParser.ATTRIBUTE, WebIDLParser.READONLY]:
                self.enterOuterAlt(localctx, 4)
                self.state = 293
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.READONLY:
                    self.state = 292
                    self.match(WebIDLParser.READONLY)


                self.state = 295
                self.attributeRest()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IncludesStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.target = None # Token
            self.includes = None # Token

        def INCLUDES(self):
            return self.getToken(WebIDLParser.INCLUDES, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def IDENTIFIER(self, i:int=None):
            if i is None:
                return self.getTokens(WebIDLParser.IDENTIFIER)
            else:
                return self.getToken(WebIDLParser.IDENTIFIER, i)

        def getRuleIndex(self):
            return WebIDLParser.RULE_includesStatement

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIncludesStatement" ):
                return visitor.visitIncludesStatement(self)
            else:
                return visitor.visitChildren(self)




    def includesStatement(self):

        localctx = WebIDLParser.IncludesStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_includesStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 298
            localctx.target = self.match(WebIDLParser.IDENTIFIER)
            self.state = 299
            self.match(WebIDLParser.INCLUDES)
            self.state = 300
            localctx.includes = self.match(WebIDLParser.IDENTIFIER)
            self.state = 301
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CallbackRestOrInterfaceContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def callbackRest(self):
            return self.getTypedRuleContext(WebIDLParser.CallbackRestContext,0)


        def INTERFACE(self):
            return self.getToken(WebIDLParser.INTERFACE, 0)

        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def LEFT_BRACE(self):
            return self.getToken(WebIDLParser.LEFT_BRACE, 0)

        def RIGHT_BRACE(self):
            return self.getToken(WebIDLParser.RIGHT_BRACE, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def callbackInterfaceMembers(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(WebIDLParser.CallbackInterfaceMembersContext)
            else:
                return self.getTypedRuleContext(WebIDLParser.CallbackInterfaceMembersContext,i)


        def getRuleIndex(self):
            return WebIDLParser.RULE_callbackRestOrInterface

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCallbackRestOrInterface" ):
                return visitor.visitCallbackRestOrInterface(self)
            else:
                return visitor.visitChildren(self)




    def callbackRestOrInterface(self):

        localctx = WebIDLParser.CallbackRestOrInterfaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_callbackRestOrInterface)
        self._la = 0 # Token type
        try:
            self.state = 315
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 303
                self.callbackRest()
                pass
            elif token in [WebIDLParser.INTERFACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 304
                self.match(WebIDLParser.INTERFACE)
                self.state = 305
                self.match(WebIDLParser.IDENTIFIER)
                self.state = 306
                self.match(WebIDLParser.LEFT_BRACE)
                self.state = 310
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.LEFT_PAREN) | (1 << WebIDLParser.LEFT_BRACKET) | (1 << WebIDLParser.ANY) | (1 << WebIDLParser.BOOLEAN) | (1 << WebIDLParser.BYTE) | (1 << WebIDLParser.BYTE_STRING) | (1 << WebIDLParser.CONST) | (1 << WebIDLParser.DOM_STRING) | (1 << WebIDLParser.DOUBLE) | (1 << WebIDLParser.FLOAT) | (1 << WebIDLParser.FROZEN_ARRAY) | (1 << WebIDLParser.LONG) | (1 << WebIDLParser.OBJECT) | (1 << WebIDLParser.OBSERVABLE_ARRAY) | (1 << WebIDLParser.OCTET) | (1 << WebIDLParser.PROMISE) | (1 << WebIDLParser.RECORD) | (1 << WebIDLParser.SEQUENCE) | (1 << WebIDLParser.SHORT))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (WebIDLParser.SYMBOL - 65)) | (1 << (WebIDLParser.UNRESTRICTED - 65)) | (1 << (WebIDLParser.UNSIGNED - 65)) | (1 << (WebIDLParser.USV_STRING - 65)) | (1 << (WebIDLParser.VOID - 65)) | (1 << (WebIDLParser.ARRAY_BUFFER - 65)) | (1 << (WebIDLParser.DATA_VIEW - 65)) | (1 << (WebIDLParser.INT_8_ARRAY - 65)) | (1 << (WebIDLParser.INT_16_ARRAY - 65)) | (1 << (WebIDLParser.INT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_ARRAY - 65)) | (1 << (WebIDLParser.UINT_16_ARRAY - 65)) | (1 << (WebIDLParser.UINT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_CLAMPED_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_32_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_64_ARRAY - 65)) | (1 << (WebIDLParser.IDENTIFIER - 65)))) != 0):
                    self.state = 307
                    self.callbackInterfaceMembers()
                    self.state = 312
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 313
                self.match(WebIDLParser.RIGHT_BRACE)
                self.state = 314
                self.match(WebIDLParser.SEMI)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CallbackInterfaceMembersContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def callbackInterfaceMember(self):
            return self.getTypedRuleContext(WebIDLParser.CallbackInterfaceMemberContext,0)


        def extendedAttributeList(self):
            return self.getTypedRuleContext(WebIDLParser.ExtendedAttributeListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_callbackInterfaceMembers

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCallbackInterfaceMembers" ):
                return visitor.visitCallbackInterfaceMembers(self)
            else:
                return visitor.visitChildren(self)




    def callbackInterfaceMembers(self):

        localctx = WebIDLParser.CallbackInterfaceMembersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_callbackInterfaceMembers)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 318
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.LEFT_BRACKET:
                self.state = 317
                self.extendedAttributeList()


            self.state = 320
            self.callbackInterfaceMember()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CallbackInterfaceMemberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def const_(self):
            return self.getTypedRuleContext(WebIDLParser.Const_Context,0)


        def regularOperation(self):
            return self.getTypedRuleContext(WebIDLParser.RegularOperationContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_callbackInterfaceMember

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCallbackInterfaceMember" ):
                return visitor.visitCallbackInterfaceMember(self)
            else:
                return visitor.visitChildren(self)




    def callbackInterfaceMember(self):

        localctx = WebIDLParser.CallbackInterfaceMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_callbackInterfaceMember)
        try:
            self.state = 324
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.CONST]:
                self.enterOuterAlt(localctx, 1)
                self.state = 322
                self.const_()
                pass
            elif token in [WebIDLParser.LEFT_PAREN, WebIDLParser.ANY, WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.BYTE_STRING, WebIDLParser.DOM_STRING, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.FROZEN_ARRAY, WebIDLParser.LONG, WebIDLParser.OBJECT, WebIDLParser.OBSERVABLE_ARRAY, WebIDLParser.OCTET, WebIDLParser.PROMISE, WebIDLParser.RECORD, WebIDLParser.SEQUENCE, WebIDLParser.SHORT, WebIDLParser.SYMBOL, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED, WebIDLParser.USV_STRING, WebIDLParser.VOID, WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY, WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 323
                self.regularOperation()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Const_Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CONST(self):
            return self.getToken(WebIDLParser.CONST, 0)

        def constType(self):
            return self.getTypedRuleContext(WebIDLParser.ConstTypeContext,0)


        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def EQUAL_SYMBOL(self):
            return self.getToken(WebIDLParser.EQUAL_SYMBOL, 0)

        def constValue(self):
            return self.getTypedRuleContext(WebIDLParser.ConstValueContext,0)


        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_const_

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConst_" ):
                return visitor.visitConst_(self)
            else:
                return visitor.visitChildren(self)




    def const_(self):

        localctx = WebIDLParser.Const_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_const_)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 326
            self.match(WebIDLParser.CONST)
            self.state = 327
            self.constType()
            self.state = 328
            self.match(WebIDLParser.IDENTIFIER)
            self.state = 329
            self.match(WebIDLParser.EQUAL_SYMBOL)
            self.state = 330
            self.constValue()
            self.state = 331
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstValueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def booleanLiteral(self):
            return self.getTypedRuleContext(WebIDLParser.BooleanLiteralContext,0)


        def floatLiteral(self):
            return self.getTypedRuleContext(WebIDLParser.FloatLiteralContext,0)


        def IntegerLiteral(self):
            return self.getToken(WebIDLParser.IntegerLiteral, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_constValue

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstValue" ):
                return visitor.visitConstValue(self)
            else:
                return visitor.visitChildren(self)




    def constValue(self):

        localctx = WebIDLParser.ConstValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_constValue)
        try:
            self.state = 336
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.FALSE, WebIDLParser.TRUE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 333
                self.booleanLiteral()
                pass
            elif token in [WebIDLParser.INFINITY, WebIDLParser.MINUS_INFINITY, WebIDLParser.NAN, WebIDLParser.DecimalLiteral]:
                self.enterOuterAlt(localctx, 2)
                self.state = 334
                self.floatLiteral()
                pass
            elif token in [WebIDLParser.IntegerLiteral]:
                self.enterOuterAlt(localctx, 3)
                self.state = 335
                self.match(WebIDLParser.IntegerLiteral)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReadOnlyMemberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def READONLY(self):
            return self.getToken(WebIDLParser.READONLY, 0)

        def readOnlyMemberRest(self):
            return self.getTypedRuleContext(WebIDLParser.ReadOnlyMemberRestContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_readOnlyMember

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReadOnlyMember" ):
                return visitor.visitReadOnlyMember(self)
            else:
                return visitor.visitChildren(self)




    def readOnlyMember(self):

        localctx = WebIDLParser.ReadOnlyMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_readOnlyMember)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 338
            self.match(WebIDLParser.READONLY)
            self.state = 339
            self.readOnlyMemberRest()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReadOnlyMemberRestContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attributeRest(self):
            return self.getTypedRuleContext(WebIDLParser.AttributeRestContext,0)


        def maplikeRest(self):
            return self.getTypedRuleContext(WebIDLParser.MaplikeRestContext,0)


        def setlikeRest(self):
            return self.getTypedRuleContext(WebIDLParser.SetlikeRestContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_readOnlyMemberRest

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReadOnlyMemberRest" ):
                return visitor.visitReadOnlyMemberRest(self)
            else:
                return visitor.visitChildren(self)




    def readOnlyMemberRest(self):

        localctx = WebIDLParser.ReadOnlyMemberRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_readOnlyMemberRest)
        try:
            self.state = 344
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 341
                self.attributeRest()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 342
                self.maplikeRest()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 343
                self.setlikeRest()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReadWriteAttributeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attributeRest(self):
            return self.getTypedRuleContext(WebIDLParser.AttributeRestContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_readWriteAttribute

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReadWriteAttribute" ):
                return visitor.visitReadWriteAttribute(self)
            else:
                return visitor.visitChildren(self)




    def readWriteAttribute(self):

        localctx = WebIDLParser.ReadWriteAttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_readWriteAttribute)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 346
            self.attributeRest()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InheritAttributeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INHERIT(self):
            return self.getToken(WebIDLParser.INHERIT, 0)

        def attributeRest(self):
            return self.getTypedRuleContext(WebIDLParser.AttributeRestContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_inheritAttribute

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInheritAttribute" ):
                return visitor.visitInheritAttribute(self)
            else:
                return visitor.visitChildren(self)




    def inheritAttribute(self):

        localctx = WebIDLParser.InheritAttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_inheritAttribute)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 348
            self.match(WebIDLParser.INHERIT)
            self.state = 349
            self.attributeRest()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeRestContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ATTRIBUTE(self):
            return self.getToken(WebIDLParser.ATTRIBUTE, 0)

        def typeWithExtendedAttributes(self):
            return self.getTypedRuleContext(WebIDLParser.TypeWithExtendedAttributesContext,0)


        def attributeName(self):
            return self.getTypedRuleContext(WebIDLParser.AttributeNameContext,0)


        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_attributeRest

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeRest" ):
                return visitor.visitAttributeRest(self)
            else:
                return visitor.visitChildren(self)




    def attributeRest(self):

        localctx = WebIDLParser.AttributeRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_attributeRest)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 351
            self.match(WebIDLParser.ATTRIBUTE)
            self.state = 352
            self.typeWithExtendedAttributes()
            self.state = 353
            self.attributeName()
            self.state = 354
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.attributeNameKeyword = None # Token

        def ASYNC(self):
            return self.getToken(WebIDLParser.ASYNC, 0)

        def REQUIRED(self):
            return self.getToken(WebIDLParser.REQUIRED, 0)

        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_attributeName

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeName" ):
                return visitor.visitAttributeName(self)
            else:
                return visitor.visitChildren(self)




    def attributeName(self):

        localctx = WebIDLParser.AttributeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_attributeName)
        self._la = 0 # Token type
        try:
            self.state = 358
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.ASYNC, WebIDLParser.REQUIRED]:
                self.enterOuterAlt(localctx, 1)
                self.state = 356
                localctx.attributeNameKeyword = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==WebIDLParser.ASYNC or _la==WebIDLParser.REQUIRED):
                    localctx.attributeNameKeyword = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 357
                self.match(WebIDLParser.IDENTIFIER)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DefaultValueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def constValue(self):
            return self.getTypedRuleContext(WebIDLParser.ConstValueContext,0)


        def StringLiteral(self):
            return self.getToken(WebIDLParser.StringLiteral, 0)

        def LEFT_BRACKET(self):
            return self.getToken(WebIDLParser.LEFT_BRACKET, 0)

        def RIGHT_BRACKET(self):
            return self.getToken(WebIDLParser.RIGHT_BRACKET, 0)

        def LEFT_BRACE(self):
            return self.getToken(WebIDLParser.LEFT_BRACE, 0)

        def RIGHT_BRACE(self):
            return self.getToken(WebIDLParser.RIGHT_BRACE, 0)

        def NULL(self):
            return self.getToken(WebIDLParser.NULL, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_defaultValue

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDefaultValue" ):
                return visitor.visitDefaultValue(self)
            else:
                return visitor.visitChildren(self)




    def defaultValue(self):

        localctx = WebIDLParser.DefaultValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_defaultValue)
        try:
            self.state = 367
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.FALSE, WebIDLParser.INFINITY, WebIDLParser.MINUS_INFINITY, WebIDLParser.NAN, WebIDLParser.TRUE, WebIDLParser.IntegerLiteral, WebIDLParser.DecimalLiteral]:
                self.enterOuterAlt(localctx, 1)
                self.state = 360
                self.constValue()
                pass
            elif token in [WebIDLParser.StringLiteral]:
                self.enterOuterAlt(localctx, 2)
                self.state = 361
                self.match(WebIDLParser.StringLiteral)
                pass
            elif token in [WebIDLParser.LEFT_BRACKET]:
                self.enterOuterAlt(localctx, 3)
                self.state = 362
                self.match(WebIDLParser.LEFT_BRACKET)
                self.state = 363
                self.match(WebIDLParser.RIGHT_BRACKET)
                pass
            elif token in [WebIDLParser.LEFT_BRACE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 364
                self.match(WebIDLParser.LEFT_BRACE)
                self.state = 365
                self.match(WebIDLParser.RIGHT_BRACE)
                pass
            elif token in [WebIDLParser.NULL]:
                self.enterOuterAlt(localctx, 5)
                self.state = 366
                self.match(WebIDLParser.NULL)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OperationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.special = None # Token

        def regularOperation(self):
            return self.getTypedRuleContext(WebIDLParser.RegularOperationContext,0)


        def GETTER(self):
            return self.getToken(WebIDLParser.GETTER, 0)

        def SETTER(self):
            return self.getToken(WebIDLParser.SETTER, 0)

        def DELETER(self):
            return self.getToken(WebIDLParser.DELETER, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_operation

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOperation" ):
                return visitor.visitOperation(self)
            else:
                return visitor.visitChildren(self)




    def operation(self):

        localctx = WebIDLParser.OperationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_operation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 370
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.DELETER) | (1 << WebIDLParser.GETTER) | (1 << WebIDLParser.SETTER))) != 0):
                self.state = 369
                localctx.special = self._input.LT(1)
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.DELETER) | (1 << WebIDLParser.GETTER) | (1 << WebIDLParser.SETTER))) != 0)):
                    localctx.special = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 372
            self.regularOperation()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RegularOperationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def returnType(self):
            return self.getTypedRuleContext(WebIDLParser.ReturnTypeContext,0)


        def operationRest(self):
            return self.getTypedRuleContext(WebIDLParser.OperationRestContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_regularOperation

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRegularOperation" ):
                return visitor.visitRegularOperation(self)
            else:
                return visitor.visitChildren(self)




    def regularOperation(self):

        localctx = WebIDLParser.RegularOperationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_regularOperation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 374
            self.returnType()
            self.state = 375
            self.operationRest()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OperationRestContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LEFT_PAREN(self):
            return self.getToken(WebIDLParser.LEFT_PAREN, 0)

        def RIGHT_PAREN(self):
            return self.getToken(WebIDLParser.RIGHT_PAREN, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def operationName(self):
            return self.getTypedRuleContext(WebIDLParser.OperationNameContext,0)


        def argumentList(self):
            return self.getTypedRuleContext(WebIDLParser.ArgumentListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_operationRest

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOperationRest" ):
                return visitor.visitOperationRest(self)
            else:
                return visitor.visitChildren(self)




    def operationRest(self):

        localctx = WebIDLParser.OperationRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_operationRest)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 378
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.INCLUDES or _la==WebIDLParser.IDENTIFIER:
                self.state = 377
                self.operationName()


            self.state = 380
            self.match(WebIDLParser.LEFT_PAREN)
            self.state = 382
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.LEFT_PAREN) | (1 << WebIDLParser.LEFT_BRACKET) | (1 << WebIDLParser.ANY) | (1 << WebIDLParser.BOOLEAN) | (1 << WebIDLParser.BYTE) | (1 << WebIDLParser.BYTE_STRING) | (1 << WebIDLParser.DOM_STRING) | (1 << WebIDLParser.DOUBLE) | (1 << WebIDLParser.FLOAT) | (1 << WebIDLParser.FROZEN_ARRAY) | (1 << WebIDLParser.LONG) | (1 << WebIDLParser.OBJECT) | (1 << WebIDLParser.OBSERVABLE_ARRAY) | (1 << WebIDLParser.OCTET) | (1 << WebIDLParser.OPTIONAL) | (1 << WebIDLParser.PROMISE) | (1 << WebIDLParser.RECORD) | (1 << WebIDLParser.SEQUENCE) | (1 << WebIDLParser.SHORT))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (WebIDLParser.SYMBOL - 65)) | (1 << (WebIDLParser.UNRESTRICTED - 65)) | (1 << (WebIDLParser.UNSIGNED - 65)) | (1 << (WebIDLParser.USV_STRING - 65)) | (1 << (WebIDLParser.ARRAY_BUFFER - 65)) | (1 << (WebIDLParser.DATA_VIEW - 65)) | (1 << (WebIDLParser.INT_8_ARRAY - 65)) | (1 << (WebIDLParser.INT_16_ARRAY - 65)) | (1 << (WebIDLParser.INT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_ARRAY - 65)) | (1 << (WebIDLParser.UINT_16_ARRAY - 65)) | (1 << (WebIDLParser.UINT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_CLAMPED_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_32_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_64_ARRAY - 65)) | (1 << (WebIDLParser.IDENTIFIER - 65)))) != 0):
                self.state = 381
                self.argumentList()


            self.state = 384
            self.match(WebIDLParser.RIGHT_PAREN)
            self.state = 385
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OperationNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def operationNameKeyword(self):
            return self.getTypedRuleContext(WebIDLParser.OperationNameKeywordContext,0)


        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_operationName

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOperationName" ):
                return visitor.visitOperationName(self)
            else:
                return visitor.visitChildren(self)




    def operationName(self):

        localctx = WebIDLParser.OperationNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_operationName)
        try:
            self.state = 389
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.INCLUDES]:
                self.enterOuterAlt(localctx, 1)
                self.state = 387
                self.operationNameKeyword()
                pass
            elif token in [WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 388
                self.match(WebIDLParser.IDENTIFIER)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OperationNameKeywordContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INCLUDES(self):
            return self.getToken(WebIDLParser.INCLUDES, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_operationNameKeyword

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOperationNameKeyword" ):
                return visitor.visitOperationNameKeyword(self)
            else:
                return visitor.visitChildren(self)




    def operationNameKeyword(self):

        localctx = WebIDLParser.OperationNameKeywordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_operationNameKeyword)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 391
            self.match(WebIDLParser.INCLUDES)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgumentListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def argument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(WebIDLParser.ArgumentContext)
            else:
                return self.getTypedRuleContext(WebIDLParser.ArgumentContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(WebIDLParser.COMMA)
            else:
                return self.getToken(WebIDLParser.COMMA, i)

        def getRuleIndex(self):
            return WebIDLParser.RULE_argumentList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArgumentList" ):
                return visitor.visitArgumentList(self)
            else:
                return visitor.visitChildren(self)




    def argumentList(self):

        localctx = WebIDLParser.ArgumentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_argumentList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 393
            self.argument()
            self.state = 398
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==WebIDLParser.COMMA:
                self.state = 394
                self.match(WebIDLParser.COMMA)
                self.state = 395
                self.argument()
                self.state = 400
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgumentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def argumentRest(self):
            return self.getTypedRuleContext(WebIDLParser.ArgumentRestContext,0)


        def extendedAttributeList(self):
            return self.getTypedRuleContext(WebIDLParser.ExtendedAttributeListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_argument

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArgument" ):
                return visitor.visitArgument(self)
            else:
                return visitor.visitChildren(self)




    def argument(self):

        localctx = WebIDLParser.ArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_argument)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 402
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.LEFT_BRACKET:
                self.state = 401
                self.extendedAttributeList()


            self.state = 404
            self.argumentRest()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgumentRestContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPTIONAL(self):
            return self.getToken(WebIDLParser.OPTIONAL, 0)

        def typeWithExtendedAttributes(self):
            return self.getTypedRuleContext(WebIDLParser.TypeWithExtendedAttributesContext,0)


        def argumentName(self):
            return self.getTypedRuleContext(WebIDLParser.ArgumentNameContext,0)


        def default_(self):
            return self.getTypedRuleContext(WebIDLParser.Default_Context,0)


        def type_(self):
            return self.getTypedRuleContext(WebIDLParser.Type_Context,0)


        def ELLIPSIS(self):
            return self.getToken(WebIDLParser.ELLIPSIS, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_argumentRest

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArgumentRest" ):
                return visitor.visitArgumentRest(self)
            else:
                return visitor.visitChildren(self)




    def argumentRest(self):

        localctx = WebIDLParser.ArgumentRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_argumentRest)
        self._la = 0 # Token type
        try:
            self.state = 418
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.OPTIONAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 406
                self.match(WebIDLParser.OPTIONAL)
                self.state = 407
                self.typeWithExtendedAttributes()
                self.state = 408
                self.argumentName()
                self.state = 410
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.EQUAL_SYMBOL:
                    self.state = 409
                    self.default_()


                pass
            elif token in [WebIDLParser.LEFT_PAREN, WebIDLParser.ANY, WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.BYTE_STRING, WebIDLParser.DOM_STRING, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.FROZEN_ARRAY, WebIDLParser.LONG, WebIDLParser.OBJECT, WebIDLParser.OBSERVABLE_ARRAY, WebIDLParser.OCTET, WebIDLParser.PROMISE, WebIDLParser.RECORD, WebIDLParser.SEQUENCE, WebIDLParser.SHORT, WebIDLParser.SYMBOL, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED, WebIDLParser.USV_STRING, WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY, WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 412
                self.type_()
                self.state = 414
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.ELLIPSIS:
                    self.state = 413
                    self.match(WebIDLParser.ELLIPSIS)


                self.state = 416
                self.argumentName()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgumentNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def argumentNameKeyword(self):
            return self.getTypedRuleContext(WebIDLParser.ArgumentNameKeywordContext,0)


        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_argumentName

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArgumentName" ):
                return visitor.visitArgumentName(self)
            else:
                return visitor.visitChildren(self)




    def argumentName(self):

        localctx = WebIDLParser.ArgumentNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_argumentName)
        try:
            self.state = 422
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.ASYNC, WebIDLParser.ATTRIBUTE, WebIDLParser.CALLBACK, WebIDLParser.CONST, WebIDLParser.CONSTRUCTOR, WebIDLParser.DELETER, WebIDLParser.DICTIONARY, WebIDLParser.ENUM, WebIDLParser.GETTER, WebIDLParser.INCLUDES, WebIDLParser.INHERIT, WebIDLParser.INTERFACE, WebIDLParser.ITERABLE, WebIDLParser.MAPLIKE, WebIDLParser.MIXIN, WebIDLParser.NAMESPACE, WebIDLParser.PARTIAL, WebIDLParser.READONLY, WebIDLParser.REQUIRED, WebIDLParser.SETLIKE, WebIDLParser.SETTER, WebIDLParser.STATIC, WebIDLParser.STRINGIFIER, WebIDLParser.TYPEDEF, WebIDLParser.UNRESTRICTED]:
                self.enterOuterAlt(localctx, 1)
                self.state = 420
                self.argumentNameKeyword()
                pass
            elif token in [WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 421
                self.match(WebIDLParser.IDENTIFIER)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstructorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CONSTRUCTOR(self):
            return self.getToken(WebIDLParser.CONSTRUCTOR, 0)

        def LEFT_PAREN(self):
            return self.getToken(WebIDLParser.LEFT_PAREN, 0)

        def RIGHT_PAREN(self):
            return self.getToken(WebIDLParser.RIGHT_PAREN, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def argumentList(self):
            return self.getTypedRuleContext(WebIDLParser.ArgumentListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_constructor

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstructor" ):
                return visitor.visitConstructor(self)
            else:
                return visitor.visitChildren(self)




    def constructor(self):

        localctx = WebIDLParser.ConstructorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_constructor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 424
            self.match(WebIDLParser.CONSTRUCTOR)
            self.state = 425
            self.match(WebIDLParser.LEFT_PAREN)
            self.state = 427
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.LEFT_PAREN) | (1 << WebIDLParser.LEFT_BRACKET) | (1 << WebIDLParser.ANY) | (1 << WebIDLParser.BOOLEAN) | (1 << WebIDLParser.BYTE) | (1 << WebIDLParser.BYTE_STRING) | (1 << WebIDLParser.DOM_STRING) | (1 << WebIDLParser.DOUBLE) | (1 << WebIDLParser.FLOAT) | (1 << WebIDLParser.FROZEN_ARRAY) | (1 << WebIDLParser.LONG) | (1 << WebIDLParser.OBJECT) | (1 << WebIDLParser.OBSERVABLE_ARRAY) | (1 << WebIDLParser.OCTET) | (1 << WebIDLParser.OPTIONAL) | (1 << WebIDLParser.PROMISE) | (1 << WebIDLParser.RECORD) | (1 << WebIDLParser.SEQUENCE) | (1 << WebIDLParser.SHORT))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (WebIDLParser.SYMBOL - 65)) | (1 << (WebIDLParser.UNRESTRICTED - 65)) | (1 << (WebIDLParser.UNSIGNED - 65)) | (1 << (WebIDLParser.USV_STRING - 65)) | (1 << (WebIDLParser.ARRAY_BUFFER - 65)) | (1 << (WebIDLParser.DATA_VIEW - 65)) | (1 << (WebIDLParser.INT_8_ARRAY - 65)) | (1 << (WebIDLParser.INT_16_ARRAY - 65)) | (1 << (WebIDLParser.INT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_ARRAY - 65)) | (1 << (WebIDLParser.UINT_16_ARRAY - 65)) | (1 << (WebIDLParser.UINT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_CLAMPED_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_32_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_64_ARRAY - 65)) | (1 << (WebIDLParser.IDENTIFIER - 65)))) != 0):
                self.state = 426
                self.argumentList()


            self.state = 429
            self.match(WebIDLParser.RIGHT_PAREN)
            self.state = 430
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StringifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STRINGIFIER(self):
            return self.getToken(WebIDLParser.STRINGIFIER, 0)

        def stringifierRest(self):
            return self.getTypedRuleContext(WebIDLParser.StringifierRestContext,0)


        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_stringifier

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStringifier" ):
                return visitor.visitStringifier(self)
            else:
                return visitor.visitChildren(self)




    def stringifier(self):

        localctx = WebIDLParser.StringifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_stringifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 432
            self.match(WebIDLParser.STRINGIFIER)
            self.state = 435
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.LEFT_PAREN, WebIDLParser.ANY, WebIDLParser.ATTRIBUTE, WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.BYTE_STRING, WebIDLParser.DOM_STRING, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.FROZEN_ARRAY, WebIDLParser.LONG, WebIDLParser.OBJECT, WebIDLParser.OBSERVABLE_ARRAY, WebIDLParser.OCTET, WebIDLParser.PROMISE, WebIDLParser.READONLY, WebIDLParser.RECORD, WebIDLParser.SEQUENCE, WebIDLParser.SHORT, WebIDLParser.SYMBOL, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED, WebIDLParser.USV_STRING, WebIDLParser.VOID, WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY, WebIDLParser.IDENTIFIER]:
                self.state = 433
                self.stringifierRest()
                pass
            elif token in [WebIDLParser.SEMI]:
                self.state = 434
                self.match(WebIDLParser.SEMI)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StringifierRestContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attributeRest(self):
            return self.getTypedRuleContext(WebIDLParser.AttributeRestContext,0)


        def READONLY(self):
            return self.getToken(WebIDLParser.READONLY, 0)

        def regularOperation(self):
            return self.getTypedRuleContext(WebIDLParser.RegularOperationContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_stringifierRest

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStringifierRest" ):
                return visitor.visitStringifierRest(self)
            else:
                return visitor.visitChildren(self)




    def stringifierRest(self):

        localctx = WebIDLParser.StringifierRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_stringifierRest)
        self._la = 0 # Token type
        try:
            self.state = 442
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.ATTRIBUTE, WebIDLParser.READONLY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 438
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.READONLY:
                    self.state = 437
                    self.match(WebIDLParser.READONLY)


                self.state = 440
                self.attributeRest()
                pass
            elif token in [WebIDLParser.LEFT_PAREN, WebIDLParser.ANY, WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.BYTE_STRING, WebIDLParser.DOM_STRING, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.FROZEN_ARRAY, WebIDLParser.LONG, WebIDLParser.OBJECT, WebIDLParser.OBSERVABLE_ARRAY, WebIDLParser.OCTET, WebIDLParser.PROMISE, WebIDLParser.RECORD, WebIDLParser.SEQUENCE, WebIDLParser.SHORT, WebIDLParser.SYMBOL, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED, WebIDLParser.USV_STRING, WebIDLParser.VOID, WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY, WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 441
                self.regularOperation()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StaticMemberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STATIC(self):
            return self.getToken(WebIDLParser.STATIC, 0)

        def staticMemberRest(self):
            return self.getTypedRuleContext(WebIDLParser.StaticMemberRestContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_staticMember

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStaticMember" ):
                return visitor.visitStaticMember(self)
            else:
                return visitor.visitChildren(self)




    def staticMember(self):

        localctx = WebIDLParser.StaticMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_staticMember)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 444
            self.match(WebIDLParser.STATIC)
            self.state = 445
            self.staticMemberRest()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StaticMemberRestContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attributeRest(self):
            return self.getTypedRuleContext(WebIDLParser.AttributeRestContext,0)


        def READONLY(self):
            return self.getToken(WebIDLParser.READONLY, 0)

        def regularOperation(self):
            return self.getTypedRuleContext(WebIDLParser.RegularOperationContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_staticMemberRest

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStaticMemberRest" ):
                return visitor.visitStaticMemberRest(self)
            else:
                return visitor.visitChildren(self)




    def staticMemberRest(self):

        localctx = WebIDLParser.StaticMemberRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_staticMemberRest)
        self._la = 0 # Token type
        try:
            self.state = 452
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.ATTRIBUTE, WebIDLParser.READONLY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 448
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.READONLY:
                    self.state = 447
                    self.match(WebIDLParser.READONLY)


                self.state = 450
                self.attributeRest()
                pass
            elif token in [WebIDLParser.LEFT_PAREN, WebIDLParser.ANY, WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.BYTE_STRING, WebIDLParser.DOM_STRING, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.FROZEN_ARRAY, WebIDLParser.LONG, WebIDLParser.OBJECT, WebIDLParser.OBSERVABLE_ARRAY, WebIDLParser.OCTET, WebIDLParser.PROMISE, WebIDLParser.RECORD, WebIDLParser.SEQUENCE, WebIDLParser.SHORT, WebIDLParser.SYMBOL, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED, WebIDLParser.USV_STRING, WebIDLParser.VOID, WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY, WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 451
                self.regularOperation()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IterableContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ITERABLE(self):
            return self.getToken(WebIDLParser.ITERABLE, 0)

        def LEFT_ANGLE(self):
            return self.getToken(WebIDLParser.LEFT_ANGLE, 0)

        def typeWithExtendedAttributes(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(WebIDLParser.TypeWithExtendedAttributesContext)
            else:
                return self.getTypedRuleContext(WebIDLParser.TypeWithExtendedAttributesContext,i)


        def RIGHT_ANGLE(self):
            return self.getToken(WebIDLParser.RIGHT_ANGLE, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def COMMA(self):
            return self.getToken(WebIDLParser.COMMA, 0)

        def ASYNC(self):
            return self.getToken(WebIDLParser.ASYNC, 0)

        def optionalArgumentList(self):
            return self.getTypedRuleContext(WebIDLParser.OptionalArgumentListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_iterable

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIterable" ):
                return visitor.visitIterable(self)
            else:
                return visitor.visitChildren(self)




    def iterable(self):

        localctx = WebIDLParser.IterableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_iterable)
        self._la = 0 # Token type
        try:
            self.state = 478
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.ITERABLE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 454
                self.match(WebIDLParser.ITERABLE)
                self.state = 455
                self.match(WebIDLParser.LEFT_ANGLE)
                self.state = 456
                self.typeWithExtendedAttributes()
                self.state = 459
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.COMMA:
                    self.state = 457
                    self.match(WebIDLParser.COMMA)
                    self.state = 458
                    self.typeWithExtendedAttributes()


                self.state = 461
                self.match(WebIDLParser.RIGHT_ANGLE)
                self.state = 462
                self.match(WebIDLParser.SEMI)
                pass
            elif token in [WebIDLParser.ASYNC]:
                self.enterOuterAlt(localctx, 2)
                self.state = 464
                self.match(WebIDLParser.ASYNC)
                self.state = 465
                self.match(WebIDLParser.ITERABLE)
                self.state = 466
                self.match(WebIDLParser.LEFT_ANGLE)
                self.state = 467
                self.typeWithExtendedAttributes()
                self.state = 470
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.COMMA:
                    self.state = 468
                    self.match(WebIDLParser.COMMA)
                    self.state = 469
                    self.typeWithExtendedAttributes()


                self.state = 472
                self.match(WebIDLParser.RIGHT_ANGLE)
                self.state = 474
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.LEFT_PAREN:
                    self.state = 473
                    self.optionalArgumentList()


                self.state = 476
                self.match(WebIDLParser.SEMI)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OptionalArgumentListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LEFT_PAREN(self):
            return self.getToken(WebIDLParser.LEFT_PAREN, 0)

        def RIGHT_PAREN(self):
            return self.getToken(WebIDLParser.RIGHT_PAREN, 0)

        def argumentList(self):
            return self.getTypedRuleContext(WebIDLParser.ArgumentListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_optionalArgumentList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOptionalArgumentList" ):
                return visitor.visitOptionalArgumentList(self)
            else:
                return visitor.visitChildren(self)




    def optionalArgumentList(self):

        localctx = WebIDLParser.OptionalArgumentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_optionalArgumentList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 480
            self.match(WebIDLParser.LEFT_PAREN)
            self.state = 482
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.LEFT_PAREN) | (1 << WebIDLParser.LEFT_BRACKET) | (1 << WebIDLParser.ANY) | (1 << WebIDLParser.BOOLEAN) | (1 << WebIDLParser.BYTE) | (1 << WebIDLParser.BYTE_STRING) | (1 << WebIDLParser.DOM_STRING) | (1 << WebIDLParser.DOUBLE) | (1 << WebIDLParser.FLOAT) | (1 << WebIDLParser.FROZEN_ARRAY) | (1 << WebIDLParser.LONG) | (1 << WebIDLParser.OBJECT) | (1 << WebIDLParser.OBSERVABLE_ARRAY) | (1 << WebIDLParser.OCTET) | (1 << WebIDLParser.OPTIONAL) | (1 << WebIDLParser.PROMISE) | (1 << WebIDLParser.RECORD) | (1 << WebIDLParser.SEQUENCE) | (1 << WebIDLParser.SHORT))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (WebIDLParser.SYMBOL - 65)) | (1 << (WebIDLParser.UNRESTRICTED - 65)) | (1 << (WebIDLParser.UNSIGNED - 65)) | (1 << (WebIDLParser.USV_STRING - 65)) | (1 << (WebIDLParser.ARRAY_BUFFER - 65)) | (1 << (WebIDLParser.DATA_VIEW - 65)) | (1 << (WebIDLParser.INT_8_ARRAY - 65)) | (1 << (WebIDLParser.INT_16_ARRAY - 65)) | (1 << (WebIDLParser.INT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_ARRAY - 65)) | (1 << (WebIDLParser.UINT_16_ARRAY - 65)) | (1 << (WebIDLParser.UINT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_CLAMPED_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_32_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_64_ARRAY - 65)) | (1 << (WebIDLParser.IDENTIFIER - 65)))) != 0):
                self.state = 481
                self.argumentList()


            self.state = 484
            self.match(WebIDLParser.RIGHT_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReadWriteMaplikeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def maplikeRest(self):
            return self.getTypedRuleContext(WebIDLParser.MaplikeRestContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_readWriteMaplike

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReadWriteMaplike" ):
                return visitor.visitReadWriteMaplike(self)
            else:
                return visitor.visitChildren(self)




    def readWriteMaplike(self):

        localctx = WebIDLParser.ReadWriteMaplikeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_readWriteMaplike)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 486
            self.maplikeRest()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MaplikeRestContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def MAPLIKE(self):
            return self.getToken(WebIDLParser.MAPLIKE, 0)

        def LEFT_ANGLE(self):
            return self.getToken(WebIDLParser.LEFT_ANGLE, 0)

        def typeWithExtendedAttributes(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(WebIDLParser.TypeWithExtendedAttributesContext)
            else:
                return self.getTypedRuleContext(WebIDLParser.TypeWithExtendedAttributesContext,i)


        def COMMA(self):
            return self.getToken(WebIDLParser.COMMA, 0)

        def RIGHT_ANGLE(self):
            return self.getToken(WebIDLParser.RIGHT_ANGLE, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def READONLY(self):
            return self.getToken(WebIDLParser.READONLY, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_maplikeRest

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMaplikeRest" ):
                return visitor.visitMaplikeRest(self)
            else:
                return visitor.visitChildren(self)




    def maplikeRest(self):

        localctx = WebIDLParser.MaplikeRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_maplikeRest)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 489
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.READONLY:
                self.state = 488
                self.match(WebIDLParser.READONLY)


            self.state = 491
            self.match(WebIDLParser.MAPLIKE)
            self.state = 492
            self.match(WebIDLParser.LEFT_ANGLE)
            self.state = 493
            self.typeWithExtendedAttributes()
            self.state = 494
            self.match(WebIDLParser.COMMA)
            self.state = 495
            self.typeWithExtendedAttributes()
            self.state = 496
            self.match(WebIDLParser.RIGHT_ANGLE)
            self.state = 497
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReadWriteSetlikeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def setlikeRest(self):
            return self.getTypedRuleContext(WebIDLParser.SetlikeRestContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_readWriteSetlike

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReadWriteSetlike" ):
                return visitor.visitReadWriteSetlike(self)
            else:
                return visitor.visitChildren(self)




    def readWriteSetlike(self):

        localctx = WebIDLParser.ReadWriteSetlikeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_readWriteSetlike)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 499
            self.setlikeRest()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SetlikeRestContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SETLIKE(self):
            return self.getToken(WebIDLParser.SETLIKE, 0)

        def LEFT_ANGLE(self):
            return self.getToken(WebIDLParser.LEFT_ANGLE, 0)

        def typeWithExtendedAttributes(self):
            return self.getTypedRuleContext(WebIDLParser.TypeWithExtendedAttributesContext,0)


        def RIGHT_ANGLE(self):
            return self.getToken(WebIDLParser.RIGHT_ANGLE, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def READONLY(self):
            return self.getToken(WebIDLParser.READONLY, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_setlikeRest

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetlikeRest" ):
                return visitor.visitSetlikeRest(self)
            else:
                return visitor.visitChildren(self)




    def setlikeRest(self):

        localctx = WebIDLParser.SetlikeRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_setlikeRest)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 502
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.READONLY:
                self.state = 501
                self.match(WebIDLParser.READONLY)


            self.state = 504
            self.match(WebIDLParser.SETLIKE)
            self.state = 505
            self.match(WebIDLParser.LEFT_ANGLE)
            self.state = 506
            self.typeWithExtendedAttributes()
            self.state = 507
            self.match(WebIDLParser.RIGHT_ANGLE)
            self.state = 508
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamespaceContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NAMESPACE(self):
            return self.getToken(WebIDLParser.NAMESPACE, 0)

        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def LEFT_BRACE(self):
            return self.getToken(WebIDLParser.LEFT_BRACE, 0)

        def RIGHT_BRACE(self):
            return self.getToken(WebIDLParser.RIGHT_BRACE, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def PARTIAL(self):
            return self.getToken(WebIDLParser.PARTIAL, 0)

        def namespaceMembers(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(WebIDLParser.NamespaceMembersContext)
            else:
                return self.getTypedRuleContext(WebIDLParser.NamespaceMembersContext,i)


        def getRuleIndex(self):
            return WebIDLParser.RULE_namespace

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamespace" ):
                return visitor.visitNamespace(self)
            else:
                return visitor.visitChildren(self)




    def namespace(self):

        localctx = WebIDLParser.NamespaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_namespace)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 511
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.PARTIAL:
                self.state = 510
                self.match(WebIDLParser.PARTIAL)


            self.state = 513
            self.match(WebIDLParser.NAMESPACE)
            self.state = 514
            self.match(WebIDLParser.IDENTIFIER)
            self.state = 515
            self.match(WebIDLParser.LEFT_BRACE)
            self.state = 519
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.LEFT_PAREN) | (1 << WebIDLParser.LEFT_BRACKET) | (1 << WebIDLParser.ANY) | (1 << WebIDLParser.BOOLEAN) | (1 << WebIDLParser.BYTE) | (1 << WebIDLParser.BYTE_STRING) | (1 << WebIDLParser.DOM_STRING) | (1 << WebIDLParser.DOUBLE) | (1 << WebIDLParser.FLOAT) | (1 << WebIDLParser.FROZEN_ARRAY) | (1 << WebIDLParser.LONG) | (1 << WebIDLParser.OBJECT) | (1 << WebIDLParser.OBSERVABLE_ARRAY) | (1 << WebIDLParser.OCTET) | (1 << WebIDLParser.PROMISE) | (1 << WebIDLParser.READONLY) | (1 << WebIDLParser.RECORD) | (1 << WebIDLParser.SEQUENCE) | (1 << WebIDLParser.SHORT))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (WebIDLParser.SYMBOL - 65)) | (1 << (WebIDLParser.UNRESTRICTED - 65)) | (1 << (WebIDLParser.UNSIGNED - 65)) | (1 << (WebIDLParser.USV_STRING - 65)) | (1 << (WebIDLParser.VOID - 65)) | (1 << (WebIDLParser.ARRAY_BUFFER - 65)) | (1 << (WebIDLParser.DATA_VIEW - 65)) | (1 << (WebIDLParser.INT_8_ARRAY - 65)) | (1 << (WebIDLParser.INT_16_ARRAY - 65)) | (1 << (WebIDLParser.INT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_ARRAY - 65)) | (1 << (WebIDLParser.UINT_16_ARRAY - 65)) | (1 << (WebIDLParser.UINT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_CLAMPED_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_32_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_64_ARRAY - 65)) | (1 << (WebIDLParser.IDENTIFIER - 65)))) != 0):
                self.state = 516
                self.namespaceMembers()
                self.state = 521
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 522
            self.match(WebIDLParser.RIGHT_BRACE)
            self.state = 523
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamespaceMembersContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def namespaceMember(self):
            return self.getTypedRuleContext(WebIDLParser.NamespaceMemberContext,0)


        def extendedAttributeList(self):
            return self.getTypedRuleContext(WebIDLParser.ExtendedAttributeListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_namespaceMembers

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamespaceMembers" ):
                return visitor.visitNamespaceMembers(self)
            else:
                return visitor.visitChildren(self)




    def namespaceMembers(self):

        localctx = WebIDLParser.NamespaceMembersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_namespaceMembers)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 526
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.LEFT_BRACKET:
                self.state = 525
                self.extendedAttributeList()


            self.state = 528
            self.namespaceMember()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamespaceMemberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def regularOperation(self):
            return self.getTypedRuleContext(WebIDLParser.RegularOperationContext,0)


        def READONLY(self):
            return self.getToken(WebIDLParser.READONLY, 0)

        def attributeRest(self):
            return self.getTypedRuleContext(WebIDLParser.AttributeRestContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_namespaceMember

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamespaceMember" ):
                return visitor.visitNamespaceMember(self)
            else:
                return visitor.visitChildren(self)




    def namespaceMember(self):

        localctx = WebIDLParser.NamespaceMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_namespaceMember)
        try:
            self.state = 533
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.LEFT_PAREN, WebIDLParser.ANY, WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.BYTE_STRING, WebIDLParser.DOM_STRING, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.FROZEN_ARRAY, WebIDLParser.LONG, WebIDLParser.OBJECT, WebIDLParser.OBSERVABLE_ARRAY, WebIDLParser.OCTET, WebIDLParser.PROMISE, WebIDLParser.RECORD, WebIDLParser.SEQUENCE, WebIDLParser.SHORT, WebIDLParser.SYMBOL, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED, WebIDLParser.USV_STRING, WebIDLParser.VOID, WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY, WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 530
                self.regularOperation()
                pass
            elif token in [WebIDLParser.READONLY]:
                self.enterOuterAlt(localctx, 2)
                self.state = 531
                self.match(WebIDLParser.READONLY)
                self.state = 532
                self.attributeRest()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DictionaryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DICTIONARY(self):
            return self.getToken(WebIDLParser.DICTIONARY, 0)

        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def LEFT_BRACE(self):
            return self.getToken(WebIDLParser.LEFT_BRACE, 0)

        def RIGHT_BRACE(self):
            return self.getToken(WebIDLParser.RIGHT_BRACE, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def inheritance(self):
            return self.getTypedRuleContext(WebIDLParser.InheritanceContext,0)


        def dictionaryMembers(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(WebIDLParser.DictionaryMembersContext)
            else:
                return self.getTypedRuleContext(WebIDLParser.DictionaryMembersContext,i)


        def PARTIAL(self):
            return self.getToken(WebIDLParser.PARTIAL, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_dictionary

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDictionary" ):
                return visitor.visitDictionary(self)
            else:
                return visitor.visitChildren(self)




    def dictionary(self):

        localctx = WebIDLParser.DictionaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_dictionary)
        self._la = 0 # Token type
        try:
            self.state = 561
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.DICTIONARY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 535
                self.match(WebIDLParser.DICTIONARY)
                self.state = 536
                self.match(WebIDLParser.IDENTIFIER)
                self.state = 538
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.COLON:
                    self.state = 537
                    self.inheritance()


                self.state = 540
                self.match(WebIDLParser.LEFT_BRACE)
                self.state = 544
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.LEFT_PAREN) | (1 << WebIDLParser.LEFT_BRACKET) | (1 << WebIDLParser.ANY) | (1 << WebIDLParser.BOOLEAN) | (1 << WebIDLParser.BYTE) | (1 << WebIDLParser.BYTE_STRING) | (1 << WebIDLParser.DOM_STRING) | (1 << WebIDLParser.DOUBLE) | (1 << WebIDLParser.FLOAT) | (1 << WebIDLParser.FROZEN_ARRAY) | (1 << WebIDLParser.LONG) | (1 << WebIDLParser.OBJECT) | (1 << WebIDLParser.OBSERVABLE_ARRAY) | (1 << WebIDLParser.OCTET) | (1 << WebIDLParser.PROMISE) | (1 << WebIDLParser.RECORD) | (1 << WebIDLParser.REQUIRED) | (1 << WebIDLParser.SEQUENCE) | (1 << WebIDLParser.SHORT))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (WebIDLParser.SYMBOL - 65)) | (1 << (WebIDLParser.UNRESTRICTED - 65)) | (1 << (WebIDLParser.UNSIGNED - 65)) | (1 << (WebIDLParser.USV_STRING - 65)) | (1 << (WebIDLParser.ARRAY_BUFFER - 65)) | (1 << (WebIDLParser.DATA_VIEW - 65)) | (1 << (WebIDLParser.INT_8_ARRAY - 65)) | (1 << (WebIDLParser.INT_16_ARRAY - 65)) | (1 << (WebIDLParser.INT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_ARRAY - 65)) | (1 << (WebIDLParser.UINT_16_ARRAY - 65)) | (1 << (WebIDLParser.UINT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_CLAMPED_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_32_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_64_ARRAY - 65)) | (1 << (WebIDLParser.IDENTIFIER - 65)))) != 0):
                    self.state = 541
                    self.dictionaryMembers()
                    self.state = 546
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 547
                self.match(WebIDLParser.RIGHT_BRACE)
                self.state = 548
                self.match(WebIDLParser.SEMI)
                pass
            elif token in [WebIDLParser.PARTIAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 549
                self.match(WebIDLParser.PARTIAL)
                self.state = 550
                self.match(WebIDLParser.DICTIONARY)
                self.state = 551
                self.match(WebIDLParser.IDENTIFIER)
                self.state = 552
                self.match(WebIDLParser.LEFT_BRACE)
                self.state = 556
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.LEFT_PAREN) | (1 << WebIDLParser.LEFT_BRACKET) | (1 << WebIDLParser.ANY) | (1 << WebIDLParser.BOOLEAN) | (1 << WebIDLParser.BYTE) | (1 << WebIDLParser.BYTE_STRING) | (1 << WebIDLParser.DOM_STRING) | (1 << WebIDLParser.DOUBLE) | (1 << WebIDLParser.FLOAT) | (1 << WebIDLParser.FROZEN_ARRAY) | (1 << WebIDLParser.LONG) | (1 << WebIDLParser.OBJECT) | (1 << WebIDLParser.OBSERVABLE_ARRAY) | (1 << WebIDLParser.OCTET) | (1 << WebIDLParser.PROMISE) | (1 << WebIDLParser.RECORD) | (1 << WebIDLParser.REQUIRED) | (1 << WebIDLParser.SEQUENCE) | (1 << WebIDLParser.SHORT))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (WebIDLParser.SYMBOL - 65)) | (1 << (WebIDLParser.UNRESTRICTED - 65)) | (1 << (WebIDLParser.UNSIGNED - 65)) | (1 << (WebIDLParser.USV_STRING - 65)) | (1 << (WebIDLParser.ARRAY_BUFFER - 65)) | (1 << (WebIDLParser.DATA_VIEW - 65)) | (1 << (WebIDLParser.INT_8_ARRAY - 65)) | (1 << (WebIDLParser.INT_16_ARRAY - 65)) | (1 << (WebIDLParser.INT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_ARRAY - 65)) | (1 << (WebIDLParser.UINT_16_ARRAY - 65)) | (1 << (WebIDLParser.UINT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_CLAMPED_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_32_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_64_ARRAY - 65)) | (1 << (WebIDLParser.IDENTIFIER - 65)))) != 0):
                    self.state = 553
                    self.dictionaryMembers()
                    self.state = 558
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 559
                self.match(WebIDLParser.RIGHT_BRACE)
                self.state = 560
                self.match(WebIDLParser.SEMI)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DictionaryMembersContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def dictionaryMember(self):
            return self.getTypedRuleContext(WebIDLParser.DictionaryMemberContext,0)


        def extendedAttributeList(self):
            return self.getTypedRuleContext(WebIDLParser.ExtendedAttributeListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_dictionaryMembers

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDictionaryMembers" ):
                return visitor.visitDictionaryMembers(self)
            else:
                return visitor.visitChildren(self)




    def dictionaryMembers(self):

        localctx = WebIDLParser.DictionaryMembersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_dictionaryMembers)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 564
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.LEFT_BRACKET:
                self.state = 563
                self.extendedAttributeList()


            self.state = 566
            self.dictionaryMember()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DictionaryMemberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def REQUIRED(self):
            return self.getToken(WebIDLParser.REQUIRED, 0)

        def typeWithExtendedAttributes(self):
            return self.getTypedRuleContext(WebIDLParser.TypeWithExtendedAttributesContext,0)


        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def type_(self):
            return self.getTypedRuleContext(WebIDLParser.Type_Context,0)


        def default_(self):
            return self.getTypedRuleContext(WebIDLParser.Default_Context,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_dictionaryMember

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDictionaryMember" ):
                return visitor.visitDictionaryMember(self)
            else:
                return visitor.visitChildren(self)




    def dictionaryMember(self):

        localctx = WebIDLParser.DictionaryMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_dictionaryMember)
        self._la = 0 # Token type
        try:
            self.state = 580
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.REQUIRED]:
                self.enterOuterAlt(localctx, 1)
                self.state = 568
                self.match(WebIDLParser.REQUIRED)
                self.state = 569
                self.typeWithExtendedAttributes()
                self.state = 570
                self.match(WebIDLParser.IDENTIFIER)
                self.state = 571
                self.match(WebIDLParser.SEMI)
                pass
            elif token in [WebIDLParser.LEFT_PAREN, WebIDLParser.ANY, WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.BYTE_STRING, WebIDLParser.DOM_STRING, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.FROZEN_ARRAY, WebIDLParser.LONG, WebIDLParser.OBJECT, WebIDLParser.OBSERVABLE_ARRAY, WebIDLParser.OCTET, WebIDLParser.PROMISE, WebIDLParser.RECORD, WebIDLParser.SEQUENCE, WebIDLParser.SHORT, WebIDLParser.SYMBOL, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED, WebIDLParser.USV_STRING, WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY, WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 573
                self.type_()
                self.state = 574
                self.match(WebIDLParser.IDENTIFIER)
                self.state = 576
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.EQUAL_SYMBOL:
                    self.state = 575
                    self.default_()


                self.state = 578
                self.match(WebIDLParser.SEMI)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Default_Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EQUAL_SYMBOL(self):
            return self.getToken(WebIDLParser.EQUAL_SYMBOL, 0)

        def defaultValue(self):
            return self.getTypedRuleContext(WebIDLParser.DefaultValueContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_default_

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDefault_" ):
                return visitor.visitDefault_(self)
            else:
                return visitor.visitChildren(self)




    def default_(self):

        localctx = WebIDLParser.Default_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_default_)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 582
            self.match(WebIDLParser.EQUAL_SYMBOL)
            self.state = 583
            self.defaultValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Enum_Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ENUM(self):
            return self.getToken(WebIDLParser.ENUM, 0)

        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def LEFT_BRACE(self):
            return self.getToken(WebIDLParser.LEFT_BRACE, 0)

        def StringLiteral(self, i:int=None):
            if i is None:
                return self.getTokens(WebIDLParser.StringLiteral)
            else:
                return self.getToken(WebIDLParser.StringLiteral, i)

        def RIGHT_BRACE(self):
            return self.getToken(WebIDLParser.RIGHT_BRACE, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(WebIDLParser.COMMA)
            else:
                return self.getToken(WebIDLParser.COMMA, i)

        def getRuleIndex(self):
            return WebIDLParser.RULE_enum_

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnum_" ):
                return visitor.visitEnum_(self)
            else:
                return visitor.visitChildren(self)




    def enum_(self):

        localctx = WebIDLParser.Enum_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_enum_)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 585
            self.match(WebIDLParser.ENUM)
            self.state = 586
            self.match(WebIDLParser.IDENTIFIER)
            self.state = 587
            self.match(WebIDLParser.LEFT_BRACE)
            self.state = 588
            self.match(WebIDLParser.StringLiteral)
            self.state = 595
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==WebIDLParser.COMMA:
                self.state = 589
                self.match(WebIDLParser.COMMA)
                self.state = 591
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.StringLiteral:
                    self.state = 590
                    self.match(WebIDLParser.StringLiteral)


                self.state = 597
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 598
            self.match(WebIDLParser.RIGHT_BRACE)
            self.state = 599
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CallbackRestContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def EQUAL_SYMBOL(self):
            return self.getToken(WebIDLParser.EQUAL_SYMBOL, 0)

        def returnType(self):
            return self.getTypedRuleContext(WebIDLParser.ReturnTypeContext,0)


        def LEFT_PAREN(self):
            return self.getToken(WebIDLParser.LEFT_PAREN, 0)

        def RIGHT_PAREN(self):
            return self.getToken(WebIDLParser.RIGHT_PAREN, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def argumentList(self):
            return self.getTypedRuleContext(WebIDLParser.ArgumentListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_callbackRest

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCallbackRest" ):
                return visitor.visitCallbackRest(self)
            else:
                return visitor.visitChildren(self)




    def callbackRest(self):

        localctx = WebIDLParser.CallbackRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_callbackRest)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 601
            self.match(WebIDLParser.IDENTIFIER)
            self.state = 602
            self.match(WebIDLParser.EQUAL_SYMBOL)
            self.state = 603
            self.returnType()
            self.state = 604
            self.match(WebIDLParser.LEFT_PAREN)
            self.state = 606
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.LEFT_PAREN) | (1 << WebIDLParser.LEFT_BRACKET) | (1 << WebIDLParser.ANY) | (1 << WebIDLParser.BOOLEAN) | (1 << WebIDLParser.BYTE) | (1 << WebIDLParser.BYTE_STRING) | (1 << WebIDLParser.DOM_STRING) | (1 << WebIDLParser.DOUBLE) | (1 << WebIDLParser.FLOAT) | (1 << WebIDLParser.FROZEN_ARRAY) | (1 << WebIDLParser.LONG) | (1 << WebIDLParser.OBJECT) | (1 << WebIDLParser.OBSERVABLE_ARRAY) | (1 << WebIDLParser.OCTET) | (1 << WebIDLParser.OPTIONAL) | (1 << WebIDLParser.PROMISE) | (1 << WebIDLParser.RECORD) | (1 << WebIDLParser.SEQUENCE) | (1 << WebIDLParser.SHORT))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (WebIDLParser.SYMBOL - 65)) | (1 << (WebIDLParser.UNRESTRICTED - 65)) | (1 << (WebIDLParser.UNSIGNED - 65)) | (1 << (WebIDLParser.USV_STRING - 65)) | (1 << (WebIDLParser.ARRAY_BUFFER - 65)) | (1 << (WebIDLParser.DATA_VIEW - 65)) | (1 << (WebIDLParser.INT_8_ARRAY - 65)) | (1 << (WebIDLParser.INT_16_ARRAY - 65)) | (1 << (WebIDLParser.INT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_ARRAY - 65)) | (1 << (WebIDLParser.UINT_16_ARRAY - 65)) | (1 << (WebIDLParser.UINT_32_ARRAY - 65)) | (1 << (WebIDLParser.UINT_8_CLAMPED_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_32_ARRAY - 65)) | (1 << (WebIDLParser.FLOAT_64_ARRAY - 65)) | (1 << (WebIDLParser.IDENTIFIER - 65)))) != 0):
                self.state = 605
                self.argumentList()


            self.state = 608
            self.match(WebIDLParser.RIGHT_PAREN)
            self.state = 609
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypedefContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TYPEDEF(self):
            return self.getToken(WebIDLParser.TYPEDEF, 0)

        def typeWithExtendedAttributes(self):
            return self.getTypedRuleContext(WebIDLParser.TypeWithExtendedAttributesContext,0)


        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_typedef

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypedef" ):
                return visitor.visitTypedef(self)
            else:
                return visitor.visitChildren(self)




    def typedef(self):

        localctx = WebIDLParser.TypedefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_typedef)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 611
            self.match(WebIDLParser.TYPEDEF)
            self.state = 612
            self.typeWithExtendedAttributes()
            self.state = 613
            self.match(WebIDLParser.IDENTIFIER)
            self.state = 614
            self.match(WebIDLParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def singleType(self):
            return self.getTypedRuleContext(WebIDLParser.SingleTypeContext,0)


        def unionType(self):
            return self.getTypedRuleContext(WebIDLParser.UnionTypeContext,0)


        def null_(self):
            return self.getTypedRuleContext(WebIDLParser.Null_Context,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_type_

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitType_" ):
                return visitor.visitType_(self)
            else:
                return visitor.visitChildren(self)




    def type_(self):

        localctx = WebIDLParser.Type_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_type_)
        self._la = 0 # Token type
        try:
            self.state = 621
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.ANY, WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.BYTE_STRING, WebIDLParser.DOM_STRING, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.FROZEN_ARRAY, WebIDLParser.LONG, WebIDLParser.OBJECT, WebIDLParser.OBSERVABLE_ARRAY, WebIDLParser.OCTET, WebIDLParser.PROMISE, WebIDLParser.RECORD, WebIDLParser.SEQUENCE, WebIDLParser.SHORT, WebIDLParser.SYMBOL, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED, WebIDLParser.USV_STRING, WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY, WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 616
                self.singleType()
                pass
            elif token in [WebIDLParser.LEFT_PAREN]:
                self.enterOuterAlt(localctx, 2)
                self.state = 617
                self.unionType()
                self.state = 619
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.QUESTION_SYMBOL:
                    self.state = 618
                    self.null_()


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeWithExtendedAttributesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def type_(self):
            return self.getTypedRuleContext(WebIDLParser.Type_Context,0)


        def extendedAttributeList(self):
            return self.getTypedRuleContext(WebIDLParser.ExtendedAttributeListContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_typeWithExtendedAttributes

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeWithExtendedAttributes" ):
                return visitor.visitTypeWithExtendedAttributes(self)
            else:
                return visitor.visitChildren(self)




    def typeWithExtendedAttributes(self):

        localctx = WebIDLParser.TypeWithExtendedAttributesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_typeWithExtendedAttributes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 624
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.LEFT_BRACKET:
                self.state = 623
                self.extendedAttributeList()


            self.state = 626
            self.type_()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExtendedAttributeListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LEFT_BRACKET(self):
            return self.getToken(WebIDLParser.LEFT_BRACKET, 0)

        def extendedAttribute(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(WebIDLParser.ExtendedAttributeContext)
            else:
                return self.getTypedRuleContext(WebIDLParser.ExtendedAttributeContext,i)


        def RIGHT_BRACKET(self):
            return self.getToken(WebIDLParser.RIGHT_BRACKET, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(WebIDLParser.COMMA)
            else:
                return self.getToken(WebIDLParser.COMMA, i)

        def getRuleIndex(self):
            return WebIDLParser.RULE_extendedAttributeList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExtendedAttributeList" ):
                return visitor.visitExtendedAttributeList(self)
            else:
                return visitor.visitChildren(self)




    def extendedAttributeList(self):

        localctx = WebIDLParser.ExtendedAttributeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_extendedAttributeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 628
            self.match(WebIDLParser.LEFT_BRACKET)
            self.state = 629
            self.extendedAttribute()
            self.state = 634
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==WebIDLParser.COMMA:
                self.state = 630
                self.match(WebIDLParser.COMMA)
                self.state = 631
                self.extendedAttribute()
                self.state = 636
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 637
            self.match(WebIDLParser.RIGHT_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExtendedAttributeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return WebIDLParser.RULE_extendedAttribute

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class ExtendedAttributeIdentListContext(ExtendedAttributeContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a WebIDLParser.ExtendedAttributeContext
            super().__init__(parser)
            self.name = None # Token
            self.copyFrom(ctx)

        def EQUAL_SYMBOL(self):
            return self.getToken(WebIDLParser.EQUAL_SYMBOL, 0)
        def LEFT_PAREN(self):
            return self.getToken(WebIDLParser.LEFT_PAREN, 0)
        def identifierList(self):
            return self.getTypedRuleContext(WebIDLParser.IdentifierListContext,0)

        def RIGHT_PAREN(self):
            return self.getToken(WebIDLParser.RIGHT_PAREN, 0)
        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExtendedAttributeIdentList" ):
                return visitor.visitExtendedAttributeIdentList(self)
            else:
                return visitor.visitChildren(self)


    class ExtendedAttributeNamedArgListContext(ExtendedAttributeContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a WebIDLParser.ExtendedAttributeContext
            super().__init__(parser)
            self.name = None # Token
            self.rhs = None # Token
            self.copyFrom(ctx)

        def EQUAL_SYMBOL(self):
            return self.getToken(WebIDLParser.EQUAL_SYMBOL, 0)
        def LEFT_PAREN(self):
            return self.getToken(WebIDLParser.LEFT_PAREN, 0)
        def argumentList(self):
            return self.getTypedRuleContext(WebIDLParser.ArgumentListContext,0)

        def RIGHT_PAREN(self):
            return self.getToken(WebIDLParser.RIGHT_PAREN, 0)
        def IDENTIFIER(self, i:int=None):
            if i is None:
                return self.getTokens(WebIDLParser.IDENTIFIER)
            else:
                return self.getToken(WebIDLParser.IDENTIFIER, i)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExtendedAttributeNamedArgList" ):
                return visitor.visitExtendedAttributeNamedArgList(self)
            else:
                return visitor.visitChildren(self)


    class ExtendedAttributeArgListContext(ExtendedAttributeContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a WebIDLParser.ExtendedAttributeContext
            super().__init__(parser)
            self.name = None # Token
            self.copyFrom(ctx)

        def LEFT_PAREN(self):
            return self.getToken(WebIDLParser.LEFT_PAREN, 0)
        def argumentList(self):
            return self.getTypedRuleContext(WebIDLParser.ArgumentListContext,0)

        def RIGHT_PAREN(self):
            return self.getToken(WebIDLParser.RIGHT_PAREN, 0)
        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExtendedAttributeArgList" ):
                return visitor.visitExtendedAttributeArgList(self)
            else:
                return visitor.visitChildren(self)


    class ExtendedAttributeIdentContext(ExtendedAttributeContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a WebIDLParser.ExtendedAttributeContext
            super().__init__(parser)
            self.name = None # Token
            self.rhs = None # IdentifierContext
            self.copyFrom(ctx)

        def EQUAL_SYMBOL(self):
            return self.getToken(WebIDLParser.EQUAL_SYMBOL, 0)
        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)
        def identifier(self):
            return self.getTypedRuleContext(WebIDLParser.IdentifierContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExtendedAttributeIdent" ):
                return visitor.visitExtendedAttributeIdent(self)
            else:
                return visitor.visitChildren(self)


    class ExtendedAttributeNoArgsContext(ExtendedAttributeContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a WebIDLParser.ExtendedAttributeContext
            super().__init__(parser)
            self.name = None # Token
            self.copyFrom(ctx)

        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExtendedAttributeNoArgs" ):
                return visitor.visitExtendedAttributeNoArgs(self)
            else:
                return visitor.visitChildren(self)



    def extendedAttribute(self):

        localctx = WebIDLParser.ExtendedAttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_extendedAttribute)
        try:
            self.state = 661
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
            if la_ == 1:
                localctx = WebIDLParser.ExtendedAttributeNoArgsContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 639
                localctx.name = self.match(WebIDLParser.IDENTIFIER)
                pass

            elif la_ == 2:
                localctx = WebIDLParser.ExtendedAttributeIdentListContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 640
                localctx.name = self.match(WebIDLParser.IDENTIFIER)
                self.state = 641
                self.match(WebIDLParser.EQUAL_SYMBOL)
                self.state = 642
                self.match(WebIDLParser.LEFT_PAREN)
                self.state = 643
                self.identifierList()
                self.state = 644
                self.match(WebIDLParser.RIGHT_PAREN)
                pass

            elif la_ == 3:
                localctx = WebIDLParser.ExtendedAttributeNamedArgListContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 646
                localctx.name = self.match(WebIDLParser.IDENTIFIER)
                self.state = 647
                self.match(WebIDLParser.EQUAL_SYMBOL)
                self.state = 648
                localctx.rhs = self.match(WebIDLParser.IDENTIFIER)
                self.state = 649
                self.match(WebIDLParser.LEFT_PAREN)
                self.state = 650
                self.argumentList()
                self.state = 651
                self.match(WebIDLParser.RIGHT_PAREN)
                pass

            elif la_ == 4:
                localctx = WebIDLParser.ExtendedAttributeIdentContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 653
                localctx.name = self.match(WebIDLParser.IDENTIFIER)
                self.state = 654
                self.match(WebIDLParser.EQUAL_SYMBOL)
                self.state = 655
                localctx.rhs = self.identifier()
                pass

            elif la_ == 5:
                localctx = WebIDLParser.ExtendedAttributeArgListContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 656
                localctx.name = self.match(WebIDLParser.IDENTIFIER)
                self.state = 657
                self.match(WebIDLParser.LEFT_PAREN)
                self.state = 658
                self.argumentList()
                self.state = 659
                self.match(WebIDLParser.RIGHT_PAREN)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(WebIDLParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(WebIDLParser.IdentifierContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(WebIDLParser.COMMA)
            else:
                return self.getToken(WebIDLParser.COMMA, i)

        def getRuleIndex(self):
            return WebIDLParser.RULE_identifierList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentifierList" ):
                return visitor.visitIdentifierList(self)
            else:
                return visitor.visitChildren(self)




    def identifierList(self):

        localctx = WebIDLParser.IdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_identifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 663
            self.identifier()
            self.state = 668
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==WebIDLParser.COMMA:
                self.state = 664
                self.match(WebIDLParser.COMMA)
                self.state = 665
                self.identifier()
                self.state = 670
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def other(self):
            return self.getTypedRuleContext(WebIDLParser.OtherContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_identifier

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentifier" ):
                return visitor.visitIdentifier(self)
            else:
                return visitor.visitChildren(self)




    def identifier(self):

        localctx = WebIDLParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_identifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 671
            self.other()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReturnTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def type_(self):
            return self.getTypedRuleContext(WebIDLParser.Type_Context,0)


        def VOID(self):
            return self.getToken(WebIDLParser.VOID, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_returnType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReturnType" ):
                return visitor.visitReturnType(self)
            else:
                return visitor.visitChildren(self)




    def returnType(self):

        localctx = WebIDLParser.ReturnTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_returnType)
        try:
            self.state = 675
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.LEFT_PAREN, WebIDLParser.ANY, WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.BYTE_STRING, WebIDLParser.DOM_STRING, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.FROZEN_ARRAY, WebIDLParser.LONG, WebIDLParser.OBJECT, WebIDLParser.OBSERVABLE_ARRAY, WebIDLParser.OCTET, WebIDLParser.PROMISE, WebIDLParser.RECORD, WebIDLParser.SEQUENCE, WebIDLParser.SHORT, WebIDLParser.SYMBOL, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED, WebIDLParser.USV_STRING, WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY, WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 673
                self.type_()
                pass
            elif token in [WebIDLParser.VOID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 674
                self.match(WebIDLParser.VOID)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SingleTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def distinguishableType(self):
            return self.getTypedRuleContext(WebIDLParser.DistinguishableTypeContext,0)


        def null_(self):
            return self.getTypedRuleContext(WebIDLParser.Null_Context,0)


        def genericType(self):
            return self.getTypedRuleContext(WebIDLParser.GenericTypeContext,0)


        def promiseType(self):
            return self.getTypedRuleContext(WebIDLParser.PromiseTypeContext,0)


        def ANY(self):
            return self.getToken(WebIDLParser.ANY, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_singleType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSingleType" ):
                return visitor.visitSingleType(self)
            else:
                return visitor.visitChildren(self)




    def singleType(self):

        localctx = WebIDLParser.SingleTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_singleType)
        self._la = 0 # Token type
        try:
            self.state = 687
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.BYTE_STRING, WebIDLParser.DOM_STRING, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.LONG, WebIDLParser.OBJECT, WebIDLParser.OCTET, WebIDLParser.RECORD, WebIDLParser.SHORT, WebIDLParser.SYMBOL, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED, WebIDLParser.USV_STRING, WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY, WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 677
                self.distinguishableType()
                self.state = 679
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.QUESTION_SYMBOL:
                    self.state = 678
                    self.null_()


                pass
            elif token in [WebIDLParser.FROZEN_ARRAY, WebIDLParser.OBSERVABLE_ARRAY, WebIDLParser.SEQUENCE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 681
                self.genericType()
                self.state = 683
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.QUESTION_SYMBOL:
                    self.state = 682
                    self.null_()


                pass
            elif token in [WebIDLParser.PROMISE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 685
                self.promiseType()
                pass
            elif token in [WebIDLParser.ANY]:
                self.enterOuterAlt(localctx, 4)
                self.state = 686
                self.match(WebIDLParser.ANY)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnionTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LEFT_PAREN(self):
            return self.getToken(WebIDLParser.LEFT_PAREN, 0)

        def unionMemberType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(WebIDLParser.UnionMemberTypeContext)
            else:
                return self.getTypedRuleContext(WebIDLParser.UnionMemberTypeContext,i)


        def RIGHT_PAREN(self):
            return self.getToken(WebIDLParser.RIGHT_PAREN, 0)

        def OR(self, i:int=None):
            if i is None:
                return self.getTokens(WebIDLParser.OR)
            else:
                return self.getToken(WebIDLParser.OR, i)

        def getRuleIndex(self):
            return WebIDLParser.RULE_unionType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnionType" ):
                return visitor.visitUnionType(self)
            else:
                return visitor.visitChildren(self)




    def unionType(self):

        localctx = WebIDLParser.UnionTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_unionType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 689
            self.match(WebIDLParser.LEFT_PAREN)
            self.state = 690
            self.unionMemberType()
            self.state = 693 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 691
                self.match(WebIDLParser.OR)
                self.state = 692
                self.unionMemberType()
                self.state = 695 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==WebIDLParser.OR):
                    break

            self.state = 697
            self.match(WebIDLParser.RIGHT_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnionMemberTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def distinguishableType(self):
            return self.getTypedRuleContext(WebIDLParser.DistinguishableTypeContext,0)


        def extendedAttributeList(self):
            return self.getTypedRuleContext(WebIDLParser.ExtendedAttributeListContext,0)


        def null_(self):
            return self.getTypedRuleContext(WebIDLParser.Null_Context,0)


        def genericType(self):
            return self.getTypedRuleContext(WebIDLParser.GenericTypeContext,0)


        def unionType(self):
            return self.getTypedRuleContext(WebIDLParser.UnionTypeContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_unionMemberType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnionMemberType" ):
                return visitor.visitUnionMemberType(self)
            else:
                return visitor.visitChildren(self)




    def unionMemberType(self):

        localctx = WebIDLParser.UnionMemberTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_unionMemberType)
        self._la = 0 # Token type
        try:
            self.state = 717
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 700
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.LEFT_BRACKET:
                    self.state = 699
                    self.extendedAttributeList()


                self.state = 702
                self.distinguishableType()
                self.state = 704
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.QUESTION_SYMBOL:
                    self.state = 703
                    self.null_()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 707
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.LEFT_BRACKET:
                    self.state = 706
                    self.extendedAttributeList()


                self.state = 709
                self.genericType()
                self.state = 711
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.QUESTION_SYMBOL:
                    self.state = 710
                    self.null_()


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 713
                self.unionType()
                self.state = 715
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.QUESTION_SYMBOL:
                    self.state = 714
                    self.null_()


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GenericTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.generic = None # Token

        def LEFT_ANGLE(self):
            return self.getToken(WebIDLParser.LEFT_ANGLE, 0)

        def typeWithExtendedAttributes(self):
            return self.getTypedRuleContext(WebIDLParser.TypeWithExtendedAttributesContext,0)


        def RIGHT_ANGLE(self):
            return self.getToken(WebIDLParser.RIGHT_ANGLE, 0)

        def SEQUENCE(self):
            return self.getToken(WebIDLParser.SEQUENCE, 0)

        def FROZEN_ARRAY(self):
            return self.getToken(WebIDLParser.FROZEN_ARRAY, 0)

        def OBSERVABLE_ARRAY(self):
            return self.getToken(WebIDLParser.OBSERVABLE_ARRAY, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_genericType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGenericType" ):
                return visitor.visitGenericType(self)
            else:
                return visitor.visitChildren(self)




    def genericType(self):

        localctx = WebIDLParser.GenericTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_genericType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 719
            localctx.generic = self._input.LT(1)
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << WebIDLParser.FROZEN_ARRAY) | (1 << WebIDLParser.OBSERVABLE_ARRAY) | (1 << WebIDLParser.SEQUENCE))) != 0)):
                localctx.generic = self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 720
            self.match(WebIDLParser.LEFT_ANGLE)
            self.state = 721
            self.typeWithExtendedAttributes()
            self.state = 722
            self.match(WebIDLParser.RIGHT_ANGLE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DistinguishableTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def primitiveType(self):
            return self.getTypedRuleContext(WebIDLParser.PrimitiveTypeContext,0)


        def stringType(self):
            return self.getTypedRuleContext(WebIDLParser.StringTypeContext,0)


        def bufferRelatedType(self):
            return self.getTypedRuleContext(WebIDLParser.BufferRelatedTypeContext,0)


        def recordType(self):
            return self.getTypedRuleContext(WebIDLParser.RecordTypeContext,0)


        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def OBJECT(self):
            return self.getToken(WebIDLParser.OBJECT, 0)

        def SYMBOL(self):
            return self.getToken(WebIDLParser.SYMBOL, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_distinguishableType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDistinguishableType" ):
                return visitor.visitDistinguishableType(self)
            else:
                return visitor.visitChildren(self)




    def distinguishableType(self):

        localctx = WebIDLParser.DistinguishableTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_distinguishableType)
        try:
            self.state = 731
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.LONG, WebIDLParser.OCTET, WebIDLParser.SHORT, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED]:
                self.enterOuterAlt(localctx, 1)
                self.state = 724
                self.primitiveType()
                pass
            elif token in [WebIDLParser.BYTE_STRING, WebIDLParser.DOM_STRING, WebIDLParser.USV_STRING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 725
                self.stringType()
                pass
            elif token in [WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY]:
                self.enterOuterAlt(localctx, 3)
                self.state = 726
                self.bufferRelatedType()
                pass
            elif token in [WebIDLParser.RECORD]:
                self.enterOuterAlt(localctx, 4)
                self.state = 727
                self.recordType()
                pass
            elif token in [WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 5)
                self.state = 728
                self.match(WebIDLParser.IDENTIFIER)
                pass
            elif token in [WebIDLParser.OBJECT]:
                self.enterOuterAlt(localctx, 6)
                self.state = 729
                self.match(WebIDLParser.OBJECT)
                pass
            elif token in [WebIDLParser.SYMBOL]:
                self.enterOuterAlt(localctx, 7)
                self.state = 730
                self.match(WebIDLParser.SYMBOL)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PrimitiveTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def unsignedIntegerType(self):
            return self.getTypedRuleContext(WebIDLParser.UnsignedIntegerTypeContext,0)


        def unrestrictedFloatType(self):
            return self.getTypedRuleContext(WebIDLParser.UnrestrictedFloatTypeContext,0)


        def BOOLEAN(self):
            return self.getToken(WebIDLParser.BOOLEAN, 0)

        def BYTE(self):
            return self.getToken(WebIDLParser.BYTE, 0)

        def OCTET(self):
            return self.getToken(WebIDLParser.OCTET, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_primitiveType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrimitiveType" ):
                return visitor.visitPrimitiveType(self)
            else:
                return visitor.visitChildren(self)




    def primitiveType(self):

        localctx = WebIDLParser.PrimitiveTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_primitiveType)
        try:
            self.state = 738
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.LONG, WebIDLParser.SHORT, WebIDLParser.UNSIGNED]:
                self.enterOuterAlt(localctx, 1)
                self.state = 733
                self.unsignedIntegerType()
                pass
            elif token in [WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.UNRESTRICTED]:
                self.enterOuterAlt(localctx, 2)
                self.state = 734
                self.unrestrictedFloatType()
                pass
            elif token in [WebIDLParser.BOOLEAN]:
                self.enterOuterAlt(localctx, 3)
                self.state = 735
                self.match(WebIDLParser.BOOLEAN)
                pass
            elif token in [WebIDLParser.BYTE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 736
                self.match(WebIDLParser.BYTE)
                pass
            elif token in [WebIDLParser.OCTET]:
                self.enterOuterAlt(localctx, 5)
                self.state = 737
                self.match(WebIDLParser.OCTET)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def primitiveType(self):
            return self.getTypedRuleContext(WebIDLParser.PrimitiveTypeContext,0)


        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_constType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstType" ):
                return visitor.visitConstType(self)
            else:
                return visitor.visitChildren(self)




    def constType(self):

        localctx = WebIDLParser.ConstTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_constType)
        try:
            self.state = 742
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.BOOLEAN, WebIDLParser.BYTE, WebIDLParser.DOUBLE, WebIDLParser.FLOAT, WebIDLParser.LONG, WebIDLParser.OCTET, WebIDLParser.SHORT, WebIDLParser.UNRESTRICTED, WebIDLParser.UNSIGNED]:
                self.enterOuterAlt(localctx, 1)
                self.state = 740
                self.primitiveType()
                pass
            elif token in [WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 741
                self.match(WebIDLParser.IDENTIFIER)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PromiseTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PROMISE(self):
            return self.getToken(WebIDLParser.PROMISE, 0)

        def LEFT_ANGLE(self):
            return self.getToken(WebIDLParser.LEFT_ANGLE, 0)

        def returnType(self):
            return self.getTypedRuleContext(WebIDLParser.ReturnTypeContext,0)


        def RIGHT_ANGLE(self):
            return self.getToken(WebIDLParser.RIGHT_ANGLE, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_promiseType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPromiseType" ):
                return visitor.visitPromiseType(self)
            else:
                return visitor.visitChildren(self)




    def promiseType(self):

        localctx = WebIDLParser.PromiseTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_promiseType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 744
            self.match(WebIDLParser.PROMISE)
            self.state = 745
            self.match(WebIDLParser.LEFT_ANGLE)
            self.state = 746
            self.returnType()
            self.state = 747
            self.match(WebIDLParser.RIGHT_ANGLE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RecordTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RECORD(self):
            return self.getToken(WebIDLParser.RECORD, 0)

        def LEFT_ANGLE(self):
            return self.getToken(WebIDLParser.LEFT_ANGLE, 0)

        def stringType(self):
            return self.getTypedRuleContext(WebIDLParser.StringTypeContext,0)


        def COMMA(self):
            return self.getToken(WebIDLParser.COMMA, 0)

        def typeWithExtendedAttributes(self):
            return self.getTypedRuleContext(WebIDLParser.TypeWithExtendedAttributesContext,0)


        def RIGHT_ANGLE(self):
            return self.getToken(WebIDLParser.RIGHT_ANGLE, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_recordType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRecordType" ):
                return visitor.visitRecordType(self)
            else:
                return visitor.visitChildren(self)




    def recordType(self):

        localctx = WebIDLParser.RecordTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_recordType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 749
            self.match(WebIDLParser.RECORD)
            self.state = 750
            self.match(WebIDLParser.LEFT_ANGLE)
            self.state = 751
            self.stringType()
            self.state = 752
            self.match(WebIDLParser.COMMA)
            self.state = 753
            self.typeWithExtendedAttributes()
            self.state = 754
            self.match(WebIDLParser.RIGHT_ANGLE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnrestrictedFloatTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def floatType(self):
            return self.getTypedRuleContext(WebIDLParser.FloatTypeContext,0)


        def UNRESTRICTED(self):
            return self.getToken(WebIDLParser.UNRESTRICTED, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_unrestrictedFloatType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnrestrictedFloatType" ):
                return visitor.visitUnrestrictedFloatType(self)
            else:
                return visitor.visitChildren(self)




    def unrestrictedFloatType(self):

        localctx = WebIDLParser.UnrestrictedFloatTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_unrestrictedFloatType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 757
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.UNRESTRICTED:
                self.state = 756
                self.match(WebIDLParser.UNRESTRICTED)


            self.state = 759
            self.floatType()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FloatTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FLOAT(self):
            return self.getToken(WebIDLParser.FLOAT, 0)

        def DOUBLE(self):
            return self.getToken(WebIDLParser.DOUBLE, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_floatType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFloatType" ):
                return visitor.visitFloatType(self)
            else:
                return visitor.visitChildren(self)




    def floatType(self):

        localctx = WebIDLParser.FloatTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_floatType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 761
            _la = self._input.LA(1)
            if not(_la==WebIDLParser.DOUBLE or _la==WebIDLParser.FLOAT):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnsignedIntegerTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def integerType(self):
            return self.getTypedRuleContext(WebIDLParser.IntegerTypeContext,0)


        def UNSIGNED(self):
            return self.getToken(WebIDLParser.UNSIGNED, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_unsignedIntegerType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnsignedIntegerType" ):
                return visitor.visitUnsignedIntegerType(self)
            else:
                return visitor.visitChildren(self)




    def unsignedIntegerType(self):

        localctx = WebIDLParser.UnsignedIntegerTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_unsignedIntegerType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 764
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==WebIDLParser.UNSIGNED:
                self.state = 763
                self.match(WebIDLParser.UNSIGNED)


            self.state = 766
            self.integerType()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IntegerTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SHORT(self):
            return self.getToken(WebIDLParser.SHORT, 0)

        def LONG(self, i:int=None):
            if i is None:
                return self.getTokens(WebIDLParser.LONG)
            else:
                return self.getToken(WebIDLParser.LONG, i)

        def getRuleIndex(self):
            return WebIDLParser.RULE_integerType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIntegerType" ):
                return visitor.visitIntegerType(self)
            else:
                return visitor.visitChildren(self)




    def integerType(self):

        localctx = WebIDLParser.IntegerTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_integerType)
        self._la = 0 # Token type
        try:
            self.state = 773
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.SHORT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 768
                self.match(WebIDLParser.SHORT)
                pass
            elif token in [WebIDLParser.LONG]:
                self.enterOuterAlt(localctx, 2)
                self.state = 769
                self.match(WebIDLParser.LONG)
                self.state = 771
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==WebIDLParser.LONG:
                    self.state = 770
                    self.match(WebIDLParser.LONG)


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StringTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def BYTE_STRING(self):
            return self.getToken(WebIDLParser.BYTE_STRING, 0)

        def DOM_STRING(self):
            return self.getToken(WebIDLParser.DOM_STRING, 0)

        def USV_STRING(self):
            return self.getToken(WebIDLParser.USV_STRING, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_stringType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStringType" ):
                return visitor.visitStringType(self)
            else:
                return visitor.visitChildren(self)




    def stringType(self):

        localctx = WebIDLParser.StringTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_stringType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 775
            _la = self._input.LA(1)
            if not(((((_la - 24)) & ~0x3f) == 0 and ((1 << (_la - 24)) & ((1 << (WebIDLParser.BYTE_STRING - 24)) | (1 << (WebIDLParser.DOM_STRING - 24)) | (1 << (WebIDLParser.USV_STRING - 24)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BufferRelatedTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ARRAY_BUFFER(self):
            return self.getToken(WebIDLParser.ARRAY_BUFFER, 0)

        def DATA_VIEW(self):
            return self.getToken(WebIDLParser.DATA_VIEW, 0)

        def INT_8_ARRAY(self):
            return self.getToken(WebIDLParser.INT_8_ARRAY, 0)

        def INT_16_ARRAY(self):
            return self.getToken(WebIDLParser.INT_16_ARRAY, 0)

        def INT_32_ARRAY(self):
            return self.getToken(WebIDLParser.INT_32_ARRAY, 0)

        def UINT_8_ARRAY(self):
            return self.getToken(WebIDLParser.UINT_8_ARRAY, 0)

        def UINT_16_ARRAY(self):
            return self.getToken(WebIDLParser.UINT_16_ARRAY, 0)

        def UINT_32_ARRAY(self):
            return self.getToken(WebIDLParser.UINT_32_ARRAY, 0)

        def UINT_8_CLAMPED_ARRAY(self):
            return self.getToken(WebIDLParser.UINT_8_CLAMPED_ARRAY, 0)

        def FLOAT_32_ARRAY(self):
            return self.getToken(WebIDLParser.FLOAT_32_ARRAY, 0)

        def FLOAT_64_ARRAY(self):
            return self.getToken(WebIDLParser.FLOAT_64_ARRAY, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_bufferRelatedType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBufferRelatedType" ):
                return visitor.visitBufferRelatedType(self)
            else:
                return visitor.visitChildren(self)




    def bufferRelatedType(self):

        localctx = WebIDLParser.BufferRelatedTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_bufferRelatedType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 777
            _la = self._input.LA(1)
            if not(((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (WebIDLParser.ARRAY_BUFFER - 72)) | (1 << (WebIDLParser.DATA_VIEW - 72)) | (1 << (WebIDLParser.INT_8_ARRAY - 72)) | (1 << (WebIDLParser.INT_16_ARRAY - 72)) | (1 << (WebIDLParser.INT_32_ARRAY - 72)) | (1 << (WebIDLParser.UINT_8_ARRAY - 72)) | (1 << (WebIDLParser.UINT_16_ARRAY - 72)) | (1 << (WebIDLParser.UINT_32_ARRAY - 72)) | (1 << (WebIDLParser.UINT_8_CLAMPED_ARRAY - 72)) | (1 << (WebIDLParser.FLOAT_32_ARRAY - 72)) | (1 << (WebIDLParser.FLOAT_64_ARRAY - 72)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BooleanLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TRUE(self):
            return self.getToken(WebIDLParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(WebIDLParser.FALSE, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_booleanLiteral

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBooleanLiteral" ):
                return visitor.visitBooleanLiteral(self)
            else:
                return visitor.visitChildren(self)




    def booleanLiteral(self):

        localctx = WebIDLParser.BooleanLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_booleanLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 779
            _la = self._input.LA(1)
            if not(_la==WebIDLParser.FALSE or _la==WebIDLParser.TRUE):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FloatLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DecimalLiteral(self):
            return self.getToken(WebIDLParser.DecimalLiteral, 0)

        def MINUS_INFINITY(self):
            return self.getToken(WebIDLParser.MINUS_INFINITY, 0)

        def INFINITY(self):
            return self.getToken(WebIDLParser.INFINITY, 0)

        def NAN(self):
            return self.getToken(WebIDLParser.NAN, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_floatLiteral

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFloatLiteral" ):
                return visitor.visitFloatLiteral(self)
            else:
                return visitor.visitChildren(self)




    def floatLiteral(self):

        localctx = WebIDLParser.FloatLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_floatLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 781
            _la = self._input.LA(1)
            if not(((((_la - 37)) & ~0x3f) == 0 and ((1 << (_la - 37)) & ((1 << (WebIDLParser.INFINITY - 37)) | (1 << (WebIDLParser.MINUS_INFINITY - 37)) | (1 << (WebIDLParser.NAN - 37)) | (1 << (WebIDLParser.DecimalLiteral - 37)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Null_Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def QUESTION_SYMBOL(self):
            return self.getToken(WebIDLParser.QUESTION_SYMBOL, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_null_

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNull_" ):
                return visitor.visitNull_(self)
            else:
                return visitor.visitChildren(self)




    def null_(self):

        localctx = WebIDLParser.Null_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_null_)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 783
            self.match(WebIDLParser.QUESTION_SYMBOL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OtherContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IntegerLiteral(self):
            return self.getToken(WebIDLParser.IntegerLiteral, 0)

        def DecimalLiteral(self):
            return self.getToken(WebIDLParser.DecimalLiteral, 0)

        def IDENTIFIER(self):
            return self.getToken(WebIDLParser.IDENTIFIER, 0)

        def StringLiteral(self):
            return self.getToken(WebIDLParser.StringLiteral, 0)

        def OTHER(self):
            return self.getToken(WebIDLParser.OTHER, 0)

        def MINUS(self):
            return self.getToken(WebIDLParser.MINUS, 0)

        def MINUS_INFINITY(self):
            return self.getToken(WebIDLParser.MINUS_INFINITY, 0)

        def DOT(self):
            return self.getToken(WebIDLParser.DOT, 0)

        def ELLIPSIS(self):
            return self.getToken(WebIDLParser.ELLIPSIS, 0)

        def COLON(self):
            return self.getToken(WebIDLParser.COLON, 0)

        def SEMI(self):
            return self.getToken(WebIDLParser.SEMI, 0)

        def LEFT_ANGLE(self):
            return self.getToken(WebIDLParser.LEFT_ANGLE, 0)

        def EQUAL_SYMBOL(self):
            return self.getToken(WebIDLParser.EQUAL_SYMBOL, 0)

        def RIGHT_ANGLE(self):
            return self.getToken(WebIDLParser.RIGHT_ANGLE, 0)

        def QUESTION_SYMBOL(self):
            return self.getToken(WebIDLParser.QUESTION_SYMBOL, 0)

        def BYTE_STRING(self):
            return self.getToken(WebIDLParser.BYTE_STRING, 0)

        def DOM_STRING(self):
            return self.getToken(WebIDLParser.DOM_STRING, 0)

        def FROZEN_ARRAY(self):
            return self.getToken(WebIDLParser.FROZEN_ARRAY, 0)

        def INFINITY(self):
            return self.getToken(WebIDLParser.INFINITY, 0)

        def NAN(self):
            return self.getToken(WebIDLParser.NAN, 0)

        def OBSERVABLE_ARRAY(self):
            return self.getToken(WebIDLParser.OBSERVABLE_ARRAY, 0)

        def PROMISE(self):
            return self.getToken(WebIDLParser.PROMISE, 0)

        def USV_STRING(self):
            return self.getToken(WebIDLParser.USV_STRING, 0)

        def ANY(self):
            return self.getToken(WebIDLParser.ANY, 0)

        def BOOLEAN(self):
            return self.getToken(WebIDLParser.BOOLEAN, 0)

        def BYTE(self):
            return self.getToken(WebIDLParser.BYTE, 0)

        def DOUBLE(self):
            return self.getToken(WebIDLParser.DOUBLE, 0)

        def FALSE(self):
            return self.getToken(WebIDLParser.FALSE, 0)

        def FLOAT(self):
            return self.getToken(WebIDLParser.FLOAT, 0)

        def LONG(self):
            return self.getToken(WebIDLParser.LONG, 0)

        def NULL(self):
            return self.getToken(WebIDLParser.NULL, 0)

        def OBJECT(self):
            return self.getToken(WebIDLParser.OBJECT, 0)

        def OCTET(self):
            return self.getToken(WebIDLParser.OCTET, 0)

        def OR(self):
            return self.getToken(WebIDLParser.OR, 0)

        def OPTIONAL(self):
            return self.getToken(WebIDLParser.OPTIONAL, 0)

        def RECORD(self):
            return self.getToken(WebIDLParser.RECORD, 0)

        def SEQUENCE(self):
            return self.getToken(WebIDLParser.SEQUENCE, 0)

        def SHORT(self):
            return self.getToken(WebIDLParser.SHORT, 0)

        def SYMBOL(self):
            return self.getToken(WebIDLParser.SYMBOL, 0)

        def TRUE(self):
            return self.getToken(WebIDLParser.TRUE, 0)

        def UNSIGNED(self):
            return self.getToken(WebIDLParser.UNSIGNED, 0)

        def VOID(self):
            return self.getToken(WebIDLParser.VOID, 0)

        def argumentNameKeyword(self):
            return self.getTypedRuleContext(WebIDLParser.ArgumentNameKeywordContext,0)


        def bufferRelatedType(self):
            return self.getTypedRuleContext(WebIDLParser.BufferRelatedTypeContext,0)


        def getRuleIndex(self):
            return WebIDLParser.RULE_other

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOther" ):
                return visitor.visitOther(self)
            else:
                return visitor.visitChildren(self)




    def other(self):

        localctx = WebIDLParser.OtherContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_other)
        try:
            self.state = 829
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [WebIDLParser.IntegerLiteral]:
                self.enterOuterAlt(localctx, 1)
                self.state = 785
                self.match(WebIDLParser.IntegerLiteral)
                pass
            elif token in [WebIDLParser.DecimalLiteral]:
                self.enterOuterAlt(localctx, 2)
                self.state = 786
                self.match(WebIDLParser.DecimalLiteral)
                pass
            elif token in [WebIDLParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 3)
                self.state = 787
                self.match(WebIDLParser.IDENTIFIER)
                pass
            elif token in [WebIDLParser.StringLiteral]:
                self.enterOuterAlt(localctx, 4)
                self.state = 788
                self.match(WebIDLParser.StringLiteral)
                pass
            elif token in [WebIDLParser.OTHER]:
                self.enterOuterAlt(localctx, 5)
                self.state = 789
                self.match(WebIDLParser.OTHER)
                pass
            elif token in [WebIDLParser.MINUS]:
                self.enterOuterAlt(localctx, 6)
                self.state = 790
                self.match(WebIDLParser.MINUS)
                pass
            elif token in [WebIDLParser.MINUS_INFINITY]:
                self.enterOuterAlt(localctx, 7)
                self.state = 791
                self.match(WebIDLParser.MINUS_INFINITY)
                pass
            elif token in [WebIDLParser.DOT]:
                self.enterOuterAlt(localctx, 8)
                self.state = 792
                self.match(WebIDLParser.DOT)
                pass
            elif token in [WebIDLParser.ELLIPSIS]:
                self.enterOuterAlt(localctx, 9)
                self.state = 793
                self.match(WebIDLParser.ELLIPSIS)
                pass
            elif token in [WebIDLParser.COLON]:
                self.enterOuterAlt(localctx, 10)
                self.state = 794
                self.match(WebIDLParser.COLON)
                pass
            elif token in [WebIDLParser.SEMI]:
                self.enterOuterAlt(localctx, 11)
                self.state = 795
                self.match(WebIDLParser.SEMI)
                pass
            elif token in [WebIDLParser.LEFT_ANGLE]:
                self.enterOuterAlt(localctx, 12)
                self.state = 796
                self.match(WebIDLParser.LEFT_ANGLE)
                pass
            elif token in [WebIDLParser.EQUAL_SYMBOL]:
                self.enterOuterAlt(localctx, 13)
                self.state = 797
                self.match(WebIDLParser.EQUAL_SYMBOL)
                pass
            elif token in [WebIDLParser.RIGHT_ANGLE]:
                self.enterOuterAlt(localctx, 14)
                self.state = 798
                self.match(WebIDLParser.RIGHT_ANGLE)
                pass
            elif token in [WebIDLParser.QUESTION_SYMBOL]:
                self.enterOuterAlt(localctx, 15)
                self.state = 799
                self.match(WebIDLParser.QUESTION_SYMBOL)
                pass
            elif token in [WebIDLParser.BYTE_STRING]:
                self.enterOuterAlt(localctx, 16)
                self.state = 800
                self.match(WebIDLParser.BYTE_STRING)
                pass
            elif token in [WebIDLParser.DOM_STRING]:
                self.enterOuterAlt(localctx, 17)
                self.state = 801
                self.match(WebIDLParser.DOM_STRING)
                pass
            elif token in [WebIDLParser.FROZEN_ARRAY]:
                self.enterOuterAlt(localctx, 18)
                self.state = 802
                self.match(WebIDLParser.FROZEN_ARRAY)
                pass
            elif token in [WebIDLParser.INFINITY]:
                self.enterOuterAlt(localctx, 19)
                self.state = 803
                self.match(WebIDLParser.INFINITY)
                pass
            elif token in [WebIDLParser.NAN]:
                self.enterOuterAlt(localctx, 20)
                self.state = 804
                self.match(WebIDLParser.NAN)
                pass
            elif token in [WebIDLParser.OBSERVABLE_ARRAY]:
                self.enterOuterAlt(localctx, 21)
                self.state = 805
                self.match(WebIDLParser.OBSERVABLE_ARRAY)
                pass
            elif token in [WebIDLParser.PROMISE]:
                self.enterOuterAlt(localctx, 22)
                self.state = 806
                self.match(WebIDLParser.PROMISE)
                pass
            elif token in [WebIDLParser.USV_STRING]:
                self.enterOuterAlt(localctx, 23)
                self.state = 807
                self.match(WebIDLParser.USV_STRING)
                pass
            elif token in [WebIDLParser.ANY]:
                self.enterOuterAlt(localctx, 24)
                self.state = 808
                self.match(WebIDLParser.ANY)
                pass
            elif token in [WebIDLParser.BOOLEAN]:
                self.enterOuterAlt(localctx, 25)
                self.state = 809
                self.match(WebIDLParser.BOOLEAN)
                pass
            elif token in [WebIDLParser.BYTE]:
                self.enterOuterAlt(localctx, 26)
                self.state = 810
                self.match(WebIDLParser.BYTE)
                pass
            elif token in [WebIDLParser.DOUBLE]:
                self.enterOuterAlt(localctx, 27)
                self.state = 811
                self.match(WebIDLParser.DOUBLE)
                pass
            elif token in [WebIDLParser.FALSE]:
                self.enterOuterAlt(localctx, 28)
                self.state = 812
                self.match(WebIDLParser.FALSE)
                pass
            elif token in [WebIDLParser.FLOAT]:
                self.enterOuterAlt(localctx, 29)
                self.state = 813
                self.match(WebIDLParser.FLOAT)
                pass
            elif token in [WebIDLParser.LONG]:
                self.enterOuterAlt(localctx, 30)
                self.state = 814
                self.match(WebIDLParser.LONG)
                pass
            elif token in [WebIDLParser.NULL]:
                self.enterOuterAlt(localctx, 31)
                self.state = 815
                self.match(WebIDLParser.NULL)
                pass
            elif token in [WebIDLParser.OBJECT]:
                self.enterOuterAlt(localctx, 32)
                self.state = 816
                self.match(WebIDLParser.OBJECT)
                pass
            elif token in [WebIDLParser.OCTET]:
                self.enterOuterAlt(localctx, 33)
                self.state = 817
                self.match(WebIDLParser.OCTET)
                pass
            elif token in [WebIDLParser.OR]:
                self.enterOuterAlt(localctx, 34)
                self.state = 818
                self.match(WebIDLParser.OR)
                pass
            elif token in [WebIDLParser.OPTIONAL]:
                self.enterOuterAlt(localctx, 35)
                self.state = 819
                self.match(WebIDLParser.OPTIONAL)
                pass
            elif token in [WebIDLParser.RECORD]:
                self.enterOuterAlt(localctx, 36)
                self.state = 820
                self.match(WebIDLParser.RECORD)
                pass
            elif token in [WebIDLParser.SEQUENCE]:
                self.enterOuterAlt(localctx, 37)
                self.state = 821
                self.match(WebIDLParser.SEQUENCE)
                pass
            elif token in [WebIDLParser.SHORT]:
                self.enterOuterAlt(localctx, 38)
                self.state = 822
                self.match(WebIDLParser.SHORT)
                pass
            elif token in [WebIDLParser.SYMBOL]:
                self.enterOuterAlt(localctx, 39)
                self.state = 823
                self.match(WebIDLParser.SYMBOL)
                pass
            elif token in [WebIDLParser.TRUE]:
                self.enterOuterAlt(localctx, 40)
                self.state = 824
                self.match(WebIDLParser.TRUE)
                pass
            elif token in [WebIDLParser.UNSIGNED]:
                self.enterOuterAlt(localctx, 41)
                self.state = 825
                self.match(WebIDLParser.UNSIGNED)
                pass
            elif token in [WebIDLParser.VOID]:
                self.enterOuterAlt(localctx, 42)
                self.state = 826
                self.match(WebIDLParser.VOID)
                pass
            elif token in [WebIDLParser.ASYNC, WebIDLParser.ATTRIBUTE, WebIDLParser.CALLBACK, WebIDLParser.CONST, WebIDLParser.CONSTRUCTOR, WebIDLParser.DELETER, WebIDLParser.DICTIONARY, WebIDLParser.ENUM, WebIDLParser.GETTER, WebIDLParser.INCLUDES, WebIDLParser.INHERIT, WebIDLParser.INTERFACE, WebIDLParser.ITERABLE, WebIDLParser.MAPLIKE, WebIDLParser.MIXIN, WebIDLParser.NAMESPACE, WebIDLParser.PARTIAL, WebIDLParser.READONLY, WebIDLParser.REQUIRED, WebIDLParser.SETLIKE, WebIDLParser.SETTER, WebIDLParser.STATIC, WebIDLParser.STRINGIFIER, WebIDLParser.TYPEDEF, WebIDLParser.UNRESTRICTED]:
                self.enterOuterAlt(localctx, 43)
                self.state = 827
                self.argumentNameKeyword()
                pass
            elif token in [WebIDLParser.ARRAY_BUFFER, WebIDLParser.DATA_VIEW, WebIDLParser.INT_8_ARRAY, WebIDLParser.INT_16_ARRAY, WebIDLParser.INT_32_ARRAY, WebIDLParser.UINT_8_ARRAY, WebIDLParser.UINT_16_ARRAY, WebIDLParser.UINT_32_ARRAY, WebIDLParser.UINT_8_CLAMPED_ARRAY, WebIDLParser.FLOAT_32_ARRAY, WebIDLParser.FLOAT_64_ARRAY]:
                self.enterOuterAlt(localctx, 44)
                self.state = 828
                self.bufferRelatedType()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgumentNameKeywordContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ASYNC(self):
            return self.getToken(WebIDLParser.ASYNC, 0)

        def ATTRIBUTE(self):
            return self.getToken(WebIDLParser.ATTRIBUTE, 0)

        def CALLBACK(self):
            return self.getToken(WebIDLParser.CALLBACK, 0)

        def CONST(self):
            return self.getToken(WebIDLParser.CONST, 0)

        def CONSTRUCTOR(self):
            return self.getToken(WebIDLParser.CONSTRUCTOR, 0)

        def DELETER(self):
            return self.getToken(WebIDLParser.DELETER, 0)

        def DICTIONARY(self):
            return self.getToken(WebIDLParser.DICTIONARY, 0)

        def ENUM(self):
            return self.getToken(WebIDLParser.ENUM, 0)

        def GETTER(self):
            return self.getToken(WebIDLParser.GETTER, 0)

        def INCLUDES(self):
            return self.getToken(WebIDLParser.INCLUDES, 0)

        def INHERIT(self):
            return self.getToken(WebIDLParser.INHERIT, 0)

        def INTERFACE(self):
            return self.getToken(WebIDLParser.INTERFACE, 0)

        def ITERABLE(self):
            return self.getToken(WebIDLParser.ITERABLE, 0)

        def MAPLIKE(self):
            return self.getToken(WebIDLParser.MAPLIKE, 0)

        def MIXIN(self):
            return self.getToken(WebIDLParser.MIXIN, 0)

        def NAMESPACE(self):
            return self.getToken(WebIDLParser.NAMESPACE, 0)

        def PARTIAL(self):
            return self.getToken(WebIDLParser.PARTIAL, 0)

        def READONLY(self):
            return self.getToken(WebIDLParser.READONLY, 0)

        def REQUIRED(self):
            return self.getToken(WebIDLParser.REQUIRED, 0)

        def SETLIKE(self):
            return self.getToken(WebIDLParser.SETLIKE, 0)

        def SETTER(self):
            return self.getToken(WebIDLParser.SETTER, 0)

        def STATIC(self):
            return self.getToken(WebIDLParser.STATIC, 0)

        def STRINGIFIER(self):
            return self.getToken(WebIDLParser.STRINGIFIER, 0)

        def TYPEDEF(self):
            return self.getToken(WebIDLParser.TYPEDEF, 0)

        def UNRESTRICTED(self):
            return self.getToken(WebIDLParser.UNRESTRICTED, 0)

        def getRuleIndex(self):
            return WebIDLParser.RULE_argumentNameKeyword

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArgumentNameKeyword" ):
                return visitor.visitArgumentNameKeyword(self)
            else:
                return visitor.visitChildren(self)




    def argumentNameKeyword(self):

        localctx = WebIDLParser.ArgumentNameKeywordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_argumentNameKeyword)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 831
            _la = self._input.LA(1)
            if not(((((_la - 20)) & ~0x3f) == 0 and ((1 << (_la - 20)) & ((1 << (WebIDLParser.ASYNC - 20)) | (1 << (WebIDLParser.ATTRIBUTE - 20)) | (1 << (WebIDLParser.CALLBACK - 20)) | (1 << (WebIDLParser.CONST - 20)) | (1 << (WebIDLParser.CONSTRUCTOR - 20)) | (1 << (WebIDLParser.DELETER - 20)) | (1 << (WebIDLParser.DICTIONARY - 20)) | (1 << (WebIDLParser.ENUM - 20)) | (1 << (WebIDLParser.GETTER - 20)) | (1 << (WebIDLParser.INCLUDES - 20)) | (1 << (WebIDLParser.INHERIT - 20)) | (1 << (WebIDLParser.INTERFACE - 20)) | (1 << (WebIDLParser.ITERABLE - 20)) | (1 << (WebIDLParser.MAPLIKE - 20)) | (1 << (WebIDLParser.MIXIN - 20)) | (1 << (WebIDLParser.NAMESPACE - 20)) | (1 << (WebIDLParser.PARTIAL - 20)) | (1 << (WebIDLParser.READONLY - 20)) | (1 << (WebIDLParser.REQUIRED - 20)) | (1 << (WebIDLParser.SETLIKE - 20)) | (1 << (WebIDLParser.SETTER - 20)) | (1 << (WebIDLParser.STATIC - 20)) | (1 << (WebIDLParser.STRINGIFIER - 20)) | (1 << (WebIDLParser.TYPEDEF - 20)) | (1 << (WebIDLParser.UNRESTRICTED - 20)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





