diff --git a/.github/release-drafter.yml b/.github/release-drafter.yml new file mode 100644 index 0000000..00977db --- /dev/null +++ b/.github/release-drafter.yml @@ -0,0 +1,32 @@ +name-template: 'v$RESOLVED_VERSION' +tag-template: 'v$RESOLVED_VERSION' +latest: 'true' + +prerelease: true +prerelease-identifier: 'alpha' +categories: + - title: '🚀 Features' + labels: + - 'feature' + - 'enhancement' + - title: '🐛 Bug Fixes' + labels: + - 'fix' + - 'bugfix' + - 'bug' +autolabeler: + - label: 'bug' + branch: + - '/fix\/.+/' + title: + - '/fix/i' + - label: 'enhancement' + branch: + - '/feature\/.+/' +change-template: '- $TITLE @$AUTHOR (#$NUMBER)' +change-title-escapes: '\<*_&' # You can add # and @ to disable mentions, and add ` to disable code blocks. + +template: | + ## Changes + + $CHANGES \ No newline at end of file diff --git a/.github/workflows/ci-master.yml b/.github/workflows/ci-master.yml new file mode 100644 index 0000000..bed4096 --- /dev/null +++ b/.github/workflows/ci-master.yml @@ -0,0 +1,120 @@ +# Main build pipeline, operates on `master` branch which is our integration branch and creates release + +name: CI Master branch + +on: + push: + branches: [ "master" ] # trap each push to master branch TODO SKA change back to master + paths: # but react only to changes in code or pipeline definition + - src/**.* + - .github/**.* + +concurrency: + group: ${{ github.ref_name }} # for the same branch + cancel-in-progress: true # run only one workflow at a time (cancel the previous) + +jobs: + build: + permissions: + # write permission is required to create a github release + contents: write + # write permission is required for autolabeler + # otherwise, read permission is required at least + pull-requests: write + outputs: + release_id: ${{ steps.create_release.outputs.id }} + released_version: ${{ steps.release_version.outputs.version }} + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 # checkout sources + with: + ref: ${{ github.head_ref }} + fetch-depth: 0 + + - name: Resolve new release version + id: release_version + uses: lukashornych/semantic-calendar-version@v1.1.3 + with: + prefix: 'v' + year_switch_mode: 'OnMinor' + minor-identifier: '/feat(?:\\([^)]+\\))?:/' + + - name: Setup Java JDK + uses: actions/setup-java@v3 + with: # running setup-java again overwrites the settings.xml + java-version: 8 + distribution: 'temurin' + cache: 'maven' + server-id: ossrh # Value of the distributionManagement/repository/id field of the pom.xml + server-username: MAVEN_USERNAME # env variable for username in deploy + server-password: MAVEN_CENTRAL_TOKEN # env variable for token in deploy + gpg-private-key: ${{ secrets.MAVEN_GPG_PRIVATE_KEY }} # Value of the GPG private key to import + gpg-passphrase: MAVEN_GPG_PASSPHRASE # env variable for GPG private key passphrase + + - name: Build with Maven # run Maven without tests (tests must pass in dev branch) + run: | + export CURRENT_VERSION="${{ steps.release_version.outputs.version }}" + export NEW_VERSION="$( echo ${CURRENT_VERSION} | sed 's/^v//')" + mvn versions:set -DnewVersion=$NEW_VERSION + mvn -T 1C -B -P release-sign-artifacts -Dmaven.test.skip=true deploy --file pom.xml + env: + EVITA_BUILD_VERSION: ${{ steps.release_version.outputs.version }} + MAVEN_USERNAME: ${{ secrets.MAVEN_USERNAME }} + MAVEN_CENTRAL_TOKEN: ${{ secrets.MAVEN_CENTRAL_TOKEN }} + MAVEN_GPG_PASSPHRASE: ${{ secrets.MAVEN_GPG_PASSPHRASE }} + + - name: Create distribution directory + run: | + mkdir -p ./dist + cp LICENSE ./dist + cp 'target/babylon-boot.jar' ./dist + + - name: Create .zip of dist + uses: thedoctor0/zip-release@0.7.1 + with: + type: 'zip' + filename: 'dist.zip' + path: './dist' + + - name: Create .tar.gz of dist + uses: thedoctor0/zip-release@0.7.1 + with: + type: 'tar' + filename: 'dist.tar.gz' + path: './dist' + + - name: Create release + id: create_release + uses: release-drafter/release-drafter@v5 + with: + version: ${{ steps.release_version.outputs.version }} + publish: true + + - name: Upload dist.zip to release + uses: actions/upload-release-asset@v1 + if: success() + with: + upload_url: ${{ steps.create_release.outputs.upload_url }} + asset_path: ./dist.zip + asset_name: Dist (zip) + asset_content_type: application/zip + + - name: Upload dist.tar.gz to release + uses: actions/upload-release-asset@v1 + if: success() + with: + upload_url: ${{ steps.create_release.outputs.upload_url }} + asset_path: ./dist.tar.gz + asset_name: Dist (tar.gz) + asset_content_type: application/gzip + + - name: Upload babylon server artifact # upload `babylon-boot.jar` for `docker-latest.yml` to deploy to DockerHub + uses: actions/upload-artifact@v2 + if: success() + with: + name: babylon-boot.jar + path: 'target/babylon-boot.jar' diff --git a/LICENSE.md b/LICENSE similarity index 100% rename from LICENSE.md rename to LICENSE diff --git a/README.md b/README.md index e2f0842..37a6c03 100644 --- a/README.md +++ b/README.md @@ -1,17 +1,17 @@ # Babylon -## Tool to automate Java property file translation. +## Tool to automate translation files. ### Description and usage -Babylon is a tool to gather messages, and their translations from property files. It performs a round-trip consisting of +Babylon is a tool to gather messages, and their translations from translation files. It performs a round-trip consisting of two phases: *export* phase and *import* phase. In the export phase the messages are written to a [Google Sheets](https://www.google.com/sheets/about/) spreadsheet. A translator will then fill in the missing translations. In the import phase, the spreadsheet (with the missing translations filled out by a translator) is examined, and the -newly translated messages are used to update the respective translation property files. Also, the state of the translation, +newly translated messages are used to update the respective translation files. Also, the state of the translation, *snapshot*, is written out to a disk in the form of JSON file. Babylon can be run as a Maven plugin or as a standalone console application. @@ -25,6 +25,8 @@ To run Babylon: - A Json configuration file must exist (see the "Configuration" section). - A Google Sheets spreadsheet must exist (empty for the export phase). +Currently only supported file types are **.properties** and **.ts** + ### Google Cloud user credentials You need a Google Cloud project with Sheets API enabled. Also, you need to download the `credentials.json` client @@ -122,7 +124,7 @@ mvn babylon:import -Dconfig.file=test-config.json -Dgoogle.sheet.id=1xhnBAOpy8-9 ### Running Babylon as a console application -Application needs the following arguments: 1.action 2.config.json 3.google sheet id +Application needs the following arguments: 1.action 2.config.json 3.google sheet id (4. optional combineSheets) 1. expected action (export, import) * `export` - takes all properties files specified in configuration file and export their properties into specified the Google spreadsheet. Each property @@ -132,6 +134,7 @@ Application needs the following arguments: 1.action 2.config.json 3.google sheet properties file (are present only in concrete mutation properties file) is placed at the end of the target mutation file. 2. path to translator-config.json file. This file serves as database for translation process. 3. ID of the Google spreadsheet (e.g. 1xhnBAOpy8-9KWhl8NP0ZIy6mhlgXKnKcLJwKcIeyjPc) +4. **Optional** boolean value whether export should be placed into only one sheet (only usable for debugging translations) Command line examples: @@ -139,3 +142,5 @@ Command line examples: java -jar babylon-1.0-SNAPSHOT.jar export test-config.json 1xhnBAOpy8-9KWhl8NP0ZIy6mhlgXKnKcLJwKcIeyjPc java -jar babylon-1.0-SNAPSHOT.jar import test-config.json 1xhnBAOpy8-9KWhl8NP0ZIy6mhlgXKnKcLJwKcIeyjPc ``` + + diff --git a/pom.xml b/pom.xml index 565eb56..0486a8a 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ one.edee.oss babylon-maven-plugin maven-plugin - 2.0.9-SNAPSHOT + 2.0.12-SNAPSHOT Babylon - translation utility https://github.com/FgForrest/Babylon/ @@ -65,11 +65,38 @@ 1.8 1.8 1.8 - 1.4.20 + 1.9.0 UTF-8 + + + + com.google.cloud + libraries-bom + 4.3.0 + pom + import + + + + + + com.theokanning.openai-gpt3-java + service + 0.18.2 + + + com.google.cloud + google-cloud-translate + + + + com.deepl.api + deepl-java + 1.4.0 + org.springframework.boot spring-boot-starter @@ -84,7 +111,7 @@ org.projectlombok lombok - 1.18.8 + 1.18.28 com.fasterxml.jackson.core @@ -99,7 +126,7 @@ de.poiu.apron apron - 2.1.1-FGFIX + 2.1.1 @@ -140,7 +167,7 @@ junit junit - 4.13.1 + 4.13 test @@ -167,9 +194,15 @@ ${kotlin.version} test + + org.antlr + antlr4 + 4.13.1 + + babylon org.apache.maven.plugins @@ -181,6 +214,7 @@ maven-javadoc-plugin 3.2.0 + false none @@ -205,7 +239,8 @@ true false forked-path - -Dgpg.passphrase=${gpg.passphrase} + -Dgpg.passphrase=${gpg.passphrase} -DskipTests=true + release-sign-artifacts @@ -347,38 +382,40 @@ + - - - release-sign-artifacts - - - performRelease - true - - - - - - org.apache.maven.plugins - maven-gpg-plugin - 1.6 - - - sign-artifacts - verify - - sign - - - - - - - - + + + release-sign-artifacts + + + + org.apache.maven.plugins + maven-gpg-plugin + 1.6 + + + sign-artifacts + verify + + sign + + + + + + + --pinentry-mode + loopback + + + + + + + - \ No newline at end of file + diff --git a/src/main/java/one/edee/babylon/MainService.java b/src/main/java/one/edee/babylon/MainService.java index bced085..2e2d62e 100644 --- a/src/main/java/one/edee/babylon/MainService.java +++ b/src/main/java/one/edee/babylon/MainService.java @@ -29,12 +29,15 @@ public MainService(Exporter exporter, this.importProcessor = importProcessor; } - public void startTranslation(Action action, TranslationConfiguration configuration, String spreadsheetId) throws IOException, GeneralSecurityException, InterruptedException { + public void startTranslation(Action action, TranslationConfiguration configuration, String spreadsheetId, boolean combineSheets) throws IOException, GeneralSecurityException, InterruptedException { long stTime = System.currentTimeMillis(); switch (action) { case EXPORT: log.info("Babylon starting..."); - exporter.walkPathsAndWriteSheets(configuration.getPath(), configuration.getMutations(), spreadsheetId, configuration.getSnapshotPath(), configuration.getLockedCellEditor()); + exporter.walkPathsAndWriteSheets( + configuration, + spreadsheetId, + combineSheets); break; case IMPORT: importProcessor.doImport(spreadsheetId); diff --git a/src/main/java/one/edee/babylon/SpringBootConsoleApplication.java b/src/main/java/one/edee/babylon/SpringBootConsoleApplication.java index 848ef83..f768935 100644 --- a/src/main/java/one/edee/babylon/SpringBootConsoleApplication.java +++ b/src/main/java/one/edee/babylon/SpringBootConsoleApplication.java @@ -44,7 +44,7 @@ public void run(String... args) { try { log.info("Loading config file: '" + arguments.getConfigFileName() + "'"); TranslationConfiguration configuration = configurationReader.readAndCheckConfiguration(arguments.getConfigFileName()); - mainService.startTranslation(arguments.getAction(), configuration, arguments.getGoogleSheetId()); + mainService.startTranslation(arguments.getAction(), configuration, arguments.getGoogleSheetId(), arguments.isCombineSheets()); } catch (Exception e) { log.error("BABYLON ERROR: ", e); System.exit(-1); @@ -56,8 +56,8 @@ public void run(String... args) { * @param args * @return */ - private Arguments parseArguments(String... args) { - if (args.length != 3) { + public static Arguments parseArguments(String... args) { + if (!(args.length == 3 || args.length == 4 || args.length == 5)) { log.error("Invalid input arguments, required: "); printRequiredArguments(); System.exit(-1); @@ -74,13 +74,17 @@ private Arguments parseArguments(String... args) { } arguments.setConfigFileName(args[1]); arguments.setGoogleSheetId(args[2]); + if (args.length > 3){ + arguments.setCombineSheets(Boolean.parseBoolean(args[3])); + } return arguments; } - private void printRequiredArguments() { + private static void printRequiredArguments() { log.info("1 - expected action (import, export)"); log.info("2 - path to translator-config.json file"); log.info("3 - ID of the google sheet (e.g. 1xhnBAOpy8-9KWhl8NP0ZIy6mhlgXKnKcLJwKcIeyjPc)"); + log.info("4 - arg to specify combineSheets mode"); } /** @@ -88,7 +92,7 @@ private void printRequiredArguments() { * @author Tomas Langer (langer@fg.cz), FG Forrest a.s. (c) 2019 */ @Data - static class Arguments { + public static class Arguments { /** * See {@link Action} @@ -104,6 +108,12 @@ static class Arguments { * Id of the target google spreadsheet. */ private String googleSheetId; + + /** + * Allows writing only to one sheet with name all. + * This mode is useful to correct duplicates, etc. + */ + private boolean combineSheets = false; } } diff --git a/src/main/java/one/edee/babylon/config/SupportedTranslators.java b/src/main/java/one/edee/babylon/config/SupportedTranslators.java new file mode 100644 index 0000000..8115d74 --- /dev/null +++ b/src/main/java/one/edee/babylon/config/SupportedTranslators.java @@ -0,0 +1,30 @@ +package one.edee.babylon.config; + +/** + * I apologize in advance for the lack of documentation in this code. + * I had every intention of providing clear and concise explanations + * for every line of code, but then I got distracted by a squirrel outside + * my window and the next thing I knew it was three weeks later. + *

+ * So instead, I've included some helpful comments here and there. + * They might not make sense, but hey, at least they're something. + * + * @author Štěpán Kameník (kamenik@fg.cz), FG Forrest a.s. (c) 2024 + **/ +public enum SupportedTranslators { + + /** + * @see one.edee.babylon.export.translator.GoogleTranslator + */ + GOOGLE, + + /** + * @see one.edee.babylon.export.translator.DeeplTranslator + */ + DEEPL, + + /** + * @see one.edee.babylon.export.translator.OpenAiTranslator + */ + OPENAI +} diff --git a/src/main/java/one/edee/babylon/config/TranslationConfiguration.java b/src/main/java/one/edee/babylon/config/TranslationConfiguration.java index 930d5eb..fa76723 100644 --- a/src/main/java/one/edee/babylon/config/TranslationConfiguration.java +++ b/src/main/java/one/edee/babylon/config/TranslationConfiguration.java @@ -5,6 +5,7 @@ import lombok.NoArgsConstructor; import lombok.NonNull; import lombok.RequiredArgsConstructor; +import org.jetbrains.annotations.Nullable; import java.io.Serializable; import java.nio.file.Path; @@ -41,7 +42,25 @@ public class TranslationConfiguration implements Serializable { */ private List mutations = new ArrayList<>(); - private List lockedCellEditor = new ArrayList<>(); + private List lockedCellEditors = new ArrayList<>(); + + /** + * Default language of project properties. + */ + @NonNull + private String defaultLang; + + /** + * Default language of project properties. + */ + @Nullable + private SupportedTranslators translator; + + /** + * Default language of project properties. + */ + @Nullable + private String translatorApiKey; @JsonIgnore public Path getSnapshotPath() { diff --git a/src/main/java/one/edee/babylon/db/SnapshotManager.java b/src/main/java/one/edee/babylon/db/SnapshotManager.java index 551d887..feba0c8 100644 --- a/src/main/java/one/edee/babylon/db/SnapshotManager.java +++ b/src/main/java/one/edee/babylon/db/SnapshotManager.java @@ -89,12 +89,12 @@ private Snapshot getExistingDataFileFromDisk(Path snapshotFile) throws IOExcepti } /** - * This map {@link Snapshot#getDataPropFilesById()} is excluded from Json serialization, so after deserialization of - * {@link Snapshot} from file is necessary to load this map from loaded {@link Snapshot#getDataPropFiles()}. + * This map {@link Snapshot#dataPropFilesById} is excluded from Json serialization, so after deserialization of + * {@link Snapshot} from file is necessary to load this map from loaded {@link Snapshot#getProps()}. * @param df DataFile object with map to load in. */ private void loadDataPropFilesIds(Snapshot df) { - df.getDataPropFiles().forEach((key, value) -> { + df.getProps().forEach((key, value) -> { if (value.getId() != null) { df.putDataPropFileById(value.getId(), value); } else { diff --git a/src/main/java/one/edee/babylon/entity/MessageFileContent.java b/src/main/java/one/edee/babylon/entity/MessageFileContent.java index d544d3b..80cf21c 100644 --- a/src/main/java/one/edee/babylon/entity/MessageFileContent.java +++ b/src/main/java/one/edee/babylon/entity/MessageFileContent.java @@ -2,10 +2,11 @@ import com.fasterxml.jackson.annotation.JsonFilter; import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.*; import one.edee.babylon.enums.PropertyStatus; import one.edee.babylon.snapshot.Snapshot; -import lombok.Data; -import lombok.NoArgsConstructor; +import org.apache.commons.io.IOUtils; import java.io.Serializable; import java.util.LinkedHashMap; @@ -30,6 +31,9 @@ public class MessageFileContent implements Serializable { /** * Properties like {@link PropertiesMap} */ + @Getter(AccessLevel.PRIVATE) + @Setter(AccessLevel.PRIVATE) + @JsonProperty("properties") private PropertiesMap properties = new PropertiesMap(); /** @@ -41,6 +45,12 @@ public class MessageFileContent implements Serializable { @JsonIgnore private Map mutationProperties = new LinkedHashMap<>(); + + public boolean hasSameValue(String msgKey, String currentMsg) { + currentMsg = normalizeContent(currentMsg); + return properties.get(msgKey).equals(currentMsg); + } + /** * Puts value for property for specified key and set logical working state of property like value of {@link PropertyStatus}:
* - {@link PropertyStatus#NEW} if key not exists
@@ -51,6 +61,7 @@ public class MessageFileContent implements Serializable { * @return Old value of property or null if no property exists for given key. */ public String putProperty(String key, String value) { + value = normalizeContent(value); String result = properties.put(key, value); if (result == null) { putPropertyStatus(key, PropertyStatus.NEW); @@ -68,7 +79,7 @@ public String putProperty(String key, String value) { * @param value property value */ public String putProperty(String key, String value, PropertyStatus propertyStatus) { - return properties.put(key, value, propertyStatus); + return properties.put(key, normalizeContent(value), propertyStatus); } public String putMutationProperty(String mutation, String key, String value) { @@ -77,7 +88,7 @@ public String putMutationProperty(String mutation, String key, String value) { propertiesMap = new PropertiesMap(); mutationProperties.put(mutation, propertiesMap); } - return propertiesMap.put(key, value); + return propertiesMap.put(key, normalizeContent(value)); } public String getPropertyValue(String propertyKey) { @@ -99,6 +110,22 @@ public PropertiesMap putMutationProperties(String mutation, PropertiesMap proper public PropertiesMap getMutationProperties(String mutation) { return mutationProperties.get(mutation); } + + private String normalizeContent(String value) { + String lineSeparator = System.lineSeparator(); + if (lineSeparator.equals(IOUtils.LINE_SEPARATOR_WINDOWS)) + return value; + return value == null ? null : value.replace(lineSeparator, IOUtils.LINE_SEPARATOR_WINDOWS); + } + + public boolean containsKey(String key) { + return properties.containsKey(key); + } + + @JsonIgnore + public Integer getPropertiesSize() { + return properties.size(); + } } diff --git a/src/main/java/one/edee/babylon/enums/PropertyType.java b/src/main/java/one/edee/babylon/enums/PropertyType.java index 85745ba..ad71e34 100644 --- a/src/main/java/one/edee/babylon/enums/PropertyType.java +++ b/src/main/java/one/edee/babylon/enums/PropertyType.java @@ -1,9 +1,9 @@ package one.edee.babylon.enums; -import one.edee.babylon.properties.Property; +import one.edee.babylon.properties.AbstractProperty; /** - * Enum of all types of properties {@link Property} + * Enum of all types of properties {@link AbstractProperty} * @author Tomas Langer (langer@fg.cz), FG Forrest a.s. (c) 2019 */ public enum PropertyType { @@ -13,7 +13,7 @@ public enum PropertyType { VALUE, /** * Property value (key=value) with multi line value escaped by '\'. * - * {@link Property#getValue()} method is overridden to return value as single string separated by '\' + line separator. + * {@link AbstractProperty#getValue()} method is overridden to return value as single string separated by '\' + line separator. */ MULTILINE, /** diff --git a/src/main/java/one/edee/babylon/export/ApronMessageLoader.java b/src/main/java/one/edee/babylon/export/ApronMessageLoader.java index 55f1401..89c4599 100644 --- a/src/main/java/one/edee/babylon/export/ApronMessageLoader.java +++ b/src/main/java/one/edee/babylon/export/ApronMessageLoader.java @@ -2,6 +2,7 @@ import de.poiu.apron.java.util.Properties; import one.edee.babylon.msgfile.TranslationFileUtils; +import one.edee.babylon.properties.Property; import one.edee.babylon.util.FileUtils; import de.poiu.apron.PropertyFile; @@ -12,6 +13,12 @@ import java.util.stream.Collectors; public class ApronMessageLoader implements MessageLoader { + public static final String PROPERTIES_FILE_EXTENSION = ".properties"; + + @Override + public boolean canBeLoaded(String filePath) { + return filePath.endsWith(PROPERTIES_FILE_EXTENSION); + } @Override public Map loadPrimaryMessages(String filePath) { @@ -63,7 +70,7 @@ private Map dumpPropertyFile(Properties properties) { } String cleanPropertyValue(String rawValue) { - return rawValue.trim(); + return Property.clearValue(rawValue).trim(); } private File fileFromPath(String path) { diff --git a/src/main/java/one/edee/babylon/export/Exporter.java b/src/main/java/one/edee/babylon/export/Exporter.java index 8967a82..d9607c3 100644 --- a/src/main/java/one/edee/babylon/export/Exporter.java +++ b/src/main/java/one/edee/babylon/export/Exporter.java @@ -1,13 +1,22 @@ package one.edee.babylon.export; +import lombok.RequiredArgsConstructor; +import lombok.extern.apachecommons.CommonsLog; +import one.edee.babylon.config.SupportedTranslators; +import one.edee.babylon.config.TranslationConfiguration; import one.edee.babylon.db.SnapshotUtils; import one.edee.babylon.export.dto.ExportResult; +import one.edee.babylon.export.dto.TranslationSheet; +import one.edee.babylon.export.translator.Translator; +import one.edee.babylon.sheets.SheetsException; import one.edee.babylon.sheets.gsheets.model.ASheet; import one.edee.babylon.snapshot.TranslationSnapshotWriteContract; import one.edee.babylon.util.AntPathResourceLoader; -import one.edee.babylon.sheets.SheetsException; import one.edee.babylon.util.PathUtils; -import lombok.extern.apachecommons.CommonsLog; +import org.jetbrains.annotations.NotNull; +import org.springframework.context.ApplicationContext; +import org.springframework.util.Assert; +import org.springframework.util.StringUtils; import java.io.File; import java.io.IOException; @@ -17,55 +26,35 @@ import java.util.function.Function; import java.util.stream.Collectors; +import static java.util.Optional.ofNullable; + /** * Performs the export phase that generates translation sheets. */ @CommonsLog +@RequiredArgsConstructor public class Exporter { + private static final String COMBINING_SHEET_NAME = "ALL"; + + private final ApplicationContext applicationContext; private final TranslationCollector translationCollector; private final TranslationSnapshotWriteContract snapshot; private final SheetContract gsc; private final AntPathResourceLoader resourceLoader; - private final PathUtils pu; - - public Exporter(TranslationCollector translationCollector, TranslationSnapshotWriteContract snapshot, SheetContract gsc, AntPathResourceLoader resourceLoader) { - this.translationCollector = translationCollector; - this.snapshot = snapshot; - this.gsc = gsc; - this.resourceLoader = resourceLoader; - this.pu = new PathUtils(); - } + private final PathUtils pu = new PathUtils(); - /** - * Walks message file paths, gathering messages and translations, producing translation sheets in given GSheet spreadsheet. - * - * @param patternPaths paths of message files to export - * @param translationLangs languages to translate messages to - * @param spreadsheetId id of GSheets spreadsheet, must be empty - * @param snapshotPath path to the translation snapshot file - */ - public void walkPathsAndWriteSheets(List patternPaths, - List translationLangs, - String spreadsheetId, - Path snapshotPath) { - walkPathsAndWriteSheets(patternPaths, translationLangs, spreadsheetId, snapshotPath, Collections.emptyList()); - } /** * Walks message file paths, gathering messages and translations, producing translation sheets in given GSheet spreadsheet. * - * @param patternPaths paths of message files to export - * @param translationLangs languages to translate messages to - * @param spreadsheetId id of GSheets spreadsheet, must be empty - * @param snapshotPath path to the translation snapshot file - * @param lockedCellEditors list of Google account emails, these account will have the permission to edit locked cells + * @param configuration configuration of translation run + * @param spreadsheetId id of GSheets spreadsheet, must be empty */ - public void walkPathsAndWriteSheets(List patternPaths, - List translationLangs, + public void walkPathsAndWriteSheets(TranslationConfiguration configuration, String spreadsheetId, - Path snapshotPath, - List lockedCellEditors) { + boolean combineSheets) { + List patternPaths = configuration.getPath(); warnDuplicatePaths(patternPaths); List prevSheets = listAllSheets(spreadsheetId); @@ -76,16 +65,107 @@ public void walkPathsAndWriteSheets(List patternPaths, throw new IllegalArgumentException("Please fix the message file paths in the configuration file."); } - ExportResult result = translationCollector.walkPathsAndCollectTranslationSheets(allUniquePaths, translationLangs); + ExportResult result = translationCollector.walkPathsAndCollectTranslationSheets(allUniquePaths, configuration.getMutations()); + + if (combineSheets) { + // only for translation debugging + List original = result.getSheets(); + List sheets = new ArrayList<>(original); + original.clear(); + + List> combine = new LinkedList<>(); + for (int i = 0; i < sheets.size(); i++) { + TranslationSheet sheet = sheets.get(i); + List> rows = sheet.getRows(); + if (i != 0){ + rows.remove(0); + } + combine.addAll(rows); + } + + original.add(new TranslationSheet(COMBINING_SHEET_NAME,combine)); + } + + Map> changed = translateTextsByExternalTool(configuration, result); - uploadTranslations(result, spreadsheetId, lockedCellEditors); + uploadTranslations(result, spreadsheetId, configuration.getLockedCellEditors(), changed); - updateSnapshotAndWriteToDisk(this.snapshot, result, snapshotPath); + updateSnapshotAndWriteToDisk(this.snapshot, result, configuration.getSnapshotPath()); List prevSheetIds = prevSheets.stream().map(ASheet::getId).collect(Collectors.toList()); deleteOldSheets(prevSheetIds, spreadsheetId); } + @NotNull + private Map> translateTextsByExternalTool(TranslationConfiguration configuration, ExportResult result) { + Map> changed = new HashMap<>(); + + if (configuration.getTranslatorApiKey() != null) { + SupportedTranslators translatorType = ofNullable(configuration.getTranslator()).orElse(SupportedTranslators.GOOGLE); + + Translator translator = applicationContext.getBeansOfType(Translator.class) + .values() + .stream() + .filter(i -> i.getSupportedTranslator().equals(translatorType)) + .findFirst() + .orElseThrow(() -> new IllegalArgumentException("Cannot find translator bean for type" + translatorType)); + translator.init(configuration.getTranslatorApiKey()); + + try { + for (TranslationSheet sheet : result.getSheets()) { + + List> rows = sheet.getRows(); + if (rows.size() == 1) + continue; + + log.info("Translating sheet " + sheet.getSheetName()); + List header = rows.get(0); + List originals = rows.stream().map(i->i.get(1)).map(i->StringUtils.hasText(i) ? i : "____DUMMY").collect(Collectors.toList()); + Map> translations = new HashMap<>(); + + for (String lang : header.stream().skip(2).collect(Collectors.toList())) { + translations.put(lang, translator.translate(configuration.getDefaultLang(), originals, lang)); + } + + for (int i = 1; i < rows.size(); i++) { + Map toChange = new HashMap<>(); + + List cells = rows.get(i); + String original = cells.get(1); + for (int l = 2; l < cells.size(); l++) { + if (StringUtils.isEmpty(cells.get(l))) { + + String lang = header.get(l); + + if (StringUtils.hasText(original)) { + String transOriginal = originals.get(i); + if (!Objects.equals(original, "____DUMMY")){ + Assert.isTrue(Objects.equals(transOriginal, original), "Originals does not equals!"); + String translatedText = translations.get(lang).get(i); + toChange.put(l, translatedText); + + changed + .computeIfAbsent(sheet.getSheetName(), key -> new LinkedList<>()) + .add(i + "_" + l); + } + } + } + } + + for (Entry entry : toChange.entrySet()) { + cells.remove((int) entry.getKey()); + cells.add(entry.getKey(), entry.getValue()); + } + + } + } + } catch (Exception e) { + log.error(e.getMessage(), e); + } + } + return changed; + } + private void warnDuplicatePaths(List patternPaths) { List duplicatePaths = detectDuplicatePatternPaths(patternPaths); if (!duplicatePaths.isEmpty()) { @@ -138,13 +218,13 @@ private List listAllSheets(String spreadsheetId) { } } - private void uploadTranslations(ExportResult exportResult, String spreadsheetId, List lockedCellEditors) { + private void uploadTranslations(ExportResult exportResult, String spreadsheetId, List lockedCellEditors, Map> changed) { exportResult.getSheets().stream() .filter(sheet -> !sheet.getDataRows().isEmpty()) .forEach(sheet -> { try { log.info("Writing " + sheet.getDataRows().size() + " rows into sheet '" + sheet.getSheetName() + "'."); - gsc.createSheet(spreadsheetId, sheet.getSheetName(), sheet.getRows(), lockedCellEditors); + gsc.createSheet(spreadsheetId, sheet.getSheetName(), sheet.getRows(), lockedCellEditors, changed); } catch (SheetsException e) { String errMsg = "Error when uploading data to spreadsheet '" + spreadsheetId + "'"; throw new RuntimeException(errMsg, e); @@ -203,10 +283,12 @@ public interface SheetContract { * @param sheetTitle name to use for the new sheet * @param sheetRows rows with data cells to fill the sheet with * @param lockedCellEditors list of email accounts that will be able to edit locked cells + * @param changed * @throws SheetsException when unable to upload sheets */ - void createSheet(String spreadsheetId, String sheetTitle, List> sheetRows, List lockedCellEditors) throws SheetsException; + void createSheet(String spreadsheetId, String sheetTitle, List> sheetRows, List lockedCellEditors, Map> changed) throws SheetsException; } + } diff --git a/src/main/java/one/edee/babylon/export/MessageLoader.java b/src/main/java/one/edee/babylon/export/MessageLoader.java index 00ae16d..2ffc89e 100644 --- a/src/main/java/one/edee/babylon/export/MessageLoader.java +++ b/src/main/java/one/edee/babylon/export/MessageLoader.java @@ -5,6 +5,12 @@ public interface MessageLoader { + + /** + * Indicates whether file could be loaded by implementation. + */ + boolean canBeLoaded(String filePath); + /** * Loads primary language messages for given message file path. * diff --git a/src/main/java/one/edee/babylon/export/TranslationCollector.java b/src/main/java/one/edee/babylon/export/TranslationCollector.java index 303a7f8..9c911cb 100644 --- a/src/main/java/one/edee/babylon/export/TranslationCollector.java +++ b/src/main/java/one/edee/babylon/export/TranslationCollector.java @@ -1,6 +1,8 @@ package one.edee.babylon.export; +import kotlin.Pair; import lombok.RequiredArgsConstructor; +import lombok.extern.apachecommons.CommonsLog; import one.edee.babylon.export.dto.ExportResult; import one.edee.babylon.export.dto.MessageFileExportResult; import one.edee.babylon.export.dto.TranslationSheet; @@ -8,8 +10,7 @@ import one.edee.babylon.sheets.SheetUtils; import one.edee.babylon.snapshot.TranslationSnapshotReadContract; import one.edee.babylon.snapshot.TranslationSnapshotWriteContract; -import kotlin.Pair; -import lombok.extern.apachecommons.CommonsLog; +import org.springframework.util.Assert; import java.util.*; import java.util.stream.Collectors; @@ -20,7 +21,7 @@ @CommonsLog @RequiredArgsConstructor public class TranslationCollector { - private final MessageLoader messageLoader; + private final List messageLoaders; private final MessageFileProcessor messageFileProcessor; private final TranslationSnapshotReadContract snapshotReadContract; private final TranslationSnapshotWriteContract snapshotWriteContract; @@ -78,8 +79,16 @@ private MessageFileExportResult processMsgFile(String msgFilePath, List } private Pair computeTranslationSheetRows(String msgFilePath, List translateTo) { - Map primaryMsgs = messageLoader.loadPrimaryMessages(msgFilePath); - Map> translations = messageLoader.loadTranslations(msgFilePath, translateTo); + Map primaryMsgs = null; + Map> translations = null; + for (MessageLoader messageLoader : messageLoaders) { + if (messageLoader.canBeLoaded(msgFilePath)) { + primaryMsgs = messageLoader.loadPrimaryMessages(msgFilePath); + translations = messageLoader.loadTranslations(msgFilePath, translateTo); + } + } + Assert.notNull(primaryMsgs, "There is no appropriate message loader for file path with extension: " + msgFilePath); + Assert.notNull(translations, "There is no appropriate message loader for file path with extension: " + msgFilePath); return messageFileProcessor.prepareTranslationSheet(msgFilePath, primaryMsgs, translations, translateTo); } diff --git a/src/main/java/one/edee/babylon/export/TsMessageLoader.java b/src/main/java/one/edee/babylon/export/TsMessageLoader.java new file mode 100644 index 0000000..4bc5aa0 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/TsMessageLoader.java @@ -0,0 +1,110 @@ +package one.edee.babylon.export; + +import lombok.extern.log4j.Log4j2; +import one.edee.babylon.export.ts.TypeScriptBabylonParserListener; +import one.edee.babylon.export.ts.gen.TypeScriptLexer; +import one.edee.babylon.export.ts.gen.TypeScriptParser; +import one.edee.babylon.msgfile.TranslationFileUtils; +import one.edee.babylon.util.FileUtils; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.tree.ParseTree; +import org.antlr.v4.runtime.tree.ParseTreeWalker; + +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.io.Reader; +import java.util.AbstractMap; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +import static java.util.Optional.ofNullable; + +@Log4j2 +public class TsMessageLoader implements MessageLoader { + + public static final String TS_FILE_EXTENSION = ".ts"; + + @Override + public boolean canBeLoaded(String filePath) { + return filePath.endsWith(TS_FILE_EXTENSION); + } + + @Override + public Map loadPrimaryMessages(String filePath) { + return ofNullable(loadFile(filePath)) + .map(TypeScriptBabylonParserListener::getPropertyDefinitions) + .orElse(Collections.emptyMap()); + } + + @Override + public Map> loadTranslations(String filePath, List languages) { + return languages + .stream() + .map(lang -> + new AbstractMap.SimpleEntry<>( + lang, + loadTranslations(filePath, lang) + ) + ).collect(Collectors.toMap( + AbstractMap.SimpleEntry::getKey, + AbstractMap.SimpleEntry::getValue) + ); + } + + + public static Map dumpTsFile(Reader reader) throws IOException { + return readTsFile(reader).getPropertyDefinitions(); + } + + public static TypeScriptBabylonParserListener readTsFile(Reader reader) throws IOException { + CharStream input = CharStreams.fromReader(reader); + + TypeScriptLexer lexer = new TypeScriptLexer(input); + CommonTokenStream tokens = new CommonTokenStream(lexer); + TypeScriptParser parser = new TypeScriptParser(tokens); + parser.addErrorListener(new BaseErrorListener() { + @Override + public void syntaxError(Recognizer recognizer, Object o, int i, int i1, String s, RecognitionException e) { + log.error("Cannot parse: " + s + " at line " + i + " with exception: " + e.getMessage()); + } + }); + ParseTree tree = parser.program(); + + TypeScriptBabylonParserListener listener = new TypeScriptBabylonParserListener(); + ParseTreeWalker walker = new ParseTreeWalker(); + walker.walk(listener, tree); + + return listener; + } + + private Map loadTranslations(String filePath, String language) { + String translationFilePath = TranslationFileUtils.getFileNameForTranslation(filePath, language); + return ofNullable(loadFile(translationFilePath)) + .map(TypeScriptBabylonParserListener::getPropertyDefinitions) + .orElse(Collections.emptyMap()); + } + + + public static TypeScriptBabylonParserListener loadFile(String filePath) { + if (FileUtils.exists(filePath)) { + + log.info("Processing ts file: " + filePath); + try (Reader inputStreamReader = new FileReader(fileFromPath(filePath))) { + return readTsFile(inputStreamReader); + } catch (IOException e) { + throw new IllegalArgumentException(e.getMessage(), e); + } + } else { + return null; + } + } + + + private static File fileFromPath(String path) { + return FileUtils.fileFromPathOrThrow(path); + } + +} diff --git a/src/main/java/one/edee/babylon/export/translator/DeeplTranslator.java b/src/main/java/one/edee/babylon/export/translator/DeeplTranslator.java new file mode 100644 index 0000000..407ef38 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/translator/DeeplTranslator.java @@ -0,0 +1,71 @@ +package one.edee.babylon.export.translator; + +import com.deepl.api.TextResult; +import com.deepl.api.TextTranslationOptions; +import com.deepl.api.Translator; +import lombok.extern.log4j.Log4j2; +import one.edee.babylon.config.SupportedTranslators; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.springframework.stereotype.Component; +import org.springframework.util.Assert; + +import java.util.List; +import java.util.stream.Collectors; + +import static java.util.Optional.ofNullable; + +/** + * I apologize in advance for the lack of documentation in this code. + * I had every intention of providing clear and concise explanations + * for every line of code, but then I got distracted by a squirrel outside + * my window and the next thing I knew it was three weeks later. + *

+ * So instead, I've included some helpful comments here and there. + * They might not make sense, but hey, at least they're something. + * + * @author Štěpán Kameník (kamenik@fg.cz), FG Forrest a.s. (c) 2024 + **/ +@Component +@Log4j2 +public class DeeplTranslator implements one.edee.babylon.export.translator.Translator { + + Translator service = null; + + @Override + public void init(@NotNull String apiKey) { + service = new Translator(apiKey); + + } + + @Override + public List translate(@Nullable String defaultLang, @NotNull List original, @NotNull String lang) { + Assert.notNull(service, "Init method with api key has to be called before translation!"); + + if (lang.equals("en")) { + lang = "en-GB"; + } + + String contextMessage = System.getProperty("babylon.deepl.context"); + try { + return service.translateText( + original, + defaultLang, + lang, + new TextTranslationOptions() + .setContext(ofNullable(contextMessage) + .orElse("You are eshop translator. Do not translate text from other languages then source lang, or technical texts."))) + .stream() + .map(TextResult::getText) + .collect(Collectors.toList()); + } catch (Exception e) { + log.error("Cannot translate " + original + " to lang: " + lang); + return null; + } + } + + @Override + public SupportedTranslators getSupportedTranslator() { + return SupportedTranslators.DEEPL; + } +} diff --git a/src/main/java/one/edee/babylon/export/translator/GoogleTranslator.java b/src/main/java/one/edee/babylon/export/translator/GoogleTranslator.java new file mode 100644 index 0000000..a0b75a7 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/translator/GoogleTranslator.java @@ -0,0 +1,57 @@ +package one.edee.babylon.export.translator; + +import com.google.cloud.translate.Translate; +import com.google.cloud.translate.TranslateOptions; +import com.google.cloud.translate.Translation; +import one.edee.babylon.config.SupportedTranslators; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.springframework.stereotype.Component; +import org.springframework.util.Assert; + +import java.util.List; +import java.util.stream.Collectors; + +import static com.google.cloud.translate.Translate.TranslateOption.sourceLanguage; +import static com.google.cloud.translate.Translate.TranslateOption.targetLanguage; + +/** + * I apologize in advance for the lack of documentation in this code. + * I had every intention of providing clear and concise explanations + * for every line of code, but then I got distracted by a squirrel outside + * my window and the next thing I knew it was three weeks later. + *

+ * So instead, I've included some helpful comments here and there. + * They might not make sense, but hey, at least they're something. + * + * @author Štěpán Kameník (kamenik@fg.cz), FG Forrest a.s. (c) 2024 + **/ +@Component +public class GoogleTranslator implements Translator{ + + Translate service = null; + + @Override + public void init(@NotNull String apiKey) { + service = TranslateOptions.newBuilder().setApiKey(apiKey).build().getService(); + + } + + @Override + public List translate(@Nullable String defaultLang, @NotNull List original, @NotNull String lang) { + Assert.notNull(service, "Init method with api key has to be called before translation!"); + return service.translate( + original, + sourceLanguage(defaultLang), + targetLanguage(lang) + ) + .stream() + .map(Translation::getTranslatedText) + .collect(Collectors.toList()); + } + + @Override + public SupportedTranslators getSupportedTranslator() { + return SupportedTranslators.GOOGLE; + } +} diff --git a/src/main/java/one/edee/babylon/export/translator/OpenAiTranslator.java b/src/main/java/one/edee/babylon/export/translator/OpenAiTranslator.java new file mode 100644 index 0000000..15b8912 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/translator/OpenAiTranslator.java @@ -0,0 +1,111 @@ +package one.edee.babylon.export.translator; + +import com.theokanning.openai.OpenAiHttpException; +import com.theokanning.openai.completion.chat.ChatCompletionRequest; +import com.theokanning.openai.completion.chat.ChatCompletionResult; +import com.theokanning.openai.completion.chat.ChatMessage; +import com.theokanning.openai.service.OpenAiService; +import lombok.SneakyThrows; +import lombok.extern.log4j.Log4j2; +import one.edee.babylon.config.SupportedTranslators; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.springframework.stereotype.Component; +import org.springframework.util.Assert; + +import java.time.Duration; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + +import static java.util.Optional.ofNullable; + +/** + * I apologize in advance for the lack of documentation in this code. + * I had every intention of providing clear and concise explanations + * for every line of code, but then I got distracted by a squirrel outside + * my window and the next thing I knew it was three weeks later. + *

+ * So instead, I've included some helpful comments here and there. + * They might not make sense, but hey, at least they're something. + * + * @author Štěpán Kameník (kamenik@fg.cz), FG Forrest a.s. (c) 2024 + **/ +@Component +@Log4j2 +public class OpenAiTranslator implements Translator { + + OpenAiService service = null; + + @Override + public void init(@NotNull String apiKey) { + service = new OpenAiService(apiKey, Duration.ofSeconds(60L)); + } + + @SneakyThrows + @Override + public List translate(@Nullable String defaultLang, @NotNull List original, @NotNull String lang) { + Assert.notNull(service, "Init method with api key has to be called before translation!"); + + String systemMessage = System.getProperty("babylon.openai.systemMessage"); + String formattedSystemMessage = String.format( + ofNullable(systemMessage) + .orElse("You are translator that translate eshop messages from %s to %s. If you cannot translate it, return original text. Texts to translate are combined by '~'. Split input by comma, translate and return in same format."), + defaultLang, + lang); + + + String joined = String.join("~", original); + List messages = Arrays.asList( + new ChatMessage("system", formattedSystemMessage), + new ChatMessage("user", joined) + ); + + int tries = 5; + List output; + do { + // translator in some cases returns fewer results than expected, try it again 5 times + String result = translateInner(messages, original); + output = Arrays.stream(result.split("~")).collect(Collectors.toList()); + if (output.size() != original.size()) + log.warn("Size not equal " + joined + " " + result); + tries--; + }while (tries > 0 && output.size() != original.size()); + + // if it occurs even after 5 tries, throw exception + if (output.size() != original.size()) + throw new IllegalArgumentException("Size not equal, even after 5 tries!"); + + return output; + } + + private String translateInner(List messages, @NotNull List original) throws InterruptedException { + + ChatCompletionResult chatCompletion; + try{ + chatCompletion = service.createChatCompletion( + ChatCompletionRequest + .builder() + .model(ofNullable(System.getProperty("babylon.openai.model")).orElse("gpt-3.5-turbo-16k-0613")) + .messages( + messages + ) + .build() + ); + + }catch (OpenAiHttpException e){ + if (e.getMessage().contains("Please try again in 20s")){ + log.info("Rate limit reached, will try again in 20 secs! Translate in progress " + original); + Thread.sleep(20_000); + return translateInner(messages, original); + } + throw e; + } + return chatCompletion.getChoices().get(0).getMessage().getContent(); + } + + @Override + public SupportedTranslators getSupportedTranslator() { + return SupportedTranslators.OPENAI; + } +} diff --git a/src/main/java/one/edee/babylon/export/translator/Translator.java b/src/main/java/one/edee/babylon/export/translator/Translator.java new file mode 100644 index 0000000..2ddfd12 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/translator/Translator.java @@ -0,0 +1,28 @@ +package one.edee.babylon.export.translator; + +import one.edee.babylon.config.SupportedTranslators; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.List; + +/** + * I apologize in advance for the lack of documentation in this code. + * I had every intention of providing clear and concise explanations + * for every line of code, but then I got distracted by a squirrel outside + * my window and the next thing I knew it was three weeks later. + *

+ * So instead, I've included some helpful comments here and there. + * They might not make sense, but hey, at least they're something. + * + * @author Štěpán Kameník (kamenik@fg.cz), FG Forrest a.s. (c) 2024 + **/ +public interface Translator { + + void init(@NotNull String apiKey); + + List translate(@Nullable String defaultLang, @NotNull List originals, @NotNull String lang); + + SupportedTranslators getSupportedTranslator(); + +} diff --git a/src/main/java/one/edee/babylon/export/ts/TypeScriptBabylonParserListener.java b/src/main/java/one/edee/babylon/export/ts/TypeScriptBabylonParserListener.java new file mode 100644 index 0000000..d9dedd0 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/TypeScriptBabylonParserListener.java @@ -0,0 +1,76 @@ +package one.edee.babylon.export.ts; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import one.edee.babylon.export.ts.gen.TypeScriptParser; +import one.edee.babylon.export.ts.gen.TypeScriptParserBaseListener; +import org.antlr.v4.runtime.ParserRuleContext; +import org.springframework.util.Assert; + +import java.util.*; + + +@EqualsAndHashCode(callSuper = true) +@Data +public class TypeScriptBabylonParserListener extends TypeScriptParserBaseListener { + + private static final String APOSTROPHE_CLEANING_REGEX = "['`].*?"; + + private final Set propertyListDefName = new HashSet<>(); + private final Map propertyDefinitions = new LinkedHashMap<>(); + private final List imports = new LinkedList<>(); + + @Override + public void enterIdentifierOrKeyWord(TypeScriptParser.IdentifierOrKeyWordContext ctx) { + propertyListDefName.add(ctx.getText()); + } + + @Override + public void enterPropertyExpressionAssignment(TypeScriptParser.PropertyExpressionAssignmentContext ctx) { + int childCount = ctx.getChildCount(); + Assert.isTrue(childCount == 3, "There has to be property name, delimiter (:) and value! In: " + ctx.getText()); + String propertyName = cleanText(ctx.getChild(0).getText()); + String propertyValue = cleanText(ctx.getChild(2).getText()); + propertyDefinitions.put(propertyName, propertyValue); + } + + @Override + public void enterComputedPropertyExpressionAssignment(TypeScriptParser.ComputedPropertyExpressionAssignmentContext ctx) { + String[] split = ctx.getText().split(":"); + Assert.isTrue(split.length == 2, "There has to be property name, delimiter (:) and value! In: " + ctx.getText()); + String propertyName = cleanText(split[0]); + String propertyValue = cleanText(split[1]); + propertyDefinitions.put(propertyName, propertyValue); + } + + @Override + public void enterImportStatement(TypeScriptParser.ImportStatementContext ctx) { + imports.add(getNodeText(ctx)); + } + + private String cleanText(String text) { + if (text.matches(APOSTROPHE_CLEANING_REGEX) || (text.contains("\n") || text.contains("\r"))) + text = text.replaceAll("['`]", ""); + return text; + } + + + private String getNodeText(ParserRuleContext ctx) { + int childCount = ctx.getChildCount(); + if (childCount == 0) { + return ""; + } else { + StringBuilder builder = new StringBuilder(); + + for (int i = 0; i < childCount; ++i) { + if (i != 0) builder.append(" "); + builder.append(ctx.getChild(i).getText()); + + } + return builder.toString(); + } + } + + + // OTHER METHODS +} diff --git a/src/main/java/one/edee/babylon/export/ts/TypeScriptLexerBase.java b/src/main/java/one/edee/babylon/export/ts/TypeScriptLexerBase.java new file mode 100644 index 0000000..7bd0de8 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/TypeScriptLexerBase.java @@ -0,0 +1,166 @@ +package one.edee.babylon.export.ts; + +import one.edee.babylon.export.ts.gen.TypeScriptLexer; +import org.antlr.v4.runtime.*; + +import java.util.ArrayDeque; +import java.util.Deque; + +/** + * All lexer methods that used in grammar (IsStrictMode) + * should start with Upper Case Char similar to Lexer rules. + */ +public abstract class TypeScriptLexerBase extends Lexer +{ + /** + * Stores values of nested modes. By default mode is strict or + * defined externally (useStrictDefault) + */ + private final Deque scopeStrictModes = new ArrayDeque<>(); + + private Token lastToken = null; + /** + * Default value of strict mode + * Can be defined externally by setUseStrictDefault + */ + private boolean useStrictDefault = false; + /** + * Current value of strict mode + * Can be defined during parsing, see StringFunctions.js and StringGlobal.js samples + */ + private boolean useStrictCurrent = false; + /** + * Keeps track of the current depth of nested template string backticks. + * E.g. after the X in: + * + * `${a ? `${X + * + * templateDepth will be 2. This variable is needed to determine if a `}` is a + * plain CloseBrace, or one that closes an expression inside a template string. + */ + private int templateDepth = 0; + + /** + * Keeps track of the depth of open- and close-braces. Used for expressions like: + * + * `${[1, 2, 3].map(x => { return x * 2;}).join("")}` + * + * where the '}' from `return x * 2;}` should not become a `TemplateCloseBrace` + * token but rather a `CloseBrace` token. + */ + private int bracesDepth = 0; + + public TypeScriptLexerBase(CharStream input) { + super(input); + } + + public boolean getStrictDefault() { + return useStrictDefault; + } + + public void setUseStrictDefault(boolean value) { + useStrictDefault = value; + useStrictCurrent = value; + } + + public boolean IsStrictMode() { + return useStrictCurrent; + } + + public void StartTemplateString() { + this.bracesDepth = 0; + } + + public boolean IsInTemplateString() { + return this.templateDepth > 0 && this.bracesDepth == 0; + } + + /** + * Return the next token from the character stream and records this last + * token in case it resides on the default channel. This recorded token + * is used to determine when the lexer could possibly match a regex + * literal. Also changes scopeStrictModes stack if tokenize special + * string 'use strict'; + * + * @return the next token from the character stream. + */ + @Override + public Token nextToken() { + Token next = super.nextToken(); + + if (next.getChannel() == Token.DEFAULT_CHANNEL) { + // Keep track of the last token on the default channel. + this.lastToken = next; + } + + return next; + } + + protected void ProcessOpenBrace() + { + bracesDepth++; + useStrictCurrent = scopeStrictModes.size() > 0 && scopeStrictModes.peek() ? true : useStrictDefault; + scopeStrictModes.push(useStrictCurrent); + } + + protected void ProcessCloseBrace() + { + bracesDepth--; + useStrictCurrent = scopeStrictModes.size() > 0 ? scopeStrictModes.pop() : useStrictDefault; + } + + protected void ProcessStringLiteral() + { + if (lastToken == null || lastToken.getType() == TypeScriptLexer.OpenBrace) + { + String text = getText(); + if (text.equals("\"use strict\"") || text.equals("'use strict'")) + { + if (scopeStrictModes.size() > 0) + scopeStrictModes.pop(); + useStrictCurrent = true; + scopeStrictModes.push(useStrictCurrent); + } + } + } + + protected void IncreaseTemplateDepth() { + this.templateDepth++; + } + + protected void DecreaseTemplateDepth() { + this.templateDepth--; + } + + /** + * Returns {@code true} if the lexer can match a regex literal. + */ + protected boolean IsRegexPossible() { + + if (this.lastToken == null) { + // No token has been produced yet: at the start of the input, + // no division is possible, so a regex literal _is_ possible. + return true; + } + + switch (this.lastToken.getType()) { + case TypeScriptLexer.Identifier: + case TypeScriptLexer.NullLiteral: + case TypeScriptLexer.BooleanLiteral: + case TypeScriptLexer.This: + case TypeScriptLexer.CloseBracket: + case TypeScriptLexer.CloseParen: + case TypeScriptLexer.OctalIntegerLiteral: + case TypeScriptLexer.DecimalLiteral: + case TypeScriptLexer.HexIntegerLiteral: + case TypeScriptLexer.StringLiteral: + case TypeScriptLexer.PlusPlus: + case TypeScriptLexer.MinusMinus: + // After any of the tokens above, no regex literal can follow. + return false; + default: + // In all other cases, a regex literal _is_ possible. + return true; + } + } +} diff --git a/src/main/java/one/edee/babylon/export/ts/TypeScriptParserBase.java b/src/main/java/one/edee/babylon/export/ts/TypeScriptParserBase.java new file mode 100644 index 0000000..a19f44a --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/TypeScriptParserBase.java @@ -0,0 +1,122 @@ +package one.edee.babylon.export.ts; + +import one.edee.babylon.export.ts.gen.TypeScriptParser; +import org.antlr.v4.runtime.*; + +/** + * All parser methods that used in grammar (p, prev, notLineTerminator, etc.) + * should start with lower case char similar to parser rules. + */ +public abstract class TypeScriptParserBase extends Parser +{ + public TypeScriptParserBase(TokenStream input) { + super(input); + } + + /** + * Short form for prev(String str) + */ + protected boolean p(String str) { + return prev(str); + } + + /** + * Whether the previous token value equals to @param str + */ + protected boolean prev(String str) { + return _input.LT(-1).getText().equals(str); + } + + /** + * Short form for next(String str) + */ + protected boolean n(String str) { + return next(str); + } + + /** + * Whether the next token value equals to @param str + */ + protected boolean next(String str) { + return _input.LT(1).getText().equals(str); + } + + protected boolean notLineTerminator() { + return !here(TypeScriptParser.LineTerminator); + } + + protected boolean notOpenBraceAndNotFunction() { + int nextTokenType = _input.LT(1).getType(); + return nextTokenType != TypeScriptParser.OpenBrace && nextTokenType != TypeScriptParser.Function_; + } + + protected boolean closeBrace() { + return _input.LT(1).getType() == TypeScriptParser.CloseBrace; + } + + /** + * Returns {@code true} iff on the current index of the parser's + * token stream a token of the given {@code type} exists on the + * {@code HIDDEN} channel. + * + * @param type + * the type of the token on the {@code HIDDEN} channel + * to check. + * + * @return {@code true} iff on the current index of the parser's + * token stream a token of the given {@code type} exists on the + * {@code HIDDEN} channel. + */ + private boolean here(final int type) { + + // Get the token ahead of the current index. + int possibleIndexEosToken = this.getCurrentToken().getTokenIndex() - 1; + Token ahead = _input.get(possibleIndexEosToken); + + // Check if the token resides on the HIDDEN channel and if it's of the + // provided type. + return (ahead.getChannel() == Lexer.HIDDEN) && (ahead.getType() == type); + } + + /** + * Returns {@code true} iff on the current index of the parser's + * token stream a token exists on the {@code HIDDEN} channel which + * either is a line terminator, or is a multi line comment that + * contains a line terminator. + * + * @return {@code true} iff on the current index of the parser's + * token stream a token exists on the {@code HIDDEN} channel which + * either is a line terminator, or is a multi line comment that + * contains a line terminator. + */ + protected boolean lineTerminatorAhead() { + + // Get the token ahead of the current index. + int possibleIndexEosToken = this.getCurrentToken().getTokenIndex() - 1; + Token ahead = _input.get(possibleIndexEosToken); + + if (ahead.getChannel() != Lexer.HIDDEN) { + // We're only interested in tokens on the HIDDEN channel. + return false; + } + + if (ahead.getType() == TypeScriptParser.LineTerminator) { + // There is definitely a line terminator ahead. + return true; + } + + if (ahead.getType() == TypeScriptParser.WhiteSpaces) { + // Get the token ahead of the current whitespaces. + possibleIndexEosToken = this.getCurrentToken().getTokenIndex() - 2; + ahead = _input.get(possibleIndexEosToken); + } + + // Get the token's text and type. + String text = ahead.getText(); + int type = ahead.getType(); + + // Check if the token is, or contains a line terminator. + return (type == TypeScriptParser.MultiLineComment && (text.contains("\r") || text.contains("\n"))) || + (type == TypeScriptParser.LineTerminator); + } +} diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.g4 b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.g4 new file mode 100644 index 0000000..78b867e --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.g4 @@ -0,0 +1,307 @@ +lexer grammar TypeScriptLexer; + +channels { ERROR } + +options { + superClass=TypeScriptLexerBase; +} + + +MultiLineComment: '/*' .*? '*/' -> channel(HIDDEN); +SingleLineComment: '//' ~[\r\n\u2028\u2029]* -> channel(HIDDEN); +RegularExpressionLiteral: '/' RegularExpressionFirstChar RegularExpressionChar* {this.IsRegexPossible()}? '/' IdentifierPart*; + +OpenBracket: '['; +CloseBracket: ']'; +OpenParen: '('; +CloseParen: ')'; +OpenBrace: '{' {this.ProcessOpenBrace();}; +TemplateCloseBrace: {this.IsInTemplateString()}? '}' -> popMode; +CloseBrace: '}' {this.ProcessCloseBrace();}; +SemiColon: ';'; +Comma: ','; +Assign: '='; +QuestionMark: '?'; +Colon: ':'; +Ellipsis: '...'; +Dot: '.'; +PlusPlus: '++'; +MinusMinus: '--'; +Plus: '+'; +Minus: '-'; +BitNot: '~'; +Not: '!'; +Multiply: '*'; +Divide: '/'; +Modulus: '%'; +RightShiftArithmetic: '>>'; +LeftShiftArithmetic: '<<'; +RightShiftLogical: '>>>'; +LessThan: '<'; +MoreThan: '>'; +LessThanEquals: '<='; +GreaterThanEquals: '>='; +Equals_: '=='; +NotEquals: '!='; +IdentityEquals: '==='; +IdentityNotEquals: '!=='; +BitAnd: '&'; +BitXOr: '^'; +BitOr: '|'; +And: '&&'; +Or: '||'; +MultiplyAssign: '*='; +DivideAssign: '/='; +ModulusAssign: '%='; +PlusAssign: '+='; +MinusAssign: '-='; +LeftShiftArithmeticAssign: '<<='; +RightShiftArithmeticAssign: '>>='; +RightShiftLogicalAssign: '>>>='; +BitAndAssign: '&='; +BitXorAssign: '^='; +BitOrAssign: '|='; +ARROW: '=>'; + +/// Null Literals + +NullLiteral: 'null'; + +/// Boolean Literals + +BooleanLiteral: 'true' + | 'false'; + +/// Numeric Literals + +DecimalLiteral: DecimalIntegerLiteral '.' [0-9]* ExponentPart? + | '.' [0-9]+ ExponentPart? + | DecimalIntegerLiteral ExponentPart? + ; + +/// Numeric Literals + +HexIntegerLiteral: '0' [xX] HexDigit+; +OctalIntegerLiteral: '0' [0-7]+ {!this.IsStrictMode()}?; +OctalIntegerLiteral2: '0' [oO] [0-7]+; +BinaryIntegerLiteral: '0' [bB] [01]+; + +/// Keywords + +Break: 'break'; +Do: 'do'; +Instanceof: 'instanceof'; +Typeof: 'typeof'; +Case: 'case'; +Else: 'else'; +New: 'new'; +Var: 'var'; +Catch: 'catch'; +Finally: 'finally'; +Return: 'return'; +Void: 'void'; +Continue: 'continue'; +For: 'for'; +Switch: 'switch'; +While: 'while'; +Debugger: 'debugger'; +Function_: 'function'; +This: 'this'; +With: 'with'; +Default: 'default'; +If: 'if'; +Throw: 'throw'; +Delete: 'delete'; +In: 'in'; +Try: 'try'; +As: 'as'; +From: 'from'; +ReadOnly: 'readonly'; +Async: 'async'; + +/// Future Reserved Words + +Class: 'class'; +Enum: 'enum'; +Extends: 'extends'; +Super: 'super'; +Const: 'const'; +Export: 'export'; +Import: 'import'; + +/// The following tokens are also considered to be FutureReservedWords +/// when parsing strict mode + +Implements: 'implements' ; +Let: 'let' ; +Private: 'private' ; +Public: 'public' ; +Interface: 'interface' ; +Package: 'package' ; +Protected: 'protected' ; +Static: 'static' ; +Yield: 'yield' ; + +//keywords: + +Any : 'any'; +Number: 'number'; +Boolean: 'boolean'; +String: 'string'; +Symbol: 'symbol'; + + +TypeAlias : 'type'; + +Get: 'get'; +Set: 'set'; + +Constructor: 'constructor'; +Namespace: 'namespace'; +Require: 'require'; +Module: 'module'; +Declare: 'declare'; + +Abstract: 'abstract'; + +Is: 'is'; + +// +// Ext.2 Additions to 1.8: Decorators +// +At: '@'; + +/// Identifier Names and Identifiers + +Identifier: IdentifierStart IdentifierPart*; + +/// String Literals +StringLiteral: ('"' DoubleStringCharacter* '"' + | '\'' SingleStringCharacter* '\'') {this.ProcessStringLiteral();} + ; + +BackTick: '`' {this.IncreaseTemplateDepth();} -> pushMode(TEMPLATE); + +WhiteSpaces: [\t\u000B\u000C\u0020\u00A0]+ -> channel(HIDDEN); + +LineTerminator: [\r\n\u2028\u2029] -> channel(HIDDEN); + +/// Comments + + +HtmlComment: '' -> channel(HIDDEN); +CDataComment: '' -> channel(HIDDEN); +UnexpectedCharacter: . -> channel(ERROR); + +mode TEMPLATE; + +TemplateStringEscapeAtom: '\\' .; +BackTickInside: '`' {this.DecreaseTemplateDepth();} -> type(BackTick), popMode; +TemplateStringStartExpression: '${' {this.StartTemplateString();} -> pushMode(DEFAULT_MODE); +TemplateStringAtom: ~[`\\]; + +// Fragment rules + +fragment DoubleStringCharacter + : ~["\\\r\n] + | '\\' EscapeSequence + | LineContinuation + ; + +fragment SingleStringCharacter + : ~['\\\r\n] + | '\\' EscapeSequence + | LineContinuation + ; + +fragment EscapeSequence + : CharacterEscapeSequence + | '0' // no digit ahead! TODO + | HexEscapeSequence + | UnicodeEscapeSequence + | ExtendedUnicodeEscapeSequence + ; + +fragment CharacterEscapeSequence + : SingleEscapeCharacter + | NonEscapeCharacter + ; + +fragment HexEscapeSequence + : 'x' HexDigit HexDigit + ; + +fragment UnicodeEscapeSequence + : 'u' HexDigit HexDigit HexDigit HexDigit + ; + +fragment ExtendedUnicodeEscapeSequence + : 'u' '{' HexDigit+ '}' + ; + +fragment SingleEscapeCharacter + : ['"\\bfnrtv] + ; + +fragment NonEscapeCharacter + : ~['"\\bfnrtv0-9xu\r\n] + ; + +fragment EscapeCharacter + : SingleEscapeCharacter + | [0-9] + | [xu] + ; + +fragment LineContinuation + : '\\' [\r\n\u2028\u2029] + ; + +fragment HexDigit + : [0-9a-fA-F] + ; + +fragment DecimalIntegerLiteral + : '0' + | [1-9] [0-9]* + ; + +fragment ExponentPart + : [eE] [+-]? [0-9]+ + ; + +fragment IdentifierPart + : IdentifierStart + | [\p{Mn}] + | [\p{Nd}] + | [\p{Pc}] + | '\u200C' + | '\u200D' + ; + +fragment IdentifierStart + : [\p{L}] + | [$_] + | '\\' UnicodeEscapeSequence + ; + +fragment RegularExpressionFirstChar + : ~[*\r\n\u2028\u2029\\/[] + | RegularExpressionBackslashSequence + | '[' RegularExpressionClassChar* ']' + ; + +fragment RegularExpressionChar + : ~[\r\n\u2028\u2029\\/[] + | RegularExpressionBackslashSequence + | '[' RegularExpressionClassChar* ']' + ; + +fragment RegularExpressionClassChar + : ~[\r\n\u2028\u2029\]\\] + | RegularExpressionBackslashSequence + ; + +fragment RegularExpressionBackslashSequence + : '\\' ~[\r\n\u2028\u2029] + ; diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.interp b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.interp new file mode 100644 index 0000000..0b64009 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.interp @@ -0,0 +1,444 @@ +token literal names: +null +null +null +null +'[' +']' +'(' +')' +'{' +null +'}' +';' +',' +'=' +'?' +':' +'...' +'.' +'++' +'--' +'+' +'-' +'~' +'!' +'*' +'/' +'%' +'>>' +'<<' +'>>>' +'<' +'>' +'<=' +'>=' +'==' +'!=' +'===' +'!==' +'&' +'^' +'|' +'&&' +'||' +'*=' +'/=' +'%=' +'+=' +'-=' +'<<=' +'>>=' +'>>>=' +'&=' +'^=' +'|=' +'=>' +'null' +null +null +null +null +null +null +'break' +'do' +'instanceof' +'typeof' +'case' +'else' +'new' +'var' +'catch' +'finally' +'return' +'void' +'continue' +'for' +'switch' +'while' +'debugger' +'function' +'this' +'with' +'default' +'if' +'throw' +'delete' +'in' +'try' +'as' +'from' +'readonly' +'async' +'class' +'enum' +'extends' +'super' +'const' +'export' +'import' +'implements' +'let' +'private' +'public' +'interface' +'package' +'protected' +'static' +'yield' +'any' +'number' +'boolean' +'string' +'symbol' +'type' +'get' +'set' +'constructor' +'namespace' +'require' +'module' +'declare' +'abstract' +'is' +'@' +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +MultiLineComment +SingleLineComment +RegularExpressionLiteral +OpenBracket +CloseBracket +OpenParen +CloseParen +OpenBrace +TemplateCloseBrace +CloseBrace +SemiColon +Comma +Assign +QuestionMark +Colon +Ellipsis +Dot +PlusPlus +MinusMinus +Plus +Minus +BitNot +Not +Multiply +Divide +Modulus +RightShiftArithmetic +LeftShiftArithmetic +RightShiftLogical +LessThan +MoreThan +LessThanEquals +GreaterThanEquals +Equals_ +NotEquals +IdentityEquals +IdentityNotEquals +BitAnd +BitXOr +BitOr +And +Or +MultiplyAssign +DivideAssign +ModulusAssign +PlusAssign +MinusAssign +LeftShiftArithmeticAssign +RightShiftArithmeticAssign +RightShiftLogicalAssign +BitAndAssign +BitXorAssign +BitOrAssign +ARROW +NullLiteral +BooleanLiteral +DecimalLiteral +HexIntegerLiteral +OctalIntegerLiteral +OctalIntegerLiteral2 +BinaryIntegerLiteral +Break +Do +Instanceof +Typeof +Case +Else +New +Var +Catch +Finally +Return +Void +Continue +For +Switch +While +Debugger +Function_ +This +With +Default +If +Throw +Delete +In +Try +As +From +ReadOnly +Async +Class +Enum +Extends +Super +Const +Export +Import +Implements +Let +Private +Public +Interface +Package +Protected +Static +Yield +Any +Number +Boolean +String +Symbol +TypeAlias +Get +Set +Constructor +Namespace +Require +Module +Declare +Abstract +Is +At +Identifier +StringLiteral +BackTick +WhiteSpaces +LineTerminator +HtmlComment +CDataComment +UnexpectedCharacter +TemplateStringEscapeAtom +TemplateStringStartExpression +TemplateStringAtom + +rule names: +MultiLineComment +SingleLineComment +RegularExpressionLiteral +OpenBracket +CloseBracket +OpenParen +CloseParen +OpenBrace +TemplateCloseBrace +CloseBrace +SemiColon +Comma +Assign +QuestionMark +Colon +Ellipsis +Dot +PlusPlus +MinusMinus +Plus +Minus +BitNot +Not +Multiply +Divide +Modulus +RightShiftArithmetic +LeftShiftArithmetic +RightShiftLogical +LessThan +MoreThan +LessThanEquals +GreaterThanEquals +Equals_ +NotEquals +IdentityEquals +IdentityNotEquals +BitAnd +BitXOr +BitOr +And +Or +MultiplyAssign +DivideAssign +ModulusAssign +PlusAssign +MinusAssign +LeftShiftArithmeticAssign +RightShiftArithmeticAssign +RightShiftLogicalAssign +BitAndAssign +BitXorAssign +BitOrAssign +ARROW +NullLiteral +BooleanLiteral +DecimalLiteral +HexIntegerLiteral +OctalIntegerLiteral +OctalIntegerLiteral2 +BinaryIntegerLiteral +Break +Do +Instanceof +Typeof +Case +Else +New +Var +Catch +Finally +Return +Void +Continue +For +Switch +While +Debugger +Function_ +This +With +Default +If +Throw +Delete +In +Try +As +From +ReadOnly +Async +Class +Enum +Extends +Super +Const +Export +Import +Implements +Let +Private +Public +Interface +Package +Protected +Static +Yield +Any +Number +Boolean +String +Symbol +TypeAlias +Get +Set +Constructor +Namespace +Require +Module +Declare +Abstract +Is +At +Identifier +StringLiteral +BackTick +WhiteSpaces +LineTerminator +HtmlComment +CDataComment +UnexpectedCharacter +TemplateStringEscapeAtom +BackTickInside +TemplateStringStartExpression +TemplateStringAtom +DoubleStringCharacter +SingleStringCharacter +EscapeSequence +CharacterEscapeSequence +HexEscapeSequence +UnicodeEscapeSequence +ExtendedUnicodeEscapeSequence +SingleEscapeCharacter +NonEscapeCharacter +EscapeCharacter +LineContinuation +HexDigit +DecimalIntegerLiteral +ExponentPart +IdentifierPart +IdentifierStart +RegularExpressionFirstChar +RegularExpressionChar +RegularExpressionClassChar +RegularExpressionBackslashSequence + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN +null +null +ERROR + +mode names: +DEFAULT_MODE +TEMPLATE + +atn: +[4, 0, 134, 1183, 6, -1, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 317, 8, 0, 10, 0, 12, 0, 320, 9, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 331, 8, 1, 10, 1, 12, 1, 334, 9, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 5, 2, 341, 8, 2, 10, 2, 12, 2, 344, 9, 2, 1, 2, 1, 2, 1, 2, 5, 2, 349, 8, 2, 10, 2, 12, 2, 352, 9, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 38, 1, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 509, 8, 55, 1, 56, 1, 56, 1, 56, 5, 56, 514, 8, 56, 10, 56, 12, 56, 517, 9, 56, 1, 56, 3, 56, 520, 8, 56, 1, 56, 1, 56, 4, 56, 524, 8, 56, 11, 56, 12, 56, 525, 1, 56, 3, 56, 529, 8, 56, 1, 56, 1, 56, 3, 56, 533, 8, 56, 3, 56, 535, 8, 56, 1, 57, 1, 57, 1, 57, 4, 57, 540, 8, 57, 11, 57, 12, 57, 541, 1, 58, 1, 58, 4, 58, 546, 8, 58, 11, 58, 12, 58, 547, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 4, 59, 555, 8, 59, 11, 59, 12, 59, 556, 1, 60, 1, 60, 1, 60, 4, 60, 562, 8, 60, 11, 60, 12, 60, 563, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 123, 1, 123, 5, 123, 968, 8, 123, 10, 123, 12, 123, 971, 9, 123, 1, 124, 1, 124, 5, 124, 975, 8, 124, 10, 124, 12, 124, 978, 9, 124, 1, 124, 1, 124, 1, 124, 5, 124, 983, 8, 124, 10, 124, 12, 124, 986, 9, 124, 1, 124, 3, 124, 989, 8, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 4, 126, 999, 8, 126, 11, 126, 12, 126, 1000, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 5, 128, 1015, 8, 128, 10, 128, 12, 128, 1018, 9, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 1037, 8, 129, 10, 129, 12, 129, 1040, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 1074, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 1080, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 1087, 8, 137, 1, 138, 1, 138, 3, 138, 1091, 8, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 4, 141, 1106, 8, 141, 11, 141, 12, 141, 1107, 1, 141, 1, 141, 1, 142, 1, 142, 1, 143, 1, 143, 1, 144, 1, 144, 3, 144, 1118, 8, 144, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 5, 147, 1128, 8, 147, 10, 147, 12, 147, 1131, 9, 147, 3, 147, 1133, 8, 147, 1, 148, 1, 148, 3, 148, 1137, 8, 148, 1, 148, 4, 148, 1140, 8, 148, 11, 148, 12, 148, 1141, 1, 149, 1, 149, 3, 149, 1146, 8, 149, 1, 150, 1, 150, 1, 150, 3, 150, 1151, 8, 150, 1, 151, 1, 151, 1, 151, 1, 151, 5, 151, 1157, 8, 151, 10, 151, 12, 151, 1160, 9, 151, 1, 151, 3, 151, 1163, 8, 151, 1, 152, 1, 152, 1, 152, 1, 152, 5, 152, 1169, 8, 152, 10, 152, 12, 152, 1172, 9, 152, 1, 152, 3, 152, 1175, 8, 152, 1, 153, 1, 153, 3, 153, 1179, 8, 153, 1, 154, 1, 154, 1, 154, 3, 318, 1016, 1038, 0, 155, 2, 1, 4, 2, 6, 3, 8, 4, 10, 5, 12, 6, 14, 7, 16, 8, 18, 9, 20, 10, 22, 11, 24, 12, 26, 13, 28, 14, 30, 15, 32, 16, 34, 17, 36, 18, 38, 19, 40, 20, 42, 21, 44, 22, 46, 23, 48, 24, 50, 25, 52, 26, 54, 27, 56, 28, 58, 29, 60, 30, 62, 31, 64, 32, 66, 33, 68, 34, 70, 35, 72, 36, 74, 37, 76, 38, 78, 39, 80, 40, 82, 41, 84, 42, 86, 43, 88, 44, 90, 45, 92, 46, 94, 47, 96, 48, 98, 49, 100, 50, 102, 51, 104, 52, 106, 53, 108, 54, 110, 55, 112, 56, 114, 57, 116, 58, 118, 59, 120, 60, 122, 61, 124, 62, 126, 63, 128, 64, 130, 65, 132, 66, 134, 67, 136, 68, 138, 69, 140, 70, 142, 71, 144, 72, 146, 73, 148, 74, 150, 75, 152, 76, 154, 77, 156, 78, 158, 79, 160, 80, 162, 81, 164, 82, 166, 83, 168, 84, 170, 85, 172, 86, 174, 87, 176, 88, 178, 89, 180, 90, 182, 91, 184, 92, 186, 93, 188, 94, 190, 95, 192, 96, 194, 97, 196, 98, 198, 99, 200, 100, 202, 101, 204, 102, 206, 103, 208, 104, 210, 105, 212, 106, 214, 107, 216, 108, 218, 109, 220, 110, 222, 111, 224, 112, 226, 113, 228, 114, 230, 115, 232, 116, 234, 117, 236, 118, 238, 119, 240, 120, 242, 121, 244, 122, 246, 123, 248, 124, 250, 125, 252, 126, 254, 127, 256, 128, 258, 129, 260, 130, 262, 131, 264, 132, 266, 0, 268, 133, 270, 134, 272, 0, 274, 0, 276, 0, 278, 0, 280, 0, 282, 0, 284, 0, 286, 0, 288, 0, 290, 0, 292, 0, 294, 0, 296, 0, 298, 0, 300, 0, 302, 0, 304, 0, 306, 0, 308, 0, 310, 0, 2, 0, 1, 23, 3, 0, 10, 10, 13, 13, 8232, 8233, 1, 0, 48, 57, 2, 0, 88, 88, 120, 120, 1, 0, 48, 55, 2, 0, 79, 79, 111, 111, 2, 0, 66, 66, 98, 98, 1, 0, 48, 49, 4, 0, 9, 9, 11, 12, 32, 32, 160, 160, 2, 0, 92, 92, 96, 96, 4, 0, 10, 10, 13, 13, 34, 34, 92, 92, 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 9, 0, 34, 34, 39, 39, 92, 92, 98, 98, 102, 102, 110, 110, 114, 114, 116, 116, 118, 118, 12, 0, 10, 10, 13, 13, 34, 34, 39, 39, 48, 57, 92, 92, 98, 98, 102, 102, 110, 110, 114, 114, 116, 118, 120, 120, 3, 0, 48, 57, 117, 117, 120, 120, 3, 0, 48, 57, 65, 70, 97, 102, 1, 0, 49, 57, 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 408, 0, 48, 57, 95, 95, 768, 879, 1155, 1159, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1552, 1562, 1611, 1641, 1648, 1648, 1750, 1756, 1759, 1764, 1767, 1768, 1770, 1773, 1776, 1785, 1809, 1809, 1840, 1866, 1958, 1968, 1984, 1993, 2027, 2035, 2045, 2045, 2070, 2073, 2075, 2083, 2085, 2087, 2089, 2093, 2137, 2139, 2200, 2207, 2250, 2273, 2275, 2306, 2362, 2362, 2364, 2364, 2369, 2376, 2381, 2381, 2385, 2391, 2402, 2403, 2406, 2415, 2433, 2433, 2492, 2492, 2497, 2500, 2509, 2509, 2530, 2531, 2534, 2543, 2558, 2558, 2561, 2562, 2620, 2620, 2625, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2662, 2673, 2677, 2677, 2689, 2690, 2748, 2748, 2753, 2757, 2759, 2760, 2765, 2765, 2786, 2787, 2790, 2799, 2810, 2815, 2817, 2817, 2876, 2876, 2879, 2879, 2881, 2884, 2893, 2893, 2901, 2902, 2914, 2915, 2918, 2927, 2946, 2946, 3008, 3008, 3021, 3021, 3046, 3055, 3072, 3072, 3076, 3076, 3132, 3132, 3134, 3136, 3142, 3144, 3146, 3149, 3157, 3158, 3170, 3171, 3174, 3183, 3201, 3201, 3260, 3260, 3263, 3263, 3270, 3270, 3276, 3277, 3298, 3299, 3302, 3311, 3328, 3329, 3387, 3388, 3393, 3396, 3405, 3405, 3426, 3427, 3430, 3439, 3457, 3457, 3530, 3530, 3538, 3540, 3542, 3542, 3558, 3567, 3633, 3633, 3636, 3642, 3655, 3662, 3664, 3673, 3761, 3761, 3764, 3772, 3784, 3790, 3792, 3801, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3953, 3966, 3968, 3972, 3974, 3975, 3981, 3991, 3993, 4028, 4038, 4038, 4141, 4144, 4146, 4151, 4153, 4154, 4157, 4158, 4160, 4169, 4184, 4185, 4190, 4192, 4209, 4212, 4226, 4226, 4229, 4230, 4237, 4237, 4240, 4249, 4253, 4253, 4957, 4959, 5906, 5908, 5938, 5939, 5970, 5971, 6002, 6003, 6068, 6069, 6071, 6077, 6086, 6086, 6089, 6099, 6109, 6109, 6112, 6121, 6155, 6157, 6159, 6169, 6277, 6278, 6313, 6313, 6432, 6434, 6439, 6440, 6450, 6450, 6457, 6459, 6470, 6479, 6608, 6617, 6679, 6680, 6683, 6683, 6742, 6742, 6744, 6750, 6752, 6752, 6754, 6754, 6757, 6764, 6771, 6780, 6783, 6793, 6800, 6809, 6832, 6845, 6847, 6862, 6912, 6915, 6964, 6964, 6966, 6970, 6972, 6972, 6978, 6978, 6992, 7001, 7019, 7027, 7040, 7041, 7074, 7077, 7080, 7081, 7083, 7085, 7088, 7097, 7142, 7142, 7144, 7145, 7149, 7149, 7151, 7153, 7212, 7219, 7222, 7223, 7232, 7241, 7248, 7257, 7376, 7378, 7380, 7392, 7394, 7400, 7405, 7405, 7412, 7412, 7416, 7417, 7616, 7679, 8204, 8205, 8255, 8256, 8276, 8276, 8400, 8412, 8417, 8417, 8421, 8432, 11503, 11505, 11647, 11647, 11744, 11775, 12330, 12333, 12441, 12442, 42528, 42537, 42607, 42607, 42612, 42621, 42654, 42655, 42736, 42737, 43010, 43010, 43014, 43014, 43019, 43019, 43045, 43046, 43052, 43052, 43204, 43205, 43216, 43225, 43232, 43249, 43263, 43273, 43302, 43309, 43335, 43345, 43392, 43394, 43443, 43443, 43446, 43449, 43452, 43453, 43472, 43481, 43493, 43493, 43504, 43513, 43561, 43566, 43569, 43570, 43573, 43574, 43587, 43587, 43596, 43596, 43600, 43609, 43644, 43644, 43696, 43696, 43698, 43700, 43703, 43704, 43710, 43711, 43713, 43713, 43756, 43757, 43766, 43766, 44005, 44005, 44008, 44008, 44013, 44013, 44016, 44025, 64286, 64286, 65024, 65039, 65056, 65071, 65075, 65076, 65101, 65103, 65296, 65305, 65343, 65343, 66045, 66045, 66272, 66272, 66422, 66426, 66720, 66729, 68097, 68099, 68101, 68102, 68108, 68111, 68152, 68154, 68159, 68159, 68325, 68326, 68900, 68903, 68912, 68921, 69291, 69292, 69373, 69375, 69446, 69456, 69506, 69509, 69633, 69633, 69688, 69702, 69734, 69744, 69747, 69748, 69759, 69761, 69811, 69814, 69817, 69818, 69826, 69826, 69872, 69881, 69888, 69890, 69927, 69931, 69933, 69940, 69942, 69951, 70003, 70003, 70016, 70017, 70070, 70078, 70089, 70092, 70095, 70105, 70191, 70193, 70196, 70196, 70198, 70199, 70206, 70206, 70209, 70209, 70367, 70367, 70371, 70378, 70384, 70393, 70400, 70401, 70459, 70460, 70464, 70464, 70502, 70508, 70512, 70516, 70712, 70719, 70722, 70724, 70726, 70726, 70736, 70745, 70750, 70750, 70835, 70840, 70842, 70842, 70847, 70848, 70850, 70851, 70864, 70873, 71090, 71093, 71100, 71101, 71103, 71104, 71132, 71133, 71219, 71226, 71229, 71229, 71231, 71232, 71248, 71257, 71339, 71339, 71341, 71341, 71344, 71349, 71351, 71351, 71360, 71369, 71453, 71455, 71458, 71461, 71463, 71467, 71472, 71481, 71727, 71735, 71737, 71738, 71904, 71913, 71995, 71996, 71998, 71998, 72003, 72003, 72016, 72025, 72148, 72151, 72154, 72155, 72160, 72160, 72193, 72202, 72243, 72248, 72251, 72254, 72263, 72263, 72273, 72278, 72281, 72283, 72330, 72342, 72344, 72345, 72752, 72758, 72760, 72765, 72767, 72767, 72784, 72793, 72850, 72871, 72874, 72880, 72882, 72883, 72885, 72886, 73009, 73014, 73018, 73018, 73020, 73021, 73023, 73029, 73031, 73031, 73040, 73049, 73104, 73105, 73109, 73109, 73111, 73111, 73120, 73129, 73459, 73460, 73472, 73473, 73526, 73530, 73536, 73536, 73538, 73538, 73552, 73561, 78912, 78912, 78919, 78933, 92768, 92777, 92864, 92873, 92912, 92916, 92976, 92982, 93008, 93017, 94031, 94031, 94095, 94098, 94180, 94180, 113821, 113822, 118528, 118573, 118576, 118598, 119143, 119145, 119163, 119170, 119173, 119179, 119210, 119213, 119362, 119364, 120782, 120831, 121344, 121398, 121403, 121452, 121461, 121461, 121476, 121476, 121499, 121503, 121505, 121519, 122880, 122886, 122888, 122904, 122907, 122913, 122915, 122916, 122918, 122922, 123023, 123023, 123184, 123190, 123200, 123209, 123566, 123566, 123628, 123641, 124140, 124153, 125136, 125142, 125252, 125258, 125264, 125273, 130032, 130041, 917760, 917999, 661, 0, 36, 36, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1488, 1514, 1519, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2144, 2154, 2160, 2183, 2185, 2190, 2208, 2249, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2432, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2556, 2556, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2809, 2809, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3133, 3160, 3162, 3165, 3165, 3168, 3169, 3200, 3200, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3293, 3294, 3296, 3297, 3313, 3314, 3332, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3412, 3414, 3423, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5873, 5880, 5888, 5905, 5919, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6264, 6272, 6276, 6279, 6312, 6314, 6314, 6320, 6389, 6400, 6430, 6480, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6988, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7401, 7404, 7406, 7411, 7413, 7414, 7418, 7418, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8579, 8580, 11264, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12294, 12337, 12341, 12347, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12735, 12784, 12799, 13312, 19903, 19968, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42653, 42656, 42725, 42775, 42783, 42786, 42888, 42891, 42954, 42960, 42961, 42963, 42963, 42965, 42969, 42994, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43261, 43262, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43488, 43492, 43494, 43503, 43514, 43518, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43646, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43881, 43888, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 66176, 66204, 66208, 66256, 66304, 66335, 66349, 66368, 66370, 66377, 66384, 66421, 66432, 66461, 66464, 66499, 66504, 66511, 66560, 66717, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 66928, 66938, 66940, 66954, 66956, 66962, 66964, 66965, 66967, 66977, 66979, 66993, 66995, 67001, 67003, 67004, 67072, 67382, 67392, 67413, 67424, 67431, 67456, 67461, 67463, 67504, 67506, 67514, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68096, 68112, 68115, 68117, 68119, 68121, 68149, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68324, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68899, 69248, 69289, 69296, 69297, 69376, 69404, 69415, 69415, 69424, 69445, 69488, 69505, 69552, 69572, 69600, 69622, 69635, 69687, 69745, 69746, 69749, 69749, 69763, 69807, 69840, 69864, 69891, 69926, 69956, 69956, 69959, 69959, 69968, 70002, 70006, 70006, 70019, 70066, 70081, 70084, 70106, 70106, 70108, 70108, 70144, 70161, 70163, 70187, 70207, 70208, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70366, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70461, 70461, 70480, 70480, 70493, 70497, 70656, 70708, 70727, 70730, 70751, 70753, 70784, 70831, 70852, 70853, 70855, 70855, 71040, 71086, 71128, 71131, 71168, 71215, 71236, 71236, 71296, 71338, 71352, 71352, 71424, 71450, 71488, 71494, 71680, 71723, 71840, 71903, 71935, 71942, 71945, 71945, 71948, 71955, 71957, 71958, 71960, 71983, 71999, 71999, 72001, 72001, 72096, 72103, 72106, 72144, 72161, 72161, 72163, 72163, 72192, 72192, 72203, 72242, 72250, 72250, 72272, 72272, 72284, 72329, 72349, 72349, 72368, 72440, 72704, 72712, 72714, 72750, 72768, 72768, 72818, 72847, 72960, 72966, 72968, 72969, 72971, 73008, 73030, 73030, 73056, 73061, 73063, 73064, 73066, 73097, 73112, 73112, 73440, 73458, 73474, 73474, 73476, 73488, 73490, 73523, 73648, 73648, 73728, 74649, 74880, 75075, 77712, 77808, 77824, 78895, 78913, 78918, 82944, 83526, 92160, 92728, 92736, 92766, 92784, 92862, 92880, 92909, 92928, 92975, 92992, 92995, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94032, 94032, 94099, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101589, 101632, 101640, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 122624, 122654, 122661, 122666, 122928, 122989, 123136, 123180, 123191, 123197, 123214, 123214, 123536, 123565, 123584, 123627, 124112, 124139, 124896, 124902, 124904, 124907, 124909, 124910, 124912, 124926, 124928, 125124, 125184, 125251, 125259, 125259, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173791, 173824, 177977, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101, 196608, 201546, 201552, 205743, 6, 0, 10, 10, 13, 13, 42, 42, 47, 47, 91, 92, 8232, 8233, 5, 0, 10, 10, 13, 13, 47, 47, 91, 92, 8232, 8233, 4, 0, 10, 10, 13, 13, 92, 93, 8232, 8233, 1208, 0, 2, 1, 0, 0, 0, 0, 4, 1, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 8, 1, 0, 0, 0, 0, 10, 1, 0, 0, 0, 0, 12, 1, 0, 0, 0, 0, 14, 1, 0, 0, 0, 0, 16, 1, 0, 0, 0, 0, 18, 1, 0, 0, 0, 0, 20, 1, 0, 0, 0, 0, 22, 1, 0, 0, 0, 0, 24, 1, 0, 0, 0, 0, 26, 1, 0, 0, 0, 0, 28, 1, 0, 0, 0, 0, 30, 1, 0, 0, 0, 0, 32, 1, 0, 0, 0, 0, 34, 1, 0, 0, 0, 0, 36, 1, 0, 0, 0, 0, 38, 1, 0, 0, 0, 0, 40, 1, 0, 0, 0, 0, 42, 1, 0, 0, 0, 0, 44, 1, 0, 0, 0, 0, 46, 1, 0, 0, 0, 0, 48, 1, 0, 0, 0, 0, 50, 1, 0, 0, 0, 0, 52, 1, 0, 0, 0, 0, 54, 1, 0, 0, 0, 0, 56, 1, 0, 0, 0, 0, 58, 1, 0, 0, 0, 0, 60, 1, 0, 0, 0, 0, 62, 1, 0, 0, 0, 0, 64, 1, 0, 0, 0, 0, 66, 1, 0, 0, 0, 0, 68, 1, 0, 0, 0, 0, 70, 1, 0, 0, 0, 0, 72, 1, 0, 0, 0, 0, 74, 1, 0, 0, 0, 0, 76, 1, 0, 0, 0, 0, 78, 1, 0, 0, 0, 0, 80, 1, 0, 0, 0, 0, 82, 1, 0, 0, 0, 0, 84, 1, 0, 0, 0, 0, 86, 1, 0, 0, 0, 0, 88, 1, 0, 0, 0, 0, 90, 1, 0, 0, 0, 0, 92, 1, 0, 0, 0, 0, 94, 1, 0, 0, 0, 0, 96, 1, 0, 0, 0, 0, 98, 1, 0, 0, 0, 0, 100, 1, 0, 0, 0, 0, 102, 1, 0, 0, 0, 0, 104, 1, 0, 0, 0, 0, 106, 1, 0, 0, 0, 0, 108, 1, 0, 0, 0, 0, 110, 1, 0, 0, 0, 0, 112, 1, 0, 0, 0, 0, 114, 1, 0, 0, 0, 0, 116, 1, 0, 0, 0, 0, 118, 1, 0, 0, 0, 0, 120, 1, 0, 0, 0, 0, 122, 1, 0, 0, 0, 0, 124, 1, 0, 0, 0, 0, 126, 1, 0, 0, 0, 0, 128, 1, 0, 0, 0, 0, 130, 1, 0, 0, 0, 0, 132, 1, 0, 0, 0, 0, 134, 1, 0, 0, 0, 0, 136, 1, 0, 0, 0, 0, 138, 1, 0, 0, 0, 0, 140, 1, 0, 0, 0, 0, 142, 1, 0, 0, 0, 0, 144, 1, 0, 0, 0, 0, 146, 1, 0, 0, 0, 0, 148, 1, 0, 0, 0, 0, 150, 1, 0, 0, 0, 0, 152, 1, 0, 0, 0, 0, 154, 1, 0, 0, 0, 0, 156, 1, 0, 0, 0, 0, 158, 1, 0, 0, 0, 0, 160, 1, 0, 0, 0, 0, 162, 1, 0, 0, 0, 0, 164, 1, 0, 0, 0, 0, 166, 1, 0, 0, 0, 0, 168, 1, 0, 0, 0, 0, 170, 1, 0, 0, 0, 0, 172, 1, 0, 0, 0, 0, 174, 1, 0, 0, 0, 0, 176, 1, 0, 0, 0, 0, 178, 1, 0, 0, 0, 0, 180, 1, 0, 0, 0, 0, 182, 1, 0, 0, 0, 0, 184, 1, 0, 0, 0, 0, 186, 1, 0, 0, 0, 0, 188, 1, 0, 0, 0, 0, 190, 1, 0, 0, 0, 0, 192, 1, 0, 0, 0, 0, 194, 1, 0, 0, 0, 0, 196, 1, 0, 0, 0, 0, 198, 1, 0, 0, 0, 0, 200, 1, 0, 0, 0, 0, 202, 1, 0, 0, 0, 0, 204, 1, 0, 0, 0, 0, 206, 1, 0, 0, 0, 0, 208, 1, 0, 0, 0, 0, 210, 1, 0, 0, 0, 0, 212, 1, 0, 0, 0, 0, 214, 1, 0, 0, 0, 0, 216, 1, 0, 0, 0, 0, 218, 1, 0, 0, 0, 0, 220, 1, 0, 0, 0, 0, 222, 1, 0, 0, 0, 0, 224, 1, 0, 0, 0, 0, 226, 1, 0, 0, 0, 0, 228, 1, 0, 0, 0, 0, 230, 1, 0, 0, 0, 0, 232, 1, 0, 0, 0, 0, 234, 1, 0, 0, 0, 0, 236, 1, 0, 0, 0, 0, 238, 1, 0, 0, 0, 0, 240, 1, 0, 0, 0, 0, 242, 1, 0, 0, 0, 0, 244, 1, 0, 0, 0, 0, 246, 1, 0, 0, 0, 0, 248, 1, 0, 0, 0, 0, 250, 1, 0, 0, 0, 0, 252, 1, 0, 0, 0, 0, 254, 1, 0, 0, 0, 0, 256, 1, 0, 0, 0, 0, 258, 1, 0, 0, 0, 0, 260, 1, 0, 0, 0, 0, 262, 1, 0, 0, 0, 1, 264, 1, 0, 0, 0, 1, 266, 1, 0, 0, 0, 1, 268, 1, 0, 0, 0, 1, 270, 1, 0, 0, 0, 2, 312, 1, 0, 0, 0, 4, 326, 1, 0, 0, 0, 6, 337, 1, 0, 0, 0, 8, 353, 1, 0, 0, 0, 10, 355, 1, 0, 0, 0, 12, 357, 1, 0, 0, 0, 14, 359, 1, 0, 0, 0, 16, 361, 1, 0, 0, 0, 18, 364, 1, 0, 0, 0, 20, 369, 1, 0, 0, 0, 22, 372, 1, 0, 0, 0, 24, 374, 1, 0, 0, 0, 26, 376, 1, 0, 0, 0, 28, 378, 1, 0, 0, 0, 30, 380, 1, 0, 0, 0, 32, 382, 1, 0, 0, 0, 34, 386, 1, 0, 0, 0, 36, 388, 1, 0, 0, 0, 38, 391, 1, 0, 0, 0, 40, 394, 1, 0, 0, 0, 42, 396, 1, 0, 0, 0, 44, 398, 1, 0, 0, 0, 46, 400, 1, 0, 0, 0, 48, 402, 1, 0, 0, 0, 50, 404, 1, 0, 0, 0, 52, 406, 1, 0, 0, 0, 54, 408, 1, 0, 0, 0, 56, 411, 1, 0, 0, 0, 58, 414, 1, 0, 0, 0, 60, 418, 1, 0, 0, 0, 62, 420, 1, 0, 0, 0, 64, 422, 1, 0, 0, 0, 66, 425, 1, 0, 0, 0, 68, 428, 1, 0, 0, 0, 70, 431, 1, 0, 0, 0, 72, 434, 1, 0, 0, 0, 74, 438, 1, 0, 0, 0, 76, 442, 1, 0, 0, 0, 78, 444, 1, 0, 0, 0, 80, 446, 1, 0, 0, 0, 82, 448, 1, 0, 0, 0, 84, 451, 1, 0, 0, 0, 86, 454, 1, 0, 0, 0, 88, 457, 1, 0, 0, 0, 90, 460, 1, 0, 0, 0, 92, 463, 1, 0, 0, 0, 94, 466, 1, 0, 0, 0, 96, 469, 1, 0, 0, 0, 98, 473, 1, 0, 0, 0, 100, 477, 1, 0, 0, 0, 102, 482, 1, 0, 0, 0, 104, 485, 1, 0, 0, 0, 106, 488, 1, 0, 0, 0, 108, 491, 1, 0, 0, 0, 110, 494, 1, 0, 0, 0, 112, 508, 1, 0, 0, 0, 114, 534, 1, 0, 0, 0, 116, 536, 1, 0, 0, 0, 118, 543, 1, 0, 0, 0, 120, 551, 1, 0, 0, 0, 122, 558, 1, 0, 0, 0, 124, 565, 1, 0, 0, 0, 126, 571, 1, 0, 0, 0, 128, 574, 1, 0, 0, 0, 130, 585, 1, 0, 0, 0, 132, 592, 1, 0, 0, 0, 134, 597, 1, 0, 0, 0, 136, 602, 1, 0, 0, 0, 138, 606, 1, 0, 0, 0, 140, 610, 1, 0, 0, 0, 142, 616, 1, 0, 0, 0, 144, 624, 1, 0, 0, 0, 146, 631, 1, 0, 0, 0, 148, 636, 1, 0, 0, 0, 150, 645, 1, 0, 0, 0, 152, 649, 1, 0, 0, 0, 154, 656, 1, 0, 0, 0, 156, 662, 1, 0, 0, 0, 158, 671, 1, 0, 0, 0, 160, 680, 1, 0, 0, 0, 162, 685, 1, 0, 0, 0, 164, 690, 1, 0, 0, 0, 166, 698, 1, 0, 0, 0, 168, 701, 1, 0, 0, 0, 170, 707, 1, 0, 0, 0, 172, 714, 1, 0, 0, 0, 174, 717, 1, 0, 0, 0, 176, 721, 1, 0, 0, 0, 178, 724, 1, 0, 0, 0, 180, 729, 1, 0, 0, 0, 182, 738, 1, 0, 0, 0, 184, 744, 1, 0, 0, 0, 186, 750, 1, 0, 0, 0, 188, 755, 1, 0, 0, 0, 190, 763, 1, 0, 0, 0, 192, 769, 1, 0, 0, 0, 194, 775, 1, 0, 0, 0, 196, 782, 1, 0, 0, 0, 198, 789, 1, 0, 0, 0, 200, 800, 1, 0, 0, 0, 202, 804, 1, 0, 0, 0, 204, 812, 1, 0, 0, 0, 206, 819, 1, 0, 0, 0, 208, 829, 1, 0, 0, 0, 210, 837, 1, 0, 0, 0, 212, 847, 1, 0, 0, 0, 214, 854, 1, 0, 0, 0, 216, 860, 1, 0, 0, 0, 218, 864, 1, 0, 0, 0, 220, 871, 1, 0, 0, 0, 222, 879, 1, 0, 0, 0, 224, 886, 1, 0, 0, 0, 226, 893, 1, 0, 0, 0, 228, 898, 1, 0, 0, 0, 230, 902, 1, 0, 0, 0, 232, 906, 1, 0, 0, 0, 234, 918, 1, 0, 0, 0, 236, 928, 1, 0, 0, 0, 238, 936, 1, 0, 0, 0, 240, 943, 1, 0, 0, 0, 242, 951, 1, 0, 0, 0, 244, 960, 1, 0, 0, 0, 246, 963, 1, 0, 0, 0, 248, 965, 1, 0, 0, 0, 250, 988, 1, 0, 0, 0, 252, 992, 1, 0, 0, 0, 254, 998, 1, 0, 0, 0, 256, 1004, 1, 0, 0, 0, 258, 1008, 1, 0, 0, 0, 260, 1025, 1, 0, 0, 0, 262, 1047, 1, 0, 0, 0, 264, 1051, 1, 0, 0, 0, 266, 1054, 1, 0, 0, 0, 268, 1060, 1, 0, 0, 0, 270, 1067, 1, 0, 0, 0, 272, 1073, 1, 0, 0, 0, 274, 1079, 1, 0, 0, 0, 276, 1086, 1, 0, 0, 0, 278, 1090, 1, 0, 0, 0, 280, 1092, 1, 0, 0, 0, 282, 1096, 1, 0, 0, 0, 284, 1102, 1, 0, 0, 0, 286, 1111, 1, 0, 0, 0, 288, 1113, 1, 0, 0, 0, 290, 1117, 1, 0, 0, 0, 292, 1119, 1, 0, 0, 0, 294, 1122, 1, 0, 0, 0, 296, 1132, 1, 0, 0, 0, 298, 1134, 1, 0, 0, 0, 300, 1145, 1, 0, 0, 0, 302, 1150, 1, 0, 0, 0, 304, 1162, 1, 0, 0, 0, 306, 1174, 1, 0, 0, 0, 308, 1178, 1, 0, 0, 0, 310, 1180, 1, 0, 0, 0, 312, 313, 5, 47, 0, 0, 313, 314, 5, 42, 0, 0, 314, 318, 1, 0, 0, 0, 315, 317, 9, 0, 0, 0, 316, 315, 1, 0, 0, 0, 317, 320, 1, 0, 0, 0, 318, 319, 1, 0, 0, 0, 318, 316, 1, 0, 0, 0, 319, 321, 1, 0, 0, 0, 320, 318, 1, 0, 0, 0, 321, 322, 5, 42, 0, 0, 322, 323, 5, 47, 0, 0, 323, 324, 1, 0, 0, 0, 324, 325, 6, 0, 0, 0, 325, 3, 1, 0, 0, 0, 326, 327, 5, 47, 0, 0, 327, 328, 5, 47, 0, 0, 328, 332, 1, 0, 0, 0, 329, 331, 8, 0, 0, 0, 330, 329, 1, 0, 0, 0, 331, 334, 1, 0, 0, 0, 332, 330, 1, 0, 0, 0, 332, 333, 1, 0, 0, 0, 333, 335, 1, 0, 0, 0, 334, 332, 1, 0, 0, 0, 335, 336, 6, 1, 0, 0, 336, 5, 1, 0, 0, 0, 337, 338, 5, 47, 0, 0, 338, 342, 3, 304, 151, 0, 339, 341, 3, 306, 152, 0, 340, 339, 1, 0, 0, 0, 341, 344, 1, 0, 0, 0, 342, 340, 1, 0, 0, 0, 342, 343, 1, 0, 0, 0, 343, 345, 1, 0, 0, 0, 344, 342, 1, 0, 0, 0, 345, 346, 4, 2, 0, 0, 346, 350, 5, 47, 0, 0, 347, 349, 3, 300, 149, 0, 348, 347, 1, 0, 0, 0, 349, 352, 1, 0, 0, 0, 350, 348, 1, 0, 0, 0, 350, 351, 1, 0, 0, 0, 351, 7, 1, 0, 0, 0, 352, 350, 1, 0, 0, 0, 353, 354, 5, 91, 0, 0, 354, 9, 1, 0, 0, 0, 355, 356, 5, 93, 0, 0, 356, 11, 1, 0, 0, 0, 357, 358, 5, 40, 0, 0, 358, 13, 1, 0, 0, 0, 359, 360, 5, 41, 0, 0, 360, 15, 1, 0, 0, 0, 361, 362, 5, 123, 0, 0, 362, 363, 6, 7, 1, 0, 363, 17, 1, 0, 0, 0, 364, 365, 4, 8, 1, 0, 365, 366, 5, 125, 0, 0, 366, 367, 1, 0, 0, 0, 367, 368, 6, 8, 2, 0, 368, 19, 1, 0, 0, 0, 369, 370, 5, 125, 0, 0, 370, 371, 6, 9, 3, 0, 371, 21, 1, 0, 0, 0, 372, 373, 5, 59, 0, 0, 373, 23, 1, 0, 0, 0, 374, 375, 5, 44, 0, 0, 375, 25, 1, 0, 0, 0, 376, 377, 5, 61, 0, 0, 377, 27, 1, 0, 0, 0, 378, 379, 5, 63, 0, 0, 379, 29, 1, 0, 0, 0, 380, 381, 5, 58, 0, 0, 381, 31, 1, 0, 0, 0, 382, 383, 5, 46, 0, 0, 383, 384, 5, 46, 0, 0, 384, 385, 5, 46, 0, 0, 385, 33, 1, 0, 0, 0, 386, 387, 5, 46, 0, 0, 387, 35, 1, 0, 0, 0, 388, 389, 5, 43, 0, 0, 389, 390, 5, 43, 0, 0, 390, 37, 1, 0, 0, 0, 391, 392, 5, 45, 0, 0, 392, 393, 5, 45, 0, 0, 393, 39, 1, 0, 0, 0, 394, 395, 5, 43, 0, 0, 395, 41, 1, 0, 0, 0, 396, 397, 5, 45, 0, 0, 397, 43, 1, 0, 0, 0, 398, 399, 5, 126, 0, 0, 399, 45, 1, 0, 0, 0, 400, 401, 5, 33, 0, 0, 401, 47, 1, 0, 0, 0, 402, 403, 5, 42, 0, 0, 403, 49, 1, 0, 0, 0, 404, 405, 5, 47, 0, 0, 405, 51, 1, 0, 0, 0, 406, 407, 5, 37, 0, 0, 407, 53, 1, 0, 0, 0, 408, 409, 5, 62, 0, 0, 409, 410, 5, 62, 0, 0, 410, 55, 1, 0, 0, 0, 411, 412, 5, 60, 0, 0, 412, 413, 5, 60, 0, 0, 413, 57, 1, 0, 0, 0, 414, 415, 5, 62, 0, 0, 415, 416, 5, 62, 0, 0, 416, 417, 5, 62, 0, 0, 417, 59, 1, 0, 0, 0, 418, 419, 5, 60, 0, 0, 419, 61, 1, 0, 0, 0, 420, 421, 5, 62, 0, 0, 421, 63, 1, 0, 0, 0, 422, 423, 5, 60, 0, 0, 423, 424, 5, 61, 0, 0, 424, 65, 1, 0, 0, 0, 425, 426, 5, 62, 0, 0, 426, 427, 5, 61, 0, 0, 427, 67, 1, 0, 0, 0, 428, 429, 5, 61, 0, 0, 429, 430, 5, 61, 0, 0, 430, 69, 1, 0, 0, 0, 431, 432, 5, 33, 0, 0, 432, 433, 5, 61, 0, 0, 433, 71, 1, 0, 0, 0, 434, 435, 5, 61, 0, 0, 435, 436, 5, 61, 0, 0, 436, 437, 5, 61, 0, 0, 437, 73, 1, 0, 0, 0, 438, 439, 5, 33, 0, 0, 439, 440, 5, 61, 0, 0, 440, 441, 5, 61, 0, 0, 441, 75, 1, 0, 0, 0, 442, 443, 5, 38, 0, 0, 443, 77, 1, 0, 0, 0, 444, 445, 5, 94, 0, 0, 445, 79, 1, 0, 0, 0, 446, 447, 5, 124, 0, 0, 447, 81, 1, 0, 0, 0, 448, 449, 5, 38, 0, 0, 449, 450, 5, 38, 0, 0, 450, 83, 1, 0, 0, 0, 451, 452, 5, 124, 0, 0, 452, 453, 5, 124, 0, 0, 453, 85, 1, 0, 0, 0, 454, 455, 5, 42, 0, 0, 455, 456, 5, 61, 0, 0, 456, 87, 1, 0, 0, 0, 457, 458, 5, 47, 0, 0, 458, 459, 5, 61, 0, 0, 459, 89, 1, 0, 0, 0, 460, 461, 5, 37, 0, 0, 461, 462, 5, 61, 0, 0, 462, 91, 1, 0, 0, 0, 463, 464, 5, 43, 0, 0, 464, 465, 5, 61, 0, 0, 465, 93, 1, 0, 0, 0, 466, 467, 5, 45, 0, 0, 467, 468, 5, 61, 0, 0, 468, 95, 1, 0, 0, 0, 469, 470, 5, 60, 0, 0, 470, 471, 5, 60, 0, 0, 471, 472, 5, 61, 0, 0, 472, 97, 1, 0, 0, 0, 473, 474, 5, 62, 0, 0, 474, 475, 5, 62, 0, 0, 475, 476, 5, 61, 0, 0, 476, 99, 1, 0, 0, 0, 477, 478, 5, 62, 0, 0, 478, 479, 5, 62, 0, 0, 479, 480, 5, 62, 0, 0, 480, 481, 5, 61, 0, 0, 481, 101, 1, 0, 0, 0, 482, 483, 5, 38, 0, 0, 483, 484, 5, 61, 0, 0, 484, 103, 1, 0, 0, 0, 485, 486, 5, 94, 0, 0, 486, 487, 5, 61, 0, 0, 487, 105, 1, 0, 0, 0, 488, 489, 5, 124, 0, 0, 489, 490, 5, 61, 0, 0, 490, 107, 1, 0, 0, 0, 491, 492, 5, 61, 0, 0, 492, 493, 5, 62, 0, 0, 493, 109, 1, 0, 0, 0, 494, 495, 5, 110, 0, 0, 495, 496, 5, 117, 0, 0, 496, 497, 5, 108, 0, 0, 497, 498, 5, 108, 0, 0, 498, 111, 1, 0, 0, 0, 499, 500, 5, 116, 0, 0, 500, 501, 5, 114, 0, 0, 501, 502, 5, 117, 0, 0, 502, 509, 5, 101, 0, 0, 503, 504, 5, 102, 0, 0, 504, 505, 5, 97, 0, 0, 505, 506, 5, 108, 0, 0, 506, 507, 5, 115, 0, 0, 507, 509, 5, 101, 0, 0, 508, 499, 1, 0, 0, 0, 508, 503, 1, 0, 0, 0, 509, 113, 1, 0, 0, 0, 510, 511, 3, 296, 147, 0, 511, 515, 5, 46, 0, 0, 512, 514, 7, 1, 0, 0, 513, 512, 1, 0, 0, 0, 514, 517, 1, 0, 0, 0, 515, 513, 1, 0, 0, 0, 515, 516, 1, 0, 0, 0, 516, 519, 1, 0, 0, 0, 517, 515, 1, 0, 0, 0, 518, 520, 3, 298, 148, 0, 519, 518, 1, 0, 0, 0, 519, 520, 1, 0, 0, 0, 520, 535, 1, 0, 0, 0, 521, 523, 5, 46, 0, 0, 522, 524, 7, 1, 0, 0, 523, 522, 1, 0, 0, 0, 524, 525, 1, 0, 0, 0, 525, 523, 1, 0, 0, 0, 525, 526, 1, 0, 0, 0, 526, 528, 1, 0, 0, 0, 527, 529, 3, 298, 148, 0, 528, 527, 1, 0, 0, 0, 528, 529, 1, 0, 0, 0, 529, 535, 1, 0, 0, 0, 530, 532, 3, 296, 147, 0, 531, 533, 3, 298, 148, 0, 532, 531, 1, 0, 0, 0, 532, 533, 1, 0, 0, 0, 533, 535, 1, 0, 0, 0, 534, 510, 1, 0, 0, 0, 534, 521, 1, 0, 0, 0, 534, 530, 1, 0, 0, 0, 535, 115, 1, 0, 0, 0, 536, 537, 5, 48, 0, 0, 537, 539, 7, 2, 0, 0, 538, 540, 3, 294, 146, 0, 539, 538, 1, 0, 0, 0, 540, 541, 1, 0, 0, 0, 541, 539, 1, 0, 0, 0, 541, 542, 1, 0, 0, 0, 542, 117, 1, 0, 0, 0, 543, 545, 5, 48, 0, 0, 544, 546, 7, 3, 0, 0, 545, 544, 1, 0, 0, 0, 546, 547, 1, 0, 0, 0, 547, 545, 1, 0, 0, 0, 547, 548, 1, 0, 0, 0, 548, 549, 1, 0, 0, 0, 549, 550, 4, 58, 2, 0, 550, 119, 1, 0, 0, 0, 551, 552, 5, 48, 0, 0, 552, 554, 7, 4, 0, 0, 553, 555, 7, 3, 0, 0, 554, 553, 1, 0, 0, 0, 555, 556, 1, 0, 0, 0, 556, 554, 1, 0, 0, 0, 556, 557, 1, 0, 0, 0, 557, 121, 1, 0, 0, 0, 558, 559, 5, 48, 0, 0, 559, 561, 7, 5, 0, 0, 560, 562, 7, 6, 0, 0, 561, 560, 1, 0, 0, 0, 562, 563, 1, 0, 0, 0, 563, 561, 1, 0, 0, 0, 563, 564, 1, 0, 0, 0, 564, 123, 1, 0, 0, 0, 565, 566, 5, 98, 0, 0, 566, 567, 5, 114, 0, 0, 567, 568, 5, 101, 0, 0, 568, 569, 5, 97, 0, 0, 569, 570, 5, 107, 0, 0, 570, 125, 1, 0, 0, 0, 571, 572, 5, 100, 0, 0, 572, 573, 5, 111, 0, 0, 573, 127, 1, 0, 0, 0, 574, 575, 5, 105, 0, 0, 575, 576, 5, 110, 0, 0, 576, 577, 5, 115, 0, 0, 577, 578, 5, 116, 0, 0, 578, 579, 5, 97, 0, 0, 579, 580, 5, 110, 0, 0, 580, 581, 5, 99, 0, 0, 581, 582, 5, 101, 0, 0, 582, 583, 5, 111, 0, 0, 583, 584, 5, 102, 0, 0, 584, 129, 1, 0, 0, 0, 585, 586, 5, 116, 0, 0, 586, 587, 5, 121, 0, 0, 587, 588, 5, 112, 0, 0, 588, 589, 5, 101, 0, 0, 589, 590, 5, 111, 0, 0, 590, 591, 5, 102, 0, 0, 591, 131, 1, 0, 0, 0, 592, 593, 5, 99, 0, 0, 593, 594, 5, 97, 0, 0, 594, 595, 5, 115, 0, 0, 595, 596, 5, 101, 0, 0, 596, 133, 1, 0, 0, 0, 597, 598, 5, 101, 0, 0, 598, 599, 5, 108, 0, 0, 599, 600, 5, 115, 0, 0, 600, 601, 5, 101, 0, 0, 601, 135, 1, 0, 0, 0, 602, 603, 5, 110, 0, 0, 603, 604, 5, 101, 0, 0, 604, 605, 5, 119, 0, 0, 605, 137, 1, 0, 0, 0, 606, 607, 5, 118, 0, 0, 607, 608, 5, 97, 0, 0, 608, 609, 5, 114, 0, 0, 609, 139, 1, 0, 0, 0, 610, 611, 5, 99, 0, 0, 611, 612, 5, 97, 0, 0, 612, 613, 5, 116, 0, 0, 613, 614, 5, 99, 0, 0, 614, 615, 5, 104, 0, 0, 615, 141, 1, 0, 0, 0, 616, 617, 5, 102, 0, 0, 617, 618, 5, 105, 0, 0, 618, 619, 5, 110, 0, 0, 619, 620, 5, 97, 0, 0, 620, 621, 5, 108, 0, 0, 621, 622, 5, 108, 0, 0, 622, 623, 5, 121, 0, 0, 623, 143, 1, 0, 0, 0, 624, 625, 5, 114, 0, 0, 625, 626, 5, 101, 0, 0, 626, 627, 5, 116, 0, 0, 627, 628, 5, 117, 0, 0, 628, 629, 5, 114, 0, 0, 629, 630, 5, 110, 0, 0, 630, 145, 1, 0, 0, 0, 631, 632, 5, 118, 0, 0, 632, 633, 5, 111, 0, 0, 633, 634, 5, 105, 0, 0, 634, 635, 5, 100, 0, 0, 635, 147, 1, 0, 0, 0, 636, 637, 5, 99, 0, 0, 637, 638, 5, 111, 0, 0, 638, 639, 5, 110, 0, 0, 639, 640, 5, 116, 0, 0, 640, 641, 5, 105, 0, 0, 641, 642, 5, 110, 0, 0, 642, 643, 5, 117, 0, 0, 643, 644, 5, 101, 0, 0, 644, 149, 1, 0, 0, 0, 645, 646, 5, 102, 0, 0, 646, 647, 5, 111, 0, 0, 647, 648, 5, 114, 0, 0, 648, 151, 1, 0, 0, 0, 649, 650, 5, 115, 0, 0, 650, 651, 5, 119, 0, 0, 651, 652, 5, 105, 0, 0, 652, 653, 5, 116, 0, 0, 653, 654, 5, 99, 0, 0, 654, 655, 5, 104, 0, 0, 655, 153, 1, 0, 0, 0, 656, 657, 5, 119, 0, 0, 657, 658, 5, 104, 0, 0, 658, 659, 5, 105, 0, 0, 659, 660, 5, 108, 0, 0, 660, 661, 5, 101, 0, 0, 661, 155, 1, 0, 0, 0, 662, 663, 5, 100, 0, 0, 663, 664, 5, 101, 0, 0, 664, 665, 5, 98, 0, 0, 665, 666, 5, 117, 0, 0, 666, 667, 5, 103, 0, 0, 667, 668, 5, 103, 0, 0, 668, 669, 5, 101, 0, 0, 669, 670, 5, 114, 0, 0, 670, 157, 1, 0, 0, 0, 671, 672, 5, 102, 0, 0, 672, 673, 5, 117, 0, 0, 673, 674, 5, 110, 0, 0, 674, 675, 5, 99, 0, 0, 675, 676, 5, 116, 0, 0, 676, 677, 5, 105, 0, 0, 677, 678, 5, 111, 0, 0, 678, 679, 5, 110, 0, 0, 679, 159, 1, 0, 0, 0, 680, 681, 5, 116, 0, 0, 681, 682, 5, 104, 0, 0, 682, 683, 5, 105, 0, 0, 683, 684, 5, 115, 0, 0, 684, 161, 1, 0, 0, 0, 685, 686, 5, 119, 0, 0, 686, 687, 5, 105, 0, 0, 687, 688, 5, 116, 0, 0, 688, 689, 5, 104, 0, 0, 689, 163, 1, 0, 0, 0, 690, 691, 5, 100, 0, 0, 691, 692, 5, 101, 0, 0, 692, 693, 5, 102, 0, 0, 693, 694, 5, 97, 0, 0, 694, 695, 5, 117, 0, 0, 695, 696, 5, 108, 0, 0, 696, 697, 5, 116, 0, 0, 697, 165, 1, 0, 0, 0, 698, 699, 5, 105, 0, 0, 699, 700, 5, 102, 0, 0, 700, 167, 1, 0, 0, 0, 701, 702, 5, 116, 0, 0, 702, 703, 5, 104, 0, 0, 703, 704, 5, 114, 0, 0, 704, 705, 5, 111, 0, 0, 705, 706, 5, 119, 0, 0, 706, 169, 1, 0, 0, 0, 707, 708, 5, 100, 0, 0, 708, 709, 5, 101, 0, 0, 709, 710, 5, 108, 0, 0, 710, 711, 5, 101, 0, 0, 711, 712, 5, 116, 0, 0, 712, 713, 5, 101, 0, 0, 713, 171, 1, 0, 0, 0, 714, 715, 5, 105, 0, 0, 715, 716, 5, 110, 0, 0, 716, 173, 1, 0, 0, 0, 717, 718, 5, 116, 0, 0, 718, 719, 5, 114, 0, 0, 719, 720, 5, 121, 0, 0, 720, 175, 1, 0, 0, 0, 721, 722, 5, 97, 0, 0, 722, 723, 5, 115, 0, 0, 723, 177, 1, 0, 0, 0, 724, 725, 5, 102, 0, 0, 725, 726, 5, 114, 0, 0, 726, 727, 5, 111, 0, 0, 727, 728, 5, 109, 0, 0, 728, 179, 1, 0, 0, 0, 729, 730, 5, 114, 0, 0, 730, 731, 5, 101, 0, 0, 731, 732, 5, 97, 0, 0, 732, 733, 5, 100, 0, 0, 733, 734, 5, 111, 0, 0, 734, 735, 5, 110, 0, 0, 735, 736, 5, 108, 0, 0, 736, 737, 5, 121, 0, 0, 737, 181, 1, 0, 0, 0, 738, 739, 5, 97, 0, 0, 739, 740, 5, 115, 0, 0, 740, 741, 5, 121, 0, 0, 741, 742, 5, 110, 0, 0, 742, 743, 5, 99, 0, 0, 743, 183, 1, 0, 0, 0, 744, 745, 5, 99, 0, 0, 745, 746, 5, 108, 0, 0, 746, 747, 5, 97, 0, 0, 747, 748, 5, 115, 0, 0, 748, 749, 5, 115, 0, 0, 749, 185, 1, 0, 0, 0, 750, 751, 5, 101, 0, 0, 751, 752, 5, 110, 0, 0, 752, 753, 5, 117, 0, 0, 753, 754, 5, 109, 0, 0, 754, 187, 1, 0, 0, 0, 755, 756, 5, 101, 0, 0, 756, 757, 5, 120, 0, 0, 757, 758, 5, 116, 0, 0, 758, 759, 5, 101, 0, 0, 759, 760, 5, 110, 0, 0, 760, 761, 5, 100, 0, 0, 761, 762, 5, 115, 0, 0, 762, 189, 1, 0, 0, 0, 763, 764, 5, 115, 0, 0, 764, 765, 5, 117, 0, 0, 765, 766, 5, 112, 0, 0, 766, 767, 5, 101, 0, 0, 767, 768, 5, 114, 0, 0, 768, 191, 1, 0, 0, 0, 769, 770, 5, 99, 0, 0, 770, 771, 5, 111, 0, 0, 771, 772, 5, 110, 0, 0, 772, 773, 5, 115, 0, 0, 773, 774, 5, 116, 0, 0, 774, 193, 1, 0, 0, 0, 775, 776, 5, 101, 0, 0, 776, 777, 5, 120, 0, 0, 777, 778, 5, 112, 0, 0, 778, 779, 5, 111, 0, 0, 779, 780, 5, 114, 0, 0, 780, 781, 5, 116, 0, 0, 781, 195, 1, 0, 0, 0, 782, 783, 5, 105, 0, 0, 783, 784, 5, 109, 0, 0, 784, 785, 5, 112, 0, 0, 785, 786, 5, 111, 0, 0, 786, 787, 5, 114, 0, 0, 787, 788, 5, 116, 0, 0, 788, 197, 1, 0, 0, 0, 789, 790, 5, 105, 0, 0, 790, 791, 5, 109, 0, 0, 791, 792, 5, 112, 0, 0, 792, 793, 5, 108, 0, 0, 793, 794, 5, 101, 0, 0, 794, 795, 5, 109, 0, 0, 795, 796, 5, 101, 0, 0, 796, 797, 5, 110, 0, 0, 797, 798, 5, 116, 0, 0, 798, 799, 5, 115, 0, 0, 799, 199, 1, 0, 0, 0, 800, 801, 5, 108, 0, 0, 801, 802, 5, 101, 0, 0, 802, 803, 5, 116, 0, 0, 803, 201, 1, 0, 0, 0, 804, 805, 5, 112, 0, 0, 805, 806, 5, 114, 0, 0, 806, 807, 5, 105, 0, 0, 807, 808, 5, 118, 0, 0, 808, 809, 5, 97, 0, 0, 809, 810, 5, 116, 0, 0, 810, 811, 5, 101, 0, 0, 811, 203, 1, 0, 0, 0, 812, 813, 5, 112, 0, 0, 813, 814, 5, 117, 0, 0, 814, 815, 5, 98, 0, 0, 815, 816, 5, 108, 0, 0, 816, 817, 5, 105, 0, 0, 817, 818, 5, 99, 0, 0, 818, 205, 1, 0, 0, 0, 819, 820, 5, 105, 0, 0, 820, 821, 5, 110, 0, 0, 821, 822, 5, 116, 0, 0, 822, 823, 5, 101, 0, 0, 823, 824, 5, 114, 0, 0, 824, 825, 5, 102, 0, 0, 825, 826, 5, 97, 0, 0, 826, 827, 5, 99, 0, 0, 827, 828, 5, 101, 0, 0, 828, 207, 1, 0, 0, 0, 829, 830, 5, 112, 0, 0, 830, 831, 5, 97, 0, 0, 831, 832, 5, 99, 0, 0, 832, 833, 5, 107, 0, 0, 833, 834, 5, 97, 0, 0, 834, 835, 5, 103, 0, 0, 835, 836, 5, 101, 0, 0, 836, 209, 1, 0, 0, 0, 837, 838, 5, 112, 0, 0, 838, 839, 5, 114, 0, 0, 839, 840, 5, 111, 0, 0, 840, 841, 5, 116, 0, 0, 841, 842, 5, 101, 0, 0, 842, 843, 5, 99, 0, 0, 843, 844, 5, 116, 0, 0, 844, 845, 5, 101, 0, 0, 845, 846, 5, 100, 0, 0, 846, 211, 1, 0, 0, 0, 847, 848, 5, 115, 0, 0, 848, 849, 5, 116, 0, 0, 849, 850, 5, 97, 0, 0, 850, 851, 5, 116, 0, 0, 851, 852, 5, 105, 0, 0, 852, 853, 5, 99, 0, 0, 853, 213, 1, 0, 0, 0, 854, 855, 5, 121, 0, 0, 855, 856, 5, 105, 0, 0, 856, 857, 5, 101, 0, 0, 857, 858, 5, 108, 0, 0, 858, 859, 5, 100, 0, 0, 859, 215, 1, 0, 0, 0, 860, 861, 5, 97, 0, 0, 861, 862, 5, 110, 0, 0, 862, 863, 5, 121, 0, 0, 863, 217, 1, 0, 0, 0, 864, 865, 5, 110, 0, 0, 865, 866, 5, 117, 0, 0, 866, 867, 5, 109, 0, 0, 867, 868, 5, 98, 0, 0, 868, 869, 5, 101, 0, 0, 869, 870, 5, 114, 0, 0, 870, 219, 1, 0, 0, 0, 871, 872, 5, 98, 0, 0, 872, 873, 5, 111, 0, 0, 873, 874, 5, 111, 0, 0, 874, 875, 5, 108, 0, 0, 875, 876, 5, 101, 0, 0, 876, 877, 5, 97, 0, 0, 877, 878, 5, 110, 0, 0, 878, 221, 1, 0, 0, 0, 879, 880, 5, 115, 0, 0, 880, 881, 5, 116, 0, 0, 881, 882, 5, 114, 0, 0, 882, 883, 5, 105, 0, 0, 883, 884, 5, 110, 0, 0, 884, 885, 5, 103, 0, 0, 885, 223, 1, 0, 0, 0, 886, 887, 5, 115, 0, 0, 887, 888, 5, 121, 0, 0, 888, 889, 5, 109, 0, 0, 889, 890, 5, 98, 0, 0, 890, 891, 5, 111, 0, 0, 891, 892, 5, 108, 0, 0, 892, 225, 1, 0, 0, 0, 893, 894, 5, 116, 0, 0, 894, 895, 5, 121, 0, 0, 895, 896, 5, 112, 0, 0, 896, 897, 5, 101, 0, 0, 897, 227, 1, 0, 0, 0, 898, 899, 5, 103, 0, 0, 899, 900, 5, 101, 0, 0, 900, 901, 5, 116, 0, 0, 901, 229, 1, 0, 0, 0, 902, 903, 5, 115, 0, 0, 903, 904, 5, 101, 0, 0, 904, 905, 5, 116, 0, 0, 905, 231, 1, 0, 0, 0, 906, 907, 5, 99, 0, 0, 907, 908, 5, 111, 0, 0, 908, 909, 5, 110, 0, 0, 909, 910, 5, 115, 0, 0, 910, 911, 5, 116, 0, 0, 911, 912, 5, 114, 0, 0, 912, 913, 5, 117, 0, 0, 913, 914, 5, 99, 0, 0, 914, 915, 5, 116, 0, 0, 915, 916, 5, 111, 0, 0, 916, 917, 5, 114, 0, 0, 917, 233, 1, 0, 0, 0, 918, 919, 5, 110, 0, 0, 919, 920, 5, 97, 0, 0, 920, 921, 5, 109, 0, 0, 921, 922, 5, 101, 0, 0, 922, 923, 5, 115, 0, 0, 923, 924, 5, 112, 0, 0, 924, 925, 5, 97, 0, 0, 925, 926, 5, 99, 0, 0, 926, 927, 5, 101, 0, 0, 927, 235, 1, 0, 0, 0, 928, 929, 5, 114, 0, 0, 929, 930, 5, 101, 0, 0, 930, 931, 5, 113, 0, 0, 931, 932, 5, 117, 0, 0, 932, 933, 5, 105, 0, 0, 933, 934, 5, 114, 0, 0, 934, 935, 5, 101, 0, 0, 935, 237, 1, 0, 0, 0, 936, 937, 5, 109, 0, 0, 937, 938, 5, 111, 0, 0, 938, 939, 5, 100, 0, 0, 939, 940, 5, 117, 0, 0, 940, 941, 5, 108, 0, 0, 941, 942, 5, 101, 0, 0, 942, 239, 1, 0, 0, 0, 943, 944, 5, 100, 0, 0, 944, 945, 5, 101, 0, 0, 945, 946, 5, 99, 0, 0, 946, 947, 5, 108, 0, 0, 947, 948, 5, 97, 0, 0, 948, 949, 5, 114, 0, 0, 949, 950, 5, 101, 0, 0, 950, 241, 1, 0, 0, 0, 951, 952, 5, 97, 0, 0, 952, 953, 5, 98, 0, 0, 953, 954, 5, 115, 0, 0, 954, 955, 5, 116, 0, 0, 955, 956, 5, 114, 0, 0, 956, 957, 5, 97, 0, 0, 957, 958, 5, 99, 0, 0, 958, 959, 5, 116, 0, 0, 959, 243, 1, 0, 0, 0, 960, 961, 5, 105, 0, 0, 961, 962, 5, 115, 0, 0, 962, 245, 1, 0, 0, 0, 963, 964, 5, 64, 0, 0, 964, 247, 1, 0, 0, 0, 965, 969, 3, 302, 150, 0, 966, 968, 3, 300, 149, 0, 967, 966, 1, 0, 0, 0, 968, 971, 1, 0, 0, 0, 969, 967, 1, 0, 0, 0, 969, 970, 1, 0, 0, 0, 970, 249, 1, 0, 0, 0, 971, 969, 1, 0, 0, 0, 972, 976, 5, 34, 0, 0, 973, 975, 3, 272, 135, 0, 974, 973, 1, 0, 0, 0, 975, 978, 1, 0, 0, 0, 976, 974, 1, 0, 0, 0, 976, 977, 1, 0, 0, 0, 977, 979, 1, 0, 0, 0, 978, 976, 1, 0, 0, 0, 979, 989, 5, 34, 0, 0, 980, 984, 5, 39, 0, 0, 981, 983, 3, 274, 136, 0, 982, 981, 1, 0, 0, 0, 983, 986, 1, 0, 0, 0, 984, 982, 1, 0, 0, 0, 984, 985, 1, 0, 0, 0, 985, 987, 1, 0, 0, 0, 986, 984, 1, 0, 0, 0, 987, 989, 5, 39, 0, 0, 988, 972, 1, 0, 0, 0, 988, 980, 1, 0, 0, 0, 989, 990, 1, 0, 0, 0, 990, 991, 6, 124, 4, 0, 991, 251, 1, 0, 0, 0, 992, 993, 5, 96, 0, 0, 993, 994, 6, 125, 5, 0, 994, 995, 1, 0, 0, 0, 995, 996, 6, 125, 6, 0, 996, 253, 1, 0, 0, 0, 997, 999, 7, 7, 0, 0, 998, 997, 1, 0, 0, 0, 999, 1000, 1, 0, 0, 0, 1000, 998, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 1002, 1, 0, 0, 0, 1002, 1003, 6, 126, 0, 0, 1003, 255, 1, 0, 0, 0, 1004, 1005, 7, 0, 0, 0, 1005, 1006, 1, 0, 0, 0, 1006, 1007, 6, 127, 0, 0, 1007, 257, 1, 0, 0, 0, 1008, 1009, 5, 60, 0, 0, 1009, 1010, 5, 33, 0, 0, 1010, 1011, 5, 45, 0, 0, 1011, 1012, 5, 45, 0, 0, 1012, 1016, 1, 0, 0, 0, 1013, 1015, 9, 0, 0, 0, 1014, 1013, 1, 0, 0, 0, 1015, 1018, 1, 0, 0, 0, 1016, 1017, 1, 0, 0, 0, 1016, 1014, 1, 0, 0, 0, 1017, 1019, 1, 0, 0, 0, 1018, 1016, 1, 0, 0, 0, 1019, 1020, 5, 45, 0, 0, 1020, 1021, 5, 45, 0, 0, 1021, 1022, 5, 62, 0, 0, 1022, 1023, 1, 0, 0, 0, 1023, 1024, 6, 128, 0, 0, 1024, 259, 1, 0, 0, 0, 1025, 1026, 5, 60, 0, 0, 1026, 1027, 5, 33, 0, 0, 1027, 1028, 5, 91, 0, 0, 1028, 1029, 5, 67, 0, 0, 1029, 1030, 5, 68, 0, 0, 1030, 1031, 5, 65, 0, 0, 1031, 1032, 5, 84, 0, 0, 1032, 1033, 5, 65, 0, 0, 1033, 1034, 5, 91, 0, 0, 1034, 1038, 1, 0, 0, 0, 1035, 1037, 9, 0, 0, 0, 1036, 1035, 1, 0, 0, 0, 1037, 1040, 1, 0, 0, 0, 1038, 1039, 1, 0, 0, 0, 1038, 1036, 1, 0, 0, 0, 1039, 1041, 1, 0, 0, 0, 1040, 1038, 1, 0, 0, 0, 1041, 1042, 5, 93, 0, 0, 1042, 1043, 5, 93, 0, 0, 1043, 1044, 5, 62, 0, 0, 1044, 1045, 1, 0, 0, 0, 1045, 1046, 6, 129, 0, 0, 1046, 261, 1, 0, 0, 0, 1047, 1048, 9, 0, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, 1050, 6, 130, 7, 0, 1050, 263, 1, 0, 0, 0, 1051, 1052, 5, 92, 0, 0, 1052, 1053, 9, 0, 0, 0, 1053, 265, 1, 0, 0, 0, 1054, 1055, 5, 96, 0, 0, 1055, 1056, 6, 132, 8, 0, 1056, 1057, 1, 0, 0, 0, 1057, 1058, 6, 132, 9, 0, 1058, 1059, 6, 132, 2, 0, 1059, 267, 1, 0, 0, 0, 1060, 1061, 5, 36, 0, 0, 1061, 1062, 5, 123, 0, 0, 1062, 1063, 1, 0, 0, 0, 1063, 1064, 6, 133, 10, 0, 1064, 1065, 1, 0, 0, 0, 1065, 1066, 6, 133, 11, 0, 1066, 269, 1, 0, 0, 0, 1067, 1068, 8, 8, 0, 0, 1068, 271, 1, 0, 0, 0, 1069, 1074, 8, 9, 0, 0, 1070, 1071, 5, 92, 0, 0, 1071, 1074, 3, 276, 137, 0, 1072, 1074, 3, 292, 145, 0, 1073, 1069, 1, 0, 0, 0, 1073, 1070, 1, 0, 0, 0, 1073, 1072, 1, 0, 0, 0, 1074, 273, 1, 0, 0, 0, 1075, 1080, 8, 10, 0, 0, 1076, 1077, 5, 92, 0, 0, 1077, 1080, 3, 276, 137, 0, 1078, 1080, 3, 292, 145, 0, 1079, 1075, 1, 0, 0, 0, 1079, 1076, 1, 0, 0, 0, 1079, 1078, 1, 0, 0, 0, 1080, 275, 1, 0, 0, 0, 1081, 1087, 3, 278, 138, 0, 1082, 1087, 5, 48, 0, 0, 1083, 1087, 3, 280, 139, 0, 1084, 1087, 3, 282, 140, 0, 1085, 1087, 3, 284, 141, 0, 1086, 1081, 1, 0, 0, 0, 1086, 1082, 1, 0, 0, 0, 1086, 1083, 1, 0, 0, 0, 1086, 1084, 1, 0, 0, 0, 1086, 1085, 1, 0, 0, 0, 1087, 277, 1, 0, 0, 0, 1088, 1091, 3, 286, 142, 0, 1089, 1091, 3, 288, 143, 0, 1090, 1088, 1, 0, 0, 0, 1090, 1089, 1, 0, 0, 0, 1091, 279, 1, 0, 0, 0, 1092, 1093, 5, 120, 0, 0, 1093, 1094, 3, 294, 146, 0, 1094, 1095, 3, 294, 146, 0, 1095, 281, 1, 0, 0, 0, 1096, 1097, 5, 117, 0, 0, 1097, 1098, 3, 294, 146, 0, 1098, 1099, 3, 294, 146, 0, 1099, 1100, 3, 294, 146, 0, 1100, 1101, 3, 294, 146, 0, 1101, 283, 1, 0, 0, 0, 1102, 1103, 5, 117, 0, 0, 1103, 1105, 5, 123, 0, 0, 1104, 1106, 3, 294, 146, 0, 1105, 1104, 1, 0, 0, 0, 1106, 1107, 1, 0, 0, 0, 1107, 1105, 1, 0, 0, 0, 1107, 1108, 1, 0, 0, 0, 1108, 1109, 1, 0, 0, 0, 1109, 1110, 5, 125, 0, 0, 1110, 285, 1, 0, 0, 0, 1111, 1112, 7, 11, 0, 0, 1112, 287, 1, 0, 0, 0, 1113, 1114, 8, 12, 0, 0, 1114, 289, 1, 0, 0, 0, 1115, 1118, 3, 286, 142, 0, 1116, 1118, 7, 13, 0, 0, 1117, 1115, 1, 0, 0, 0, 1117, 1116, 1, 0, 0, 0, 1118, 291, 1, 0, 0, 0, 1119, 1120, 5, 92, 0, 0, 1120, 1121, 7, 0, 0, 0, 1121, 293, 1, 0, 0, 0, 1122, 1123, 7, 14, 0, 0, 1123, 295, 1, 0, 0, 0, 1124, 1133, 5, 48, 0, 0, 1125, 1129, 7, 15, 0, 0, 1126, 1128, 7, 1, 0, 0, 1127, 1126, 1, 0, 0, 0, 1128, 1131, 1, 0, 0, 0, 1129, 1127, 1, 0, 0, 0, 1129, 1130, 1, 0, 0, 0, 1130, 1133, 1, 0, 0, 0, 1131, 1129, 1, 0, 0, 0, 1132, 1124, 1, 0, 0, 0, 1132, 1125, 1, 0, 0, 0, 1133, 297, 1, 0, 0, 0, 1134, 1136, 7, 16, 0, 0, 1135, 1137, 7, 17, 0, 0, 1136, 1135, 1, 0, 0, 0, 1136, 1137, 1, 0, 0, 0, 1137, 1139, 1, 0, 0, 0, 1138, 1140, 7, 1, 0, 0, 1139, 1138, 1, 0, 0, 0, 1140, 1141, 1, 0, 0, 0, 1141, 1139, 1, 0, 0, 0, 1141, 1142, 1, 0, 0, 0, 1142, 299, 1, 0, 0, 0, 1143, 1146, 3, 302, 150, 0, 1144, 1146, 7, 18, 0, 0, 1145, 1143, 1, 0, 0, 0, 1145, 1144, 1, 0, 0, 0, 1146, 301, 1, 0, 0, 0, 1147, 1151, 7, 19, 0, 0, 1148, 1149, 5, 92, 0, 0, 1149, 1151, 3, 282, 140, 0, 1150, 1147, 1, 0, 0, 0, 1150, 1148, 1, 0, 0, 0, 1151, 303, 1, 0, 0, 0, 1152, 1163, 8, 20, 0, 0, 1153, 1163, 3, 310, 154, 0, 1154, 1158, 5, 91, 0, 0, 1155, 1157, 3, 308, 153, 0, 1156, 1155, 1, 0, 0, 0, 1157, 1160, 1, 0, 0, 0, 1158, 1156, 1, 0, 0, 0, 1158, 1159, 1, 0, 0, 0, 1159, 1161, 1, 0, 0, 0, 1160, 1158, 1, 0, 0, 0, 1161, 1163, 5, 93, 0, 0, 1162, 1152, 1, 0, 0, 0, 1162, 1153, 1, 0, 0, 0, 1162, 1154, 1, 0, 0, 0, 1163, 305, 1, 0, 0, 0, 1164, 1175, 8, 21, 0, 0, 1165, 1175, 3, 310, 154, 0, 1166, 1170, 5, 91, 0, 0, 1167, 1169, 3, 308, 153, 0, 1168, 1167, 1, 0, 0, 0, 1169, 1172, 1, 0, 0, 0, 1170, 1168, 1, 0, 0, 0, 1170, 1171, 1, 0, 0, 0, 1171, 1173, 1, 0, 0, 0, 1172, 1170, 1, 0, 0, 0, 1173, 1175, 5, 93, 0, 0, 1174, 1164, 1, 0, 0, 0, 1174, 1165, 1, 0, 0, 0, 1174, 1166, 1, 0, 0, 0, 1175, 307, 1, 0, 0, 0, 1176, 1179, 8, 22, 0, 0, 1177, 1179, 3, 310, 154, 0, 1178, 1176, 1, 0, 0, 0, 1178, 1177, 1, 0, 0, 0, 1179, 309, 1, 0, 0, 0, 1180, 1181, 5, 92, 0, 0, 1181, 1182, 8, 0, 0, 0, 1182, 311, 1, 0, 0, 0, 41, 0, 1, 318, 332, 342, 350, 508, 515, 519, 525, 528, 532, 534, 541, 547, 556, 563, 969, 976, 984, 988, 1000, 1016, 1038, 1073, 1079, 1086, 1090, 1107, 1117, 1129, 1132, 1136, 1141, 1145, 1150, 1158, 1162, 1170, 1174, 1178, 12, 0, 1, 0, 1, 7, 0, 4, 0, 0, 1, 9, 1, 1, 124, 2, 1, 125, 3, 5, 1, 0, 0, 2, 0, 1, 132, 4, 7, 126, 0, 1, 133, 5, 5, 0, 0] \ No newline at end of file diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.java b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.java new file mode 100644 index 0000000..1c8bb39 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.java @@ -0,0 +1,1309 @@ +// Generated from /www/p_java/babylon/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.g4 by ANTLR 4.13.1 +package one.edee.babylon.export.ts.gen; +import one.edee.babylon.export.ts.TypeScriptLexerBase; +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class TypeScriptLexer extends TypeScriptLexerBase { + static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + MultiLineComment=1, SingleLineComment=2, RegularExpressionLiteral=3, OpenBracket=4, + CloseBracket=5, OpenParen=6, CloseParen=7, OpenBrace=8, TemplateCloseBrace=9, + CloseBrace=10, SemiColon=11, Comma=12, Assign=13, QuestionMark=14, Colon=15, + Ellipsis=16, Dot=17, PlusPlus=18, MinusMinus=19, Plus=20, Minus=21, BitNot=22, + Not=23, Multiply=24, Divide=25, Modulus=26, RightShiftArithmetic=27, LeftShiftArithmetic=28, + RightShiftLogical=29, LessThan=30, MoreThan=31, LessThanEquals=32, GreaterThanEquals=33, + Equals_=34, NotEquals=35, IdentityEquals=36, IdentityNotEquals=37, BitAnd=38, + BitXOr=39, BitOr=40, And=41, Or=42, MultiplyAssign=43, DivideAssign=44, + ModulusAssign=45, PlusAssign=46, MinusAssign=47, LeftShiftArithmeticAssign=48, + RightShiftArithmeticAssign=49, RightShiftLogicalAssign=50, BitAndAssign=51, + BitXorAssign=52, BitOrAssign=53, ARROW=54, NullLiteral=55, BooleanLiteral=56, + DecimalLiteral=57, HexIntegerLiteral=58, OctalIntegerLiteral=59, OctalIntegerLiteral2=60, + BinaryIntegerLiteral=61, Break=62, Do=63, Instanceof=64, Typeof=65, Case=66, + Else=67, New=68, Var=69, Catch=70, Finally=71, Return=72, Void=73, Continue=74, + For=75, Switch=76, While=77, Debugger=78, Function_=79, This=80, With=81, + Default=82, If=83, Throw=84, Delete=85, In=86, Try=87, As=88, From=89, + ReadOnly=90, Async=91, Class=92, Enum=93, Extends=94, Super=95, Const=96, + Export=97, Import=98, Implements=99, Let=100, Private=101, Public=102, + Interface=103, Package=104, Protected=105, Static=106, Yield=107, Any=108, + Number=109, Boolean=110, String=111, Symbol=112, TypeAlias=113, Get=114, + Set=115, Constructor=116, Namespace=117, Require=118, Module=119, Declare=120, + Abstract=121, Is=122, At=123, Identifier=124, StringLiteral=125, BackTick=126, + WhiteSpaces=127, LineTerminator=128, HtmlComment=129, CDataComment=130, + UnexpectedCharacter=131, TemplateStringEscapeAtom=132, TemplateStringStartExpression=133, + TemplateStringAtom=134; + public static final int + ERROR=2; + public static final int + TEMPLATE=1; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", "ERROR" + }; + + public static String[] modeNames = { + "DEFAULT_MODE", "TEMPLATE" + }; + + private static String[] makeRuleNames() { + return new String[] { + "MultiLineComment", "SingleLineComment", "RegularExpressionLiteral", + "OpenBracket", "CloseBracket", "OpenParen", "CloseParen", "OpenBrace", + "TemplateCloseBrace", "CloseBrace", "SemiColon", "Comma", "Assign", "QuestionMark", + "Colon", "Ellipsis", "Dot", "PlusPlus", "MinusMinus", "Plus", "Minus", + "BitNot", "Not", "Multiply", "Divide", "Modulus", "RightShiftArithmetic", + "LeftShiftArithmetic", "RightShiftLogical", "LessThan", "MoreThan", "LessThanEquals", + "GreaterThanEquals", "Equals_", "NotEquals", "IdentityEquals", "IdentityNotEquals", + "BitAnd", "BitXOr", "BitOr", "And", "Or", "MultiplyAssign", "DivideAssign", + "ModulusAssign", "PlusAssign", "MinusAssign", "LeftShiftArithmeticAssign", + "RightShiftArithmeticAssign", "RightShiftLogicalAssign", "BitAndAssign", + "BitXorAssign", "BitOrAssign", "ARROW", "NullLiteral", "BooleanLiteral", + "DecimalLiteral", "HexIntegerLiteral", "OctalIntegerLiteral", "OctalIntegerLiteral2", + "BinaryIntegerLiteral", "Break", "Do", "Instanceof", "Typeof", "Case", + "Else", "New", "Var", "Catch", "Finally", "Return", "Void", "Continue", + "For", "Switch", "While", "Debugger", "Function_", "This", "With", "Default", + "If", "Throw", "Delete", "In", "Try", "As", "From", "ReadOnly", "Async", + "Class", "Enum", "Extends", "Super", "Const", "Export", "Import", "Implements", + "Let", "Private", "Public", "Interface", "Package", "Protected", "Static", + "Yield", "Any", "Number", "Boolean", "String", "Symbol", "TypeAlias", + "Get", "Set", "Constructor", "Namespace", "Require", "Module", "Declare", + "Abstract", "Is", "At", "Identifier", "StringLiteral", "BackTick", "WhiteSpaces", + "LineTerminator", "HtmlComment", "CDataComment", "UnexpectedCharacter", + "TemplateStringEscapeAtom", "BackTickInside", "TemplateStringStartExpression", + "TemplateStringAtom", "DoubleStringCharacter", "SingleStringCharacter", + "EscapeSequence", "CharacterEscapeSequence", "HexEscapeSequence", "UnicodeEscapeSequence", + "ExtendedUnicodeEscapeSequence", "SingleEscapeCharacter", "NonEscapeCharacter", + "EscapeCharacter", "LineContinuation", "HexDigit", "DecimalIntegerLiteral", + "ExponentPart", "IdentifierPart", "IdentifierStart", "RegularExpressionFirstChar", + "RegularExpressionChar", "RegularExpressionClassChar", "RegularExpressionBackslashSequence" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, null, null, null, "'['", "']'", "'('", "')'", "'{'", null, "'}'", + "';'", "','", "'='", "'?'", "':'", "'...'", "'.'", "'++'", "'--'", "'+'", + "'-'", "'~'", "'!'", "'*'", "'/'", "'%'", "'>>'", "'<<'", "'>>>'", "'<'", + "'>'", "'<='", "'>='", "'=='", "'!='", "'==='", "'!=='", "'&'", "'^'", + "'|'", "'&&'", "'||'", "'*='", "'/='", "'%='", "'+='", "'-='", "'<<='", + "'>>='", "'>>>='", "'&='", "'^='", "'|='", "'=>'", "'null'", null, null, + null, null, null, null, "'break'", "'do'", "'instanceof'", "'typeof'", + "'case'", "'else'", "'new'", "'var'", "'catch'", "'finally'", "'return'", + "'void'", "'continue'", "'for'", "'switch'", "'while'", "'debugger'", + "'function'", "'this'", "'with'", "'default'", "'if'", "'throw'", "'delete'", + "'in'", "'try'", "'as'", "'from'", "'readonly'", "'async'", "'class'", + "'enum'", "'extends'", "'super'", "'const'", "'export'", "'import'", + "'implements'", "'let'", "'private'", "'public'", "'interface'", "'package'", + "'protected'", "'static'", "'yield'", "'any'", "'number'", "'boolean'", + "'string'", "'symbol'", "'type'", "'get'", "'set'", "'constructor'", + "'namespace'", "'require'", "'module'", "'declare'", "'abstract'", "'is'", + "'@'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "MultiLineComment", "SingleLineComment", "RegularExpressionLiteral", + "OpenBracket", "CloseBracket", "OpenParen", "CloseParen", "OpenBrace", + "TemplateCloseBrace", "CloseBrace", "SemiColon", "Comma", "Assign", "QuestionMark", + "Colon", "Ellipsis", "Dot", "PlusPlus", "MinusMinus", "Plus", "Minus", + "BitNot", "Not", "Multiply", "Divide", "Modulus", "RightShiftArithmetic", + "LeftShiftArithmetic", "RightShiftLogical", "LessThan", "MoreThan", "LessThanEquals", + "GreaterThanEquals", "Equals_", "NotEquals", "IdentityEquals", "IdentityNotEquals", + "BitAnd", "BitXOr", "BitOr", "And", "Or", "MultiplyAssign", "DivideAssign", + "ModulusAssign", "PlusAssign", "MinusAssign", "LeftShiftArithmeticAssign", + "RightShiftArithmeticAssign", "RightShiftLogicalAssign", "BitAndAssign", + "BitXorAssign", "BitOrAssign", "ARROW", "NullLiteral", "BooleanLiteral", + "DecimalLiteral", "HexIntegerLiteral", "OctalIntegerLiteral", "OctalIntegerLiteral2", + "BinaryIntegerLiteral", "Break", "Do", "Instanceof", "Typeof", "Case", + "Else", "New", "Var", "Catch", "Finally", "Return", "Void", "Continue", + "For", "Switch", "While", "Debugger", "Function_", "This", "With", "Default", + "If", "Throw", "Delete", "In", "Try", "As", "From", "ReadOnly", "Async", + "Class", "Enum", "Extends", "Super", "Const", "Export", "Import", "Implements", + "Let", "Private", "Public", "Interface", "Package", "Protected", "Static", + "Yield", "Any", "Number", "Boolean", "String", "Symbol", "TypeAlias", + "Get", "Set", "Constructor", "Namespace", "Require", "Module", "Declare", + "Abstract", "Is", "At", "Identifier", "StringLiteral", "BackTick", "WhiteSpaces", + "LineTerminator", "HtmlComment", "CDataComment", "UnexpectedCharacter", + "TemplateStringEscapeAtom", "TemplateStringStartExpression", "TemplateStringAtom" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public TypeScriptLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "TypeScriptLexer.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getChannelNames() { return channelNames; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + @Override + public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { + switch (ruleIndex) { + case 7: + OpenBrace_action((RuleContext)_localctx, actionIndex); + break; + case 9: + CloseBrace_action((RuleContext)_localctx, actionIndex); + break; + case 124: + StringLiteral_action((RuleContext)_localctx, actionIndex); + break; + case 125: + BackTick_action((RuleContext)_localctx, actionIndex); + break; + case 132: + BackTickInside_action((RuleContext)_localctx, actionIndex); + break; + case 133: + TemplateStringStartExpression_action((RuleContext)_localctx, actionIndex); + break; + } + } + private void OpenBrace_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 0: + this.ProcessOpenBrace(); + break; + } + } + private void CloseBrace_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 1: + this.ProcessCloseBrace(); + break; + } + } + private void StringLiteral_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 2: + this.ProcessStringLiteral(); + break; + } + } + private void BackTick_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 3: + this.IncreaseTemplateDepth(); + break; + } + } + private void BackTickInside_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 4: + this.DecreaseTemplateDepth(); + break; + } + } + private void TemplateStringStartExpression_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 5: + this.StartTemplateString(); + break; + } + } + @Override + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 2: + return RegularExpressionLiteral_sempred((RuleContext)_localctx, predIndex); + case 8: + return TemplateCloseBrace_sempred((RuleContext)_localctx, predIndex); + case 58: + return OctalIntegerLiteral_sempred((RuleContext)_localctx, predIndex); + } + return true; + } + private boolean RegularExpressionLiteral_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return this.IsRegexPossible(); + } + return true; + } + private boolean TemplateCloseBrace_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 1: + return this.IsInTemplateString(); + } + return true; + } + private boolean OctalIntegerLiteral_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 2: + return !this.IsStrictMode(); + } + return true; + } + + public static final String _serializedATN = + "\u0004\u0000\u0086\u049f\u0006\uffff\uffff\u0006\uffff\uffff\u0002\u0000"+ + "\u0007\u0000\u0002\u0001\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003"+ + "\u0007\u0003\u0002\u0004\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006"+ + "\u0007\u0006\u0002\u0007\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002"+ + "\n\u0007\n\u0002\u000b\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002"+ + "\u000e\u0007\u000e\u0002\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002"+ + "\u0011\u0007\u0011\u0002\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002"+ + "\u0014\u0007\u0014\u0002\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002"+ + "\u0017\u0007\u0017\u0002\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002"+ + "\u001a\u0007\u001a\u0002\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002"+ + "\u001d\u0007\u001d\u0002\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002"+ + " \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002"+ + "%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002"+ + "*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002"+ + "/\u0007/\u00020\u00070\u00021\u00071\u00022\u00072\u00023\u00073\u0002"+ + "4\u00074\u00025\u00075\u00026\u00076\u00027\u00077\u00028\u00078\u0002"+ + "9\u00079\u0002:\u0007:\u0002;\u0007;\u0002<\u0007<\u0002=\u0007=\u0002"+ + ">\u0007>\u0002?\u0007?\u0002@\u0007@\u0002A\u0007A\u0002B\u0007B\u0002"+ + "C\u0007C\u0002D\u0007D\u0002E\u0007E\u0002F\u0007F\u0002G\u0007G\u0002"+ + "H\u0007H\u0002I\u0007I\u0002J\u0007J\u0002K\u0007K\u0002L\u0007L\u0002"+ + "M\u0007M\u0002N\u0007N\u0002O\u0007O\u0002P\u0007P\u0002Q\u0007Q\u0002"+ + "R\u0007R\u0002S\u0007S\u0002T\u0007T\u0002U\u0007U\u0002V\u0007V\u0002"+ + "W\u0007W\u0002X\u0007X\u0002Y\u0007Y\u0002Z\u0007Z\u0002[\u0007[\u0002"+ + "\\\u0007\\\u0002]\u0007]\u0002^\u0007^\u0002_\u0007_\u0002`\u0007`\u0002"+ + "a\u0007a\u0002b\u0007b\u0002c\u0007c\u0002d\u0007d\u0002e\u0007e\u0002"+ + "f\u0007f\u0002g\u0007g\u0002h\u0007h\u0002i\u0007i\u0002j\u0007j\u0002"+ + "k\u0007k\u0002l\u0007l\u0002m\u0007m\u0002n\u0007n\u0002o\u0007o\u0002"+ + "p\u0007p\u0002q\u0007q\u0002r\u0007r\u0002s\u0007s\u0002t\u0007t\u0002"+ + "u\u0007u\u0002v\u0007v\u0002w\u0007w\u0002x\u0007x\u0002y\u0007y\u0002"+ + "z\u0007z\u0002{\u0007{\u0002|\u0007|\u0002}\u0007}\u0002~\u0007~\u0002"+ + "\u007f\u0007\u007f\u0002\u0080\u0007\u0080\u0002\u0081\u0007\u0081\u0002"+ + "\u0082\u0007\u0082\u0002\u0083\u0007\u0083\u0002\u0084\u0007\u0084\u0002"+ + "\u0085\u0007\u0085\u0002\u0086\u0007\u0086\u0002\u0087\u0007\u0087\u0002"+ + "\u0088\u0007\u0088\u0002\u0089\u0007\u0089\u0002\u008a\u0007\u008a\u0002"+ + "\u008b\u0007\u008b\u0002\u008c\u0007\u008c\u0002\u008d\u0007\u008d\u0002"+ + "\u008e\u0007\u008e\u0002\u008f\u0007\u008f\u0002\u0090\u0007\u0090\u0002"+ + "\u0091\u0007\u0091\u0002\u0092\u0007\u0092\u0002\u0093\u0007\u0093\u0002"+ + "\u0094\u0007\u0094\u0002\u0095\u0007\u0095\u0002\u0096\u0007\u0096\u0002"+ + "\u0097\u0007\u0097\u0002\u0098\u0007\u0098\u0002\u0099\u0007\u0099\u0002"+ + "\u009a\u0007\u009a\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0005"+ + "\u0000\u013d\b\u0000\n\u0000\f\u0000\u0140\t\u0000\u0001\u0000\u0001\u0000"+ + "\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001"+ + "\u0001\u0001\u0005\u0001\u014b\b\u0001\n\u0001\f\u0001\u014e\t\u0001\u0001"+ + "\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0005\u0002\u0155"+ + "\b\u0002\n\u0002\f\u0002\u0158\t\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+ + "\u0005\u0002\u015d\b\u0002\n\u0002\f\u0002\u0160\t\u0002\u0001\u0003\u0001"+ + "\u0003\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0006\u0001"+ + "\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0001"+ + "\b\u0001\b\u0001\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001\u000b\u0001\u000b"+ + "\u0001\f\u0001\f\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000f\u0001"+ + "\u000f\u0001\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0011\u0001"+ + "\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001"+ + "\u0013\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015\u0001\u0016\u0001"+ + "\u0016\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0019\u0001"+ + "\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001"+ + "\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001d\u0001"+ + "\u001d\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001"+ + " \u0001 \u0001 \u0001!\u0001!\u0001!\u0001\"\u0001\"\u0001\"\u0001#\u0001"+ + "#\u0001#\u0001#\u0001$\u0001$\u0001$\u0001$\u0001%\u0001%\u0001&\u0001"+ + "&\u0001\'\u0001\'\u0001(\u0001(\u0001(\u0001)\u0001)\u0001)\u0001*\u0001"+ + "*\u0001*\u0001+\u0001+\u0001+\u0001,\u0001,\u0001,\u0001-\u0001-\u0001"+ + "-\u0001.\u0001.\u0001.\u0001/\u0001/\u0001/\u0001/\u00010\u00010\u0001"+ + "0\u00010\u00011\u00011\u00011\u00011\u00011\u00012\u00012\u00012\u0001"+ + "3\u00013\u00013\u00014\u00014\u00014\u00015\u00015\u00015\u00016\u0001"+ + "6\u00016\u00016\u00016\u00017\u00017\u00017\u00017\u00017\u00017\u0001"+ + "7\u00017\u00017\u00037\u01fd\b7\u00018\u00018\u00018\u00058\u0202\b8\n"+ + "8\f8\u0205\t8\u00018\u00038\u0208\b8\u00018\u00018\u00048\u020c\b8\u000b"+ + "8\f8\u020d\u00018\u00038\u0211\b8\u00018\u00018\u00038\u0215\b8\u0003"+ + "8\u0217\b8\u00019\u00019\u00019\u00049\u021c\b9\u000b9\f9\u021d\u0001"+ + ":\u0001:\u0004:\u0222\b:\u000b:\f:\u0223\u0001:\u0001:\u0001;\u0001;\u0001"+ + ";\u0004;\u022b\b;\u000b;\f;\u022c\u0001<\u0001<\u0001<\u0004<\u0232\b"+ + "<\u000b<\f<\u0233\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001>\u0001"+ + ">\u0001>\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001"+ + "?\u0001?\u0001?\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001"+ + "A\u0001A\u0001A\u0001A\u0001A\u0001B\u0001B\u0001B\u0001B\u0001B\u0001"+ + "C\u0001C\u0001C\u0001C\u0001D\u0001D\u0001D\u0001D\u0001E\u0001E\u0001"+ + "E\u0001E\u0001E\u0001E\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+ + "F\u0001F\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001H\u0001"+ + "H\u0001H\u0001H\u0001H\u0001I\u0001I\u0001I\u0001I\u0001I\u0001I\u0001"+ + "I\u0001I\u0001I\u0001J\u0001J\u0001J\u0001J\u0001K\u0001K\u0001K\u0001"+ + "K\u0001K\u0001K\u0001K\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001"+ + "M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001N\u0001"+ + "N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001O\u0001O\u0001"+ + "O\u0001O\u0001O\u0001P\u0001P\u0001P\u0001P\u0001P\u0001Q\u0001Q\u0001"+ + "Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001R\u0001R\u0001R\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0001T\u0001T\u0001T\u0001T\u0001T\u0001"+ + "T\u0001T\u0001U\u0001U\u0001U\u0001V\u0001V\u0001V\u0001V\u0001W\u0001"+ + "W\u0001W\u0001X\u0001X\u0001X\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0001"+ + "Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Z\u0001Z\u0001Z\u0001Z\u0001"+ + "Z\u0001Z\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001_\u0001_\u0001_\u0001"+ + "_\u0001_\u0001_\u0001`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001"+ + "a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001b\u0001b\u0001b\u0001"+ + "b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001c\u0001c\u0001"+ + "c\u0001c\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001"+ + "e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001f\u0001f\u0001f\u0001"+ + "f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001g\u0001g\u0001g\u0001"+ + "g\u0001g\u0001g\u0001g\u0001g\u0001h\u0001h\u0001h\u0001h\u0001h\u0001"+ + "h\u0001h\u0001h\u0001h\u0001h\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+ + "i\u0001i\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001k\u0001k\u0001"+ + "k\u0001k\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001m\u0001"+ + "m\u0001m\u0001m\u0001m\u0001m\u0001m\u0001m\u0001n\u0001n\u0001n\u0001"+ + "n\u0001n\u0001n\u0001n\u0001o\u0001o\u0001o\u0001o\u0001o\u0001o\u0001"+ + "o\u0001p\u0001p\u0001p\u0001p\u0001p\u0001q\u0001q\u0001q\u0001q\u0001"+ + "r\u0001r\u0001r\u0001r\u0001s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001"+ + "s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001t\u0001t\u0001t\u0001t\u0001"+ + "t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001u\u0001u\u0001u\u0001u\u0001"+ + "u\u0001u\u0001u\u0001u\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0001"+ + "v\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001x\u0001"+ + "x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001y\u0001y\u0001"+ + "y\u0001z\u0001z\u0001{\u0001{\u0005{\u03c8\b{\n{\f{\u03cb\t{\u0001|\u0001"+ + "|\u0005|\u03cf\b|\n|\f|\u03d2\t|\u0001|\u0001|\u0001|\u0005|\u03d7\b|"+ + "\n|\f|\u03da\t|\u0001|\u0003|\u03dd\b|\u0001|\u0001|\u0001}\u0001}\u0001"+ + "}\u0001}\u0001}\u0001~\u0004~\u03e7\b~\u000b~\f~\u03e8\u0001~\u0001~\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u0080\u0001\u0080\u0001"+ + "\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0005\u0080\u03f7\b\u0080\n"+ + "\u0080\f\u0080\u03fa\t\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001"+ + "\u0080\u0001\u0080\u0001\u0080\u0001\u0081\u0001\u0081\u0001\u0081\u0001"+ + "\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001"+ + "\u0081\u0001\u0081\u0005\u0081\u040d\b\u0081\n\u0081\f\u0081\u0410\t\u0081"+ + "\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081"+ + "\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0083\u0001\u0083"+ + "\u0001\u0083\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084"+ + "\u0001\u0084\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085"+ + "\u0001\u0085\u0001\u0085\u0001\u0086\u0001\u0086\u0001\u0087\u0001\u0087"+ + "\u0001\u0087\u0001\u0087\u0003\u0087\u0432\b\u0087\u0001\u0088\u0001\u0088"+ + "\u0001\u0088\u0001\u0088\u0003\u0088\u0438\b\u0088\u0001\u0089\u0001\u0089"+ + "\u0001\u0089\u0001\u0089\u0001\u0089\u0003\u0089\u043f\b\u0089\u0001\u008a"+ + "\u0001\u008a\u0003\u008a\u0443\b\u008a\u0001\u008b\u0001\u008b\u0001\u008b"+ + "\u0001\u008b\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c"+ + "\u0001\u008c\u0001\u008d\u0001\u008d\u0001\u008d\u0004\u008d\u0452\b\u008d"+ + "\u000b\u008d\f\u008d\u0453\u0001\u008d\u0001\u008d\u0001\u008e\u0001\u008e"+ + "\u0001\u008f\u0001\u008f\u0001\u0090\u0001\u0090\u0003\u0090\u045e\b\u0090"+ + "\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0092\u0001\u0092\u0001\u0093"+ + "\u0001\u0093\u0001\u0093\u0005\u0093\u0468\b\u0093\n\u0093\f\u0093\u046b"+ + "\t\u0093\u0003\u0093\u046d\b\u0093\u0001\u0094\u0001\u0094\u0003\u0094"+ + "\u0471\b\u0094\u0001\u0094\u0004\u0094\u0474\b\u0094\u000b\u0094\f\u0094"+ + "\u0475\u0001\u0095\u0001\u0095\u0003\u0095\u047a\b\u0095\u0001\u0096\u0001"+ + "\u0096\u0001\u0096\u0003\u0096\u047f\b\u0096\u0001\u0097\u0001\u0097\u0001"+ + "\u0097\u0001\u0097\u0005\u0097\u0485\b\u0097\n\u0097\f\u0097\u0488\t\u0097"+ + "\u0001\u0097\u0003\u0097\u048b\b\u0097\u0001\u0098\u0001\u0098\u0001\u0098"+ + "\u0001\u0098\u0005\u0098\u0491\b\u0098\n\u0098\f\u0098\u0494\t\u0098\u0001"+ + "\u0098\u0003\u0098\u0497\b\u0098\u0001\u0099\u0001\u0099\u0003\u0099\u049b"+ + "\b\u0099\u0001\u009a\u0001\u009a\u0001\u009a\u0003\u013e\u03f8\u040e\u0000"+ + "\u009b\u0002\u0001\u0004\u0002\u0006\u0003\b\u0004\n\u0005\f\u0006\u000e"+ + "\u0007\u0010\b\u0012\t\u0014\n\u0016\u000b\u0018\f\u001a\r\u001c\u000e"+ + "\u001e\u000f \u0010\"\u0011$\u0012&\u0013(\u0014*\u0015,\u0016.\u0017"+ + "0\u00182\u00194\u001a6\u001b8\u001c:\u001d<\u001e>\u001f@ B!D\"F#H$J%"+ + "L&N\'P(R)T*V+X,Z-\\.^/`0b1d2f3h4j5l6n7p8r9t:v;x~?\u0080@\u0082A\u0084"+ + "B\u0086C\u0088D\u008aE\u008cF\u008eG\u0090H\u0092I\u0094J\u0096K\u0098"+ + "L\u009aM\u009cN\u009eO\u00a0P\u00a2Q\u00a4R\u00a6S\u00a8T\u00aaU\u00ac"+ + "V\u00aeW\u00b0X\u00b2Y\u00b4Z\u00b6[\u00b8\\\u00ba]\u00bc^\u00be_\u00c0"+ + "`\u00c2a\u00c4b\u00c6c\u00c8d\u00cae\u00ccf\u00ceg\u00d0h\u00d2i\u00d4"+ + "j\u00d6k\u00d8l\u00dam\u00dcn\u00deo\u00e0p\u00e2q\u00e4r\u00e6s\u00e8"+ + "t\u00eau\u00ecv\u00eew\u00f0x\u00f2y\u00f4z\u00f6{\u00f8|\u00fa}\u00fc"+ + "~\u00fe\u007f\u0100\u0080\u0102\u0081\u0104\u0082\u0106\u0083\u0108\u0084"+ + "\u010a\u0000\u010c\u0085\u010e\u0086\u0110\u0000\u0112\u0000\u0114\u0000"+ + "\u0116\u0000\u0118\u0000\u011a\u0000\u011c\u0000\u011e\u0000\u0120\u0000"+ + "\u0122\u0000\u0124\u0000\u0126\u0000\u0128\u0000\u012a\u0000\u012c\u0000"+ + "\u012e\u0000\u0130\u0000\u0132\u0000\u0134\u0000\u0136\u0000\u0002\u0000"+ + "\u0001\u0017\u0003\u0000\n\n\r\r\u2028\u2029\u0001\u000009\u0002\u0000"+ + "XXxx\u0001\u000007\u0002\u0000OOoo\u0002\u0000BBbb\u0001\u000001\u0004"+ + "\u0000\t\t\u000b\f \u00a0\u00a0\u0002\u0000\\\\``\u0004\u0000\n\n\r\r"+ + "\"\"\\\\\u0004\u0000\n\n\r\r\'\'\\\\\t\u0000\"\"\'\'\\\\bbffnnrrttvv\f"+ + "\u0000\n\n\r\r\"\"\'\'09\\\\bbffnnrrtvxx\u0003\u000009uuxx\u0003\u0000"+ + "09AFaf\u0001\u000019\u0002\u0000EEee\u0002\u0000++--\u0198\u000009__\u0300"+ + "\u036f\u0483\u0487\u0591\u05bd\u05bf\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7"+ + "\u05c7\u0610\u061a\u064b\u0669\u0670\u0670\u06d6\u06dc\u06df\u06e4\u06e7"+ + "\u06e8\u06ea\u06ed\u06f0\u06f9\u0711\u0711\u0730\u074a\u07a6\u07b0\u07c0"+ + "\u07c9\u07eb\u07f3\u07fd\u07fd\u0816\u0819\u081b\u0823\u0825\u0827\u0829"+ + "\u082d\u0859\u085b\u0898\u089f\u08ca\u08e1\u08e3\u0902\u093a\u093a\u093c"+ + "\u093c\u0941\u0948\u094d\u094d\u0951\u0957\u0962\u0963\u0966\u096f\u0981"+ + "\u0981\u09bc\u09bc\u09c1\u09c4\u09cd\u09cd\u09e2\u09e3\u09e6\u09ef\u09fe"+ + "\u09fe\u0a01\u0a02\u0a3c\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b\u0a4d\u0a51"+ + "\u0a51\u0a66\u0a71\u0a75\u0a75\u0a81\u0a82\u0abc\u0abc\u0ac1\u0ac5\u0ac7"+ + "\u0ac8\u0acd\u0acd\u0ae2\u0ae3\u0ae6\u0aef\u0afa\u0aff\u0b01\u0b01\u0b3c"+ + "\u0b3c\u0b3f\u0b3f\u0b41\u0b44\u0b4d\u0b4d\u0b55\u0b56\u0b62\u0b63\u0b66"+ + "\u0b6f\u0b82\u0b82\u0bc0\u0bc0\u0bcd\u0bcd\u0be6\u0bef\u0c00\u0c00\u0c04"+ + "\u0c04\u0c3c\u0c3c\u0c3e\u0c40\u0c46\u0c48\u0c4a\u0c4d\u0c55\u0c56\u0c62"+ + "\u0c63\u0c66\u0c6f\u0c81\u0c81\u0cbc\u0cbc\u0cbf\u0cbf\u0cc6\u0cc6\u0ccc"+ + "\u0ccd\u0ce2\u0ce3\u0ce6\u0cef\u0d00\u0d01\u0d3b\u0d3c\u0d41\u0d44\u0d4d"+ + "\u0d4d\u0d62\u0d63\u0d66\u0d6f\u0d81\u0d81\u0dca\u0dca\u0dd2\u0dd4\u0dd6"+ + "\u0dd6\u0de6\u0def\u0e31\u0e31\u0e34\u0e3a\u0e47\u0e4e\u0e50\u0e59\u0eb1"+ + "\u0eb1\u0eb4\u0ebc\u0ec8\u0ece\u0ed0\u0ed9\u0f18\u0f19\u0f20\u0f29\u0f35"+ + "\u0f35\u0f37\u0f37\u0f39\u0f39\u0f71\u0f7e\u0f80\u0f84\u0f86\u0f87\u0f8d"+ + "\u0f97\u0f99\u0fbc\u0fc6\u0fc6\u102d\u1030\u1032\u1037\u1039\u103a\u103d"+ + "\u103e\u1040\u1049\u1058\u1059\u105e\u1060\u1071\u1074\u1082\u1082\u1085"+ + "\u1086\u108d\u108d\u1090\u1099\u109d\u109d\u135d\u135f\u1712\u1714\u1732"+ + "\u1733\u1752\u1753\u1772\u1773\u17b4\u17b5\u17b7\u17bd\u17c6\u17c6\u17c9"+ + "\u17d3\u17dd\u17dd\u17e0\u17e9\u180b\u180d\u180f\u1819\u1885\u1886\u18a9"+ + "\u18a9\u1920\u1922\u1927\u1928\u1932\u1932\u1939\u193b\u1946\u194f\u19d0"+ + "\u19d9\u1a17\u1a18\u1a1b\u1a1b\u1a56\u1a56\u1a58\u1a5e\u1a60\u1a60\u1a62"+ + "\u1a62\u1a65\u1a6c\u1a73\u1a7c\u1a7f\u1a89\u1a90\u1a99\u1ab0\u1abd\u1abf"+ + "\u1ace\u1b00\u1b03\u1b34\u1b34\u1b36\u1b3a\u1b3c\u1b3c\u1b42\u1b42\u1b50"+ + "\u1b59\u1b6b\u1b73\u1b80\u1b81\u1ba2\u1ba5\u1ba8\u1ba9\u1bab\u1bad\u1bb0"+ + "\u1bb9\u1be6\u1be6\u1be8\u1be9\u1bed\u1bed\u1bef\u1bf1\u1c2c\u1c33\u1c36"+ + "\u1c37\u1c40\u1c49\u1c50\u1c59\u1cd0\u1cd2\u1cd4\u1ce0\u1ce2\u1ce8\u1ced"+ + "\u1ced\u1cf4\u1cf4\u1cf8\u1cf9\u1dc0\u1dff\u200c\u200d\u203f\u2040\u2054"+ + "\u2054\u20d0\u20dc\u20e1\u20e1\u20e5\u20f0\u2cef\u2cf1\u2d7f\u2d7f\u2de0"+ + "\u2dff\u302a\u302d\u3099\u309a\u8000\ua620\u8000\ua629\u8000\ua66f\u8000"+ + "\ua66f\u8000\ua674\u8000\ua67d\u8000\ua69e\u8000\ua69f\u8000\ua6f0\u8000"+ + "\ua6f1\u8000\ua802\u8000\ua802\u8000\ua806\u8000\ua806\u8000\ua80b\u8000"+ + "\ua80b\u8000\ua825\u8000\ua826\u8000\ua82c\u8000\ua82c\u8000\ua8c4\u8000"+ + "\ua8c5\u8000\ua8d0\u8000\ua8d9\u8000\ua8e0\u8000\ua8f1\u8000\ua8ff\u8000"+ + "\ua909\u8000\ua926\u8000\ua92d\u8000\ua947\u8000\ua951\u8000\ua980\u8000"+ + "\ua982\u8000\ua9b3\u8000\ua9b3\u8000\ua9b6\u8000\ua9b9\u8000\ua9bc\u8000"+ + "\ua9bd\u8000\ua9d0\u8000\ua9d9\u8000\ua9e5\u8000\ua9e5\u8000\ua9f0\u8000"+ + "\ua9f9\u8000\uaa29\u8000\uaa2e\u8000\uaa31\u8000\uaa32\u8000\uaa35\u8000"+ + "\uaa36\u8000\uaa43\u8000\uaa43\u8000\uaa4c\u8000\uaa4c\u8000\uaa50\u8000"+ + "\uaa59\u8000\uaa7c\u8000\uaa7c\u8000\uaab0\u8000\uaab0\u8000\uaab2\u8000"+ + "\uaab4\u8000\uaab7\u8000\uaab8\u8000\uaabe\u8000\uaabf\u8000\uaac1\u8000"+ + "\uaac1\u8000\uaaec\u8000\uaaed\u8000\uaaf6\u8000\uaaf6\u8000\uabe5\u8000"+ + "\uabe5\u8000\uabe8\u8000\uabe8\u8000\uabed\u8000\uabed\u8000\uabf0\u8000"+ + "\uabf9\u8000\ufb1e\u8000\ufb1e\u8000\ufe00\u8000\ufe0f\u8000\ufe20\u8000"+ + "\ufe2f\u8000\ufe33\u8000\ufe34\u8000\ufe4d\u8000\ufe4f\u8000\uff10\u8000"+ + "\uff19\u8000\uff3f\u8000\uff3f\u8001\u01fd\u8001\u01fd\u8001\u02e0\u8001"+ + "\u02e0\u8001\u0376\u8001\u037a\u8001\u04a0\u8001\u04a9\u8001\u0a01\u8001"+ + "\u0a03\u8001\u0a05\u8001\u0a06\u8001\u0a0c\u8001\u0a0f\u8001\u0a38\u8001"+ + "\u0a3a\u8001\u0a3f\u8001\u0a3f\u8001\u0ae5\u8001\u0ae6\u8001\u0d24\u8001"+ + "\u0d27\u8001\u0d30\u8001\u0d39\u8001\u0eab\u8001\u0eac\u8001\u0efd\u8001"+ + "\u0eff\u8001\u0f46\u8001\u0f50\u8001\u0f82\u8001\u0f85\u8001\u1001\u8001"+ + "\u1001\u8001\u1038\u8001\u1046\u8001\u1066\u8001\u1070\u8001\u1073\u8001"+ + "\u1074\u8001\u107f\u8001\u1081\u8001\u10b3\u8001\u10b6\u8001\u10b9\u8001"+ + "\u10ba\u8001\u10c2\u8001\u10c2\u8001\u10f0\u8001\u10f9\u8001\u1100\u8001"+ + "\u1102\u8001\u1127\u8001\u112b\u8001\u112d\u8001\u1134\u8001\u1136\u8001"+ + "\u113f\u8001\u1173\u8001\u1173\u8001\u1180\u8001\u1181\u8001\u11b6\u8001"+ + "\u11be\u8001\u11c9\u8001\u11cc\u8001\u11cf\u8001\u11d9\u8001\u122f\u8001"+ + "\u1231\u8001\u1234\u8001\u1234\u8001\u1236\u8001\u1237\u8001\u123e\u8001"+ + "\u123e\u8001\u1241\u8001\u1241\u8001\u12df\u8001\u12df\u8001\u12e3\u8001"+ + "\u12ea\u8001\u12f0\u8001\u12f9\u8001\u1300\u8001\u1301\u8001\u133b\u8001"+ + "\u133c\u8001\u1340\u8001\u1340\u8001\u1366\u8001\u136c\u8001\u1370\u8001"+ + "\u1374\u8001\u1438\u8001\u143f\u8001\u1442\u8001\u1444\u8001\u1446\u8001"+ + "\u1446\u8001\u1450\u8001\u1459\u8001\u145e\u8001\u145e\u8001\u14b3\u8001"+ + "\u14b8\u8001\u14ba\u8001\u14ba\u8001\u14bf\u8001\u14c0\u8001\u14c2\u8001"+ + "\u14c3\u8001\u14d0\u8001\u14d9\u8001\u15b2\u8001\u15b5\u8001\u15bc\u8001"+ + "\u15bd\u8001\u15bf\u8001\u15c0\u8001\u15dc\u8001\u15dd\u8001\u1633\u8001"+ + "\u163a\u8001\u163d\u8001\u163d\u8001\u163f\u8001\u1640\u8001\u1650\u8001"+ + "\u1659\u8001\u16ab\u8001\u16ab\u8001\u16ad\u8001\u16ad\u8001\u16b0\u8001"+ + "\u16b5\u8001\u16b7\u8001\u16b7\u8001\u16c0\u8001\u16c9\u8001\u171d\u8001"+ + "\u171f\u8001\u1722\u8001\u1725\u8001\u1727\u8001\u172b\u8001\u1730\u8001"+ + "\u1739\u8001\u182f\u8001\u1837\u8001\u1839\u8001\u183a\u8001\u18e0\u8001"+ + "\u18e9\u8001\u193b\u8001\u193c\u8001\u193e\u8001\u193e\u8001\u1943\u8001"+ + "\u1943\u8001\u1950\u8001\u1959\u8001\u19d4\u8001\u19d7\u8001\u19da\u8001"+ + "\u19db\u8001\u19e0\u8001\u19e0\u8001\u1a01\u8001\u1a0a\u8001\u1a33\u8001"+ + "\u1a38\u8001\u1a3b\u8001\u1a3e\u8001\u1a47\u8001\u1a47\u8001\u1a51\u8001"+ + "\u1a56\u8001\u1a59\u8001\u1a5b\u8001\u1a8a\u8001\u1a96\u8001\u1a98\u8001"+ + "\u1a99\u8001\u1c30\u8001\u1c36\u8001\u1c38\u8001\u1c3d\u8001\u1c3f\u8001"+ + "\u1c3f\u8001\u1c50\u8001\u1c59\u8001\u1c92\u8001\u1ca7\u8001\u1caa\u8001"+ + "\u1cb0\u8001\u1cb2\u8001\u1cb3\u8001\u1cb5\u8001\u1cb6\u8001\u1d31\u8001"+ + "\u1d36\u8001\u1d3a\u8001\u1d3a\u8001\u1d3c\u8001\u1d3d\u8001\u1d3f\u8001"+ + "\u1d45\u8001\u1d47\u8001\u1d47\u8001\u1d50\u8001\u1d59\u8001\u1d90\u8001"+ + "\u1d91\u8001\u1d95\u8001\u1d95\u8001\u1d97\u8001\u1d97\u8001\u1da0\u8001"+ + "\u1da9\u8001\u1ef3\u8001\u1ef4\u8001\u1f00\u8001\u1f01\u8001\u1f36\u8001"+ + "\u1f3a\u8001\u1f40\u8001\u1f40\u8001\u1f42\u8001\u1f42\u8001\u1f50\u8001"+ + "\u1f59\u8001\u3440\u8001\u3440\u8001\u3447\u8001\u3455\u8001\u6a60\u8001"+ + "\u6a69\u8001\u6ac0\u8001\u6ac9\u8001\u6af0\u8001\u6af4\u8001\u6b30\u8001"+ + "\u6b36\u8001\u6b50\u8001\u6b59\u8001\u6f4f\u8001\u6f4f\u8001\u6f8f\u8001"+ + "\u6f92\u8001\u6fe4\u8001\u6fe4\u8001\ubc9d\u8001\ubc9e\u8001\ucf00\u8001"+ + "\ucf2d\u8001\ucf30\u8001\ucf46\u8001\ud167\u8001\ud169\u8001\ud17b\u8001"+ + "\ud182\u8001\ud185\u8001\ud18b\u8001\ud1aa\u8001\ud1ad\u8001\ud242\u8001"+ + "\ud244\u8001\ud7ce\u8001\ud7ff\u8001\uda00\u8001\uda36\u8001\uda3b\u8001"+ + "\uda6c\u8001\uda75\u8001\uda75\u8001\uda84\u8001\uda84\u8001\uda9b\u8001"+ + "\uda9f\u8001\udaa1\u8001\udaaf\u8001\ue000\u8001\ue006\u8001\ue008\u8001"+ + "\ue018\u8001\ue01b\u8001\ue021\u8001\ue023\u8001\ue024\u8001\ue026\u8001"+ + "\ue02a\u8001\ue08f\u8001\ue08f\u8001\ue130\u8001\ue136\u8001\ue140\u8001"+ + "\ue149\u8001\ue2ae\u8001\ue2ae\u8001\ue2ec\u8001\ue2f9\u8001\ue4ec\u8001"+ + "\ue4f9\u8001\ue8d0\u8001\ue8d6\u8001\ue944\u8001\ue94a\u8001\ue950\u8001"+ + "\ue959\u8001\ufbf0\u8001\ufbf9\u800e\u0100\u800e\u01ef\u0295\u0000$$A"+ + "Z__az\u00aa\u00aa\u00b5\u00b5\u00ba\u00ba\u00c0\u00d6\u00d8\u00f6\u00f8"+ + "\u02c1\u02c6\u02d1\u02e0\u02e4\u02ec\u02ec\u02ee\u02ee\u0370\u0374\u0376"+ + "\u0377\u037a\u037d\u037f\u037f\u0386\u0386\u0388\u038a\u038c\u038c\u038e"+ + "\u03a1\u03a3\u03f5\u03f7\u0481\u048a\u052f\u0531\u0556\u0559\u0559\u0560"+ + "\u0588\u05d0\u05ea\u05ef\u05f2\u0620\u064a\u066e\u066f\u0671\u06d3\u06d5"+ + "\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa\u06fc\u06ff\u06ff\u0710\u0710\u0712"+ + "\u072f\u074d\u07a5\u07b1\u07b1\u07ca\u07ea\u07f4\u07f5\u07fa\u07fa\u0800"+ + "\u0815\u081a\u081a\u0824\u0824\u0828\u0828\u0840\u0858\u0860\u086a\u0870"+ + "\u0887\u0889\u088e\u08a0\u08c9\u0904\u0939\u093d\u093d\u0950\u0950\u0958"+ + "\u0961\u0971\u0980\u0985\u098c\u098f\u0990\u0993\u09a8\u09aa\u09b0\u09b2"+ + "\u09b2\u09b6\u09b9\u09bd\u09bd\u09ce\u09ce\u09dc\u09dd\u09df\u09e1\u09f0"+ + "\u09f1\u09fc\u09fc\u0a05\u0a0a\u0a0f\u0a10\u0a13\u0a28\u0a2a\u0a30\u0a32"+ + "\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59\u0a5c\u0a5e\u0a5e\u0a72\u0a74\u0a85"+ + "\u0a8d\u0a8f\u0a91\u0a93\u0aa8\u0aaa\u0ab0\u0ab2\u0ab3\u0ab5\u0ab9\u0abd"+ + "\u0abd\u0ad0\u0ad0\u0ae0\u0ae1\u0af9\u0af9\u0b05\u0b0c\u0b0f\u0b10\u0b13"+ + "\u0b28\u0b2a\u0b30\u0b32\u0b33\u0b35\u0b39\u0b3d\u0b3d\u0b5c\u0b5d\u0b5f"+ + "\u0b61\u0b71\u0b71\u0b83\u0b83\u0b85\u0b8a\u0b8e\u0b90\u0b92\u0b95\u0b99"+ + "\u0b9a\u0b9c\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8\u0baa\u0bae\u0bb9\u0bd0"+ + "\u0bd0\u0c05\u0c0c\u0c0e\u0c10\u0c12\u0c28\u0c2a\u0c39\u0c3d\u0c3d\u0c58"+ + "\u0c5a\u0c5d\u0c5d\u0c60\u0c61\u0c80\u0c80\u0c85\u0c8c\u0c8e\u0c90\u0c92"+ + "\u0ca8\u0caa\u0cb3\u0cb5\u0cb9\u0cbd\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1"+ + "\u0cf2\u0d04\u0d0c\u0d0e\u0d10\u0d12\u0d3a\u0d3d\u0d3d\u0d4e\u0d4e\u0d54"+ + "\u0d56\u0d5f\u0d61\u0d7a\u0d7f\u0d85\u0d96\u0d9a\u0db1\u0db3\u0dbb\u0dbd"+ + "\u0dbd\u0dc0\u0dc6\u0e01\u0e30\u0e32\u0e33\u0e40\u0e46\u0e81\u0e82\u0e84"+ + "\u0e84\u0e86\u0e8a\u0e8c\u0ea3\u0ea5\u0ea5\u0ea7\u0eb0\u0eb2\u0eb3\u0ebd"+ + "\u0ebd\u0ec0\u0ec4\u0ec6\u0ec6\u0edc\u0edf\u0f00\u0f00\u0f40\u0f47\u0f49"+ + "\u0f6c\u0f88\u0f8c\u1000\u102a\u103f\u103f\u1050\u1055\u105a\u105d\u1061"+ + "\u1061\u1065\u1066\u106e\u1070\u1075\u1081\u108e\u108e\u10a0\u10c5\u10c7"+ + "\u10c7\u10cd\u10cd\u10d0\u10fa\u10fc\u1248\u124a\u124d\u1250\u1256\u1258"+ + "\u1258\u125a\u125d\u1260\u1288\u128a\u128d\u1290\u12b0\u12b2\u12b5\u12b8"+ + "\u12be\u12c0\u12c0\u12c2\u12c5\u12c8\u12d6\u12d8\u1310\u1312\u1315\u1318"+ + "\u135a\u1380\u138f\u13a0\u13f5\u13f8\u13fd\u1401\u166c\u166f\u167f\u1681"+ + "\u169a\u16a0\u16ea\u16f1\u16f8\u1700\u1711\u171f\u1731\u1740\u1751\u1760"+ + "\u176c\u176e\u1770\u1780\u17b3\u17d7\u17d7\u17dc\u17dc\u1820\u1878\u1880"+ + "\u1884\u1887\u18a8\u18aa\u18aa\u18b0\u18f5\u1900\u191e\u1950\u196d\u1970"+ + "\u1974\u1980\u19ab\u19b0\u19c9\u1a00\u1a16\u1a20\u1a54\u1aa7\u1aa7\u1b05"+ + "\u1b33\u1b45\u1b4c\u1b83\u1ba0\u1bae\u1baf\u1bba\u1be5\u1c00\u1c23\u1c4d"+ + "\u1c4f\u1c5a\u1c7d\u1c80\u1c88\u1c90\u1cba\u1cbd\u1cbf\u1ce9\u1cec\u1cee"+ + "\u1cf3\u1cf5\u1cf6\u1cfa\u1cfa\u1d00\u1dbf\u1e00\u1f15\u1f18\u1f1d\u1f20"+ + "\u1f45\u1f48\u1f4d\u1f50\u1f57\u1f59\u1f59\u1f5b\u1f5b\u1f5d\u1f5d\u1f5f"+ + "\u1f7d\u1f80\u1fb4\u1fb6\u1fbc\u1fbe\u1fbe\u1fc2\u1fc4\u1fc6\u1fcc\u1fd0"+ + "\u1fd3\u1fd6\u1fdb\u1fe0\u1fec\u1ff2\u1ff4\u1ff6\u1ffc\u2071\u2071\u207f"+ + "\u207f\u2090\u209c\u2102\u2102\u2107\u2107\u210a\u2113\u2115\u2115\u2119"+ + "\u211d\u2124\u2124\u2126\u2126\u2128\u2128\u212a\u212d\u212f\u2139\u213c"+ + "\u213f\u2145\u2149\u214e\u214e\u2183\u2184\u2c00\u2ce4\u2ceb\u2cee\u2cf2"+ + "\u2cf3\u2d00\u2d25\u2d27\u2d27\u2d2d\u2d2d\u2d30\u2d67\u2d6f\u2d6f\u2d80"+ + "\u2d96\u2da0\u2da6\u2da8\u2dae\u2db0\u2db6\u2db8\u2dbe\u2dc0\u2dc6\u2dc8"+ + "\u2dce\u2dd0\u2dd6\u2dd8\u2dde\u2e2f\u2e2f\u3005\u3006\u3031\u3035\u303b"+ + "\u303c\u3041\u3096\u309d\u309f\u30a1\u30fa\u30fc\u30ff\u3105\u312f\u3131"+ + "\u318e\u31a0\u31bf\u31f0\u31ff\u3400\u4dbf\u4e00\u8000\ua48c\u8000\ua4d0"+ + "\u8000\ua4fd\u8000\ua500\u8000\ua60c\u8000\ua610\u8000\ua61f\u8000\ua62a"+ + "\u8000\ua62b\u8000\ua640\u8000\ua66e\u8000\ua67f\u8000\ua69d\u8000\ua6a0"+ + "\u8000\ua6e5\u8000\ua717\u8000\ua71f\u8000\ua722\u8000\ua788\u8000\ua78b"+ + "\u8000\ua7ca\u8000\ua7d0\u8000\ua7d1\u8000\ua7d3\u8000\ua7d3\u8000\ua7d5"+ + "\u8000\ua7d9\u8000\ua7f2\u8000\ua801\u8000\ua803\u8000\ua805\u8000\ua807"+ + "\u8000\ua80a\u8000\ua80c\u8000\ua822\u8000\ua840\u8000\ua873\u8000\ua882"+ + "\u8000\ua8b3\u8000\ua8f2\u8000\ua8f7\u8000\ua8fb\u8000\ua8fb\u8000\ua8fd"+ + "\u8000\ua8fe\u8000\ua90a\u8000\ua925\u8000\ua930\u8000\ua946\u8000\ua960"+ + "\u8000\ua97c\u8000\ua984\u8000\ua9b2\u8000\ua9cf\u8000\ua9cf\u8000\ua9e0"+ + "\u8000\ua9e4\u8000\ua9e6\u8000\ua9ef\u8000\ua9fa\u8000\ua9fe\u8000\uaa00"+ + "\u8000\uaa28\u8000\uaa40\u8000\uaa42\u8000\uaa44\u8000\uaa4b\u8000\uaa60"+ + "\u8000\uaa76\u8000\uaa7a\u8000\uaa7a\u8000\uaa7e\u8000\uaaaf\u8000\uaab1"+ + "\u8000\uaab1\u8000\uaab5\u8000\uaab6\u8000\uaab9\u8000\uaabd\u8000\uaac0"+ + "\u8000\uaac0\u8000\uaac2\u8000\uaac2\u8000\uaadb\u8000\uaadd\u8000\uaae0"+ + "\u8000\uaaea\u8000\uaaf2\u8000\uaaf4\u8000\uab01\u8000\uab06\u8000\uab09"+ + "\u8000\uab0e\u8000\uab11\u8000\uab16\u8000\uab20\u8000\uab26\u8000\uab28"+ + "\u8000\uab2e\u8000\uab30\u8000\uab5a\u8000\uab5c\u8000\uab69\u8000\uab70"+ + "\u8000\uabe2\u8000\uac00\u8000\ud7a3\u8000\ud7b0\u8000\ud7c6\u8000\ud7cb"+ + "\u8000\ud7fb\u8000\uf900\u8000\ufa6d\u8000\ufa70\u8000\ufad9\u8000\ufb00"+ + "\u8000\ufb06\u8000\ufb13\u8000\ufb17\u8000\ufb1d\u8000\ufb1d\u8000\ufb1f"+ + "\u8000\ufb28\u8000\ufb2a\u8000\ufb36\u8000\ufb38\u8000\ufb3c\u8000\ufb3e"+ + "\u8000\ufb3e\u8000\ufb40\u8000\ufb41\u8000\ufb43\u8000\ufb44\u8000\ufb46"+ + "\u8000\ufbb1\u8000\ufbd3\u8000\ufd3d\u8000\ufd50\u8000\ufd8f\u8000\ufd92"+ + "\u8000\ufdc7\u8000\ufdf0\u8000\ufdfb\u8000\ufe70\u8000\ufe74\u8000\ufe76"+ + "\u8000\ufefc\u8000\uff21\u8000\uff3a\u8000\uff41\u8000\uff5a\u8000\uff66"+ + "\u8000\uffbe\u8000\uffc2\u8000\uffc7\u8000\uffca\u8000\uffcf\u8000\uffd2"+ + "\u8000\uffd7\u8000\uffda\u8000\uffdc\u8001\u0000\u8001\u000b\u8001\r\u8001"+ + "&\u8001(\u8001:\u8001<\u8001=\u8001?\u8001M\u8001P\u8001]\u8001\u0080"+ + "\u8001\u00fa\u8001\u0280\u8001\u029c\u8001\u02a0\u8001\u02d0\u8001\u0300"+ + "\u8001\u031f\u8001\u032d\u8001\u0340\u8001\u0342\u8001\u0349\u8001\u0350"+ + "\u8001\u0375\u8001\u0380\u8001\u039d\u8001\u03a0\u8001\u03c3\u8001\u03c8"+ + "\u8001\u03cf\u8001\u0400\u8001\u049d\u8001\u04b0\u8001\u04d3\u8001\u04d8"+ + "\u8001\u04fb\u8001\u0500\u8001\u0527\u8001\u0530\u8001\u0563\u8001\u0570"+ + "\u8001\u057a\u8001\u057c\u8001\u058a\u8001\u058c\u8001\u0592\u8001\u0594"+ + "\u8001\u0595\u8001\u0597\u8001\u05a1\u8001\u05a3\u8001\u05b1\u8001\u05b3"+ + "\u8001\u05b9\u8001\u05bb\u8001\u05bc\u8001\u0600\u8001\u0736\u8001\u0740"+ + "\u8001\u0755\u8001\u0760\u8001\u0767\u8001\u0780\u8001\u0785\u8001\u0787"+ + "\u8001\u07b0\u8001\u07b2\u8001\u07ba\u8001\u0800\u8001\u0805\u8001\u0808"+ + "\u8001\u0808\u8001\u080a\u8001\u0835\u8001\u0837\u8001\u0838\u8001\u083c"+ + "\u8001\u083c\u8001\u083f\u8001\u0855\u8001\u0860\u8001\u0876\u8001\u0880"+ + "\u8001\u089e\u8001\u08e0\u8001\u08f2\u8001\u08f4\u8001\u08f5\u8001\u0900"+ + "\u8001\u0915\u8001\u0920\u8001\u0939\u8001\u0980\u8001\u09b7\u8001\u09be"+ + "\u8001\u09bf\u8001\u0a00\u8001\u0a00\u8001\u0a10\u8001\u0a13\u8001\u0a15"+ + "\u8001\u0a17\u8001\u0a19\u8001\u0a35\u8001\u0a60\u8001\u0a7c\u8001\u0a80"+ + "\u8001\u0a9c\u8001\u0ac0\u8001\u0ac7\u8001\u0ac9\u8001\u0ae4\u8001\u0b00"+ + "\u8001\u0b35\u8001\u0b40\u8001\u0b55\u8001\u0b60\u8001\u0b72\u8001\u0b80"+ + "\u8001\u0b91\u8001\u0c00\u8001\u0c48\u8001\u0c80\u8001\u0cb2\u8001\u0cc0"+ + "\u8001\u0cf2\u8001\u0d00\u8001\u0d23\u8001\u0e80\u8001\u0ea9\u8001\u0eb0"+ + "\u8001\u0eb1\u8001\u0f00\u8001\u0f1c\u8001\u0f27\u8001\u0f27\u8001\u0f30"+ + "\u8001\u0f45\u8001\u0f70\u8001\u0f81\u8001\u0fb0\u8001\u0fc4\u8001\u0fe0"+ + "\u8001\u0ff6\u8001\u1003\u8001\u1037\u8001\u1071\u8001\u1072\u8001\u1075"+ + "\u8001\u1075\u8001\u1083\u8001\u10af\u8001\u10d0\u8001\u10e8\u8001\u1103"+ + "\u8001\u1126\u8001\u1144\u8001\u1144\u8001\u1147\u8001\u1147\u8001\u1150"+ + "\u8001\u1172\u8001\u1176\u8001\u1176\u8001\u1183\u8001\u11b2\u8001\u11c1"+ + "\u8001\u11c4\u8001\u11da\u8001\u11da\u8001\u11dc\u8001\u11dc\u8001\u1200"+ + "\u8001\u1211\u8001\u1213\u8001\u122b\u8001\u123f\u8001\u1240\u8001\u1280"+ + "\u8001\u1286\u8001\u1288\u8001\u1288\u8001\u128a\u8001\u128d\u8001\u128f"+ + "\u8001\u129d\u8001\u129f\u8001\u12a8\u8001\u12b0\u8001\u12de\u8001\u1305"+ + "\u8001\u130c\u8001\u130f\u8001\u1310\u8001\u1313\u8001\u1328\u8001\u132a"+ + "\u8001\u1330\u8001\u1332\u8001\u1333\u8001\u1335\u8001\u1339\u8001\u133d"+ + "\u8001\u133d\u8001\u1350\u8001\u1350\u8001\u135d\u8001\u1361\u8001\u1400"+ + "\u8001\u1434\u8001\u1447\u8001\u144a\u8001\u145f\u8001\u1461\u8001\u1480"+ + "\u8001\u14af\u8001\u14c4\u8001\u14c5\u8001\u14c7\u8001\u14c7\u8001\u1580"+ + "\u8001\u15ae\u8001\u15d8\u8001\u15db\u8001\u1600\u8001\u162f\u8001\u1644"+ + "\u8001\u1644\u8001\u1680\u8001\u16aa\u8001\u16b8\u8001\u16b8\u8001\u1700"+ + "\u8001\u171a\u8001\u1740\u8001\u1746\u8001\u1800\u8001\u182b\u8001\u18a0"+ + "\u8001\u18df\u8001\u18ff\u8001\u1906\u8001\u1909\u8001\u1909\u8001\u190c"+ + "\u8001\u1913\u8001\u1915\u8001\u1916\u8001\u1918\u8001\u192f\u8001\u193f"+ + "\u8001\u193f\u8001\u1941\u8001\u1941\u8001\u19a0\u8001\u19a7\u8001\u19aa"+ + "\u8001\u19d0\u8001\u19e1\u8001\u19e1\u8001\u19e3\u8001\u19e3\u8001\u1a00"+ + "\u8001\u1a00\u8001\u1a0b\u8001\u1a32\u8001\u1a3a\u8001\u1a3a\u8001\u1a50"+ + "\u8001\u1a50\u8001\u1a5c\u8001\u1a89\u8001\u1a9d\u8001\u1a9d\u8001\u1ab0"+ + "\u8001\u1af8\u8001\u1c00\u8001\u1c08\u8001\u1c0a\u8001\u1c2e\u8001\u1c40"+ + "\u8001\u1c40\u8001\u1c72\u8001\u1c8f\u8001\u1d00\u8001\u1d06\u8001\u1d08"+ + "\u8001\u1d09\u8001\u1d0b\u8001\u1d30\u8001\u1d46\u8001\u1d46\u8001\u1d60"+ + "\u8001\u1d65\u8001\u1d67\u8001\u1d68\u8001\u1d6a\u8001\u1d89\u8001\u1d98"+ + "\u8001\u1d98\u8001\u1ee0\u8001\u1ef2\u8001\u1f02\u8001\u1f02\u8001\u1f04"+ + "\u8001\u1f10\u8001\u1f12\u8001\u1f33\u8001\u1fb0\u8001\u1fb0\u8001\u2000"+ + "\u8001\u2399\u8001\u2480\u8001\u2543\u8001\u2f90\u8001\u2ff0\u8001\u3000"+ + "\u8001\u342f\u8001\u3441\u8001\u3446\u8001\u4400\u8001\u4646\u8001\u6800"+ + "\u8001\u6a38\u8001\u6a40\u8001\u6a5e\u8001\u6a70\u8001\u6abe\u8001\u6ad0"+ + "\u8001\u6aed\u8001\u6b00\u8001\u6b2f\u8001\u6b40\u8001\u6b43\u8001\u6b63"+ + "\u8001\u6b77\u8001\u6b7d\u8001\u6b8f\u8001\u6e40\u8001\u6e7f\u8001\u6f00"+ + "\u8001\u6f4a\u8001\u6f50\u8001\u6f50\u8001\u6f93\u8001\u6f9f\u8001\u6fe0"+ + "\u8001\u6fe1\u8001\u6fe3\u8001\u6fe3\u8001\u7000\u8001\u87f7\u8001\u8800"+ + "\u8001\u8cd5\u8001\u8d00\u8001\u8d08\u8001\uaff0\u8001\uaff3\u8001\uaff5"+ + "\u8001\uaffb\u8001\uaffd\u8001\uaffe\u8001\ub000\u8001\ub122\u8001\ub132"+ + "\u8001\ub132\u8001\ub150\u8001\ub152\u8001\ub155\u8001\ub155\u8001\ub164"+ + "\u8001\ub167\u8001\ub170\u8001\ub2fb\u8001\ubc00\u8001\ubc6a\u8001\ubc70"+ + "\u8001\ubc7c\u8001\ubc80\u8001\ubc88\u8001\ubc90\u8001\ubc99\u8001\ud400"+ + "\u8001\ud454\u8001\ud456\u8001\ud49c\u8001\ud49e\u8001\ud49f\u8001\ud4a2"+ + "\u8001\ud4a2\u8001\ud4a5\u8001\ud4a6\u8001\ud4a9\u8001\ud4ac\u8001\ud4ae"+ + "\u8001\ud4b9\u8001\ud4bb\u8001\ud4bb\u8001\ud4bd\u8001\ud4c3\u8001\ud4c5"+ + "\u8001\ud505\u8001\ud507\u8001\ud50a\u8001\ud50d\u8001\ud514\u8001\ud516"+ + "\u8001\ud51c\u8001\ud51e\u8001\ud539\u8001\ud53b\u8001\ud53e\u8001\ud540"+ + "\u8001\ud544\u8001\ud546\u8001\ud546\u8001\ud54a\u8001\ud550\u8001\ud552"+ + "\u8001\ud6a5\u8001\ud6a8\u8001\ud6c0\u8001\ud6c2\u8001\ud6da\u8001\ud6dc"+ + "\u8001\ud6fa\u8001\ud6fc\u8001\ud714\u8001\ud716\u8001\ud734\u8001\ud736"+ + "\u8001\ud74e\u8001\ud750\u8001\ud76e\u8001\ud770\u8001\ud788\u8001\ud78a"+ + "\u8001\ud7a8\u8001\ud7aa\u8001\ud7c2\u8001\ud7c4\u8001\ud7cb\u8001\udf00"+ + "\u8001\udf1e\u8001\udf25\u8001\udf2a\u8001\ue030\u8001\ue06d\u8001\ue100"+ + "\u8001\ue12c\u8001\ue137\u8001\ue13d\u8001\ue14e\u8001\ue14e\u8001\ue290"+ + "\u8001\ue2ad\u8001\ue2c0\u8001\ue2eb\u8001\ue4d0\u8001\ue4eb\u8001\ue7e0"+ + "\u8001\ue7e6\u8001\ue7e8\u8001\ue7eb\u8001\ue7ed\u8001\ue7ee\u8001\ue7f0"+ + "\u8001\ue7fe\u8001\ue800\u8001\ue8c4\u8001\ue900\u8001\ue943\u8001\ue94b"+ + "\u8001\ue94b\u8001\uee00\u8001\uee03\u8001\uee05\u8001\uee1f\u8001\uee21"+ + "\u8001\uee22\u8001\uee24\u8001\uee24\u8001\uee27\u8001\uee27\u8001\uee29"+ + "\u8001\uee32\u8001\uee34\u8001\uee37\u8001\uee39\u8001\uee39\u8001\uee3b"+ + "\u8001\uee3b\u8001\uee42\u8001\uee42\u8001\uee47\u8001\uee47\u8001\uee49"+ + "\u8001\uee49\u8001\uee4b\u8001\uee4b\u8001\uee4d\u8001\uee4f\u8001\uee51"+ + "\u8001\uee52\u8001\uee54\u8001\uee54\u8001\uee57\u8001\uee57\u8001\uee59"+ + "\u8001\uee59\u8001\uee5b\u8001\uee5b\u8001\uee5d\u8001\uee5d\u8001\uee5f"+ + "\u8001\uee5f\u8001\uee61\u8001\uee62\u8001\uee64\u8001\uee64\u8001\uee67"+ + "\u8001\uee6a\u8001\uee6c\u8001\uee72\u8001\uee74\u8001\uee77\u8001\uee79"+ + "\u8001\uee7c\u8001\uee7e\u8001\uee7e\u8001\uee80\u8001\uee89\u8001\uee8b"+ + "\u8001\uee9b\u8001\ueea1\u8001\ueea3\u8001\ueea5\u8001\ueea9\u8001\ueeab"+ + "\u8001\ueebb\u8002\u0000\u8002\ua6df\u8002\ua700\u8002\ub739\u8002\ub740"+ + "\u8002\ub81d\u8002\ub820\u8002\ucea1\u8002\uceb0\u8002\uebe0\u8002\uf800"+ + "\u8002\ufa1d\u8003\u0000\u8003\u134a\u8003\u1350\u8003\u23af\u0006\u0000"+ + "\n\n\r\r**//[\\\u2028\u2029\u0005\u0000\n\n\r\r//[\\\u2028\u2029\u0004"+ + "\u0000\n\n\r\r\\]\u2028\u2029\u04b8\u0000\u0002\u0001\u0000\u0000\u0000"+ + "\u0000\u0004\u0001\u0000\u0000\u0000\u0000\u0006\u0001\u0000\u0000\u0000"+ + "\u0000\b\u0001\u0000\u0000\u0000\u0000\n\u0001\u0000\u0000\u0000\u0000"+ + "\f\u0001\u0000\u0000\u0000\u0000\u000e\u0001\u0000\u0000\u0000\u0000\u0010"+ + "\u0001\u0000\u0000\u0000\u0000\u0012\u0001\u0000\u0000\u0000\u0000\u0014"+ + "\u0001\u0000\u0000\u0000\u0000\u0016\u0001\u0000\u0000\u0000\u0000\u0018"+ + "\u0001\u0000\u0000\u0000\u0000\u001a\u0001\u0000\u0000\u0000\u0000\u001c"+ + "\u0001\u0000\u0000\u0000\u0000\u001e\u0001\u0000\u0000\u0000\u0000 \u0001"+ + "\u0000\u0000\u0000\u0000\"\u0001\u0000\u0000\u0000\u0000$\u0001\u0000"+ + "\u0000\u0000\u0000&\u0001\u0000\u0000\u0000\u0000(\u0001\u0000\u0000\u0000"+ + "\u0000*\u0001\u0000\u0000\u0000\u0000,\u0001\u0000\u0000\u0000\u0000."+ + "\u0001\u0000\u0000\u0000\u00000\u0001\u0000\u0000\u0000\u00002\u0001\u0000"+ + "\u0000\u0000\u00004\u0001\u0000\u0000\u0000\u00006\u0001\u0000\u0000\u0000"+ + "\u00008\u0001\u0000\u0000\u0000\u0000:\u0001\u0000\u0000\u0000\u0000<"+ + "\u0001\u0000\u0000\u0000\u0000>\u0001\u0000\u0000\u0000\u0000@\u0001\u0000"+ + "\u0000\u0000\u0000B\u0001\u0000\u0000\u0000\u0000D\u0001\u0000\u0000\u0000"+ + "\u0000F\u0001\u0000\u0000\u0000\u0000H\u0001\u0000\u0000\u0000\u0000J"+ + "\u0001\u0000\u0000\u0000\u0000L\u0001\u0000\u0000\u0000\u0000N\u0001\u0000"+ + "\u0000\u0000\u0000P\u0001\u0000\u0000\u0000\u0000R\u0001\u0000\u0000\u0000"+ + "\u0000T\u0001\u0000\u0000\u0000\u0000V\u0001\u0000\u0000\u0000\u0000X"+ + "\u0001\u0000\u0000\u0000\u0000Z\u0001\u0000\u0000\u0000\u0000\\\u0001"+ + "\u0000\u0000\u0000\u0000^\u0001\u0000\u0000\u0000\u0000`\u0001\u0000\u0000"+ + "\u0000\u0000b\u0001\u0000\u0000\u0000\u0000d\u0001\u0000\u0000\u0000\u0000"+ + "f\u0001\u0000\u0000\u0000\u0000h\u0001\u0000\u0000\u0000\u0000j\u0001"+ + "\u0000\u0000\u0000\u0000l\u0001\u0000\u0000\u0000\u0000n\u0001\u0000\u0000"+ + "\u0000\u0000p\u0001\u0000\u0000\u0000\u0000r\u0001\u0000\u0000\u0000\u0000"+ + "t\u0001\u0000\u0000\u0000\u0000v\u0001\u0000\u0000\u0000\u0000x\u0001"+ + "\u0000\u0000\u0000\u0000z\u0001\u0000\u0000\u0000\u0000|\u0001\u0000\u0000"+ + "\u0000\u0000~\u0001\u0000\u0000\u0000\u0000\u0080\u0001\u0000\u0000\u0000"+ + "\u0000\u0082\u0001\u0000\u0000\u0000\u0000\u0084\u0001\u0000\u0000\u0000"+ + "\u0000\u0086\u0001\u0000\u0000\u0000\u0000\u0088\u0001\u0000\u0000\u0000"+ + "\u0000\u008a\u0001\u0000\u0000\u0000\u0000\u008c\u0001\u0000\u0000\u0000"+ + "\u0000\u008e\u0001\u0000\u0000\u0000\u0000\u0090\u0001\u0000\u0000\u0000"+ + "\u0000\u0092\u0001\u0000\u0000\u0000\u0000\u0094\u0001\u0000\u0000\u0000"+ + "\u0000\u0096\u0001\u0000\u0000\u0000\u0000\u0098\u0001\u0000\u0000\u0000"+ + "\u0000\u009a\u0001\u0000\u0000\u0000\u0000\u009c\u0001\u0000\u0000\u0000"+ + "\u0000\u009e\u0001\u0000\u0000\u0000\u0000\u00a0\u0001\u0000\u0000\u0000"+ + "\u0000\u00a2\u0001\u0000\u0000\u0000\u0000\u00a4\u0001\u0000\u0000\u0000"+ + "\u0000\u00a6\u0001\u0000\u0000\u0000\u0000\u00a8\u0001\u0000\u0000\u0000"+ + "\u0000\u00aa\u0001\u0000\u0000\u0000\u0000\u00ac\u0001\u0000\u0000\u0000"+ + "\u0000\u00ae\u0001\u0000\u0000\u0000\u0000\u00b0\u0001\u0000\u0000\u0000"+ + "\u0000\u00b2\u0001\u0000\u0000\u0000\u0000\u00b4\u0001\u0000\u0000\u0000"+ + "\u0000\u00b6\u0001\u0000\u0000\u0000\u0000\u00b8\u0001\u0000\u0000\u0000"+ + "\u0000\u00ba\u0001\u0000\u0000\u0000\u0000\u00bc\u0001\u0000\u0000\u0000"+ + "\u0000\u00be\u0001\u0000\u0000\u0000\u0000\u00c0\u0001\u0000\u0000\u0000"+ + "\u0000\u00c2\u0001\u0000\u0000\u0000\u0000\u00c4\u0001\u0000\u0000\u0000"+ + "\u0000\u00c6\u0001\u0000\u0000\u0000\u0000\u00c8\u0001\u0000\u0000\u0000"+ + "\u0000\u00ca\u0001\u0000\u0000\u0000\u0000\u00cc\u0001\u0000\u0000\u0000"+ + "\u0000\u00ce\u0001\u0000\u0000\u0000\u0000\u00d0\u0001\u0000\u0000\u0000"+ + "\u0000\u00d2\u0001\u0000\u0000\u0000\u0000\u00d4\u0001\u0000\u0000\u0000"+ + "\u0000\u00d6\u0001\u0000\u0000\u0000\u0000\u00d8\u0001\u0000\u0000\u0000"+ + "\u0000\u00da\u0001\u0000\u0000\u0000\u0000\u00dc\u0001\u0000\u0000\u0000"+ + "\u0000\u00de\u0001\u0000\u0000\u0000\u0000\u00e0\u0001\u0000\u0000\u0000"+ + "\u0000\u00e2\u0001\u0000\u0000\u0000\u0000\u00e4\u0001\u0000\u0000\u0000"+ + "\u0000\u00e6\u0001\u0000\u0000\u0000\u0000\u00e8\u0001\u0000\u0000\u0000"+ + "\u0000\u00ea\u0001\u0000\u0000\u0000\u0000\u00ec\u0001\u0000\u0000\u0000"+ + "\u0000\u00ee\u0001\u0000\u0000\u0000\u0000\u00f0\u0001\u0000\u0000\u0000"+ + "\u0000\u00f2\u0001\u0000\u0000\u0000\u0000\u00f4\u0001\u0000\u0000\u0000"+ + "\u0000\u00f6\u0001\u0000\u0000\u0000\u0000\u00f8\u0001\u0000\u0000\u0000"+ + "\u0000\u00fa\u0001\u0000\u0000\u0000\u0000\u00fc\u0001\u0000\u0000\u0000"+ + "\u0000\u00fe\u0001\u0000\u0000\u0000\u0000\u0100\u0001\u0000\u0000\u0000"+ + "\u0000\u0102\u0001\u0000\u0000\u0000\u0000\u0104\u0001\u0000\u0000\u0000"+ + "\u0000\u0106\u0001\u0000\u0000\u0000\u0001\u0108\u0001\u0000\u0000\u0000"+ + "\u0001\u010a\u0001\u0000\u0000\u0000\u0001\u010c\u0001\u0000\u0000\u0000"+ + "\u0001\u010e\u0001\u0000\u0000\u0000\u0002\u0138\u0001\u0000\u0000\u0000"+ + "\u0004\u0146\u0001\u0000\u0000\u0000\u0006\u0151\u0001\u0000\u0000\u0000"+ + "\b\u0161\u0001\u0000\u0000\u0000\n\u0163\u0001\u0000\u0000\u0000\f\u0165"+ + "\u0001\u0000\u0000\u0000\u000e\u0167\u0001\u0000\u0000\u0000\u0010\u0169"+ + "\u0001\u0000\u0000\u0000\u0012\u016c\u0001\u0000\u0000\u0000\u0014\u0171"+ + "\u0001\u0000\u0000\u0000\u0016\u0174\u0001\u0000\u0000\u0000\u0018\u0176"+ + "\u0001\u0000\u0000\u0000\u001a\u0178\u0001\u0000\u0000\u0000\u001c\u017a"+ + "\u0001\u0000\u0000\u0000\u001e\u017c\u0001\u0000\u0000\u0000 \u017e\u0001"+ + "\u0000\u0000\u0000\"\u0182\u0001\u0000\u0000\u0000$\u0184\u0001\u0000"+ + "\u0000\u0000&\u0187\u0001\u0000\u0000\u0000(\u018a\u0001\u0000\u0000\u0000"+ + "*\u018c\u0001\u0000\u0000\u0000,\u018e\u0001\u0000\u0000\u0000.\u0190"+ + "\u0001\u0000\u0000\u00000\u0192\u0001\u0000\u0000\u00002\u0194\u0001\u0000"+ + "\u0000\u00004\u0196\u0001\u0000\u0000\u00006\u0198\u0001\u0000\u0000\u0000"+ + "8\u019b\u0001\u0000\u0000\u0000:\u019e\u0001\u0000\u0000\u0000<\u01a2"+ + "\u0001\u0000\u0000\u0000>\u01a4\u0001\u0000\u0000\u0000@\u01a6\u0001\u0000"+ + "\u0000\u0000B\u01a9\u0001\u0000\u0000\u0000D\u01ac\u0001\u0000\u0000\u0000"+ + "F\u01af\u0001\u0000\u0000\u0000H\u01b2\u0001\u0000\u0000\u0000J\u01b6"+ + "\u0001\u0000\u0000\u0000L\u01ba\u0001\u0000\u0000\u0000N\u01bc\u0001\u0000"+ + "\u0000\u0000P\u01be\u0001\u0000\u0000\u0000R\u01c0\u0001\u0000\u0000\u0000"+ + "T\u01c3\u0001\u0000\u0000\u0000V\u01c6\u0001\u0000\u0000\u0000X\u01c9"+ + "\u0001\u0000\u0000\u0000Z\u01cc\u0001\u0000\u0000\u0000\\\u01cf\u0001"+ + "\u0000\u0000\u0000^\u01d2\u0001\u0000\u0000\u0000`\u01d5\u0001\u0000\u0000"+ + "\u0000b\u01d9\u0001\u0000\u0000\u0000d\u01dd\u0001\u0000\u0000\u0000f"+ + "\u01e2\u0001\u0000\u0000\u0000h\u01e5\u0001\u0000\u0000\u0000j\u01e8\u0001"+ + "\u0000\u0000\u0000l\u01eb\u0001\u0000\u0000\u0000n\u01ee\u0001\u0000\u0000"+ + "\u0000p\u01fc\u0001\u0000\u0000\u0000r\u0216\u0001\u0000\u0000\u0000t"+ + "\u0218\u0001\u0000\u0000\u0000v\u021f\u0001\u0000\u0000\u0000x\u0227\u0001"+ + "\u0000\u0000\u0000z\u022e\u0001\u0000\u0000\u0000|\u0235\u0001\u0000\u0000"+ + "\u0000~\u023b\u0001\u0000\u0000\u0000\u0080\u023e\u0001\u0000\u0000\u0000"+ + "\u0082\u0249\u0001\u0000\u0000\u0000\u0084\u0250\u0001\u0000\u0000\u0000"+ + "\u0086\u0255\u0001\u0000\u0000\u0000\u0088\u025a\u0001\u0000\u0000\u0000"+ + "\u008a\u025e\u0001\u0000\u0000\u0000\u008c\u0262\u0001\u0000\u0000\u0000"+ + "\u008e\u0268\u0001\u0000\u0000\u0000\u0090\u0270\u0001\u0000\u0000\u0000"+ + "\u0092\u0277\u0001\u0000\u0000\u0000\u0094\u027c\u0001\u0000\u0000\u0000"+ + "\u0096\u0285\u0001\u0000\u0000\u0000\u0098\u0289\u0001\u0000\u0000\u0000"+ + "\u009a\u0290\u0001\u0000\u0000\u0000\u009c\u0296\u0001\u0000\u0000\u0000"+ + "\u009e\u029f\u0001\u0000\u0000\u0000\u00a0\u02a8\u0001\u0000\u0000\u0000"+ + "\u00a2\u02ad\u0001\u0000\u0000\u0000\u00a4\u02b2\u0001\u0000\u0000\u0000"+ + "\u00a6\u02ba\u0001\u0000\u0000\u0000\u00a8\u02bd\u0001\u0000\u0000\u0000"+ + "\u00aa\u02c3\u0001\u0000\u0000\u0000\u00ac\u02ca\u0001\u0000\u0000\u0000"+ + "\u00ae\u02cd\u0001\u0000\u0000\u0000\u00b0\u02d1\u0001\u0000\u0000\u0000"+ + "\u00b2\u02d4\u0001\u0000\u0000\u0000\u00b4\u02d9\u0001\u0000\u0000\u0000"+ + "\u00b6\u02e2\u0001\u0000\u0000\u0000\u00b8\u02e8\u0001\u0000\u0000\u0000"+ + "\u00ba\u02ee\u0001\u0000\u0000\u0000\u00bc\u02f3\u0001\u0000\u0000\u0000"+ + "\u00be\u02fb\u0001\u0000\u0000\u0000\u00c0\u0301\u0001\u0000\u0000\u0000"+ + "\u00c2\u0307\u0001\u0000\u0000\u0000\u00c4\u030e\u0001\u0000\u0000\u0000"+ + "\u00c6\u0315\u0001\u0000\u0000\u0000\u00c8\u0320\u0001\u0000\u0000\u0000"+ + "\u00ca\u0324\u0001\u0000\u0000\u0000\u00cc\u032c\u0001\u0000\u0000\u0000"+ + "\u00ce\u0333\u0001\u0000\u0000\u0000\u00d0\u033d\u0001\u0000\u0000\u0000"+ + "\u00d2\u0345\u0001\u0000\u0000\u0000\u00d4\u034f\u0001\u0000\u0000\u0000"+ + "\u00d6\u0356\u0001\u0000\u0000\u0000\u00d8\u035c\u0001\u0000\u0000\u0000"+ + "\u00da\u0360\u0001\u0000\u0000\u0000\u00dc\u0367\u0001\u0000\u0000\u0000"+ + "\u00de\u036f\u0001\u0000\u0000\u0000\u00e0\u0376\u0001\u0000\u0000\u0000"+ + "\u00e2\u037d\u0001\u0000\u0000\u0000\u00e4\u0382\u0001\u0000\u0000\u0000"+ + "\u00e6\u0386\u0001\u0000\u0000\u0000\u00e8\u038a\u0001\u0000\u0000\u0000"+ + "\u00ea\u0396\u0001\u0000\u0000\u0000\u00ec\u03a0\u0001\u0000\u0000\u0000"+ + "\u00ee\u03a8\u0001\u0000\u0000\u0000\u00f0\u03af\u0001\u0000\u0000\u0000"+ + "\u00f2\u03b7\u0001\u0000\u0000\u0000\u00f4\u03c0\u0001\u0000\u0000\u0000"+ + "\u00f6\u03c3\u0001\u0000\u0000\u0000\u00f8\u03c5\u0001\u0000\u0000\u0000"+ + "\u00fa\u03dc\u0001\u0000\u0000\u0000\u00fc\u03e0\u0001\u0000\u0000\u0000"+ + "\u00fe\u03e6\u0001\u0000\u0000\u0000\u0100\u03ec\u0001\u0000\u0000\u0000"+ + "\u0102\u03f0\u0001\u0000\u0000\u0000\u0104\u0401\u0001\u0000\u0000\u0000"+ + "\u0106\u0417\u0001\u0000\u0000\u0000\u0108\u041b\u0001\u0000\u0000\u0000"+ + "\u010a\u041e\u0001\u0000\u0000\u0000\u010c\u0424\u0001\u0000\u0000\u0000"+ + "\u010e\u042b\u0001\u0000\u0000\u0000\u0110\u0431\u0001\u0000\u0000\u0000"+ + "\u0112\u0437\u0001\u0000\u0000\u0000\u0114\u043e\u0001\u0000\u0000\u0000"+ + "\u0116\u0442\u0001\u0000\u0000\u0000\u0118\u0444\u0001\u0000\u0000\u0000"+ + "\u011a\u0448\u0001\u0000\u0000\u0000\u011c\u044e\u0001\u0000\u0000\u0000"+ + "\u011e\u0457\u0001\u0000\u0000\u0000\u0120\u0459\u0001\u0000\u0000\u0000"+ + "\u0122\u045d\u0001\u0000\u0000\u0000\u0124\u045f\u0001\u0000\u0000\u0000"+ + "\u0126\u0462\u0001\u0000\u0000\u0000\u0128\u046c\u0001\u0000\u0000\u0000"+ + "\u012a\u046e\u0001\u0000\u0000\u0000\u012c\u0479\u0001\u0000\u0000\u0000"+ + "\u012e\u047e\u0001\u0000\u0000\u0000\u0130\u048a\u0001\u0000\u0000\u0000"+ + "\u0132\u0496\u0001\u0000\u0000\u0000\u0134\u049a\u0001\u0000\u0000\u0000"+ + "\u0136\u049c\u0001\u0000\u0000\u0000\u0138\u0139\u0005/\u0000\u0000\u0139"+ + "\u013a\u0005*\u0000\u0000\u013a\u013e\u0001\u0000\u0000\u0000\u013b\u013d"+ + "\t\u0000\u0000\u0000\u013c\u013b\u0001\u0000\u0000\u0000\u013d\u0140\u0001"+ + "\u0000\u0000\u0000\u013e\u013f\u0001\u0000\u0000\u0000\u013e\u013c\u0001"+ + "\u0000\u0000\u0000\u013f\u0141\u0001\u0000\u0000\u0000\u0140\u013e\u0001"+ + "\u0000\u0000\u0000\u0141\u0142\u0005*\u0000\u0000\u0142\u0143\u0005/\u0000"+ + "\u0000\u0143\u0144\u0001\u0000\u0000\u0000\u0144\u0145\u0006\u0000\u0000"+ + "\u0000\u0145\u0003\u0001\u0000\u0000\u0000\u0146\u0147\u0005/\u0000\u0000"+ + "\u0147\u0148\u0005/\u0000\u0000\u0148\u014c\u0001\u0000\u0000\u0000\u0149"+ + "\u014b\b\u0000\u0000\u0000\u014a\u0149\u0001\u0000\u0000\u0000\u014b\u014e"+ + "\u0001\u0000\u0000\u0000\u014c\u014a\u0001\u0000\u0000\u0000\u014c\u014d"+ + "\u0001\u0000\u0000\u0000\u014d\u014f\u0001\u0000\u0000\u0000\u014e\u014c"+ + "\u0001\u0000\u0000\u0000\u014f\u0150\u0006\u0001\u0000\u0000\u0150\u0005"+ + "\u0001\u0000\u0000\u0000\u0151\u0152\u0005/\u0000\u0000\u0152\u0156\u0003"+ + "\u0130\u0097\u0000\u0153\u0155\u0003\u0132\u0098\u0000\u0154\u0153\u0001"+ + "\u0000\u0000\u0000\u0155\u0158\u0001\u0000\u0000\u0000\u0156\u0154\u0001"+ + "\u0000\u0000\u0000\u0156\u0157\u0001\u0000\u0000\u0000\u0157\u0159\u0001"+ + "\u0000\u0000\u0000\u0158\u0156\u0001\u0000\u0000\u0000\u0159\u015a\u0004"+ + "\u0002\u0000\u0000\u015a\u015e\u0005/\u0000\u0000\u015b\u015d\u0003\u012c"+ + "\u0095\u0000\u015c\u015b\u0001\u0000\u0000\u0000\u015d\u0160\u0001\u0000"+ + "\u0000\u0000\u015e\u015c\u0001\u0000\u0000\u0000\u015e\u015f\u0001\u0000"+ + "\u0000\u0000\u015f\u0007\u0001\u0000\u0000\u0000\u0160\u015e\u0001\u0000"+ + "\u0000\u0000\u0161\u0162\u0005[\u0000\u0000\u0162\t\u0001\u0000\u0000"+ + "\u0000\u0163\u0164\u0005]\u0000\u0000\u0164\u000b\u0001\u0000\u0000\u0000"+ + "\u0165\u0166\u0005(\u0000\u0000\u0166\r\u0001\u0000\u0000\u0000\u0167"+ + "\u0168\u0005)\u0000\u0000\u0168\u000f\u0001\u0000\u0000\u0000\u0169\u016a"+ + "\u0005{\u0000\u0000\u016a\u016b\u0006\u0007\u0001\u0000\u016b\u0011\u0001"+ + "\u0000\u0000\u0000\u016c\u016d\u0004\b\u0001\u0000\u016d\u016e\u0005}"+ + "\u0000\u0000\u016e\u016f\u0001\u0000\u0000\u0000\u016f\u0170\u0006\b\u0002"+ + "\u0000\u0170\u0013\u0001\u0000\u0000\u0000\u0171\u0172\u0005}\u0000\u0000"+ + "\u0172\u0173\u0006\t\u0003\u0000\u0173\u0015\u0001\u0000\u0000\u0000\u0174"+ + "\u0175\u0005;\u0000\u0000\u0175\u0017\u0001\u0000\u0000\u0000\u0176\u0177"+ + "\u0005,\u0000\u0000\u0177\u0019\u0001\u0000\u0000\u0000\u0178\u0179\u0005"+ + "=\u0000\u0000\u0179\u001b\u0001\u0000\u0000\u0000\u017a\u017b\u0005?\u0000"+ + "\u0000\u017b\u001d\u0001\u0000\u0000\u0000\u017c\u017d\u0005:\u0000\u0000"+ + "\u017d\u001f\u0001\u0000\u0000\u0000\u017e\u017f\u0005.\u0000\u0000\u017f"+ + "\u0180\u0005.\u0000\u0000\u0180\u0181\u0005.\u0000\u0000\u0181!\u0001"+ + "\u0000\u0000\u0000\u0182\u0183\u0005.\u0000\u0000\u0183#\u0001\u0000\u0000"+ + "\u0000\u0184\u0185\u0005+\u0000\u0000\u0185\u0186\u0005+\u0000\u0000\u0186"+ + "%\u0001\u0000\u0000\u0000\u0187\u0188\u0005-\u0000\u0000\u0188\u0189\u0005"+ + "-\u0000\u0000\u0189\'\u0001\u0000\u0000\u0000\u018a\u018b\u0005+\u0000"+ + "\u0000\u018b)\u0001\u0000\u0000\u0000\u018c\u018d\u0005-\u0000\u0000\u018d"+ + "+\u0001\u0000\u0000\u0000\u018e\u018f\u0005~\u0000\u0000\u018f-\u0001"+ + "\u0000\u0000\u0000\u0190\u0191\u0005!\u0000\u0000\u0191/\u0001\u0000\u0000"+ + "\u0000\u0192\u0193\u0005*\u0000\u0000\u01931\u0001\u0000\u0000\u0000\u0194"+ + "\u0195\u0005/\u0000\u0000\u01953\u0001\u0000\u0000\u0000\u0196\u0197\u0005"+ + "%\u0000\u0000\u01975\u0001\u0000\u0000\u0000\u0198\u0199\u0005>\u0000"+ + "\u0000\u0199\u019a\u0005>\u0000\u0000\u019a7\u0001\u0000\u0000\u0000\u019b"+ + "\u019c\u0005<\u0000\u0000\u019c\u019d\u0005<\u0000\u0000\u019d9\u0001"+ + "\u0000\u0000\u0000\u019e\u019f\u0005>\u0000\u0000\u019f\u01a0\u0005>\u0000"+ + "\u0000\u01a0\u01a1\u0005>\u0000\u0000\u01a1;\u0001\u0000\u0000\u0000\u01a2"+ + "\u01a3\u0005<\u0000\u0000\u01a3=\u0001\u0000\u0000\u0000\u01a4\u01a5\u0005"+ + ">\u0000\u0000\u01a5?\u0001\u0000\u0000\u0000\u01a6\u01a7\u0005<\u0000"+ + "\u0000\u01a7\u01a8\u0005=\u0000\u0000\u01a8A\u0001\u0000\u0000\u0000\u01a9"+ + "\u01aa\u0005>\u0000\u0000\u01aa\u01ab\u0005=\u0000\u0000\u01abC\u0001"+ + "\u0000\u0000\u0000\u01ac\u01ad\u0005=\u0000\u0000\u01ad\u01ae\u0005=\u0000"+ + "\u0000\u01aeE\u0001\u0000\u0000\u0000\u01af\u01b0\u0005!\u0000\u0000\u01b0"+ + "\u01b1\u0005=\u0000\u0000\u01b1G\u0001\u0000\u0000\u0000\u01b2\u01b3\u0005"+ + "=\u0000\u0000\u01b3\u01b4\u0005=\u0000\u0000\u01b4\u01b5\u0005=\u0000"+ + "\u0000\u01b5I\u0001\u0000\u0000\u0000\u01b6\u01b7\u0005!\u0000\u0000\u01b7"+ + "\u01b8\u0005=\u0000\u0000\u01b8\u01b9\u0005=\u0000\u0000\u01b9K\u0001"+ + "\u0000\u0000\u0000\u01ba\u01bb\u0005&\u0000\u0000\u01bbM\u0001\u0000\u0000"+ + "\u0000\u01bc\u01bd\u0005^\u0000\u0000\u01bdO\u0001\u0000\u0000\u0000\u01be"+ + "\u01bf\u0005|\u0000\u0000\u01bfQ\u0001\u0000\u0000\u0000\u01c0\u01c1\u0005"+ + "&\u0000\u0000\u01c1\u01c2\u0005&\u0000\u0000\u01c2S\u0001\u0000\u0000"+ + "\u0000\u01c3\u01c4\u0005|\u0000\u0000\u01c4\u01c5\u0005|\u0000\u0000\u01c5"+ + "U\u0001\u0000\u0000\u0000\u01c6\u01c7\u0005*\u0000\u0000\u01c7\u01c8\u0005"+ + "=\u0000\u0000\u01c8W\u0001\u0000\u0000\u0000\u01c9\u01ca\u0005/\u0000"+ + "\u0000\u01ca\u01cb\u0005=\u0000\u0000\u01cbY\u0001\u0000\u0000\u0000\u01cc"+ + "\u01cd\u0005%\u0000\u0000\u01cd\u01ce\u0005=\u0000\u0000\u01ce[\u0001"+ + "\u0000\u0000\u0000\u01cf\u01d0\u0005+\u0000\u0000\u01d0\u01d1\u0005=\u0000"+ + "\u0000\u01d1]\u0001\u0000\u0000\u0000\u01d2\u01d3\u0005-\u0000\u0000\u01d3"+ + "\u01d4\u0005=\u0000\u0000\u01d4_\u0001\u0000\u0000\u0000\u01d5\u01d6\u0005"+ + "<\u0000\u0000\u01d6\u01d7\u0005<\u0000\u0000\u01d7\u01d8\u0005=\u0000"+ + "\u0000\u01d8a\u0001\u0000\u0000\u0000\u01d9\u01da\u0005>\u0000\u0000\u01da"+ + "\u01db\u0005>\u0000\u0000\u01db\u01dc\u0005=\u0000\u0000\u01dcc\u0001"+ + "\u0000\u0000\u0000\u01dd\u01de\u0005>\u0000\u0000\u01de\u01df\u0005>\u0000"+ + "\u0000\u01df\u01e0\u0005>\u0000\u0000\u01e0\u01e1\u0005=\u0000\u0000\u01e1"+ + "e\u0001\u0000\u0000\u0000\u01e2\u01e3\u0005&\u0000\u0000\u01e3\u01e4\u0005"+ + "=\u0000\u0000\u01e4g\u0001\u0000\u0000\u0000\u01e5\u01e6\u0005^\u0000"+ + "\u0000\u01e6\u01e7\u0005=\u0000\u0000\u01e7i\u0001\u0000\u0000\u0000\u01e8"+ + "\u01e9\u0005|\u0000\u0000\u01e9\u01ea\u0005=\u0000\u0000\u01eak\u0001"+ + "\u0000\u0000\u0000\u01eb\u01ec\u0005=\u0000\u0000\u01ec\u01ed\u0005>\u0000"+ + "\u0000\u01edm\u0001\u0000\u0000\u0000\u01ee\u01ef\u0005n\u0000\u0000\u01ef"+ + "\u01f0\u0005u\u0000\u0000\u01f0\u01f1\u0005l\u0000\u0000\u01f1\u01f2\u0005"+ + "l\u0000\u0000\u01f2o\u0001\u0000\u0000\u0000\u01f3\u01f4\u0005t\u0000"+ + "\u0000\u01f4\u01f5\u0005r\u0000\u0000\u01f5\u01f6\u0005u\u0000\u0000\u01f6"+ + "\u01fd\u0005e\u0000\u0000\u01f7\u01f8\u0005f\u0000\u0000\u01f8\u01f9\u0005"+ + "a\u0000\u0000\u01f9\u01fa\u0005l\u0000\u0000\u01fa\u01fb\u0005s\u0000"+ + "\u0000\u01fb\u01fd\u0005e\u0000\u0000\u01fc\u01f3\u0001\u0000\u0000\u0000"+ + "\u01fc\u01f7\u0001\u0000\u0000\u0000\u01fdq\u0001\u0000\u0000\u0000\u01fe"+ + "\u01ff\u0003\u0128\u0093\u0000\u01ff\u0203\u0005.\u0000\u0000\u0200\u0202"+ + "\u0007\u0001\u0000\u0000\u0201\u0200\u0001\u0000\u0000\u0000\u0202\u0205"+ + "\u0001\u0000\u0000\u0000\u0203\u0201\u0001\u0000\u0000\u0000\u0203\u0204"+ + "\u0001\u0000\u0000\u0000\u0204\u0207\u0001\u0000\u0000\u0000\u0205\u0203"+ + "\u0001\u0000\u0000\u0000\u0206\u0208\u0003\u012a\u0094\u0000\u0207\u0206"+ + "\u0001\u0000\u0000\u0000\u0207\u0208\u0001\u0000\u0000\u0000\u0208\u0217"+ + "\u0001\u0000\u0000\u0000\u0209\u020b\u0005.\u0000\u0000\u020a\u020c\u0007"+ + "\u0001\u0000\u0000\u020b\u020a\u0001\u0000\u0000\u0000\u020c\u020d\u0001"+ + "\u0000\u0000\u0000\u020d\u020b\u0001\u0000\u0000\u0000\u020d\u020e\u0001"+ + "\u0000\u0000\u0000\u020e\u0210\u0001\u0000\u0000\u0000\u020f\u0211\u0003"+ + "\u012a\u0094\u0000\u0210\u020f\u0001\u0000\u0000\u0000\u0210\u0211\u0001"+ + "\u0000\u0000\u0000\u0211\u0217\u0001\u0000\u0000\u0000\u0212\u0214\u0003"+ + "\u0128\u0093\u0000\u0213\u0215\u0003\u012a\u0094\u0000\u0214\u0213\u0001"+ + "\u0000\u0000\u0000\u0214\u0215\u0001\u0000\u0000\u0000\u0215\u0217\u0001"+ + "\u0000\u0000\u0000\u0216\u01fe\u0001\u0000\u0000\u0000\u0216\u0209\u0001"+ + "\u0000\u0000\u0000\u0216\u0212\u0001\u0000\u0000\u0000\u0217s\u0001\u0000"+ + "\u0000\u0000\u0218\u0219\u00050\u0000\u0000\u0219\u021b\u0007\u0002\u0000"+ + "\u0000\u021a\u021c\u0003\u0126\u0092\u0000\u021b\u021a\u0001\u0000\u0000"+ + "\u0000\u021c\u021d\u0001\u0000\u0000\u0000\u021d\u021b\u0001\u0000\u0000"+ + "\u0000\u021d\u021e\u0001\u0000\u0000\u0000\u021eu\u0001\u0000\u0000\u0000"+ + "\u021f\u0221\u00050\u0000\u0000\u0220\u0222\u0007\u0003\u0000\u0000\u0221"+ + "\u0220\u0001\u0000\u0000\u0000\u0222\u0223\u0001\u0000\u0000\u0000\u0223"+ + "\u0221\u0001\u0000\u0000\u0000\u0223\u0224\u0001\u0000\u0000\u0000\u0224"+ + "\u0225\u0001\u0000\u0000\u0000\u0225\u0226\u0004:\u0002\u0000\u0226w\u0001"+ + "\u0000\u0000\u0000\u0227\u0228\u00050\u0000\u0000\u0228\u022a\u0007\u0004"+ + "\u0000\u0000\u0229\u022b\u0007\u0003\u0000\u0000\u022a\u0229\u0001\u0000"+ + "\u0000\u0000\u022b\u022c\u0001\u0000\u0000\u0000\u022c\u022a\u0001\u0000"+ + "\u0000\u0000\u022c\u022d\u0001\u0000\u0000\u0000\u022dy\u0001\u0000\u0000"+ + "\u0000\u022e\u022f\u00050\u0000\u0000\u022f\u0231\u0007\u0005\u0000\u0000"+ + "\u0230\u0232\u0007\u0006\u0000\u0000\u0231\u0230\u0001\u0000\u0000\u0000"+ + "\u0232\u0233\u0001\u0000\u0000\u0000\u0233\u0231\u0001\u0000\u0000\u0000"+ + "\u0233\u0234\u0001\u0000\u0000\u0000\u0234{\u0001\u0000\u0000\u0000\u0235"+ + "\u0236\u0005b\u0000\u0000\u0236\u0237\u0005r\u0000\u0000\u0237\u0238\u0005"+ + "e\u0000\u0000\u0238\u0239\u0005a\u0000\u0000\u0239\u023a\u0005k\u0000"+ + "\u0000\u023a}\u0001\u0000\u0000\u0000\u023b\u023c\u0005d\u0000\u0000\u023c"+ + "\u023d\u0005o\u0000\u0000\u023d\u007f\u0001\u0000\u0000\u0000\u023e\u023f"+ + "\u0005i\u0000\u0000\u023f\u0240\u0005n\u0000\u0000\u0240\u0241\u0005s"+ + "\u0000\u0000\u0241\u0242\u0005t\u0000\u0000\u0242\u0243\u0005a\u0000\u0000"+ + "\u0243\u0244\u0005n\u0000\u0000\u0244\u0245\u0005c\u0000\u0000\u0245\u0246"+ + "\u0005e\u0000\u0000\u0246\u0247\u0005o\u0000\u0000\u0247\u0248\u0005f"+ + "\u0000\u0000\u0248\u0081\u0001\u0000\u0000\u0000\u0249\u024a\u0005t\u0000"+ + "\u0000\u024a\u024b\u0005y\u0000\u0000\u024b\u024c\u0005p\u0000\u0000\u024c"+ + "\u024d\u0005e\u0000\u0000\u024d\u024e\u0005o\u0000\u0000\u024e\u024f\u0005"+ + "f\u0000\u0000\u024f\u0083\u0001\u0000\u0000\u0000\u0250\u0251\u0005c\u0000"+ + "\u0000\u0251\u0252\u0005a\u0000\u0000\u0252\u0253\u0005s\u0000\u0000\u0253"+ + "\u0254\u0005e\u0000\u0000\u0254\u0085\u0001\u0000\u0000\u0000\u0255\u0256"+ + "\u0005e\u0000\u0000\u0256\u0257\u0005l\u0000\u0000\u0257\u0258\u0005s"+ + "\u0000\u0000\u0258\u0259\u0005e\u0000\u0000\u0259\u0087\u0001\u0000\u0000"+ + "\u0000\u025a\u025b\u0005n\u0000\u0000\u025b\u025c\u0005e\u0000\u0000\u025c"+ + "\u025d\u0005w\u0000\u0000\u025d\u0089\u0001\u0000\u0000\u0000\u025e\u025f"+ + "\u0005v\u0000\u0000\u025f\u0260\u0005a\u0000\u0000\u0260\u0261\u0005r"+ + "\u0000\u0000\u0261\u008b\u0001\u0000\u0000\u0000\u0262\u0263\u0005c\u0000"+ + "\u0000\u0263\u0264\u0005a\u0000\u0000\u0264\u0265\u0005t\u0000\u0000\u0265"+ + "\u0266\u0005c\u0000\u0000\u0266\u0267\u0005h\u0000\u0000\u0267\u008d\u0001"+ + "\u0000\u0000\u0000\u0268\u0269\u0005f\u0000\u0000\u0269\u026a\u0005i\u0000"+ + "\u0000\u026a\u026b\u0005n\u0000\u0000\u026b\u026c\u0005a\u0000\u0000\u026c"+ + "\u026d\u0005l\u0000\u0000\u026d\u026e\u0005l\u0000\u0000\u026e\u026f\u0005"+ + "y\u0000\u0000\u026f\u008f\u0001\u0000\u0000\u0000\u0270\u0271\u0005r\u0000"+ + "\u0000\u0271\u0272\u0005e\u0000\u0000\u0272\u0273\u0005t\u0000\u0000\u0273"+ + "\u0274\u0005u\u0000\u0000\u0274\u0275\u0005r\u0000\u0000\u0275\u0276\u0005"+ + "n\u0000\u0000\u0276\u0091\u0001\u0000\u0000\u0000\u0277\u0278\u0005v\u0000"+ + "\u0000\u0278\u0279\u0005o\u0000\u0000\u0279\u027a\u0005i\u0000\u0000\u027a"+ + "\u027b\u0005d\u0000\u0000\u027b\u0093\u0001\u0000\u0000\u0000\u027c\u027d"+ + "\u0005c\u0000\u0000\u027d\u027e\u0005o\u0000\u0000\u027e\u027f\u0005n"+ + "\u0000\u0000\u027f\u0280\u0005t\u0000\u0000\u0280\u0281\u0005i\u0000\u0000"+ + "\u0281\u0282\u0005n\u0000\u0000\u0282\u0283\u0005u\u0000\u0000\u0283\u0284"+ + "\u0005e\u0000\u0000\u0284\u0095\u0001\u0000\u0000\u0000\u0285\u0286\u0005"+ + "f\u0000\u0000\u0286\u0287\u0005o\u0000\u0000\u0287\u0288\u0005r\u0000"+ + "\u0000\u0288\u0097\u0001\u0000\u0000\u0000\u0289\u028a\u0005s\u0000\u0000"+ + "\u028a\u028b\u0005w\u0000\u0000\u028b\u028c\u0005i\u0000\u0000\u028c\u028d"+ + "\u0005t\u0000\u0000\u028d\u028e\u0005c\u0000\u0000\u028e\u028f\u0005h"+ + "\u0000\u0000\u028f\u0099\u0001\u0000\u0000\u0000\u0290\u0291\u0005w\u0000"+ + "\u0000\u0291\u0292\u0005h\u0000\u0000\u0292\u0293\u0005i\u0000\u0000\u0293"+ + "\u0294\u0005l\u0000\u0000\u0294\u0295\u0005e\u0000\u0000\u0295\u009b\u0001"+ + "\u0000\u0000\u0000\u0296\u0297\u0005d\u0000\u0000\u0297\u0298\u0005e\u0000"+ + "\u0000\u0298\u0299\u0005b\u0000\u0000\u0299\u029a\u0005u\u0000\u0000\u029a"+ + "\u029b\u0005g\u0000\u0000\u029b\u029c\u0005g\u0000\u0000\u029c\u029d\u0005"+ + "e\u0000\u0000\u029d\u029e\u0005r\u0000\u0000\u029e\u009d\u0001\u0000\u0000"+ + "\u0000\u029f\u02a0\u0005f\u0000\u0000\u02a0\u02a1\u0005u\u0000\u0000\u02a1"+ + "\u02a2\u0005n\u0000\u0000\u02a2\u02a3\u0005c\u0000\u0000\u02a3\u02a4\u0005"+ + "t\u0000\u0000\u02a4\u02a5\u0005i\u0000\u0000\u02a5\u02a6\u0005o\u0000"+ + "\u0000\u02a6\u02a7\u0005n\u0000\u0000\u02a7\u009f\u0001\u0000\u0000\u0000"+ + "\u02a8\u02a9\u0005t\u0000\u0000\u02a9\u02aa\u0005h\u0000\u0000\u02aa\u02ab"+ + "\u0005i\u0000\u0000\u02ab\u02ac\u0005s\u0000\u0000\u02ac\u00a1\u0001\u0000"+ + "\u0000\u0000\u02ad\u02ae\u0005w\u0000\u0000\u02ae\u02af\u0005i\u0000\u0000"+ + "\u02af\u02b0\u0005t\u0000\u0000\u02b0\u02b1\u0005h\u0000\u0000\u02b1\u00a3"+ + "\u0001\u0000\u0000\u0000\u02b2\u02b3\u0005d\u0000\u0000\u02b3\u02b4\u0005"+ + "e\u0000\u0000\u02b4\u02b5\u0005f\u0000\u0000\u02b5\u02b6\u0005a\u0000"+ + "\u0000\u02b6\u02b7\u0005u\u0000\u0000\u02b7\u02b8\u0005l\u0000\u0000\u02b8"+ + "\u02b9\u0005t\u0000\u0000\u02b9\u00a5\u0001\u0000\u0000\u0000\u02ba\u02bb"+ + "\u0005i\u0000\u0000\u02bb\u02bc\u0005f\u0000\u0000\u02bc\u00a7\u0001\u0000"+ + "\u0000\u0000\u02bd\u02be\u0005t\u0000\u0000\u02be\u02bf\u0005h\u0000\u0000"+ + "\u02bf\u02c0\u0005r\u0000\u0000\u02c0\u02c1\u0005o\u0000\u0000\u02c1\u02c2"+ + "\u0005w\u0000\u0000\u02c2\u00a9\u0001\u0000\u0000\u0000\u02c3\u02c4\u0005"+ + "d\u0000\u0000\u02c4\u02c5\u0005e\u0000\u0000\u02c5\u02c6\u0005l\u0000"+ + "\u0000\u02c6\u02c7\u0005e\u0000\u0000\u02c7\u02c8\u0005t\u0000\u0000\u02c8"+ + "\u02c9\u0005e\u0000\u0000\u02c9\u00ab\u0001\u0000\u0000\u0000\u02ca\u02cb"+ + "\u0005i\u0000\u0000\u02cb\u02cc\u0005n\u0000\u0000\u02cc\u00ad\u0001\u0000"+ + "\u0000\u0000\u02cd\u02ce\u0005t\u0000\u0000\u02ce\u02cf\u0005r\u0000\u0000"+ + "\u02cf\u02d0\u0005y\u0000\u0000\u02d0\u00af\u0001\u0000\u0000\u0000\u02d1"+ + "\u02d2\u0005a\u0000\u0000\u02d2\u02d3\u0005s\u0000\u0000\u02d3\u00b1\u0001"+ + "\u0000\u0000\u0000\u02d4\u02d5\u0005f\u0000\u0000\u02d5\u02d6\u0005r\u0000"+ + "\u0000\u02d6\u02d7\u0005o\u0000\u0000\u02d7\u02d8\u0005m\u0000\u0000\u02d8"+ + "\u00b3\u0001\u0000\u0000\u0000\u02d9\u02da\u0005r\u0000\u0000\u02da\u02db"+ + "\u0005e\u0000\u0000\u02db\u02dc\u0005a\u0000\u0000\u02dc\u02dd\u0005d"+ + "\u0000\u0000\u02dd\u02de\u0005o\u0000\u0000\u02de\u02df\u0005n\u0000\u0000"+ + "\u02df\u02e0\u0005l\u0000\u0000\u02e0\u02e1\u0005y\u0000\u0000\u02e1\u00b5"+ + "\u0001\u0000\u0000\u0000\u02e2\u02e3\u0005a\u0000\u0000\u02e3\u02e4\u0005"+ + "s\u0000\u0000\u02e4\u02e5\u0005y\u0000\u0000\u02e5\u02e6\u0005n\u0000"+ + "\u0000\u02e6\u02e7\u0005c\u0000\u0000\u02e7\u00b7\u0001\u0000\u0000\u0000"+ + "\u02e8\u02e9\u0005c\u0000\u0000\u02e9\u02ea\u0005l\u0000\u0000\u02ea\u02eb"+ + "\u0005a\u0000\u0000\u02eb\u02ec\u0005s\u0000\u0000\u02ec\u02ed\u0005s"+ + "\u0000\u0000\u02ed\u00b9\u0001\u0000\u0000\u0000\u02ee\u02ef\u0005e\u0000"+ + "\u0000\u02ef\u02f0\u0005n\u0000\u0000\u02f0\u02f1\u0005u\u0000\u0000\u02f1"+ + "\u02f2\u0005m\u0000\u0000\u02f2\u00bb\u0001\u0000\u0000\u0000\u02f3\u02f4"+ + "\u0005e\u0000\u0000\u02f4\u02f5\u0005x\u0000\u0000\u02f5\u02f6\u0005t"+ + "\u0000\u0000\u02f6\u02f7\u0005e\u0000\u0000\u02f7\u02f8\u0005n\u0000\u0000"+ + "\u02f8\u02f9\u0005d\u0000\u0000\u02f9\u02fa\u0005s\u0000\u0000\u02fa\u00bd"+ + "\u0001\u0000\u0000\u0000\u02fb\u02fc\u0005s\u0000\u0000\u02fc\u02fd\u0005"+ + "u\u0000\u0000\u02fd\u02fe\u0005p\u0000\u0000\u02fe\u02ff\u0005e\u0000"+ + "\u0000\u02ff\u0300\u0005r\u0000\u0000\u0300\u00bf\u0001\u0000\u0000\u0000"+ + "\u0301\u0302\u0005c\u0000\u0000\u0302\u0303\u0005o\u0000\u0000\u0303\u0304"+ + "\u0005n\u0000\u0000\u0304\u0305\u0005s\u0000\u0000\u0305\u0306\u0005t"+ + "\u0000\u0000\u0306\u00c1\u0001\u0000\u0000\u0000\u0307\u0308\u0005e\u0000"+ + "\u0000\u0308\u0309\u0005x\u0000\u0000\u0309\u030a\u0005p\u0000\u0000\u030a"+ + "\u030b\u0005o\u0000\u0000\u030b\u030c\u0005r\u0000\u0000\u030c\u030d\u0005"+ + "t\u0000\u0000\u030d\u00c3\u0001\u0000\u0000\u0000\u030e\u030f\u0005i\u0000"+ + "\u0000\u030f\u0310\u0005m\u0000\u0000\u0310\u0311\u0005p\u0000\u0000\u0311"+ + "\u0312\u0005o\u0000\u0000\u0312\u0313\u0005r\u0000\u0000\u0313\u0314\u0005"+ + "t\u0000\u0000\u0314\u00c5\u0001\u0000\u0000\u0000\u0315\u0316\u0005i\u0000"+ + "\u0000\u0316\u0317\u0005m\u0000\u0000\u0317\u0318\u0005p\u0000\u0000\u0318"+ + "\u0319\u0005l\u0000\u0000\u0319\u031a\u0005e\u0000\u0000\u031a\u031b\u0005"+ + "m\u0000\u0000\u031b\u031c\u0005e\u0000\u0000\u031c\u031d\u0005n\u0000"+ + "\u0000\u031d\u031e\u0005t\u0000\u0000\u031e\u031f\u0005s\u0000\u0000\u031f"+ + "\u00c7\u0001\u0000\u0000\u0000\u0320\u0321\u0005l\u0000\u0000\u0321\u0322"+ + "\u0005e\u0000\u0000\u0322\u0323\u0005t\u0000\u0000\u0323\u00c9\u0001\u0000"+ + "\u0000\u0000\u0324\u0325\u0005p\u0000\u0000\u0325\u0326\u0005r\u0000\u0000"+ + "\u0326\u0327\u0005i\u0000\u0000\u0327\u0328\u0005v\u0000\u0000\u0328\u0329"+ + "\u0005a\u0000\u0000\u0329\u032a\u0005t\u0000\u0000\u032a\u032b\u0005e"+ + "\u0000\u0000\u032b\u00cb\u0001\u0000\u0000\u0000\u032c\u032d\u0005p\u0000"+ + "\u0000\u032d\u032e\u0005u\u0000\u0000\u032e\u032f\u0005b\u0000\u0000\u032f"+ + "\u0330\u0005l\u0000\u0000\u0330\u0331\u0005i\u0000\u0000\u0331\u0332\u0005"+ + "c\u0000\u0000\u0332\u00cd\u0001\u0000\u0000\u0000\u0333\u0334\u0005i\u0000"+ + "\u0000\u0334\u0335\u0005n\u0000\u0000\u0335\u0336\u0005t\u0000\u0000\u0336"+ + "\u0337\u0005e\u0000\u0000\u0337\u0338\u0005r\u0000\u0000\u0338\u0339\u0005"+ + "f\u0000\u0000\u0339\u033a\u0005a\u0000\u0000\u033a\u033b\u0005c\u0000"+ + "\u0000\u033b\u033c\u0005e\u0000\u0000\u033c\u00cf\u0001\u0000\u0000\u0000"+ + "\u033d\u033e\u0005p\u0000\u0000\u033e\u033f\u0005a\u0000\u0000\u033f\u0340"+ + "\u0005c\u0000\u0000\u0340\u0341\u0005k\u0000\u0000\u0341\u0342\u0005a"+ + "\u0000\u0000\u0342\u0343\u0005g\u0000\u0000\u0343\u0344\u0005e\u0000\u0000"+ + "\u0344\u00d1\u0001\u0000\u0000\u0000\u0345\u0346\u0005p\u0000\u0000\u0346"+ + "\u0347\u0005r\u0000\u0000\u0347\u0348\u0005o\u0000\u0000\u0348\u0349\u0005"+ + "t\u0000\u0000\u0349\u034a\u0005e\u0000\u0000\u034a\u034b\u0005c\u0000"+ + "\u0000\u034b\u034c\u0005t\u0000\u0000\u034c\u034d\u0005e\u0000\u0000\u034d"+ + "\u034e\u0005d\u0000\u0000\u034e\u00d3\u0001\u0000\u0000\u0000\u034f\u0350"+ + "\u0005s\u0000\u0000\u0350\u0351\u0005t\u0000\u0000\u0351\u0352\u0005a"+ + "\u0000\u0000\u0352\u0353\u0005t\u0000\u0000\u0353\u0354\u0005i\u0000\u0000"+ + "\u0354\u0355\u0005c\u0000\u0000\u0355\u00d5\u0001\u0000\u0000\u0000\u0356"+ + "\u0357\u0005y\u0000\u0000\u0357\u0358\u0005i\u0000\u0000\u0358\u0359\u0005"+ + "e\u0000\u0000\u0359\u035a\u0005l\u0000\u0000\u035a\u035b\u0005d\u0000"+ + "\u0000\u035b\u00d7\u0001\u0000\u0000\u0000\u035c\u035d\u0005a\u0000\u0000"+ + "\u035d\u035e\u0005n\u0000\u0000\u035e\u035f\u0005y\u0000\u0000\u035f\u00d9"+ + "\u0001\u0000\u0000\u0000\u0360\u0361\u0005n\u0000\u0000\u0361\u0362\u0005"+ + "u\u0000\u0000\u0362\u0363\u0005m\u0000\u0000\u0363\u0364\u0005b\u0000"+ + "\u0000\u0364\u0365\u0005e\u0000\u0000\u0365\u0366\u0005r\u0000\u0000\u0366"+ + "\u00db\u0001\u0000\u0000\u0000\u0367\u0368\u0005b\u0000\u0000\u0368\u0369"+ + "\u0005o\u0000\u0000\u0369\u036a\u0005o\u0000\u0000\u036a\u036b\u0005l"+ + "\u0000\u0000\u036b\u036c\u0005e\u0000\u0000\u036c\u036d\u0005a\u0000\u0000"+ + "\u036d\u036e\u0005n\u0000\u0000\u036e\u00dd\u0001\u0000\u0000\u0000\u036f"+ + "\u0370\u0005s\u0000\u0000\u0370\u0371\u0005t\u0000\u0000\u0371\u0372\u0005"+ + "r\u0000\u0000\u0372\u0373\u0005i\u0000\u0000\u0373\u0374\u0005n\u0000"+ + "\u0000\u0374\u0375\u0005g\u0000\u0000\u0375\u00df\u0001\u0000\u0000\u0000"+ + "\u0376\u0377\u0005s\u0000\u0000\u0377\u0378\u0005y\u0000\u0000\u0378\u0379"+ + "\u0005m\u0000\u0000\u0379\u037a\u0005b\u0000\u0000\u037a\u037b\u0005o"+ + "\u0000\u0000\u037b\u037c\u0005l\u0000\u0000\u037c\u00e1\u0001\u0000\u0000"+ + "\u0000\u037d\u037e\u0005t\u0000\u0000\u037e\u037f\u0005y\u0000\u0000\u037f"+ + "\u0380\u0005p\u0000\u0000\u0380\u0381\u0005e\u0000\u0000\u0381\u00e3\u0001"+ + "\u0000\u0000\u0000\u0382\u0383\u0005g\u0000\u0000\u0383\u0384\u0005e\u0000"+ + "\u0000\u0384\u0385\u0005t\u0000\u0000\u0385\u00e5\u0001\u0000\u0000\u0000"+ + "\u0386\u0387\u0005s\u0000\u0000\u0387\u0388\u0005e\u0000\u0000\u0388\u0389"+ + "\u0005t\u0000\u0000\u0389\u00e7\u0001\u0000\u0000\u0000\u038a\u038b\u0005"+ + "c\u0000\u0000\u038b\u038c\u0005o\u0000\u0000\u038c\u038d\u0005n\u0000"+ + "\u0000\u038d\u038e\u0005s\u0000\u0000\u038e\u038f\u0005t\u0000\u0000\u038f"+ + "\u0390\u0005r\u0000\u0000\u0390\u0391\u0005u\u0000\u0000\u0391\u0392\u0005"+ + "c\u0000\u0000\u0392\u0393\u0005t\u0000\u0000\u0393\u0394\u0005o\u0000"+ + "\u0000\u0394\u0395\u0005r\u0000\u0000\u0395\u00e9\u0001\u0000\u0000\u0000"+ + "\u0396\u0397\u0005n\u0000\u0000\u0397\u0398\u0005a\u0000\u0000\u0398\u0399"+ + "\u0005m\u0000\u0000\u0399\u039a\u0005e\u0000\u0000\u039a\u039b\u0005s"+ + "\u0000\u0000\u039b\u039c\u0005p\u0000\u0000\u039c\u039d\u0005a\u0000\u0000"+ + "\u039d\u039e\u0005c\u0000\u0000\u039e\u039f\u0005e\u0000\u0000\u039f\u00eb"+ + "\u0001\u0000\u0000\u0000\u03a0\u03a1\u0005r\u0000\u0000\u03a1\u03a2\u0005"+ + "e\u0000\u0000\u03a2\u03a3\u0005q\u0000\u0000\u03a3\u03a4\u0005u\u0000"+ + "\u0000\u03a4\u03a5\u0005i\u0000\u0000\u03a5\u03a6\u0005r\u0000\u0000\u03a6"+ + "\u03a7\u0005e\u0000\u0000\u03a7\u00ed\u0001\u0000\u0000\u0000\u03a8\u03a9"+ + "\u0005m\u0000\u0000\u03a9\u03aa\u0005o\u0000\u0000\u03aa\u03ab\u0005d"+ + "\u0000\u0000\u03ab\u03ac\u0005u\u0000\u0000\u03ac\u03ad\u0005l\u0000\u0000"+ + "\u03ad\u03ae\u0005e\u0000\u0000\u03ae\u00ef\u0001\u0000\u0000\u0000\u03af"+ + "\u03b0\u0005d\u0000\u0000\u03b0\u03b1\u0005e\u0000\u0000\u03b1\u03b2\u0005"+ + "c\u0000\u0000\u03b2\u03b3\u0005l\u0000\u0000\u03b3\u03b4\u0005a\u0000"+ + "\u0000\u03b4\u03b5\u0005r\u0000\u0000\u03b5\u03b6\u0005e\u0000\u0000\u03b6"+ + "\u00f1\u0001\u0000\u0000\u0000\u03b7\u03b8\u0005a\u0000\u0000\u03b8\u03b9"+ + "\u0005b\u0000\u0000\u03b9\u03ba\u0005s\u0000\u0000\u03ba\u03bb\u0005t"+ + "\u0000\u0000\u03bb\u03bc\u0005r\u0000\u0000\u03bc\u03bd\u0005a\u0000\u0000"+ + "\u03bd\u03be\u0005c\u0000\u0000\u03be\u03bf\u0005t\u0000\u0000\u03bf\u00f3"+ + "\u0001\u0000\u0000\u0000\u03c0\u03c1\u0005i\u0000\u0000\u03c1\u03c2\u0005"+ + "s\u0000\u0000\u03c2\u00f5\u0001\u0000\u0000\u0000\u03c3\u03c4\u0005@\u0000"+ + "\u0000\u03c4\u00f7\u0001\u0000\u0000\u0000\u03c5\u03c9\u0003\u012e\u0096"+ + "\u0000\u03c6\u03c8\u0003\u012c\u0095\u0000\u03c7\u03c6\u0001\u0000\u0000"+ + "\u0000\u03c8\u03cb\u0001\u0000\u0000\u0000\u03c9\u03c7\u0001\u0000\u0000"+ + "\u0000\u03c9\u03ca\u0001\u0000\u0000\u0000\u03ca\u00f9\u0001\u0000\u0000"+ + "\u0000\u03cb\u03c9\u0001\u0000\u0000\u0000\u03cc\u03d0\u0005\"\u0000\u0000"+ + "\u03cd\u03cf\u0003\u0110\u0087\u0000\u03ce\u03cd\u0001\u0000\u0000\u0000"+ + "\u03cf\u03d2\u0001\u0000\u0000\u0000\u03d0\u03ce\u0001\u0000\u0000\u0000"+ + "\u03d0\u03d1\u0001\u0000\u0000\u0000\u03d1\u03d3\u0001\u0000\u0000\u0000"+ + "\u03d2\u03d0\u0001\u0000\u0000\u0000\u03d3\u03dd\u0005\"\u0000\u0000\u03d4"+ + "\u03d8\u0005\'\u0000\u0000\u03d5\u03d7\u0003\u0112\u0088\u0000\u03d6\u03d5"+ + "\u0001\u0000\u0000\u0000\u03d7\u03da\u0001\u0000\u0000\u0000\u03d8\u03d6"+ + "\u0001\u0000\u0000\u0000\u03d8\u03d9\u0001\u0000\u0000\u0000\u03d9\u03db"+ + "\u0001\u0000\u0000\u0000\u03da\u03d8\u0001\u0000\u0000\u0000\u03db\u03dd"+ + "\u0005\'\u0000\u0000\u03dc\u03cc\u0001\u0000\u0000\u0000\u03dc\u03d4\u0001"+ + "\u0000\u0000\u0000\u03dd\u03de\u0001\u0000\u0000\u0000\u03de\u03df\u0006"+ + "|\u0004\u0000\u03df\u00fb\u0001\u0000\u0000\u0000\u03e0\u03e1\u0005`\u0000"+ + "\u0000\u03e1\u03e2\u0006}\u0005\u0000\u03e2\u03e3\u0001\u0000\u0000\u0000"+ + "\u03e3\u03e4\u0006}\u0006\u0000\u03e4\u00fd\u0001\u0000\u0000\u0000\u03e5"+ + "\u03e7\u0007\u0007\u0000\u0000\u03e6\u03e5\u0001\u0000\u0000\u0000\u03e7"+ + "\u03e8\u0001\u0000\u0000\u0000\u03e8\u03e6\u0001\u0000\u0000\u0000\u03e8"+ + "\u03e9\u0001\u0000\u0000\u0000\u03e9\u03ea\u0001\u0000\u0000\u0000\u03ea"+ + "\u03eb\u0006~\u0000\u0000\u03eb\u00ff\u0001\u0000\u0000\u0000\u03ec\u03ed"+ + "\u0007\u0000\u0000\u0000\u03ed\u03ee\u0001\u0000\u0000\u0000\u03ee\u03ef"+ + "\u0006\u007f\u0000\u0000\u03ef\u0101\u0001\u0000\u0000\u0000\u03f0\u03f1"+ + "\u0005<\u0000\u0000\u03f1\u03f2\u0005!\u0000\u0000\u03f2\u03f3\u0005-"+ + "\u0000\u0000\u03f3\u03f4\u0005-\u0000\u0000\u03f4\u03f8\u0001\u0000\u0000"+ + "\u0000\u03f5\u03f7\t\u0000\u0000\u0000\u03f6\u03f5\u0001\u0000\u0000\u0000"+ + "\u03f7\u03fa\u0001\u0000\u0000\u0000\u03f8\u03f9\u0001\u0000\u0000\u0000"+ + "\u03f8\u03f6\u0001\u0000\u0000\u0000\u03f9\u03fb\u0001\u0000\u0000\u0000"+ + "\u03fa\u03f8\u0001\u0000\u0000\u0000\u03fb\u03fc\u0005-\u0000\u0000\u03fc"+ + "\u03fd\u0005-\u0000\u0000\u03fd\u03fe\u0005>\u0000\u0000\u03fe\u03ff\u0001"+ + "\u0000\u0000\u0000\u03ff\u0400\u0006\u0080\u0000\u0000\u0400\u0103\u0001"+ + "\u0000\u0000\u0000\u0401\u0402\u0005<\u0000\u0000\u0402\u0403\u0005!\u0000"+ + "\u0000\u0403\u0404\u0005[\u0000\u0000\u0404\u0405\u0005C\u0000\u0000\u0405"+ + "\u0406\u0005D\u0000\u0000\u0406\u0407\u0005A\u0000\u0000\u0407\u0408\u0005"+ + "T\u0000\u0000\u0408\u0409\u0005A\u0000\u0000\u0409\u040a\u0005[\u0000"+ + "\u0000\u040a\u040e\u0001\u0000\u0000\u0000\u040b\u040d\t\u0000\u0000\u0000"+ + "\u040c\u040b\u0001\u0000\u0000\u0000\u040d\u0410\u0001\u0000\u0000\u0000"+ + "\u040e\u040f\u0001\u0000\u0000\u0000\u040e\u040c\u0001\u0000\u0000\u0000"+ + "\u040f\u0411\u0001\u0000\u0000\u0000\u0410\u040e\u0001\u0000\u0000\u0000"+ + "\u0411\u0412\u0005]\u0000\u0000\u0412\u0413\u0005]\u0000\u0000\u0413\u0414"+ + "\u0005>\u0000\u0000\u0414\u0415\u0001\u0000\u0000\u0000\u0415\u0416\u0006"+ + "\u0081\u0000\u0000\u0416\u0105\u0001\u0000\u0000\u0000\u0417\u0418\t\u0000"+ + "\u0000\u0000\u0418\u0419\u0001\u0000\u0000\u0000\u0419\u041a\u0006\u0082"+ + "\u0007\u0000\u041a\u0107\u0001\u0000\u0000\u0000\u041b\u041c\u0005\\\u0000"+ + "\u0000\u041c\u041d\t\u0000\u0000\u0000\u041d\u0109\u0001\u0000\u0000\u0000"+ + "\u041e\u041f\u0005`\u0000\u0000\u041f\u0420\u0006\u0084\b\u0000\u0420"+ + "\u0421\u0001\u0000\u0000\u0000\u0421\u0422\u0006\u0084\t\u0000\u0422\u0423"+ + "\u0006\u0084\u0002\u0000\u0423\u010b\u0001\u0000\u0000\u0000\u0424\u0425"+ + "\u0005$\u0000\u0000\u0425\u0426\u0005{\u0000\u0000\u0426\u0427\u0001\u0000"+ + "\u0000\u0000\u0427\u0428\u0006\u0085\n\u0000\u0428\u0429\u0001\u0000\u0000"+ + "\u0000\u0429\u042a\u0006\u0085\u000b\u0000\u042a\u010d\u0001\u0000\u0000"+ + "\u0000\u042b\u042c\b\b\u0000\u0000\u042c\u010f\u0001\u0000\u0000\u0000"+ + "\u042d\u0432\b\t\u0000\u0000\u042e\u042f\u0005\\\u0000\u0000\u042f\u0432"+ + "\u0003\u0114\u0089\u0000\u0430\u0432\u0003\u0124\u0091\u0000\u0431\u042d"+ + "\u0001\u0000\u0000\u0000\u0431\u042e\u0001\u0000\u0000\u0000\u0431\u0430"+ + "\u0001\u0000\u0000\u0000\u0432\u0111\u0001\u0000\u0000\u0000\u0433\u0438"+ + "\b\n\u0000\u0000\u0434\u0435\u0005\\\u0000\u0000\u0435\u0438\u0003\u0114"+ + "\u0089\u0000\u0436\u0438\u0003\u0124\u0091\u0000\u0437\u0433\u0001\u0000"+ + "\u0000\u0000\u0437\u0434\u0001\u0000\u0000\u0000\u0437\u0436\u0001\u0000"+ + "\u0000\u0000\u0438\u0113\u0001\u0000\u0000\u0000\u0439\u043f\u0003\u0116"+ + "\u008a\u0000\u043a\u043f\u00050\u0000\u0000\u043b\u043f\u0003\u0118\u008b"+ + "\u0000\u043c\u043f\u0003\u011a\u008c\u0000\u043d\u043f\u0003\u011c\u008d"+ + "\u0000\u043e\u0439\u0001\u0000\u0000\u0000\u043e\u043a\u0001\u0000\u0000"+ + "\u0000\u043e\u043b\u0001\u0000\u0000\u0000\u043e\u043c\u0001\u0000\u0000"+ + "\u0000\u043e\u043d\u0001\u0000\u0000\u0000\u043f\u0115\u0001\u0000\u0000"+ + "\u0000\u0440\u0443\u0003\u011e\u008e\u0000\u0441\u0443\u0003\u0120\u008f"+ + "\u0000\u0442\u0440\u0001\u0000\u0000\u0000\u0442\u0441\u0001\u0000\u0000"+ + "\u0000\u0443\u0117\u0001\u0000\u0000\u0000\u0444\u0445\u0005x\u0000\u0000"+ + "\u0445\u0446\u0003\u0126\u0092\u0000\u0446\u0447\u0003\u0126\u0092\u0000"+ + "\u0447\u0119\u0001\u0000\u0000\u0000\u0448\u0449\u0005u\u0000\u0000\u0449"+ + "\u044a\u0003\u0126\u0092\u0000\u044a\u044b\u0003\u0126\u0092\u0000\u044b"+ + "\u044c\u0003\u0126\u0092\u0000\u044c\u044d\u0003\u0126\u0092\u0000\u044d"+ + "\u011b\u0001\u0000\u0000\u0000\u044e\u044f\u0005u\u0000\u0000\u044f\u0451"+ + "\u0005{\u0000\u0000\u0450\u0452\u0003\u0126\u0092\u0000\u0451\u0450\u0001"+ + "\u0000\u0000\u0000\u0452\u0453\u0001\u0000\u0000\u0000\u0453\u0451\u0001"+ + "\u0000\u0000\u0000\u0453\u0454\u0001\u0000\u0000\u0000\u0454\u0455\u0001"+ + "\u0000\u0000\u0000\u0455\u0456\u0005}\u0000\u0000\u0456\u011d\u0001\u0000"+ + "\u0000\u0000\u0457\u0458\u0007\u000b\u0000\u0000\u0458\u011f\u0001\u0000"+ + "\u0000\u0000\u0459\u045a\b\f\u0000\u0000\u045a\u0121\u0001\u0000\u0000"+ + "\u0000\u045b\u045e\u0003\u011e\u008e\u0000\u045c\u045e\u0007\r\u0000\u0000"+ + "\u045d\u045b\u0001\u0000\u0000\u0000\u045d\u045c\u0001\u0000\u0000\u0000"+ + "\u045e\u0123\u0001\u0000\u0000\u0000\u045f\u0460\u0005\\\u0000\u0000\u0460"+ + "\u0461\u0007\u0000\u0000\u0000\u0461\u0125\u0001\u0000\u0000\u0000\u0462"+ + "\u0463\u0007\u000e\u0000\u0000\u0463\u0127\u0001\u0000\u0000\u0000\u0464"+ + "\u046d\u00050\u0000\u0000\u0465\u0469\u0007\u000f\u0000\u0000\u0466\u0468"+ + "\u0007\u0001\u0000\u0000\u0467\u0466\u0001\u0000\u0000\u0000\u0468\u046b"+ + "\u0001\u0000\u0000\u0000\u0469\u0467\u0001\u0000\u0000\u0000\u0469\u046a"+ + "\u0001\u0000\u0000\u0000\u046a\u046d\u0001\u0000\u0000\u0000\u046b\u0469"+ + "\u0001\u0000\u0000\u0000\u046c\u0464\u0001\u0000\u0000\u0000\u046c\u0465"+ + "\u0001\u0000\u0000\u0000\u046d\u0129\u0001\u0000\u0000\u0000\u046e\u0470"+ + "\u0007\u0010\u0000\u0000\u046f\u0471\u0007\u0011\u0000\u0000\u0470\u046f"+ + "\u0001\u0000\u0000\u0000\u0470\u0471\u0001\u0000\u0000\u0000\u0471\u0473"+ + "\u0001\u0000\u0000\u0000\u0472\u0474\u0007\u0001\u0000\u0000\u0473\u0472"+ + "\u0001\u0000\u0000\u0000\u0474\u0475\u0001\u0000\u0000\u0000\u0475\u0473"+ + "\u0001\u0000\u0000\u0000\u0475\u0476\u0001\u0000\u0000\u0000\u0476\u012b"+ + "\u0001\u0000\u0000\u0000\u0477\u047a\u0003\u012e\u0096\u0000\u0478\u047a"+ + "\u0007\u0012\u0000\u0000\u0479\u0477\u0001\u0000\u0000\u0000\u0479\u0478"+ + "\u0001\u0000\u0000\u0000\u047a\u012d\u0001\u0000\u0000\u0000\u047b\u047f"+ + "\u0007\u0013\u0000\u0000\u047c\u047d\u0005\\\u0000\u0000\u047d\u047f\u0003"+ + "\u011a\u008c\u0000\u047e\u047b\u0001\u0000\u0000\u0000\u047e\u047c\u0001"+ + "\u0000\u0000\u0000\u047f\u012f\u0001\u0000\u0000\u0000\u0480\u048b\b\u0014"+ + "\u0000\u0000\u0481\u048b\u0003\u0136\u009a\u0000\u0482\u0486\u0005[\u0000"+ + "\u0000\u0483\u0485\u0003\u0134\u0099\u0000\u0484\u0483\u0001\u0000\u0000"+ + "\u0000\u0485\u0488\u0001\u0000\u0000\u0000\u0486\u0484\u0001\u0000\u0000"+ + "\u0000\u0486\u0487\u0001\u0000\u0000\u0000\u0487\u0489\u0001\u0000\u0000"+ + "\u0000\u0488\u0486\u0001\u0000\u0000\u0000\u0489\u048b\u0005]\u0000\u0000"+ + "\u048a\u0480\u0001\u0000\u0000\u0000\u048a\u0481\u0001\u0000\u0000\u0000"+ + "\u048a\u0482\u0001\u0000\u0000\u0000\u048b\u0131\u0001\u0000\u0000\u0000"+ + "\u048c\u0497\b\u0015\u0000\u0000\u048d\u0497\u0003\u0136\u009a\u0000\u048e"+ + "\u0492\u0005[\u0000\u0000\u048f\u0491\u0003\u0134\u0099\u0000\u0490\u048f"+ + "\u0001\u0000\u0000\u0000\u0491\u0494\u0001\u0000\u0000\u0000\u0492\u0490"+ + "\u0001\u0000\u0000\u0000\u0492\u0493\u0001\u0000\u0000\u0000\u0493\u0495"+ + "\u0001\u0000\u0000\u0000\u0494\u0492\u0001\u0000\u0000\u0000\u0495\u0497"+ + "\u0005]\u0000\u0000\u0496\u048c\u0001\u0000\u0000\u0000\u0496\u048d\u0001"+ + "\u0000\u0000\u0000\u0496\u048e\u0001\u0000\u0000\u0000\u0497\u0133\u0001"+ + "\u0000\u0000\u0000\u0498\u049b\b\u0016\u0000\u0000\u0499\u049b\u0003\u0136"+ + "\u009a\u0000\u049a\u0498\u0001\u0000\u0000\u0000\u049a\u0499\u0001\u0000"+ + "\u0000\u0000\u049b\u0135\u0001\u0000\u0000\u0000\u049c\u049d\u0005\\\u0000"+ + "\u0000\u049d\u049e\b\u0000\u0000\u0000\u049e\u0137\u0001\u0000\u0000\u0000"+ + ")\u0000\u0001\u013e\u014c\u0156\u015e\u01fc\u0203\u0207\u020d\u0210\u0214"+ + "\u0216\u021d\u0223\u022c\u0233\u03c9\u03d0\u03d8\u03dc\u03e8\u03f8\u040e"+ + "\u0431\u0437\u043e\u0442\u0453\u045d\u0469\u046c\u0470\u0475\u0479\u047e"+ + "\u0486\u048a\u0492\u0496\u049a\f\u0000\u0001\u0000\u0001\u0007\u0000\u0004"+ + "\u0000\u0000\u0001\t\u0001\u0001|\u0002\u0001}\u0003\u0005\u0001\u0000"+ + "\u0000\u0002\u0000\u0001\u0084\u0004\u0007~\u0000\u0001\u0085\u0005\u0005"+ + "\u0000\u0000"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.tokens b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.tokens new file mode 100644 index 0000000..8679637 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.tokens @@ -0,0 +1,247 @@ +MultiLineComment=1 +SingleLineComment=2 +RegularExpressionLiteral=3 +OpenBracket=4 +CloseBracket=5 +OpenParen=6 +CloseParen=7 +OpenBrace=8 +TemplateCloseBrace=9 +CloseBrace=10 +SemiColon=11 +Comma=12 +Assign=13 +QuestionMark=14 +Colon=15 +Ellipsis=16 +Dot=17 +PlusPlus=18 +MinusMinus=19 +Plus=20 +Minus=21 +BitNot=22 +Not=23 +Multiply=24 +Divide=25 +Modulus=26 +RightShiftArithmetic=27 +LeftShiftArithmetic=28 +RightShiftLogical=29 +LessThan=30 +MoreThan=31 +LessThanEquals=32 +GreaterThanEquals=33 +Equals_=34 +NotEquals=35 +IdentityEquals=36 +IdentityNotEquals=37 +BitAnd=38 +BitXOr=39 +BitOr=40 +And=41 +Or=42 +MultiplyAssign=43 +DivideAssign=44 +ModulusAssign=45 +PlusAssign=46 +MinusAssign=47 +LeftShiftArithmeticAssign=48 +RightShiftArithmeticAssign=49 +RightShiftLogicalAssign=50 +BitAndAssign=51 +BitXorAssign=52 +BitOrAssign=53 +ARROW=54 +NullLiteral=55 +BooleanLiteral=56 +DecimalLiteral=57 +HexIntegerLiteral=58 +OctalIntegerLiteral=59 +OctalIntegerLiteral2=60 +BinaryIntegerLiteral=61 +Break=62 +Do=63 +Instanceof=64 +Typeof=65 +Case=66 +Else=67 +New=68 +Var=69 +Catch=70 +Finally=71 +Return=72 +Void=73 +Continue=74 +For=75 +Switch=76 +While=77 +Debugger=78 +Function_=79 +This=80 +With=81 +Default=82 +If=83 +Throw=84 +Delete=85 +In=86 +Try=87 +As=88 +From=89 +ReadOnly=90 +Async=91 +Class=92 +Enum=93 +Extends=94 +Super=95 +Const=96 +Export=97 +Import=98 +Implements=99 +Let=100 +Private=101 +Public=102 +Interface=103 +Package=104 +Protected=105 +Static=106 +Yield=107 +Any=108 +Number=109 +Boolean=110 +String=111 +Symbol=112 +TypeAlias=113 +Get=114 +Set=115 +Constructor=116 +Namespace=117 +Require=118 +Module=119 +Declare=120 +Abstract=121 +Is=122 +At=123 +Identifier=124 +StringLiteral=125 +BackTick=126 +WhiteSpaces=127 +LineTerminator=128 +HtmlComment=129 +CDataComment=130 +UnexpectedCharacter=131 +TemplateStringEscapeAtom=132 +TemplateStringStartExpression=133 +TemplateStringAtom=134 +'['=4 +']'=5 +'('=6 +')'=7 +'{'=8 +'}'=10 +';'=11 +','=12 +'='=13 +'?'=14 +':'=15 +'...'=16 +'.'=17 +'++'=18 +'--'=19 +'+'=20 +'-'=21 +'~'=22 +'!'=23 +'*'=24 +'/'=25 +'%'=26 +'>>'=27 +'<<'=28 +'>>>'=29 +'<'=30 +'>'=31 +'<='=32 +'>='=33 +'=='=34 +'!='=35 +'==='=36 +'!=='=37 +'&'=38 +'^'=39 +'|'=40 +'&&'=41 +'||'=42 +'*='=43 +'/='=44 +'%='=45 +'+='=46 +'-='=47 +'<<='=48 +'>>='=49 +'>>>='=50 +'&='=51 +'^='=52 +'|='=53 +'=>'=54 +'null'=55 +'break'=62 +'do'=63 +'instanceof'=64 +'typeof'=65 +'case'=66 +'else'=67 +'new'=68 +'var'=69 +'catch'=70 +'finally'=71 +'return'=72 +'void'=73 +'continue'=74 +'for'=75 +'switch'=76 +'while'=77 +'debugger'=78 +'function'=79 +'this'=80 +'with'=81 +'default'=82 +'if'=83 +'throw'=84 +'delete'=85 +'in'=86 +'try'=87 +'as'=88 +'from'=89 +'readonly'=90 +'async'=91 +'class'=92 +'enum'=93 +'extends'=94 +'super'=95 +'const'=96 +'export'=97 +'import'=98 +'implements'=99 +'let'=100 +'private'=101 +'public'=102 +'interface'=103 +'package'=104 +'protected'=105 +'static'=106 +'yield'=107 +'any'=108 +'number'=109 +'boolean'=110 +'string'=111 +'symbol'=112 +'type'=113 +'get'=114 +'set'=115 +'constructor'=116 +'namespace'=117 +'require'=118 +'module'=119 +'declare'=120 +'abstract'=121 +'is'=122 +'@'=123 diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.g4 b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.g4 new file mode 100644 index 0000000..6e81b63 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.g4 @@ -0,0 +1,854 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2014 by Bart Kiers (original author) and Alexandre Vitorelli (contributor -> ported to CSharp) + * Copyright (c) 2017 by Ivan Kochurkin (Positive Technologies): + added ECMAScript 6 support, cleared and transformed to the universal grammar. + * Copyright (c) 2018 by Juan Alvarez (contributor -> ported to Go) + * Copyright (c) 2019 by Andrii Artiushok (contributor -> added TypeScript support) + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + */ +parser grammar TypeScriptParser; + +options { + tokenVocab=TypeScriptLexer; + superClass=TypeScriptParserBase; +} + +// SupportSyntax + +initializer + : '=' singleExpression + ; + +bindingPattern + : (arrayLiteral | objectLiteral) + ; + +// TypeScript SPart +// A.1 Types + +typeParameters + : '<' typeParameterList? '>' + ; + +typeParameterList + : typeParameter (',' typeParameter)* + ; + +typeParameter + : Identifier constraint? + | typeParameters + ; + +constraint + : 'extends' type_ + ; + +typeArguments + : '<' typeArgumentList? '>' + ; + +typeArgumentList + : typeArgument (',' typeArgument)* + ; + +typeArgument + : type_ + ; + +type_ + : unionOrIntersectionOrPrimaryType + | functionType + | constructorType + | typeGeneric + | StringLiteral + ; + +unionOrIntersectionOrPrimaryType + : unionOrIntersectionOrPrimaryType '|' unionOrIntersectionOrPrimaryType #Union + | unionOrIntersectionOrPrimaryType '&' unionOrIntersectionOrPrimaryType #Intersection + | primaryType #Primary + ; + +primaryType + : '(' type_ ')' #ParenthesizedPrimType + | predefinedType #PredefinedPrimType + | typeReference #ReferencePrimType + | objectType #ObjectPrimType + | primaryType {notLineTerminator()}? '[' ']' #ArrayPrimType + | '[' tupleElementTypes ']' #TuplePrimType + | typeQuery #QueryPrimType + | This #ThisPrimType + | typeReference Is primaryType #RedefinitionOfType + ; + +predefinedType + : Any + | Number + | Boolean + | String + | Symbol + | Void + ; + +typeReference + : typeName nestedTypeGeneric? + ; + +nestedTypeGeneric + : typeIncludeGeneric + | typeGeneric + ; + +// I tried recursive include, but it's not working. +// typeGeneric +// : '<' typeArgumentList typeGeneric?'>' +// ; +// +// TODO: Fix recursive +// +typeGeneric + : '<' typeArgumentList '>' + ; + +typeIncludeGeneric + :'<' typeArgumentList '<' typeArgumentList ('>' bindingPattern '>' | '>>') + ; + +typeName + : Identifier + | namespaceName + ; + +objectType + : '{' typeBody? '}' + ; + +typeBody + : typeMemberList (SemiColon | ',')? + ; + +typeMemberList + : typeMember ((SemiColon | ',') typeMember)* + ; + +typeMember + : propertySignatur + | callSignature + | constructSignature + | indexSignature + | methodSignature ('=>' type_)? + ; + +arrayType + : primaryType {notLineTerminator()}? '[' ']' + ; + +tupleType + : '[' tupleElementTypes ']' + ; + +tupleElementTypes + : type_ (',' type_)* + ; + +functionType + : typeParameters? '(' parameterList? ')' '=>' type_ + ; + +constructorType + : 'new' typeParameters? '(' parameterList? ')' '=>' type_ + ; + +typeQuery + : 'typeof' typeQueryExpression + ; + +typeQueryExpression + : Identifier + | (identifierName '.')+ identifierName + ; + +propertySignatur + : ReadOnly? propertyName '?'? typeAnnotation? ('=>' type_)? + ; + +typeAnnotation + : ':' type_ + ; + +callSignature + : typeParameters? '(' parameterList? ')' typeAnnotation? + ; + +parameterList + : restParameter + | parameter (',' parameter)* (',' restParameter)? + ; + +requiredParameterList + : requiredParameter (',' requiredParameter)* + ; + +parameter + : requiredParameter + | optionalParameter + ; + +optionalParameter + : decoratorList? ( accessibilityModifier? identifierOrPattern ('?' typeAnnotation? | typeAnnotation? initializer)) + ; + +restParameter + : '...' singleExpression typeAnnotation? + ; + +requiredParameter + : decoratorList? accessibilityModifier? identifierOrPattern typeAnnotation? + ; + +accessibilityModifier + : Public + | Private + | Protected + ; + +identifierOrPattern + : identifierName + | bindingPattern + ; + +constructSignature + : 'new' typeParameters? '(' parameterList? ')' typeAnnotation? + ; + +indexSignature + : '[' Identifier ':' (Number|String) ']' typeAnnotation + ; + +methodSignature + : propertyName '?'? callSignature + ; + +typeAliasDeclaration + : 'type' Identifier typeParameters? '=' type_ SemiColon + ; + +constructorDeclaration + : accessibilityModifier? Constructor '(' formalParameterList? ')' ( ('{' functionBody '}') | SemiColon)? + ; + +// A.5 Interface + +interfaceDeclaration + : Export? Declare? Interface Identifier typeParameters? interfaceExtendsClause? objectType SemiColon? + ; + +interfaceExtendsClause + : Extends classOrInterfaceTypeList + ; + +classOrInterfaceTypeList + : typeReference (',' typeReference)* + ; + +// A.7 Interface + +enumDeclaration + : Const? Enum Identifier '{' enumBody? '}' + ; + +enumBody + : enumMemberList ','? + ; + +enumMemberList + : enumMember (',' enumMember)* + ; + +enumMember + : propertyName ('=' singleExpression)? + ; + +// A.8 Namespaces + +namespaceDeclaration + : Namespace namespaceName '{' statementList? '}' + ; + +namespaceName + : Identifier ('.'+ Identifier)* + ; + +importAliasDeclaration + : Identifier '=' namespaceName SemiColon + ; + +// Ext.2 Additions to 1.8: Decorators + +decoratorList + : decorator+ ; + +decorator + : '@' (decoratorMemberExpression | decoratorCallExpression) + ; + +decoratorMemberExpression + : Identifier + | decoratorMemberExpression '.' identifierName + | '(' singleExpression ')' + ; + +decoratorCallExpression + : decoratorMemberExpression arguments; + +// ECMAPart +program + : sourceElements? EOF + ; + +sourceElement + : Export? statement + ; + +statement + : block + | importStatement + | exportStatement + | emptyStatement_ + | abstractDeclaration //ADDED + | classDeclaration + | interfaceDeclaration //ADDED + | namespaceDeclaration //ADDED + | ifStatement + | iterationStatement + | continueStatement + | breakStatement + | returnStatement + | yieldStatement + | withStatement + | labelledStatement + | switchStatement + | throwStatement + | tryStatement + | debuggerStatement + | functionDeclaration + | arrowFunctionDeclaration + | generatorFunctionDeclaration + | variableStatement + | typeAliasDeclaration //ADDED + | enumDeclaration //ADDED + | expressionStatement + | Export statement + ; + +block + : '{' statementList? '}' + ; + +statementList + : statement+ + ; + +abstractDeclaration + : Abstract (Identifier callSignature | variableStatement) eos + ; + +importStatement + : Import (fromBlock | importAliasDeclaration) + ; + +fromBlock + : (Multiply | multipleImportStatement) (As identifierName)? From StringLiteral eos + ; + +multipleImportStatement + : (identifierName ',')? '{' identifierName (',' identifierName)* '}' + ; + +exportStatement + : Export Default? (fromBlock | statement) + ; + +variableStatement + : bindingPattern typeAnnotation? initializer SemiColon? + | accessibilityModifier? varModifier? ReadOnly? variableDeclarationList SemiColon? + | Declare varModifier? variableDeclarationList SemiColon? + ; + +variableDeclarationList + : variableDeclaration (',' variableDeclaration)* + ; + +variableDeclaration + : ( identifierOrKeyWord | arrayLiteral | objectLiteral) typeAnnotation? singleExpression? ('=' typeParameters? singleExpression)? // ECMAScript 6: Array & Object Matching + ; + +emptyStatement_ + : SemiColon + ; + +expressionStatement + : {this.notOpenBraceAndNotFunction()}? expressionSequence SemiColon? + ; + +ifStatement + : If '(' expressionSequence ')' statement (Else statement)? + ; + + +iterationStatement + : Do statement While '(' expressionSequence ')' eos # DoStatement + | While '(' expressionSequence ')' statement # WhileStatement + | For '(' expressionSequence? SemiColon expressionSequence? SemiColon expressionSequence? ')' statement # ForStatement + | For '(' varModifier variableDeclarationList SemiColon expressionSequence? SemiColon expressionSequence? ')' + statement # ForVarStatement + | For '(' singleExpression (In | Identifier{this.p("of")}?) expressionSequence ')' statement # ForInStatement + | For '(' varModifier variableDeclaration (In | Identifier{this.p("of")}?) expressionSequence ')' statement # ForVarInStatement + ; + +varModifier + : Var + | Let + | Const + ; + +continueStatement + : Continue ({this.notLineTerminator()}? Identifier)? eos + ; + +breakStatement + : Break ({this.notLineTerminator()}? Identifier)? eos + ; + +returnStatement + : Return ({this.notLineTerminator()}? expressionSequence)? eos + ; + +yieldStatement + : Yield ({this.notLineTerminator()}? expressionSequence)? eos + ; + +withStatement + : With '(' expressionSequence ')' statement + ; + +switchStatement + : Switch '(' expressionSequence ')' caseBlock + ; + +caseBlock + : '{' caseClauses? (defaultClause caseClauses?)? '}' + ; + +caseClauses + : caseClause+ + ; + +caseClause + : Case expressionSequence ':' statementList? + ; + +defaultClause + : Default ':' statementList? + ; + +labelledStatement + : Identifier ':' statement + ; + +throwStatement + : Throw {this.notLineTerminator()}? expressionSequence eos + ; + +tryStatement + : Try block (catchProduction finallyProduction? | finallyProduction) + ; + +catchProduction + : Catch '(' Identifier ')' block + ; + +finallyProduction + : Finally block + ; + +debuggerStatement + : Debugger eos + ; + +functionDeclaration + : Function_ Identifier callSignature ( ('{' functionBody '}') | SemiColon) + ; + +//Ovveride ECMA +classDeclaration + : decoratorList? (Export Default?)? Abstract? Class Identifier typeParameters? classHeritage classTail + ; + +classHeritage + : classExtendsClause? implementsClause? + ; + +classTail + : '{' classElement* '}' + ; + +classExtendsClause + : Extends typeReference + ; + +implementsClause + : Implements classOrInterfaceTypeList + ; + +// Classes modified +classElement + : constructorDeclaration + | decoratorList? propertyMemberDeclaration + | indexMemberDeclaration + | statement + ; + +propertyMemberDeclaration + : propertyMemberBase propertyName '?'? typeAnnotation? initializer? SemiColon # PropertyDeclarationExpression + | propertyMemberBase propertyName callSignature ( ('{' functionBody '}') | SemiColon) # MethodDeclarationExpression + | propertyMemberBase (getAccessor | setAccessor) # GetterSetterDeclarationExpression + | abstractDeclaration # AbstractMemberDeclaration + ; + +propertyMemberBase + : accessibilityModifier? Async? Static? ReadOnly? + ; + +indexMemberDeclaration + : indexSignature SemiColon + ; + +generatorMethod + : '*'? Identifier '(' formalParameterList? ')' '{' functionBody '}' + ; + +generatorFunctionDeclaration + : Function_ '*' Identifier? '(' formalParameterList? ')' '{' functionBody '}' + ; + +generatorBlock + : '{' generatorDefinition (',' generatorDefinition)* ','? '}' + ; + +generatorDefinition + : '*' iteratorDefinition + ; + +iteratorBlock + : '{' iteratorDefinition (',' iteratorDefinition)* ','? '}' + ; + +iteratorDefinition + : '[' singleExpression ']' '(' formalParameterList? ')' '{' functionBody '}' + ; + +formalParameterList + : formalParameterArg (',' formalParameterArg)* (',' lastFormalParameterArg)? + | lastFormalParameterArg + | arrayLiteral // ECMAScript 6: Parameter Context Matching + | objectLiteral (':' formalParameterList)? // ECMAScript 6: Parameter Context Matching + ; + +formalParameterArg + : decorator? accessibilityModifier? identifierOrKeyWord '?'? typeAnnotation? ('=' singleExpression)? // ECMAScript 6: Initialization + ; + +lastFormalParameterArg // ECMAScript 6: Rest Parameter + : Ellipsis Identifier typeAnnotation? + ; + +functionBody + : sourceElements? + ; + +sourceElements + : sourceElement+ + ; + +arrayLiteral + : ('[' elementList? ']') + ; + +elementList + : arrayElement (','+ arrayElement)* + ; + +arrayElement // ECMAScript 6: Spread Operator + : Ellipsis? (singleExpression | Identifier) ','? + ; + +objectLiteral + : '{' (propertyAssignment (',' propertyAssignment)* ','?)? '}' + ; + +// MODIFIED +propertyAssignment + : propertyName (':' |'=') singleExpression # PropertyExpressionAssignment + | '[' singleExpression ']' ':' singleExpression # ComputedPropertyExpressionAssignment + | getAccessor # PropertyGetter + | setAccessor # PropertySetter + | generatorMethod # MethodProperty + | identifierOrKeyWord # PropertyShorthand + | restParameter # RestParameterInObject + ; + +getAccessor + : getter '(' ')' typeAnnotation? '{' functionBody '}' + ; + +setAccessor + : setter '(' ( Identifier | bindingPattern) typeAnnotation? ')' '{' functionBody '}' + ; + +propertyName + : identifierName + | StringLiteral + | numericLiteral + ; + +arguments + : '(' (argumentList ','?)? ')' + ; + +argumentList + : argument (',' argument)* + ; + +argument // ECMAScript 6: Spread Operator + : Ellipsis? (singleExpression | Identifier) + ; + +expressionSequence + : singleExpression (',' singleExpression)* + ; + +functionExpressionDeclaration + : Function_ Identifier? '(' formalParameterList? ')' typeAnnotation? '{' functionBody '}' + ; + +singleExpression + : functionExpressionDeclaration # FunctionExpression + | arrowFunctionDeclaration # ArrowFunctionExpression // ECMAScript 6 + | singleExpression '[' expressionSequence ']' # MemberIndexExpression + | singleExpression '!'? '.' identifierName nestedTypeGeneric? # MemberDotExpression + // Split to try `new Date()` first, then `new Date`. + | New singleExpression typeArguments? arguments # NewExpression + | New singleExpression typeArguments? # NewExpression + | singleExpression arguments # ArgumentsExpression + | singleExpression {this.notLineTerminator()}? '++' # PostIncrementExpression + | singleExpression {this.notLineTerminator()}? '--' # PostDecreaseExpression + | Delete singleExpression # DeleteExpression + | Void singleExpression # VoidExpression + | Typeof singleExpression # TypeofExpression + | '++' singleExpression # PreIncrementExpression + | '--' singleExpression # PreDecreaseExpression + | '+' singleExpression # UnaryPlusExpression + | '-' singleExpression # UnaryMinusExpression + | '~' singleExpression # BitNotExpression + | '!' singleExpression # NotExpression + | singleExpression ('*' | '/' | '%') singleExpression # MultiplicativeExpression + | singleExpression ('+' | '-') singleExpression # AdditiveExpression + | singleExpression ('<<' | '>>' | '>>>') singleExpression # BitShiftExpression + | singleExpression ('<' | '>' | '<=' | '>=') singleExpression # RelationalExpression + | singleExpression Instanceof singleExpression # InstanceofExpression + | singleExpression In singleExpression # InExpression + | singleExpression ('==' | '!=' | '===' | '!==') singleExpression # EqualityExpression + | singleExpression '&' singleExpression # BitAndExpression + | singleExpression '^' singleExpression # BitXOrExpression + | singleExpression '|' singleExpression # BitOrExpression + | singleExpression '&&' singleExpression # LogicalAndExpression + | singleExpression '||' singleExpression # LogicalOrExpression + | singleExpression '?' singleExpression ':' singleExpression # TernaryExpression + | singleExpression '=' singleExpression # AssignmentExpression + | singleExpression assignmentOperator singleExpression # AssignmentOperatorExpression + | singleExpression templateStringLiteral # TemplateStringExpression // ECMAScript 6 + | iteratorBlock # IteratorsExpression // ECMAScript 6 + | generatorBlock # GeneratorsExpression // ECMAScript 6 + | generatorFunctionDeclaration # GeneratorsFunctionExpression // ECMAScript 6 + | yieldStatement # YieldExpression // ECMAScript 6 + | This # ThisExpression + | identifierName singleExpression? # IdentifierExpression + | Super # SuperExpression + | literal # LiteralExpression + | arrayLiteral # ArrayLiteralExpression + | objectLiteral # ObjectLiteralExpression + | '(' expressionSequence ')' # ParenthesizedExpression + | typeArguments expressionSequence? # GenericTypes + | singleExpression As asExpression # CastAsExpression + ; + +asExpression + : predefinedType ('[' ']')? + | singleExpression + ; + +arrowFunctionDeclaration + : Async? arrowFunctionParameters typeAnnotation? '=>' arrowFunctionBody + ; + +arrowFunctionParameters + : Identifier + | '(' formalParameterList? ')' + ; + +arrowFunctionBody + : singleExpression + | '{' functionBody '}' + ; + +assignmentOperator + : '*=' + | '/=' + | '%=' + | '+=' + | '-=' + | '<<=' + | '>>=' + | '>>>=' + | '&=' + | '^=' + | '|=' + ; + +literal + : NullLiteral + | BooleanLiteral + | StringLiteral + | templateStringLiteral + | RegularExpressionLiteral + | numericLiteral + ; + +templateStringLiteral + : BackTick templateStringAtom* BackTick + ; + +templateStringAtom + : TemplateStringAtom + | TemplateStringStartExpression singleExpression TemplateCloseBrace + | TemplateStringEscapeAtom + ; + +numericLiteral + : DecimalLiteral + | HexIntegerLiteral + | OctalIntegerLiteral + | OctalIntegerLiteral2 + | BinaryIntegerLiteral + ; + +identifierName + : Identifier + | reservedWord + ; + +identifierOrKeyWord + : Identifier + | TypeAlias + | Require + ; + +reservedWord + : keyword + | NullLiteral + | BooleanLiteral + ; + +keyword + : Break + | Do + | Instanceof + | Typeof + | Case + | Else + | New + | Var + | Catch + | Finally + | Return + | Void + | Continue + | For + | Switch + | While + | Debugger + | Function_ + | This + | With + | Default + | If + | Throw + | Delete + | In + | Try + | ReadOnly + | Async + | From + | Class + | Enum + | Extends + | Super + | Const + | Export + | Import + | Implements + | Let + | Private + | Public + | Interface + | Package + | Protected + | Static + | Yield + | Get + | Set + | Require + | TypeAlias + | String + | Boolean + | Number + | Module + ; + +getter + : Get propertyName + ; + +setter + : Set propertyName + ; + +eos + : SemiColon + | EOF + | {this.lineTerminatorAhead()}? + | {this.closeBrace()}? + ; diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.interp b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.interp new file mode 100644 index 0000000..1d4d372 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.interp @@ -0,0 +1,423 @@ +token literal names: +null +null +null +null +'[' +']' +'(' +')' +'{' +null +'}' +';' +',' +'=' +'?' +':' +'...' +'.' +'++' +'--' +'+' +'-' +'~' +'!' +'*' +'/' +'%' +'>>' +'<<' +'>>>' +'<' +'>' +'<=' +'>=' +'==' +'!=' +'===' +'!==' +'&' +'^' +'|' +'&&' +'||' +'*=' +'/=' +'%=' +'+=' +'-=' +'<<=' +'>>=' +'>>>=' +'&=' +'^=' +'|=' +'=>' +'null' +null +null +null +null +null +null +'break' +'do' +'instanceof' +'typeof' +'case' +'else' +'new' +'var' +'catch' +'finally' +'return' +'void' +'continue' +'for' +'switch' +'while' +'debugger' +'function' +'this' +'with' +'default' +'if' +'throw' +'delete' +'in' +'try' +'as' +'from' +'readonly' +'async' +'class' +'enum' +'extends' +'super' +'const' +'export' +'import' +'implements' +'let' +'private' +'public' +'interface' +'package' +'protected' +'static' +'yield' +'any' +'number' +'boolean' +'string' +'symbol' +'type' +'get' +'set' +'constructor' +'namespace' +'require' +'module' +'declare' +'abstract' +'is' +'@' +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +MultiLineComment +SingleLineComment +RegularExpressionLiteral +OpenBracket +CloseBracket +OpenParen +CloseParen +OpenBrace +TemplateCloseBrace +CloseBrace +SemiColon +Comma +Assign +QuestionMark +Colon +Ellipsis +Dot +PlusPlus +MinusMinus +Plus +Minus +BitNot +Not +Multiply +Divide +Modulus +RightShiftArithmetic +LeftShiftArithmetic +RightShiftLogical +LessThan +MoreThan +LessThanEquals +GreaterThanEquals +Equals_ +NotEquals +IdentityEquals +IdentityNotEquals +BitAnd +BitXOr +BitOr +And +Or +MultiplyAssign +DivideAssign +ModulusAssign +PlusAssign +MinusAssign +LeftShiftArithmeticAssign +RightShiftArithmeticAssign +RightShiftLogicalAssign +BitAndAssign +BitXorAssign +BitOrAssign +ARROW +NullLiteral +BooleanLiteral +DecimalLiteral +HexIntegerLiteral +OctalIntegerLiteral +OctalIntegerLiteral2 +BinaryIntegerLiteral +Break +Do +Instanceof +Typeof +Case +Else +New +Var +Catch +Finally +Return +Void +Continue +For +Switch +While +Debugger +Function_ +This +With +Default +If +Throw +Delete +In +Try +As +From +ReadOnly +Async +Class +Enum +Extends +Super +Const +Export +Import +Implements +Let +Private +Public +Interface +Package +Protected +Static +Yield +Any +Number +Boolean +String +Symbol +TypeAlias +Get +Set +Constructor +Namespace +Require +Module +Declare +Abstract +Is +At +Identifier +StringLiteral +BackTick +WhiteSpaces +LineTerminator +HtmlComment +CDataComment +UnexpectedCharacter +TemplateStringEscapeAtom +TemplateStringStartExpression +TemplateStringAtom + +rule names: +initializer +bindingPattern +typeParameters +typeParameterList +typeParameter +constraint +typeArguments +typeArgumentList +typeArgument +type_ +unionOrIntersectionOrPrimaryType +primaryType +predefinedType +typeReference +nestedTypeGeneric +typeGeneric +typeIncludeGeneric +typeName +objectType +typeBody +typeMemberList +typeMember +arrayType +tupleType +tupleElementTypes +functionType +constructorType +typeQuery +typeQueryExpression +propertySignatur +typeAnnotation +callSignature +parameterList +requiredParameterList +parameter +optionalParameter +restParameter +requiredParameter +accessibilityModifier +identifierOrPattern +constructSignature +indexSignature +methodSignature +typeAliasDeclaration +constructorDeclaration +interfaceDeclaration +interfaceExtendsClause +classOrInterfaceTypeList +enumDeclaration +enumBody +enumMemberList +enumMember +namespaceDeclaration +namespaceName +importAliasDeclaration +decoratorList +decorator +decoratorMemberExpression +decoratorCallExpression +program +sourceElement +statement +block +statementList +abstractDeclaration +importStatement +fromBlock +multipleImportStatement +exportStatement +variableStatement +variableDeclarationList +variableDeclaration +emptyStatement_ +expressionStatement +ifStatement +iterationStatement +varModifier +continueStatement +breakStatement +returnStatement +yieldStatement +withStatement +switchStatement +caseBlock +caseClauses +caseClause +defaultClause +labelledStatement +throwStatement +tryStatement +catchProduction +finallyProduction +debuggerStatement +functionDeclaration +classDeclaration +classHeritage +classTail +classExtendsClause +implementsClause +classElement +propertyMemberDeclaration +propertyMemberBase +indexMemberDeclaration +generatorMethod +generatorFunctionDeclaration +generatorBlock +generatorDefinition +iteratorBlock +iteratorDefinition +formalParameterList +formalParameterArg +lastFormalParameterArg +functionBody +sourceElements +arrayLiteral +elementList +arrayElement +objectLiteral +propertyAssignment +getAccessor +setAccessor +propertyName +arguments +argumentList +argument +expressionSequence +functionExpressionDeclaration +singleExpression +asExpression +arrowFunctionDeclaration +arrowFunctionParameters +arrowFunctionBody +assignmentOperator +literal +templateStringLiteral +templateStringAtom +numericLiteral +identifierName +identifierOrKeyWord +reservedWord +keyword +getter +setter +eos + + +atn: +[4, 1, 134, 1687, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 294, 8, 1, 1, 2, 1, 2, 3, 2, 298, 8, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 305, 8, 3, 10, 3, 12, 3, 308, 9, 3, 1, 4, 1, 4, 3, 4, 312, 8, 4, 1, 4, 3, 4, 315, 8, 4, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 3, 6, 322, 8, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 5, 7, 329, 8, 7, 10, 7, 12, 7, 332, 9, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 341, 8, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 5, 10, 352, 8, 10, 10, 10, 12, 10, 355, 9, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 375, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 5, 11, 381, 8, 11, 10, 11, 12, 11, 384, 9, 11, 1, 12, 1, 12, 1, 13, 1, 13, 3, 13, 390, 8, 13, 1, 14, 1, 14, 3, 14, 394, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 409, 8, 16, 1, 17, 1, 17, 3, 17, 413, 8, 17, 1, 18, 1, 18, 3, 18, 417, 8, 18, 1, 18, 1, 18, 1, 19, 1, 19, 3, 19, 423, 8, 19, 1, 20, 1, 20, 1, 20, 5, 20, 428, 8, 20, 10, 20, 12, 20, 431, 9, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 440, 8, 21, 3, 21, 442, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 5, 24, 456, 8, 24, 10, 24, 12, 24, 459, 9, 24, 1, 25, 3, 25, 462, 8, 25, 1, 25, 1, 25, 3, 25, 466, 8, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 3, 26, 474, 8, 26, 1, 26, 1, 26, 3, 26, 478, 8, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 4, 28, 491, 8, 28, 11, 28, 12, 28, 492, 1, 28, 1, 28, 3, 28, 497, 8, 28, 1, 29, 3, 29, 500, 8, 29, 1, 29, 1, 29, 3, 29, 504, 8, 29, 1, 29, 3, 29, 507, 8, 29, 1, 29, 1, 29, 3, 29, 511, 8, 29, 1, 30, 1, 30, 1, 30, 1, 31, 3, 31, 517, 8, 31, 1, 31, 1, 31, 3, 31, 521, 8, 31, 1, 31, 1, 31, 3, 31, 525, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 5, 32, 531, 8, 32, 10, 32, 12, 32, 534, 9, 32, 1, 32, 1, 32, 3, 32, 538, 8, 32, 3, 32, 540, 8, 32, 1, 33, 1, 33, 1, 33, 5, 33, 545, 8, 33, 10, 33, 12, 33, 548, 9, 33, 1, 34, 1, 34, 3, 34, 552, 8, 34, 1, 35, 3, 35, 555, 8, 35, 1, 35, 3, 35, 558, 8, 35, 1, 35, 1, 35, 1, 35, 3, 35, 563, 8, 35, 1, 35, 3, 35, 566, 8, 35, 1, 35, 3, 35, 569, 8, 35, 1, 36, 1, 36, 1, 36, 3, 36, 574, 8, 36, 1, 37, 3, 37, 577, 8, 37, 1, 37, 3, 37, 580, 8, 37, 1, 37, 1, 37, 3, 37, 584, 8, 37, 1, 38, 1, 38, 1, 39, 1, 39, 3, 39, 590, 8, 39, 1, 40, 1, 40, 3, 40, 594, 8, 40, 1, 40, 1, 40, 3, 40, 598, 8, 40, 1, 40, 1, 40, 3, 40, 602, 8, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 3, 42, 613, 8, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 3, 43, 620, 8, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 3, 44, 627, 8, 44, 1, 44, 1, 44, 1, 44, 3, 44, 632, 8, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 640, 8, 44, 1, 45, 3, 45, 643, 8, 45, 1, 45, 3, 45, 646, 8, 45, 1, 45, 1, 45, 1, 45, 3, 45, 651, 8, 45, 1, 45, 3, 45, 654, 8, 45, 1, 45, 1, 45, 3, 45, 658, 8, 45, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 5, 47, 666, 8, 47, 10, 47, 12, 47, 669, 9, 47, 1, 48, 3, 48, 672, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 678, 8, 48, 1, 48, 1, 48, 1, 49, 1, 49, 3, 49, 684, 8, 49, 1, 50, 1, 50, 1, 50, 5, 50, 689, 8, 50, 10, 50, 12, 50, 692, 9, 50, 1, 51, 1, 51, 1, 51, 3, 51, 697, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 703, 8, 52, 1, 52, 1, 52, 1, 53, 1, 53, 4, 53, 709, 8, 53, 11, 53, 12, 53, 710, 1, 53, 5, 53, 714, 8, 53, 10, 53, 12, 53, 717, 9, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 4, 55, 725, 8, 55, 11, 55, 12, 55, 726, 1, 56, 1, 56, 1, 56, 3, 56, 732, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 740, 8, 57, 1, 57, 1, 57, 1, 57, 5, 57, 745, 8, 57, 10, 57, 12, 57, 748, 9, 57, 1, 58, 1, 58, 1, 58, 1, 59, 3, 59, 754, 8, 59, 1, 59, 1, 59, 1, 60, 3, 60, 759, 8, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 792, 8, 61, 1, 62, 1, 62, 3, 62, 796, 8, 62, 1, 62, 1, 62, 1, 63, 4, 63, 801, 8, 63, 11, 63, 12, 63, 802, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 809, 8, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 3, 65, 816, 8, 65, 1, 66, 1, 66, 3, 66, 820, 8, 66, 1, 66, 1, 66, 3, 66, 824, 8, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 3, 67, 833, 8, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 839, 8, 67, 10, 67, 12, 67, 842, 9, 67, 1, 67, 1, 67, 1, 68, 1, 68, 3, 68, 848, 8, 68, 1, 68, 1, 68, 3, 68, 852, 8, 68, 1, 69, 1, 69, 3, 69, 856, 8, 69, 1, 69, 1, 69, 3, 69, 860, 8, 69, 1, 69, 3, 69, 863, 8, 69, 1, 69, 3, 69, 866, 8, 69, 1, 69, 3, 69, 869, 8, 69, 1, 69, 1, 69, 3, 69, 873, 8, 69, 1, 69, 1, 69, 3, 69, 877, 8, 69, 1, 69, 1, 69, 3, 69, 881, 8, 69, 3, 69, 883, 8, 69, 1, 70, 1, 70, 1, 70, 5, 70, 888, 8, 70, 10, 70, 12, 70, 891, 9, 70, 1, 71, 1, 71, 1, 71, 3, 71, 896, 8, 71, 1, 71, 3, 71, 899, 8, 71, 1, 71, 3, 71, 902, 8, 71, 1, 71, 1, 71, 3, 71, 906, 8, 71, 1, 71, 3, 71, 909, 8, 71, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 3, 73, 916, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 925, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 944, 8, 75, 1, 75, 1, 75, 3, 75, 948, 8, 75, 1, 75, 1, 75, 3, 75, 952, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 962, 8, 75, 1, 75, 1, 75, 3, 75, 966, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 977, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 990, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 996, 8, 75, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 3, 77, 1003, 8, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 3, 78, 1010, 8, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 3, 79, 1017, 8, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 3, 80, 1024, 8, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 3, 83, 1042, 8, 83, 1, 83, 1, 83, 3, 83, 1046, 8, 83, 3, 83, 1048, 8, 83, 1, 83, 1, 83, 1, 84, 4, 84, 1053, 8, 84, 11, 84, 12, 84, 1054, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1061, 8, 85, 1, 86, 1, 86, 1, 86, 3, 86, 1066, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1081, 8, 89, 1, 89, 3, 89, 1084, 8, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 1106, 8, 93, 1, 94, 3, 94, 1109, 8, 94, 1, 94, 1, 94, 3, 94, 1113, 8, 94, 3, 94, 1115, 8, 94, 1, 94, 3, 94, 1118, 8, 94, 1, 94, 1, 94, 1, 94, 3, 94, 1123, 8, 94, 1, 94, 1, 94, 1, 94, 1, 95, 3, 95, 1129, 8, 95, 1, 95, 3, 95, 1132, 8, 95, 1, 96, 1, 96, 5, 96, 1136, 8, 96, 10, 96, 12, 96, 1139, 9, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 3, 99, 1151, 8, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1156, 8, 99, 1, 100, 1, 100, 1, 100, 3, 100, 1161, 8, 100, 1, 100, 3, 100, 1164, 8, 100, 1, 100, 3, 100, 1167, 8, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 1179, 8, 100, 1, 100, 1, 100, 1, 100, 3, 100, 1184, 8, 100, 1, 100, 3, 100, 1187, 8, 100, 1, 101, 3, 101, 1190, 8, 101, 1, 101, 3, 101, 1193, 8, 101, 1, 101, 3, 101, 1196, 8, 101, 1, 101, 3, 101, 1199, 8, 101, 1, 102, 1, 102, 1, 102, 1, 103, 3, 103, 1205, 8, 103, 1, 103, 1, 103, 1, 103, 3, 103, 1210, 8, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 3, 104, 1220, 8, 104, 1, 104, 1, 104, 3, 104, 1224, 8, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 1235, 8, 105, 10, 105, 12, 105, 1238, 9, 105, 1, 105, 3, 105, 1241, 8, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 5, 107, 1252, 8, 107, 10, 107, 12, 107, 1255, 9, 107, 1, 107, 3, 107, 1258, 8, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 1267, 8, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 5, 109, 1277, 8, 109, 10, 109, 12, 109, 1280, 9, 109, 1, 109, 1, 109, 3, 109, 1284, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 1291, 8, 109, 3, 109, 1293, 8, 109, 1, 110, 3, 110, 1296, 8, 110, 1, 110, 3, 110, 1299, 8, 110, 1, 110, 1, 110, 3, 110, 1303, 8, 110, 1, 110, 3, 110, 1306, 8, 110, 1, 110, 1, 110, 3, 110, 1310, 8, 110, 1, 111, 1, 111, 1, 111, 3, 111, 1315, 8, 111, 1, 112, 3, 112, 1318, 8, 112, 1, 113, 4, 113, 1321, 8, 113, 11, 113, 12, 113, 1322, 1, 114, 1, 114, 3, 114, 1327, 8, 114, 1, 114, 1, 114, 1, 115, 1, 115, 4, 115, 1333, 8, 115, 11, 115, 12, 115, 1334, 1, 115, 5, 115, 1338, 8, 115, 10, 115, 12, 115, 1341, 9, 115, 1, 116, 3, 116, 1344, 8, 116, 1, 116, 1, 116, 3, 116, 1348, 8, 116, 1, 116, 3, 116, 1351, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 1357, 8, 117, 10, 117, 12, 117, 1360, 9, 117, 1, 117, 3, 117, 1363, 8, 117, 3, 117, 1365, 8, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 1384, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 1390, 8, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 1400, 8, 120, 1, 120, 3, 120, 1403, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 3, 121, 1413, 8, 121, 1, 122, 1, 122, 1, 122, 3, 122, 1418, 8, 122, 3, 122, 1420, 8, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 5, 123, 1427, 8, 123, 10, 123, 12, 123, 1430, 9, 123, 1, 124, 3, 124, 1433, 8, 124, 1, 124, 1, 124, 3, 124, 1437, 8, 124, 1, 125, 1, 125, 1, 125, 5, 125, 1442, 8, 125, 10, 125, 12, 125, 1445, 9, 125, 1, 126, 1, 126, 3, 126, 1449, 8, 126, 1, 126, 1, 126, 3, 126, 1453, 8, 126, 1, 126, 1, 126, 3, 126, 1457, 8, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1469, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1476, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1503, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1515, 8, 127, 3, 127, 1517, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1575, 8, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1580, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 5, 127, 1595, 8, 127, 10, 127, 12, 127, 1598, 9, 127, 1, 128, 1, 128, 1, 128, 3, 128, 1603, 8, 128, 1, 128, 3, 128, 1606, 8, 128, 1, 129, 3, 129, 1609, 8, 129, 1, 129, 1, 129, 3, 129, 1613, 8, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 3, 130, 1621, 8, 130, 1, 130, 3, 130, 1624, 8, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1631, 8, 131, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 1641, 8, 133, 1, 134, 1, 134, 5, 134, 1645, 8, 134, 10, 134, 12, 134, 1648, 9, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 1658, 8, 135, 1, 136, 1, 136, 1, 137, 1, 137, 3, 137, 1664, 8, 137, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 3, 139, 1671, 8, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 1685, 8, 143, 1, 143, 0, 4, 20, 22, 114, 254, 144, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 0, 15, 2, 0, 73, 73, 108, 112, 1, 0, 11, 12, 2, 0, 101, 102, 105, 105, 2, 0, 109, 109, 111, 111, 3, 0, 69, 69, 96, 96, 100, 100, 2, 0, 13, 13, 15, 15, 1, 0, 24, 26, 1, 0, 20, 21, 1, 0, 27, 29, 1, 0, 30, 33, 1, 0, 34, 37, 1, 0, 43, 53, 1, 0, 57, 61, 3, 0, 113, 113, 118, 118, 124, 124, 5, 0, 62, 87, 89, 107, 109, 111, 113, 115, 118, 119, 1863, 0, 288, 1, 0, 0, 0, 2, 293, 1, 0, 0, 0, 4, 295, 1, 0, 0, 0, 6, 301, 1, 0, 0, 0, 8, 314, 1, 0, 0, 0, 10, 316, 1, 0, 0, 0, 12, 319, 1, 0, 0, 0, 14, 325, 1, 0, 0, 0, 16, 333, 1, 0, 0, 0, 18, 340, 1, 0, 0, 0, 20, 342, 1, 0, 0, 0, 22, 374, 1, 0, 0, 0, 24, 385, 1, 0, 0, 0, 26, 387, 1, 0, 0, 0, 28, 393, 1, 0, 0, 0, 30, 395, 1, 0, 0, 0, 32, 399, 1, 0, 0, 0, 34, 412, 1, 0, 0, 0, 36, 414, 1, 0, 0, 0, 38, 420, 1, 0, 0, 0, 40, 424, 1, 0, 0, 0, 42, 441, 1, 0, 0, 0, 44, 443, 1, 0, 0, 0, 46, 448, 1, 0, 0, 0, 48, 452, 1, 0, 0, 0, 50, 461, 1, 0, 0, 0, 52, 471, 1, 0, 0, 0, 54, 483, 1, 0, 0, 0, 56, 496, 1, 0, 0, 0, 58, 499, 1, 0, 0, 0, 60, 512, 1, 0, 0, 0, 62, 516, 1, 0, 0, 0, 64, 539, 1, 0, 0, 0, 66, 541, 1, 0, 0, 0, 68, 551, 1, 0, 0, 0, 70, 554, 1, 0, 0, 0, 72, 570, 1, 0, 0, 0, 74, 576, 1, 0, 0, 0, 76, 585, 1, 0, 0, 0, 78, 589, 1, 0, 0, 0, 80, 591, 1, 0, 0, 0, 82, 603, 1, 0, 0, 0, 84, 610, 1, 0, 0, 0, 86, 616, 1, 0, 0, 0, 88, 626, 1, 0, 0, 0, 90, 642, 1, 0, 0, 0, 92, 659, 1, 0, 0, 0, 94, 662, 1, 0, 0, 0, 96, 671, 1, 0, 0, 0, 98, 681, 1, 0, 0, 0, 100, 685, 1, 0, 0, 0, 102, 693, 1, 0, 0, 0, 104, 698, 1, 0, 0, 0, 106, 706, 1, 0, 0, 0, 108, 718, 1, 0, 0, 0, 110, 724, 1, 0, 0, 0, 112, 728, 1, 0, 0, 0, 114, 739, 1, 0, 0, 0, 116, 749, 1, 0, 0, 0, 118, 753, 1, 0, 0, 0, 120, 758, 1, 0, 0, 0, 122, 791, 1, 0, 0, 0, 124, 793, 1, 0, 0, 0, 126, 800, 1, 0, 0, 0, 128, 804, 1, 0, 0, 0, 130, 812, 1, 0, 0, 0, 132, 819, 1, 0, 0, 0, 134, 832, 1, 0, 0, 0, 136, 845, 1, 0, 0, 0, 138, 882, 1, 0, 0, 0, 140, 884, 1, 0, 0, 0, 142, 895, 1, 0, 0, 0, 144, 910, 1, 0, 0, 0, 146, 912, 1, 0, 0, 0, 148, 917, 1, 0, 0, 0, 150, 995, 1, 0, 0, 0, 152, 997, 1, 0, 0, 0, 154, 999, 1, 0, 0, 0, 156, 1006, 1, 0, 0, 0, 158, 1013, 1, 0, 0, 0, 160, 1020, 1, 0, 0, 0, 162, 1027, 1, 0, 0, 0, 164, 1033, 1, 0, 0, 0, 166, 1039, 1, 0, 0, 0, 168, 1052, 1, 0, 0, 0, 170, 1056, 1, 0, 0, 0, 172, 1062, 1, 0, 0, 0, 174, 1067, 1, 0, 0, 0, 176, 1071, 1, 0, 0, 0, 178, 1076, 1, 0, 0, 0, 180, 1085, 1, 0, 0, 0, 182, 1091, 1, 0, 0, 0, 184, 1094, 1, 0, 0, 0, 186, 1097, 1, 0, 0, 0, 188, 1108, 1, 0, 0, 0, 190, 1128, 1, 0, 0, 0, 192, 1133, 1, 0, 0, 0, 194, 1142, 1, 0, 0, 0, 196, 1145, 1, 0, 0, 0, 198, 1155, 1, 0, 0, 0, 200, 1186, 1, 0, 0, 0, 202, 1189, 1, 0, 0, 0, 204, 1200, 1, 0, 0, 0, 206, 1204, 1, 0, 0, 0, 208, 1216, 1, 0, 0, 0, 210, 1230, 1, 0, 0, 0, 212, 1244, 1, 0, 0, 0, 214, 1247, 1, 0, 0, 0, 216, 1261, 1, 0, 0, 0, 218, 1292, 1, 0, 0, 0, 220, 1295, 1, 0, 0, 0, 222, 1311, 1, 0, 0, 0, 224, 1317, 1, 0, 0, 0, 226, 1320, 1, 0, 0, 0, 228, 1324, 1, 0, 0, 0, 230, 1330, 1, 0, 0, 0, 232, 1343, 1, 0, 0, 0, 234, 1352, 1, 0, 0, 0, 236, 1383, 1, 0, 0, 0, 238, 1385, 1, 0, 0, 0, 240, 1395, 1, 0, 0, 0, 242, 1412, 1, 0, 0, 0, 244, 1414, 1, 0, 0, 0, 246, 1423, 1, 0, 0, 0, 248, 1432, 1, 0, 0, 0, 250, 1438, 1, 0, 0, 0, 252, 1446, 1, 0, 0, 0, 254, 1516, 1, 0, 0, 0, 256, 1605, 1, 0, 0, 0, 258, 1608, 1, 0, 0, 0, 260, 1623, 1, 0, 0, 0, 262, 1630, 1, 0, 0, 0, 264, 1632, 1, 0, 0, 0, 266, 1640, 1, 0, 0, 0, 268, 1642, 1, 0, 0, 0, 270, 1657, 1, 0, 0, 0, 272, 1659, 1, 0, 0, 0, 274, 1663, 1, 0, 0, 0, 276, 1665, 1, 0, 0, 0, 278, 1670, 1, 0, 0, 0, 280, 1672, 1, 0, 0, 0, 282, 1674, 1, 0, 0, 0, 284, 1677, 1, 0, 0, 0, 286, 1684, 1, 0, 0, 0, 288, 289, 5, 13, 0, 0, 289, 290, 3, 254, 127, 0, 290, 1, 1, 0, 0, 0, 291, 294, 3, 228, 114, 0, 292, 294, 3, 234, 117, 0, 293, 291, 1, 0, 0, 0, 293, 292, 1, 0, 0, 0, 294, 3, 1, 0, 0, 0, 295, 297, 5, 30, 0, 0, 296, 298, 3, 6, 3, 0, 297, 296, 1, 0, 0, 0, 297, 298, 1, 0, 0, 0, 298, 299, 1, 0, 0, 0, 299, 300, 5, 31, 0, 0, 300, 5, 1, 0, 0, 0, 301, 306, 3, 8, 4, 0, 302, 303, 5, 12, 0, 0, 303, 305, 3, 8, 4, 0, 304, 302, 1, 0, 0, 0, 305, 308, 1, 0, 0, 0, 306, 304, 1, 0, 0, 0, 306, 307, 1, 0, 0, 0, 307, 7, 1, 0, 0, 0, 308, 306, 1, 0, 0, 0, 309, 311, 5, 124, 0, 0, 310, 312, 3, 10, 5, 0, 311, 310, 1, 0, 0, 0, 311, 312, 1, 0, 0, 0, 312, 315, 1, 0, 0, 0, 313, 315, 3, 4, 2, 0, 314, 309, 1, 0, 0, 0, 314, 313, 1, 0, 0, 0, 315, 9, 1, 0, 0, 0, 316, 317, 5, 94, 0, 0, 317, 318, 3, 18, 9, 0, 318, 11, 1, 0, 0, 0, 319, 321, 5, 30, 0, 0, 320, 322, 3, 14, 7, 0, 321, 320, 1, 0, 0, 0, 321, 322, 1, 0, 0, 0, 322, 323, 1, 0, 0, 0, 323, 324, 5, 31, 0, 0, 324, 13, 1, 0, 0, 0, 325, 330, 3, 16, 8, 0, 326, 327, 5, 12, 0, 0, 327, 329, 3, 16, 8, 0, 328, 326, 1, 0, 0, 0, 329, 332, 1, 0, 0, 0, 330, 328, 1, 0, 0, 0, 330, 331, 1, 0, 0, 0, 331, 15, 1, 0, 0, 0, 332, 330, 1, 0, 0, 0, 333, 334, 3, 18, 9, 0, 334, 17, 1, 0, 0, 0, 335, 341, 3, 20, 10, 0, 336, 341, 3, 50, 25, 0, 337, 341, 3, 52, 26, 0, 338, 341, 3, 30, 15, 0, 339, 341, 5, 125, 0, 0, 340, 335, 1, 0, 0, 0, 340, 336, 1, 0, 0, 0, 340, 337, 1, 0, 0, 0, 340, 338, 1, 0, 0, 0, 340, 339, 1, 0, 0, 0, 341, 19, 1, 0, 0, 0, 342, 343, 6, 10, -1, 0, 343, 344, 3, 22, 11, 0, 344, 353, 1, 0, 0, 0, 345, 346, 10, 3, 0, 0, 346, 347, 5, 40, 0, 0, 347, 352, 3, 20, 10, 4, 348, 349, 10, 2, 0, 0, 349, 350, 5, 38, 0, 0, 350, 352, 3, 20, 10, 3, 351, 345, 1, 0, 0, 0, 351, 348, 1, 0, 0, 0, 352, 355, 1, 0, 0, 0, 353, 351, 1, 0, 0, 0, 353, 354, 1, 0, 0, 0, 354, 21, 1, 0, 0, 0, 355, 353, 1, 0, 0, 0, 356, 357, 6, 11, -1, 0, 357, 358, 5, 6, 0, 0, 358, 359, 3, 18, 9, 0, 359, 360, 5, 7, 0, 0, 360, 375, 1, 0, 0, 0, 361, 375, 3, 24, 12, 0, 362, 375, 3, 26, 13, 0, 363, 375, 3, 36, 18, 0, 364, 365, 5, 4, 0, 0, 365, 366, 3, 48, 24, 0, 366, 367, 5, 5, 0, 0, 367, 375, 1, 0, 0, 0, 368, 375, 3, 54, 27, 0, 369, 375, 5, 80, 0, 0, 370, 371, 3, 26, 13, 0, 371, 372, 5, 122, 0, 0, 372, 373, 3, 22, 11, 1, 373, 375, 1, 0, 0, 0, 374, 356, 1, 0, 0, 0, 374, 361, 1, 0, 0, 0, 374, 362, 1, 0, 0, 0, 374, 363, 1, 0, 0, 0, 374, 364, 1, 0, 0, 0, 374, 368, 1, 0, 0, 0, 374, 369, 1, 0, 0, 0, 374, 370, 1, 0, 0, 0, 375, 382, 1, 0, 0, 0, 376, 377, 10, 5, 0, 0, 377, 378, 4, 11, 3, 0, 378, 379, 5, 4, 0, 0, 379, 381, 5, 5, 0, 0, 380, 376, 1, 0, 0, 0, 381, 384, 1, 0, 0, 0, 382, 380, 1, 0, 0, 0, 382, 383, 1, 0, 0, 0, 383, 23, 1, 0, 0, 0, 384, 382, 1, 0, 0, 0, 385, 386, 7, 0, 0, 0, 386, 25, 1, 0, 0, 0, 387, 389, 3, 34, 17, 0, 388, 390, 3, 28, 14, 0, 389, 388, 1, 0, 0, 0, 389, 390, 1, 0, 0, 0, 390, 27, 1, 0, 0, 0, 391, 394, 3, 32, 16, 0, 392, 394, 3, 30, 15, 0, 393, 391, 1, 0, 0, 0, 393, 392, 1, 0, 0, 0, 394, 29, 1, 0, 0, 0, 395, 396, 5, 30, 0, 0, 396, 397, 3, 14, 7, 0, 397, 398, 5, 31, 0, 0, 398, 31, 1, 0, 0, 0, 399, 400, 5, 30, 0, 0, 400, 401, 3, 14, 7, 0, 401, 402, 5, 30, 0, 0, 402, 408, 3, 14, 7, 0, 403, 404, 5, 31, 0, 0, 404, 405, 3, 2, 1, 0, 405, 406, 5, 31, 0, 0, 406, 409, 1, 0, 0, 0, 407, 409, 5, 27, 0, 0, 408, 403, 1, 0, 0, 0, 408, 407, 1, 0, 0, 0, 409, 33, 1, 0, 0, 0, 410, 413, 5, 124, 0, 0, 411, 413, 3, 106, 53, 0, 412, 410, 1, 0, 0, 0, 412, 411, 1, 0, 0, 0, 413, 35, 1, 0, 0, 0, 414, 416, 5, 8, 0, 0, 415, 417, 3, 38, 19, 0, 416, 415, 1, 0, 0, 0, 416, 417, 1, 0, 0, 0, 417, 418, 1, 0, 0, 0, 418, 419, 5, 10, 0, 0, 419, 37, 1, 0, 0, 0, 420, 422, 3, 40, 20, 0, 421, 423, 7, 1, 0, 0, 422, 421, 1, 0, 0, 0, 422, 423, 1, 0, 0, 0, 423, 39, 1, 0, 0, 0, 424, 429, 3, 42, 21, 0, 425, 426, 7, 1, 0, 0, 426, 428, 3, 42, 21, 0, 427, 425, 1, 0, 0, 0, 428, 431, 1, 0, 0, 0, 429, 427, 1, 0, 0, 0, 429, 430, 1, 0, 0, 0, 430, 41, 1, 0, 0, 0, 431, 429, 1, 0, 0, 0, 432, 442, 3, 58, 29, 0, 433, 442, 3, 62, 31, 0, 434, 442, 3, 80, 40, 0, 435, 442, 3, 82, 41, 0, 436, 439, 3, 84, 42, 0, 437, 438, 5, 54, 0, 0, 438, 440, 3, 18, 9, 0, 439, 437, 1, 0, 0, 0, 439, 440, 1, 0, 0, 0, 440, 442, 1, 0, 0, 0, 441, 432, 1, 0, 0, 0, 441, 433, 1, 0, 0, 0, 441, 434, 1, 0, 0, 0, 441, 435, 1, 0, 0, 0, 441, 436, 1, 0, 0, 0, 442, 43, 1, 0, 0, 0, 443, 444, 3, 22, 11, 0, 444, 445, 4, 22, 4, 0, 445, 446, 5, 4, 0, 0, 446, 447, 5, 5, 0, 0, 447, 45, 1, 0, 0, 0, 448, 449, 5, 4, 0, 0, 449, 450, 3, 48, 24, 0, 450, 451, 5, 5, 0, 0, 451, 47, 1, 0, 0, 0, 452, 457, 3, 18, 9, 0, 453, 454, 5, 12, 0, 0, 454, 456, 3, 18, 9, 0, 455, 453, 1, 0, 0, 0, 456, 459, 1, 0, 0, 0, 457, 455, 1, 0, 0, 0, 457, 458, 1, 0, 0, 0, 458, 49, 1, 0, 0, 0, 459, 457, 1, 0, 0, 0, 460, 462, 3, 4, 2, 0, 461, 460, 1, 0, 0, 0, 461, 462, 1, 0, 0, 0, 462, 463, 1, 0, 0, 0, 463, 465, 5, 6, 0, 0, 464, 466, 3, 64, 32, 0, 465, 464, 1, 0, 0, 0, 465, 466, 1, 0, 0, 0, 466, 467, 1, 0, 0, 0, 467, 468, 5, 7, 0, 0, 468, 469, 5, 54, 0, 0, 469, 470, 3, 18, 9, 0, 470, 51, 1, 0, 0, 0, 471, 473, 5, 68, 0, 0, 472, 474, 3, 4, 2, 0, 473, 472, 1, 0, 0, 0, 473, 474, 1, 0, 0, 0, 474, 475, 1, 0, 0, 0, 475, 477, 5, 6, 0, 0, 476, 478, 3, 64, 32, 0, 477, 476, 1, 0, 0, 0, 477, 478, 1, 0, 0, 0, 478, 479, 1, 0, 0, 0, 479, 480, 5, 7, 0, 0, 480, 481, 5, 54, 0, 0, 481, 482, 3, 18, 9, 0, 482, 53, 1, 0, 0, 0, 483, 484, 5, 65, 0, 0, 484, 485, 3, 56, 28, 0, 485, 55, 1, 0, 0, 0, 486, 497, 5, 124, 0, 0, 487, 488, 3, 274, 137, 0, 488, 489, 5, 17, 0, 0, 489, 491, 1, 0, 0, 0, 490, 487, 1, 0, 0, 0, 491, 492, 1, 0, 0, 0, 492, 490, 1, 0, 0, 0, 492, 493, 1, 0, 0, 0, 493, 494, 1, 0, 0, 0, 494, 495, 3, 274, 137, 0, 495, 497, 1, 0, 0, 0, 496, 486, 1, 0, 0, 0, 496, 490, 1, 0, 0, 0, 497, 57, 1, 0, 0, 0, 498, 500, 5, 90, 0, 0, 499, 498, 1, 0, 0, 0, 499, 500, 1, 0, 0, 0, 500, 501, 1, 0, 0, 0, 501, 503, 3, 242, 121, 0, 502, 504, 5, 14, 0, 0, 503, 502, 1, 0, 0, 0, 503, 504, 1, 0, 0, 0, 504, 506, 1, 0, 0, 0, 505, 507, 3, 60, 30, 0, 506, 505, 1, 0, 0, 0, 506, 507, 1, 0, 0, 0, 507, 510, 1, 0, 0, 0, 508, 509, 5, 54, 0, 0, 509, 511, 3, 18, 9, 0, 510, 508, 1, 0, 0, 0, 510, 511, 1, 0, 0, 0, 511, 59, 1, 0, 0, 0, 512, 513, 5, 15, 0, 0, 513, 514, 3, 18, 9, 0, 514, 61, 1, 0, 0, 0, 515, 517, 3, 4, 2, 0, 516, 515, 1, 0, 0, 0, 516, 517, 1, 0, 0, 0, 517, 518, 1, 0, 0, 0, 518, 520, 5, 6, 0, 0, 519, 521, 3, 64, 32, 0, 520, 519, 1, 0, 0, 0, 520, 521, 1, 0, 0, 0, 521, 522, 1, 0, 0, 0, 522, 524, 5, 7, 0, 0, 523, 525, 3, 60, 30, 0, 524, 523, 1, 0, 0, 0, 524, 525, 1, 0, 0, 0, 525, 63, 1, 0, 0, 0, 526, 540, 3, 72, 36, 0, 527, 532, 3, 68, 34, 0, 528, 529, 5, 12, 0, 0, 529, 531, 3, 68, 34, 0, 530, 528, 1, 0, 0, 0, 531, 534, 1, 0, 0, 0, 532, 530, 1, 0, 0, 0, 532, 533, 1, 0, 0, 0, 533, 537, 1, 0, 0, 0, 534, 532, 1, 0, 0, 0, 535, 536, 5, 12, 0, 0, 536, 538, 3, 72, 36, 0, 537, 535, 1, 0, 0, 0, 537, 538, 1, 0, 0, 0, 538, 540, 1, 0, 0, 0, 539, 526, 1, 0, 0, 0, 539, 527, 1, 0, 0, 0, 540, 65, 1, 0, 0, 0, 541, 546, 3, 74, 37, 0, 542, 543, 5, 12, 0, 0, 543, 545, 3, 74, 37, 0, 544, 542, 1, 0, 0, 0, 545, 548, 1, 0, 0, 0, 546, 544, 1, 0, 0, 0, 546, 547, 1, 0, 0, 0, 547, 67, 1, 0, 0, 0, 548, 546, 1, 0, 0, 0, 549, 552, 3, 74, 37, 0, 550, 552, 3, 70, 35, 0, 551, 549, 1, 0, 0, 0, 551, 550, 1, 0, 0, 0, 552, 69, 1, 0, 0, 0, 553, 555, 3, 110, 55, 0, 554, 553, 1, 0, 0, 0, 554, 555, 1, 0, 0, 0, 555, 557, 1, 0, 0, 0, 556, 558, 3, 76, 38, 0, 557, 556, 1, 0, 0, 0, 557, 558, 1, 0, 0, 0, 558, 559, 1, 0, 0, 0, 559, 568, 3, 78, 39, 0, 560, 562, 5, 14, 0, 0, 561, 563, 3, 60, 30, 0, 562, 561, 1, 0, 0, 0, 562, 563, 1, 0, 0, 0, 563, 569, 1, 0, 0, 0, 564, 566, 3, 60, 30, 0, 565, 564, 1, 0, 0, 0, 565, 566, 1, 0, 0, 0, 566, 567, 1, 0, 0, 0, 567, 569, 3, 0, 0, 0, 568, 560, 1, 0, 0, 0, 568, 565, 1, 0, 0, 0, 569, 71, 1, 0, 0, 0, 570, 571, 5, 16, 0, 0, 571, 573, 3, 254, 127, 0, 572, 574, 3, 60, 30, 0, 573, 572, 1, 0, 0, 0, 573, 574, 1, 0, 0, 0, 574, 73, 1, 0, 0, 0, 575, 577, 3, 110, 55, 0, 576, 575, 1, 0, 0, 0, 576, 577, 1, 0, 0, 0, 577, 579, 1, 0, 0, 0, 578, 580, 3, 76, 38, 0, 579, 578, 1, 0, 0, 0, 579, 580, 1, 0, 0, 0, 580, 581, 1, 0, 0, 0, 581, 583, 3, 78, 39, 0, 582, 584, 3, 60, 30, 0, 583, 582, 1, 0, 0, 0, 583, 584, 1, 0, 0, 0, 584, 75, 1, 0, 0, 0, 585, 586, 7, 2, 0, 0, 586, 77, 1, 0, 0, 0, 587, 590, 3, 274, 137, 0, 588, 590, 3, 2, 1, 0, 589, 587, 1, 0, 0, 0, 589, 588, 1, 0, 0, 0, 590, 79, 1, 0, 0, 0, 591, 593, 5, 68, 0, 0, 592, 594, 3, 4, 2, 0, 593, 592, 1, 0, 0, 0, 593, 594, 1, 0, 0, 0, 594, 595, 1, 0, 0, 0, 595, 597, 5, 6, 0, 0, 596, 598, 3, 64, 32, 0, 597, 596, 1, 0, 0, 0, 597, 598, 1, 0, 0, 0, 598, 599, 1, 0, 0, 0, 599, 601, 5, 7, 0, 0, 600, 602, 3, 60, 30, 0, 601, 600, 1, 0, 0, 0, 601, 602, 1, 0, 0, 0, 602, 81, 1, 0, 0, 0, 603, 604, 5, 4, 0, 0, 604, 605, 5, 124, 0, 0, 605, 606, 5, 15, 0, 0, 606, 607, 7, 3, 0, 0, 607, 608, 5, 5, 0, 0, 608, 609, 3, 60, 30, 0, 609, 83, 1, 0, 0, 0, 610, 612, 3, 242, 121, 0, 611, 613, 5, 14, 0, 0, 612, 611, 1, 0, 0, 0, 612, 613, 1, 0, 0, 0, 613, 614, 1, 0, 0, 0, 614, 615, 3, 62, 31, 0, 615, 85, 1, 0, 0, 0, 616, 617, 5, 113, 0, 0, 617, 619, 5, 124, 0, 0, 618, 620, 3, 4, 2, 0, 619, 618, 1, 0, 0, 0, 619, 620, 1, 0, 0, 0, 620, 621, 1, 0, 0, 0, 621, 622, 5, 13, 0, 0, 622, 623, 3, 18, 9, 0, 623, 624, 5, 11, 0, 0, 624, 87, 1, 0, 0, 0, 625, 627, 3, 76, 38, 0, 626, 625, 1, 0, 0, 0, 626, 627, 1, 0, 0, 0, 627, 628, 1, 0, 0, 0, 628, 629, 5, 116, 0, 0, 629, 631, 5, 6, 0, 0, 630, 632, 3, 218, 109, 0, 631, 630, 1, 0, 0, 0, 631, 632, 1, 0, 0, 0, 632, 633, 1, 0, 0, 0, 633, 639, 5, 7, 0, 0, 634, 635, 5, 8, 0, 0, 635, 636, 3, 224, 112, 0, 636, 637, 5, 10, 0, 0, 637, 640, 1, 0, 0, 0, 638, 640, 5, 11, 0, 0, 639, 634, 1, 0, 0, 0, 639, 638, 1, 0, 0, 0, 639, 640, 1, 0, 0, 0, 640, 89, 1, 0, 0, 0, 641, 643, 5, 97, 0, 0, 642, 641, 1, 0, 0, 0, 642, 643, 1, 0, 0, 0, 643, 645, 1, 0, 0, 0, 644, 646, 5, 120, 0, 0, 645, 644, 1, 0, 0, 0, 645, 646, 1, 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 648, 5, 103, 0, 0, 648, 650, 5, 124, 0, 0, 649, 651, 3, 4, 2, 0, 650, 649, 1, 0, 0, 0, 650, 651, 1, 0, 0, 0, 651, 653, 1, 0, 0, 0, 652, 654, 3, 92, 46, 0, 653, 652, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 655, 1, 0, 0, 0, 655, 657, 3, 36, 18, 0, 656, 658, 5, 11, 0, 0, 657, 656, 1, 0, 0, 0, 657, 658, 1, 0, 0, 0, 658, 91, 1, 0, 0, 0, 659, 660, 5, 94, 0, 0, 660, 661, 3, 94, 47, 0, 661, 93, 1, 0, 0, 0, 662, 667, 3, 26, 13, 0, 663, 664, 5, 12, 0, 0, 664, 666, 3, 26, 13, 0, 665, 663, 1, 0, 0, 0, 666, 669, 1, 0, 0, 0, 667, 665, 1, 0, 0, 0, 667, 668, 1, 0, 0, 0, 668, 95, 1, 0, 0, 0, 669, 667, 1, 0, 0, 0, 670, 672, 5, 96, 0, 0, 671, 670, 1, 0, 0, 0, 671, 672, 1, 0, 0, 0, 672, 673, 1, 0, 0, 0, 673, 674, 5, 93, 0, 0, 674, 675, 5, 124, 0, 0, 675, 677, 5, 8, 0, 0, 676, 678, 3, 98, 49, 0, 677, 676, 1, 0, 0, 0, 677, 678, 1, 0, 0, 0, 678, 679, 1, 0, 0, 0, 679, 680, 5, 10, 0, 0, 680, 97, 1, 0, 0, 0, 681, 683, 3, 100, 50, 0, 682, 684, 5, 12, 0, 0, 683, 682, 1, 0, 0, 0, 683, 684, 1, 0, 0, 0, 684, 99, 1, 0, 0, 0, 685, 690, 3, 102, 51, 0, 686, 687, 5, 12, 0, 0, 687, 689, 3, 102, 51, 0, 688, 686, 1, 0, 0, 0, 689, 692, 1, 0, 0, 0, 690, 688, 1, 0, 0, 0, 690, 691, 1, 0, 0, 0, 691, 101, 1, 0, 0, 0, 692, 690, 1, 0, 0, 0, 693, 696, 3, 242, 121, 0, 694, 695, 5, 13, 0, 0, 695, 697, 3, 254, 127, 0, 696, 694, 1, 0, 0, 0, 696, 697, 1, 0, 0, 0, 697, 103, 1, 0, 0, 0, 698, 699, 5, 117, 0, 0, 699, 700, 3, 106, 53, 0, 700, 702, 5, 8, 0, 0, 701, 703, 3, 126, 63, 0, 702, 701, 1, 0, 0, 0, 702, 703, 1, 0, 0, 0, 703, 704, 1, 0, 0, 0, 704, 705, 5, 10, 0, 0, 705, 105, 1, 0, 0, 0, 706, 715, 5, 124, 0, 0, 707, 709, 5, 17, 0, 0, 708, 707, 1, 0, 0, 0, 709, 710, 1, 0, 0, 0, 710, 708, 1, 0, 0, 0, 710, 711, 1, 0, 0, 0, 711, 712, 1, 0, 0, 0, 712, 714, 5, 124, 0, 0, 713, 708, 1, 0, 0, 0, 714, 717, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 107, 1, 0, 0, 0, 717, 715, 1, 0, 0, 0, 718, 719, 5, 124, 0, 0, 719, 720, 5, 13, 0, 0, 720, 721, 3, 106, 53, 0, 721, 722, 5, 11, 0, 0, 722, 109, 1, 0, 0, 0, 723, 725, 3, 112, 56, 0, 724, 723, 1, 0, 0, 0, 725, 726, 1, 0, 0, 0, 726, 724, 1, 0, 0, 0, 726, 727, 1, 0, 0, 0, 727, 111, 1, 0, 0, 0, 728, 731, 5, 123, 0, 0, 729, 732, 3, 114, 57, 0, 730, 732, 3, 116, 58, 0, 731, 729, 1, 0, 0, 0, 731, 730, 1, 0, 0, 0, 732, 113, 1, 0, 0, 0, 733, 734, 6, 57, -1, 0, 734, 740, 5, 124, 0, 0, 735, 736, 5, 6, 0, 0, 736, 737, 3, 254, 127, 0, 737, 738, 5, 7, 0, 0, 738, 740, 1, 0, 0, 0, 739, 733, 1, 0, 0, 0, 739, 735, 1, 0, 0, 0, 740, 746, 1, 0, 0, 0, 741, 742, 10, 2, 0, 0, 742, 743, 5, 17, 0, 0, 743, 745, 3, 274, 137, 0, 744, 741, 1, 0, 0, 0, 745, 748, 1, 0, 0, 0, 746, 744, 1, 0, 0, 0, 746, 747, 1, 0, 0, 0, 747, 115, 1, 0, 0, 0, 748, 746, 1, 0, 0, 0, 749, 750, 3, 114, 57, 0, 750, 751, 3, 244, 122, 0, 751, 117, 1, 0, 0, 0, 752, 754, 3, 226, 113, 0, 753, 752, 1, 0, 0, 0, 753, 754, 1, 0, 0, 0, 754, 755, 1, 0, 0, 0, 755, 756, 5, 0, 0, 1, 756, 119, 1, 0, 0, 0, 757, 759, 5, 97, 0, 0, 758, 757, 1, 0, 0, 0, 758, 759, 1, 0, 0, 0, 759, 760, 1, 0, 0, 0, 760, 761, 3, 122, 61, 0, 761, 121, 1, 0, 0, 0, 762, 792, 3, 124, 62, 0, 763, 792, 3, 130, 65, 0, 764, 792, 3, 136, 68, 0, 765, 792, 3, 144, 72, 0, 766, 792, 3, 128, 64, 0, 767, 792, 3, 188, 94, 0, 768, 792, 3, 90, 45, 0, 769, 792, 3, 104, 52, 0, 770, 792, 3, 148, 74, 0, 771, 792, 3, 150, 75, 0, 772, 792, 3, 154, 77, 0, 773, 792, 3, 156, 78, 0, 774, 792, 3, 158, 79, 0, 775, 792, 3, 160, 80, 0, 776, 792, 3, 162, 81, 0, 777, 792, 3, 174, 87, 0, 778, 792, 3, 164, 82, 0, 779, 792, 3, 176, 88, 0, 780, 792, 3, 178, 89, 0, 781, 792, 3, 184, 92, 0, 782, 792, 3, 186, 93, 0, 783, 792, 3, 258, 129, 0, 784, 792, 3, 208, 104, 0, 785, 792, 3, 138, 69, 0, 786, 792, 3, 86, 43, 0, 787, 792, 3, 96, 48, 0, 788, 792, 3, 146, 73, 0, 789, 790, 5, 97, 0, 0, 790, 792, 3, 122, 61, 0, 791, 762, 1, 0, 0, 0, 791, 763, 1, 0, 0, 0, 791, 764, 1, 0, 0, 0, 791, 765, 1, 0, 0, 0, 791, 766, 1, 0, 0, 0, 791, 767, 1, 0, 0, 0, 791, 768, 1, 0, 0, 0, 791, 769, 1, 0, 0, 0, 791, 770, 1, 0, 0, 0, 791, 771, 1, 0, 0, 0, 791, 772, 1, 0, 0, 0, 791, 773, 1, 0, 0, 0, 791, 774, 1, 0, 0, 0, 791, 775, 1, 0, 0, 0, 791, 776, 1, 0, 0, 0, 791, 777, 1, 0, 0, 0, 791, 778, 1, 0, 0, 0, 791, 779, 1, 0, 0, 0, 791, 780, 1, 0, 0, 0, 791, 781, 1, 0, 0, 0, 791, 782, 1, 0, 0, 0, 791, 783, 1, 0, 0, 0, 791, 784, 1, 0, 0, 0, 791, 785, 1, 0, 0, 0, 791, 786, 1, 0, 0, 0, 791, 787, 1, 0, 0, 0, 791, 788, 1, 0, 0, 0, 791, 789, 1, 0, 0, 0, 792, 123, 1, 0, 0, 0, 793, 795, 5, 8, 0, 0, 794, 796, 3, 126, 63, 0, 795, 794, 1, 0, 0, 0, 795, 796, 1, 0, 0, 0, 796, 797, 1, 0, 0, 0, 797, 798, 5, 10, 0, 0, 798, 125, 1, 0, 0, 0, 799, 801, 3, 122, 61, 0, 800, 799, 1, 0, 0, 0, 801, 802, 1, 0, 0, 0, 802, 800, 1, 0, 0, 0, 802, 803, 1, 0, 0, 0, 803, 127, 1, 0, 0, 0, 804, 808, 5, 121, 0, 0, 805, 806, 5, 124, 0, 0, 806, 809, 3, 62, 31, 0, 807, 809, 3, 138, 69, 0, 808, 805, 1, 0, 0, 0, 808, 807, 1, 0, 0, 0, 809, 810, 1, 0, 0, 0, 810, 811, 3, 286, 143, 0, 811, 129, 1, 0, 0, 0, 812, 815, 5, 98, 0, 0, 813, 816, 3, 132, 66, 0, 814, 816, 3, 108, 54, 0, 815, 813, 1, 0, 0, 0, 815, 814, 1, 0, 0, 0, 816, 131, 1, 0, 0, 0, 817, 820, 5, 24, 0, 0, 818, 820, 3, 134, 67, 0, 819, 817, 1, 0, 0, 0, 819, 818, 1, 0, 0, 0, 820, 823, 1, 0, 0, 0, 821, 822, 5, 88, 0, 0, 822, 824, 3, 274, 137, 0, 823, 821, 1, 0, 0, 0, 823, 824, 1, 0, 0, 0, 824, 825, 1, 0, 0, 0, 825, 826, 5, 89, 0, 0, 826, 827, 5, 125, 0, 0, 827, 828, 3, 286, 143, 0, 828, 133, 1, 0, 0, 0, 829, 830, 3, 274, 137, 0, 830, 831, 5, 12, 0, 0, 831, 833, 1, 0, 0, 0, 832, 829, 1, 0, 0, 0, 832, 833, 1, 0, 0, 0, 833, 834, 1, 0, 0, 0, 834, 835, 5, 8, 0, 0, 835, 840, 3, 274, 137, 0, 836, 837, 5, 12, 0, 0, 837, 839, 3, 274, 137, 0, 838, 836, 1, 0, 0, 0, 839, 842, 1, 0, 0, 0, 840, 838, 1, 0, 0, 0, 840, 841, 1, 0, 0, 0, 841, 843, 1, 0, 0, 0, 842, 840, 1, 0, 0, 0, 843, 844, 5, 10, 0, 0, 844, 135, 1, 0, 0, 0, 845, 847, 5, 97, 0, 0, 846, 848, 5, 82, 0, 0, 847, 846, 1, 0, 0, 0, 847, 848, 1, 0, 0, 0, 848, 851, 1, 0, 0, 0, 849, 852, 3, 132, 66, 0, 850, 852, 3, 122, 61, 0, 851, 849, 1, 0, 0, 0, 851, 850, 1, 0, 0, 0, 852, 137, 1, 0, 0, 0, 853, 855, 3, 2, 1, 0, 854, 856, 3, 60, 30, 0, 855, 854, 1, 0, 0, 0, 855, 856, 1, 0, 0, 0, 856, 857, 1, 0, 0, 0, 857, 859, 3, 0, 0, 0, 858, 860, 5, 11, 0, 0, 859, 858, 1, 0, 0, 0, 859, 860, 1, 0, 0, 0, 860, 883, 1, 0, 0, 0, 861, 863, 3, 76, 38, 0, 862, 861, 1, 0, 0, 0, 862, 863, 1, 0, 0, 0, 863, 865, 1, 0, 0, 0, 864, 866, 3, 152, 76, 0, 865, 864, 1, 0, 0, 0, 865, 866, 1, 0, 0, 0, 866, 868, 1, 0, 0, 0, 867, 869, 5, 90, 0, 0, 868, 867, 1, 0, 0, 0, 868, 869, 1, 0, 0, 0, 869, 870, 1, 0, 0, 0, 870, 872, 3, 140, 70, 0, 871, 873, 5, 11, 0, 0, 872, 871, 1, 0, 0, 0, 872, 873, 1, 0, 0, 0, 873, 883, 1, 0, 0, 0, 874, 876, 5, 120, 0, 0, 875, 877, 3, 152, 76, 0, 876, 875, 1, 0, 0, 0, 876, 877, 1, 0, 0, 0, 877, 878, 1, 0, 0, 0, 878, 880, 3, 140, 70, 0, 879, 881, 5, 11, 0, 0, 880, 879, 1, 0, 0, 0, 880, 881, 1, 0, 0, 0, 881, 883, 1, 0, 0, 0, 882, 853, 1, 0, 0, 0, 882, 862, 1, 0, 0, 0, 882, 874, 1, 0, 0, 0, 883, 139, 1, 0, 0, 0, 884, 889, 3, 142, 71, 0, 885, 886, 5, 12, 0, 0, 886, 888, 3, 142, 71, 0, 887, 885, 1, 0, 0, 0, 888, 891, 1, 0, 0, 0, 889, 887, 1, 0, 0, 0, 889, 890, 1, 0, 0, 0, 890, 141, 1, 0, 0, 0, 891, 889, 1, 0, 0, 0, 892, 896, 3, 276, 138, 0, 893, 896, 3, 228, 114, 0, 894, 896, 3, 234, 117, 0, 895, 892, 1, 0, 0, 0, 895, 893, 1, 0, 0, 0, 895, 894, 1, 0, 0, 0, 896, 898, 1, 0, 0, 0, 897, 899, 3, 60, 30, 0, 898, 897, 1, 0, 0, 0, 898, 899, 1, 0, 0, 0, 899, 901, 1, 0, 0, 0, 900, 902, 3, 254, 127, 0, 901, 900, 1, 0, 0, 0, 901, 902, 1, 0, 0, 0, 902, 908, 1, 0, 0, 0, 903, 905, 5, 13, 0, 0, 904, 906, 3, 4, 2, 0, 905, 904, 1, 0, 0, 0, 905, 906, 1, 0, 0, 0, 906, 907, 1, 0, 0, 0, 907, 909, 3, 254, 127, 0, 908, 903, 1, 0, 0, 0, 908, 909, 1, 0, 0, 0, 909, 143, 1, 0, 0, 0, 910, 911, 5, 11, 0, 0, 911, 145, 1, 0, 0, 0, 912, 913, 4, 73, 6, 0, 913, 915, 3, 250, 125, 0, 914, 916, 5, 11, 0, 0, 915, 914, 1, 0, 0, 0, 915, 916, 1, 0, 0, 0, 916, 147, 1, 0, 0, 0, 917, 918, 5, 83, 0, 0, 918, 919, 5, 6, 0, 0, 919, 920, 3, 250, 125, 0, 920, 921, 5, 7, 0, 0, 921, 924, 3, 122, 61, 0, 922, 923, 5, 67, 0, 0, 923, 925, 3, 122, 61, 0, 924, 922, 1, 0, 0, 0, 924, 925, 1, 0, 0, 0, 925, 149, 1, 0, 0, 0, 926, 927, 5, 63, 0, 0, 927, 928, 3, 122, 61, 0, 928, 929, 5, 77, 0, 0, 929, 930, 5, 6, 0, 0, 930, 931, 3, 250, 125, 0, 931, 932, 5, 7, 0, 0, 932, 933, 3, 286, 143, 0, 933, 996, 1, 0, 0, 0, 934, 935, 5, 77, 0, 0, 935, 936, 5, 6, 0, 0, 936, 937, 3, 250, 125, 0, 937, 938, 5, 7, 0, 0, 938, 939, 3, 122, 61, 0, 939, 996, 1, 0, 0, 0, 940, 941, 5, 75, 0, 0, 941, 943, 5, 6, 0, 0, 942, 944, 3, 250, 125, 0, 943, 942, 1, 0, 0, 0, 943, 944, 1, 0, 0, 0, 944, 945, 1, 0, 0, 0, 945, 947, 5, 11, 0, 0, 946, 948, 3, 250, 125, 0, 947, 946, 1, 0, 0, 0, 947, 948, 1, 0, 0, 0, 948, 949, 1, 0, 0, 0, 949, 951, 5, 11, 0, 0, 950, 952, 3, 250, 125, 0, 951, 950, 1, 0, 0, 0, 951, 952, 1, 0, 0, 0, 952, 953, 1, 0, 0, 0, 953, 954, 5, 7, 0, 0, 954, 996, 3, 122, 61, 0, 955, 956, 5, 75, 0, 0, 956, 957, 5, 6, 0, 0, 957, 958, 3, 152, 76, 0, 958, 959, 3, 140, 70, 0, 959, 961, 5, 11, 0, 0, 960, 962, 3, 250, 125, 0, 961, 960, 1, 0, 0, 0, 961, 962, 1, 0, 0, 0, 962, 963, 1, 0, 0, 0, 963, 965, 5, 11, 0, 0, 964, 966, 3, 250, 125, 0, 965, 964, 1, 0, 0, 0, 965, 966, 1, 0, 0, 0, 966, 967, 1, 0, 0, 0, 967, 968, 5, 7, 0, 0, 968, 969, 3, 122, 61, 0, 969, 996, 1, 0, 0, 0, 970, 971, 5, 75, 0, 0, 971, 972, 5, 6, 0, 0, 972, 976, 3, 254, 127, 0, 973, 977, 5, 86, 0, 0, 974, 975, 5, 124, 0, 0, 975, 977, 4, 75, 7, 0, 976, 973, 1, 0, 0, 0, 976, 974, 1, 0, 0, 0, 977, 978, 1, 0, 0, 0, 978, 979, 3, 250, 125, 0, 979, 980, 5, 7, 0, 0, 980, 981, 3, 122, 61, 0, 981, 996, 1, 0, 0, 0, 982, 983, 5, 75, 0, 0, 983, 984, 5, 6, 0, 0, 984, 985, 3, 152, 76, 0, 985, 989, 3, 142, 71, 0, 986, 990, 5, 86, 0, 0, 987, 988, 5, 124, 0, 0, 988, 990, 4, 75, 8, 0, 989, 986, 1, 0, 0, 0, 989, 987, 1, 0, 0, 0, 990, 991, 1, 0, 0, 0, 991, 992, 3, 250, 125, 0, 992, 993, 5, 7, 0, 0, 993, 994, 3, 122, 61, 0, 994, 996, 1, 0, 0, 0, 995, 926, 1, 0, 0, 0, 995, 934, 1, 0, 0, 0, 995, 940, 1, 0, 0, 0, 995, 955, 1, 0, 0, 0, 995, 970, 1, 0, 0, 0, 995, 982, 1, 0, 0, 0, 996, 151, 1, 0, 0, 0, 997, 998, 7, 4, 0, 0, 998, 153, 1, 0, 0, 0, 999, 1002, 5, 74, 0, 0, 1000, 1001, 4, 77, 9, 0, 1001, 1003, 5, 124, 0, 0, 1002, 1000, 1, 0, 0, 0, 1002, 1003, 1, 0, 0, 0, 1003, 1004, 1, 0, 0, 0, 1004, 1005, 3, 286, 143, 0, 1005, 155, 1, 0, 0, 0, 1006, 1009, 5, 62, 0, 0, 1007, 1008, 4, 78, 10, 0, 1008, 1010, 5, 124, 0, 0, 1009, 1007, 1, 0, 0, 0, 1009, 1010, 1, 0, 0, 0, 1010, 1011, 1, 0, 0, 0, 1011, 1012, 3, 286, 143, 0, 1012, 157, 1, 0, 0, 0, 1013, 1016, 5, 72, 0, 0, 1014, 1015, 4, 79, 11, 0, 1015, 1017, 3, 250, 125, 0, 1016, 1014, 1, 0, 0, 0, 1016, 1017, 1, 0, 0, 0, 1017, 1018, 1, 0, 0, 0, 1018, 1019, 3, 286, 143, 0, 1019, 159, 1, 0, 0, 0, 1020, 1023, 5, 107, 0, 0, 1021, 1022, 4, 80, 12, 0, 1022, 1024, 3, 250, 125, 0, 1023, 1021, 1, 0, 0, 0, 1023, 1024, 1, 0, 0, 0, 1024, 1025, 1, 0, 0, 0, 1025, 1026, 3, 286, 143, 0, 1026, 161, 1, 0, 0, 0, 1027, 1028, 5, 81, 0, 0, 1028, 1029, 5, 6, 0, 0, 1029, 1030, 3, 250, 125, 0, 1030, 1031, 5, 7, 0, 0, 1031, 1032, 3, 122, 61, 0, 1032, 163, 1, 0, 0, 0, 1033, 1034, 5, 76, 0, 0, 1034, 1035, 5, 6, 0, 0, 1035, 1036, 3, 250, 125, 0, 1036, 1037, 5, 7, 0, 0, 1037, 1038, 3, 166, 83, 0, 1038, 165, 1, 0, 0, 0, 1039, 1041, 5, 8, 0, 0, 1040, 1042, 3, 168, 84, 0, 1041, 1040, 1, 0, 0, 0, 1041, 1042, 1, 0, 0, 0, 1042, 1047, 1, 0, 0, 0, 1043, 1045, 3, 172, 86, 0, 1044, 1046, 3, 168, 84, 0, 1045, 1044, 1, 0, 0, 0, 1045, 1046, 1, 0, 0, 0, 1046, 1048, 1, 0, 0, 0, 1047, 1043, 1, 0, 0, 0, 1047, 1048, 1, 0, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, 1050, 5, 10, 0, 0, 1050, 167, 1, 0, 0, 0, 1051, 1053, 3, 170, 85, 0, 1052, 1051, 1, 0, 0, 0, 1053, 1054, 1, 0, 0, 0, 1054, 1052, 1, 0, 0, 0, 1054, 1055, 1, 0, 0, 0, 1055, 169, 1, 0, 0, 0, 1056, 1057, 5, 66, 0, 0, 1057, 1058, 3, 250, 125, 0, 1058, 1060, 5, 15, 0, 0, 1059, 1061, 3, 126, 63, 0, 1060, 1059, 1, 0, 0, 0, 1060, 1061, 1, 0, 0, 0, 1061, 171, 1, 0, 0, 0, 1062, 1063, 5, 82, 0, 0, 1063, 1065, 5, 15, 0, 0, 1064, 1066, 3, 126, 63, 0, 1065, 1064, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 173, 1, 0, 0, 0, 1067, 1068, 5, 124, 0, 0, 1068, 1069, 5, 15, 0, 0, 1069, 1070, 3, 122, 61, 0, 1070, 175, 1, 0, 0, 0, 1071, 1072, 5, 84, 0, 0, 1072, 1073, 4, 88, 13, 0, 1073, 1074, 3, 250, 125, 0, 1074, 1075, 3, 286, 143, 0, 1075, 177, 1, 0, 0, 0, 1076, 1077, 5, 87, 0, 0, 1077, 1083, 3, 124, 62, 0, 1078, 1080, 3, 180, 90, 0, 1079, 1081, 3, 182, 91, 0, 1080, 1079, 1, 0, 0, 0, 1080, 1081, 1, 0, 0, 0, 1081, 1084, 1, 0, 0, 0, 1082, 1084, 3, 182, 91, 0, 1083, 1078, 1, 0, 0, 0, 1083, 1082, 1, 0, 0, 0, 1084, 179, 1, 0, 0, 0, 1085, 1086, 5, 70, 0, 0, 1086, 1087, 5, 6, 0, 0, 1087, 1088, 5, 124, 0, 0, 1088, 1089, 5, 7, 0, 0, 1089, 1090, 3, 124, 62, 0, 1090, 181, 1, 0, 0, 0, 1091, 1092, 5, 71, 0, 0, 1092, 1093, 3, 124, 62, 0, 1093, 183, 1, 0, 0, 0, 1094, 1095, 5, 78, 0, 0, 1095, 1096, 3, 286, 143, 0, 1096, 185, 1, 0, 0, 0, 1097, 1098, 5, 79, 0, 0, 1098, 1099, 5, 124, 0, 0, 1099, 1105, 3, 62, 31, 0, 1100, 1101, 5, 8, 0, 0, 1101, 1102, 3, 224, 112, 0, 1102, 1103, 5, 10, 0, 0, 1103, 1106, 1, 0, 0, 0, 1104, 1106, 5, 11, 0, 0, 1105, 1100, 1, 0, 0, 0, 1105, 1104, 1, 0, 0, 0, 1106, 187, 1, 0, 0, 0, 1107, 1109, 3, 110, 55, 0, 1108, 1107, 1, 0, 0, 0, 1108, 1109, 1, 0, 0, 0, 1109, 1114, 1, 0, 0, 0, 1110, 1112, 5, 97, 0, 0, 1111, 1113, 5, 82, 0, 0, 1112, 1111, 1, 0, 0, 0, 1112, 1113, 1, 0, 0, 0, 1113, 1115, 1, 0, 0, 0, 1114, 1110, 1, 0, 0, 0, 1114, 1115, 1, 0, 0, 0, 1115, 1117, 1, 0, 0, 0, 1116, 1118, 5, 121, 0, 0, 1117, 1116, 1, 0, 0, 0, 1117, 1118, 1, 0, 0, 0, 1118, 1119, 1, 0, 0, 0, 1119, 1120, 5, 92, 0, 0, 1120, 1122, 5, 124, 0, 0, 1121, 1123, 3, 4, 2, 0, 1122, 1121, 1, 0, 0, 0, 1122, 1123, 1, 0, 0, 0, 1123, 1124, 1, 0, 0, 0, 1124, 1125, 3, 190, 95, 0, 1125, 1126, 3, 192, 96, 0, 1126, 189, 1, 0, 0, 0, 1127, 1129, 3, 194, 97, 0, 1128, 1127, 1, 0, 0, 0, 1128, 1129, 1, 0, 0, 0, 1129, 1131, 1, 0, 0, 0, 1130, 1132, 3, 196, 98, 0, 1131, 1130, 1, 0, 0, 0, 1131, 1132, 1, 0, 0, 0, 1132, 191, 1, 0, 0, 0, 1133, 1137, 5, 8, 0, 0, 1134, 1136, 3, 198, 99, 0, 1135, 1134, 1, 0, 0, 0, 1136, 1139, 1, 0, 0, 0, 1137, 1135, 1, 0, 0, 0, 1137, 1138, 1, 0, 0, 0, 1138, 1140, 1, 0, 0, 0, 1139, 1137, 1, 0, 0, 0, 1140, 1141, 5, 10, 0, 0, 1141, 193, 1, 0, 0, 0, 1142, 1143, 5, 94, 0, 0, 1143, 1144, 3, 26, 13, 0, 1144, 195, 1, 0, 0, 0, 1145, 1146, 5, 99, 0, 0, 1146, 1147, 3, 94, 47, 0, 1147, 197, 1, 0, 0, 0, 1148, 1156, 3, 88, 44, 0, 1149, 1151, 3, 110, 55, 0, 1150, 1149, 1, 0, 0, 0, 1150, 1151, 1, 0, 0, 0, 1151, 1152, 1, 0, 0, 0, 1152, 1156, 3, 200, 100, 0, 1153, 1156, 3, 204, 102, 0, 1154, 1156, 3, 122, 61, 0, 1155, 1148, 1, 0, 0, 0, 1155, 1150, 1, 0, 0, 0, 1155, 1153, 1, 0, 0, 0, 1155, 1154, 1, 0, 0, 0, 1156, 199, 1, 0, 0, 0, 1157, 1158, 3, 202, 101, 0, 1158, 1160, 3, 242, 121, 0, 1159, 1161, 5, 14, 0, 0, 1160, 1159, 1, 0, 0, 0, 1160, 1161, 1, 0, 0, 0, 1161, 1163, 1, 0, 0, 0, 1162, 1164, 3, 60, 30, 0, 1163, 1162, 1, 0, 0, 0, 1163, 1164, 1, 0, 0, 0, 1164, 1166, 1, 0, 0, 0, 1165, 1167, 3, 0, 0, 0, 1166, 1165, 1, 0, 0, 0, 1166, 1167, 1, 0, 0, 0, 1167, 1168, 1, 0, 0, 0, 1168, 1169, 5, 11, 0, 0, 1169, 1187, 1, 0, 0, 0, 1170, 1171, 3, 202, 101, 0, 1171, 1172, 3, 242, 121, 0, 1172, 1178, 3, 62, 31, 0, 1173, 1174, 5, 8, 0, 0, 1174, 1175, 3, 224, 112, 0, 1175, 1176, 5, 10, 0, 0, 1176, 1179, 1, 0, 0, 0, 1177, 1179, 5, 11, 0, 0, 1178, 1173, 1, 0, 0, 0, 1178, 1177, 1, 0, 0, 0, 1179, 1187, 1, 0, 0, 0, 1180, 1183, 3, 202, 101, 0, 1181, 1184, 3, 238, 119, 0, 1182, 1184, 3, 240, 120, 0, 1183, 1181, 1, 0, 0, 0, 1183, 1182, 1, 0, 0, 0, 1184, 1187, 1, 0, 0, 0, 1185, 1187, 3, 128, 64, 0, 1186, 1157, 1, 0, 0, 0, 1186, 1170, 1, 0, 0, 0, 1186, 1180, 1, 0, 0, 0, 1186, 1185, 1, 0, 0, 0, 1187, 201, 1, 0, 0, 0, 1188, 1190, 3, 76, 38, 0, 1189, 1188, 1, 0, 0, 0, 1189, 1190, 1, 0, 0, 0, 1190, 1192, 1, 0, 0, 0, 1191, 1193, 5, 91, 0, 0, 1192, 1191, 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, 1195, 1, 0, 0, 0, 1194, 1196, 5, 106, 0, 0, 1195, 1194, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1198, 1, 0, 0, 0, 1197, 1199, 5, 90, 0, 0, 1198, 1197, 1, 0, 0, 0, 1198, 1199, 1, 0, 0, 0, 1199, 203, 1, 0, 0, 0, 1200, 1201, 3, 82, 41, 0, 1201, 1202, 5, 11, 0, 0, 1202, 205, 1, 0, 0, 0, 1203, 1205, 5, 24, 0, 0, 1204, 1203, 1, 0, 0, 0, 1204, 1205, 1, 0, 0, 0, 1205, 1206, 1, 0, 0, 0, 1206, 1207, 5, 124, 0, 0, 1207, 1209, 5, 6, 0, 0, 1208, 1210, 3, 218, 109, 0, 1209, 1208, 1, 0, 0, 0, 1209, 1210, 1, 0, 0, 0, 1210, 1211, 1, 0, 0, 0, 1211, 1212, 5, 7, 0, 0, 1212, 1213, 5, 8, 0, 0, 1213, 1214, 3, 224, 112, 0, 1214, 1215, 5, 10, 0, 0, 1215, 207, 1, 0, 0, 0, 1216, 1217, 5, 79, 0, 0, 1217, 1219, 5, 24, 0, 0, 1218, 1220, 5, 124, 0, 0, 1219, 1218, 1, 0, 0, 0, 1219, 1220, 1, 0, 0, 0, 1220, 1221, 1, 0, 0, 0, 1221, 1223, 5, 6, 0, 0, 1222, 1224, 3, 218, 109, 0, 1223, 1222, 1, 0, 0, 0, 1223, 1224, 1, 0, 0, 0, 1224, 1225, 1, 0, 0, 0, 1225, 1226, 5, 7, 0, 0, 1226, 1227, 5, 8, 0, 0, 1227, 1228, 3, 224, 112, 0, 1228, 1229, 5, 10, 0, 0, 1229, 209, 1, 0, 0, 0, 1230, 1231, 5, 8, 0, 0, 1231, 1236, 3, 212, 106, 0, 1232, 1233, 5, 12, 0, 0, 1233, 1235, 3, 212, 106, 0, 1234, 1232, 1, 0, 0, 0, 1235, 1238, 1, 0, 0, 0, 1236, 1234, 1, 0, 0, 0, 1236, 1237, 1, 0, 0, 0, 1237, 1240, 1, 0, 0, 0, 1238, 1236, 1, 0, 0, 0, 1239, 1241, 5, 12, 0, 0, 1240, 1239, 1, 0, 0, 0, 1240, 1241, 1, 0, 0, 0, 1241, 1242, 1, 0, 0, 0, 1242, 1243, 5, 10, 0, 0, 1243, 211, 1, 0, 0, 0, 1244, 1245, 5, 24, 0, 0, 1245, 1246, 3, 216, 108, 0, 1246, 213, 1, 0, 0, 0, 1247, 1248, 5, 8, 0, 0, 1248, 1253, 3, 216, 108, 0, 1249, 1250, 5, 12, 0, 0, 1250, 1252, 3, 216, 108, 0, 1251, 1249, 1, 0, 0, 0, 1252, 1255, 1, 0, 0, 0, 1253, 1251, 1, 0, 0, 0, 1253, 1254, 1, 0, 0, 0, 1254, 1257, 1, 0, 0, 0, 1255, 1253, 1, 0, 0, 0, 1256, 1258, 5, 12, 0, 0, 1257, 1256, 1, 0, 0, 0, 1257, 1258, 1, 0, 0, 0, 1258, 1259, 1, 0, 0, 0, 1259, 1260, 5, 10, 0, 0, 1260, 215, 1, 0, 0, 0, 1261, 1262, 5, 4, 0, 0, 1262, 1263, 3, 254, 127, 0, 1263, 1264, 5, 5, 0, 0, 1264, 1266, 5, 6, 0, 0, 1265, 1267, 3, 218, 109, 0, 1266, 1265, 1, 0, 0, 0, 1266, 1267, 1, 0, 0, 0, 1267, 1268, 1, 0, 0, 0, 1268, 1269, 5, 7, 0, 0, 1269, 1270, 5, 8, 0, 0, 1270, 1271, 3, 224, 112, 0, 1271, 1272, 5, 10, 0, 0, 1272, 217, 1, 0, 0, 0, 1273, 1278, 3, 220, 110, 0, 1274, 1275, 5, 12, 0, 0, 1275, 1277, 3, 220, 110, 0, 1276, 1274, 1, 0, 0, 0, 1277, 1280, 1, 0, 0, 0, 1278, 1276, 1, 0, 0, 0, 1278, 1279, 1, 0, 0, 0, 1279, 1283, 1, 0, 0, 0, 1280, 1278, 1, 0, 0, 0, 1281, 1282, 5, 12, 0, 0, 1282, 1284, 3, 222, 111, 0, 1283, 1281, 1, 0, 0, 0, 1283, 1284, 1, 0, 0, 0, 1284, 1293, 1, 0, 0, 0, 1285, 1293, 3, 222, 111, 0, 1286, 1293, 3, 228, 114, 0, 1287, 1290, 3, 234, 117, 0, 1288, 1289, 5, 15, 0, 0, 1289, 1291, 3, 218, 109, 0, 1290, 1288, 1, 0, 0, 0, 1290, 1291, 1, 0, 0, 0, 1291, 1293, 1, 0, 0, 0, 1292, 1273, 1, 0, 0, 0, 1292, 1285, 1, 0, 0, 0, 1292, 1286, 1, 0, 0, 0, 1292, 1287, 1, 0, 0, 0, 1293, 219, 1, 0, 0, 0, 1294, 1296, 3, 112, 56, 0, 1295, 1294, 1, 0, 0, 0, 1295, 1296, 1, 0, 0, 0, 1296, 1298, 1, 0, 0, 0, 1297, 1299, 3, 76, 38, 0, 1298, 1297, 1, 0, 0, 0, 1298, 1299, 1, 0, 0, 0, 1299, 1300, 1, 0, 0, 0, 1300, 1302, 3, 276, 138, 0, 1301, 1303, 5, 14, 0, 0, 1302, 1301, 1, 0, 0, 0, 1302, 1303, 1, 0, 0, 0, 1303, 1305, 1, 0, 0, 0, 1304, 1306, 3, 60, 30, 0, 1305, 1304, 1, 0, 0, 0, 1305, 1306, 1, 0, 0, 0, 1306, 1309, 1, 0, 0, 0, 1307, 1308, 5, 13, 0, 0, 1308, 1310, 3, 254, 127, 0, 1309, 1307, 1, 0, 0, 0, 1309, 1310, 1, 0, 0, 0, 1310, 221, 1, 0, 0, 0, 1311, 1312, 5, 16, 0, 0, 1312, 1314, 5, 124, 0, 0, 1313, 1315, 3, 60, 30, 0, 1314, 1313, 1, 0, 0, 0, 1314, 1315, 1, 0, 0, 0, 1315, 223, 1, 0, 0, 0, 1316, 1318, 3, 226, 113, 0, 1317, 1316, 1, 0, 0, 0, 1317, 1318, 1, 0, 0, 0, 1318, 225, 1, 0, 0, 0, 1319, 1321, 3, 120, 60, 0, 1320, 1319, 1, 0, 0, 0, 1321, 1322, 1, 0, 0, 0, 1322, 1320, 1, 0, 0, 0, 1322, 1323, 1, 0, 0, 0, 1323, 227, 1, 0, 0, 0, 1324, 1326, 5, 4, 0, 0, 1325, 1327, 3, 230, 115, 0, 1326, 1325, 1, 0, 0, 0, 1326, 1327, 1, 0, 0, 0, 1327, 1328, 1, 0, 0, 0, 1328, 1329, 5, 5, 0, 0, 1329, 229, 1, 0, 0, 0, 1330, 1339, 3, 232, 116, 0, 1331, 1333, 5, 12, 0, 0, 1332, 1331, 1, 0, 0, 0, 1333, 1334, 1, 0, 0, 0, 1334, 1332, 1, 0, 0, 0, 1334, 1335, 1, 0, 0, 0, 1335, 1336, 1, 0, 0, 0, 1336, 1338, 3, 232, 116, 0, 1337, 1332, 1, 0, 0, 0, 1338, 1341, 1, 0, 0, 0, 1339, 1337, 1, 0, 0, 0, 1339, 1340, 1, 0, 0, 0, 1340, 231, 1, 0, 0, 0, 1341, 1339, 1, 0, 0, 0, 1342, 1344, 5, 16, 0, 0, 1343, 1342, 1, 0, 0, 0, 1343, 1344, 1, 0, 0, 0, 1344, 1347, 1, 0, 0, 0, 1345, 1348, 3, 254, 127, 0, 1346, 1348, 5, 124, 0, 0, 1347, 1345, 1, 0, 0, 0, 1347, 1346, 1, 0, 0, 0, 1348, 1350, 1, 0, 0, 0, 1349, 1351, 5, 12, 0, 0, 1350, 1349, 1, 0, 0, 0, 1350, 1351, 1, 0, 0, 0, 1351, 233, 1, 0, 0, 0, 1352, 1364, 5, 8, 0, 0, 1353, 1358, 3, 236, 118, 0, 1354, 1355, 5, 12, 0, 0, 1355, 1357, 3, 236, 118, 0, 1356, 1354, 1, 0, 0, 0, 1357, 1360, 1, 0, 0, 0, 1358, 1356, 1, 0, 0, 0, 1358, 1359, 1, 0, 0, 0, 1359, 1362, 1, 0, 0, 0, 1360, 1358, 1, 0, 0, 0, 1361, 1363, 5, 12, 0, 0, 1362, 1361, 1, 0, 0, 0, 1362, 1363, 1, 0, 0, 0, 1363, 1365, 1, 0, 0, 0, 1364, 1353, 1, 0, 0, 0, 1364, 1365, 1, 0, 0, 0, 1365, 1366, 1, 0, 0, 0, 1366, 1367, 5, 10, 0, 0, 1367, 235, 1, 0, 0, 0, 1368, 1369, 3, 242, 121, 0, 1369, 1370, 7, 5, 0, 0, 1370, 1371, 3, 254, 127, 0, 1371, 1384, 1, 0, 0, 0, 1372, 1373, 5, 4, 0, 0, 1373, 1374, 3, 254, 127, 0, 1374, 1375, 5, 5, 0, 0, 1375, 1376, 5, 15, 0, 0, 1376, 1377, 3, 254, 127, 0, 1377, 1384, 1, 0, 0, 0, 1378, 1384, 3, 238, 119, 0, 1379, 1384, 3, 240, 120, 0, 1380, 1384, 3, 206, 103, 0, 1381, 1384, 3, 276, 138, 0, 1382, 1384, 3, 72, 36, 0, 1383, 1368, 1, 0, 0, 0, 1383, 1372, 1, 0, 0, 0, 1383, 1378, 1, 0, 0, 0, 1383, 1379, 1, 0, 0, 0, 1383, 1380, 1, 0, 0, 0, 1383, 1381, 1, 0, 0, 0, 1383, 1382, 1, 0, 0, 0, 1384, 237, 1, 0, 0, 0, 1385, 1386, 3, 282, 141, 0, 1386, 1387, 5, 6, 0, 0, 1387, 1389, 5, 7, 0, 0, 1388, 1390, 3, 60, 30, 0, 1389, 1388, 1, 0, 0, 0, 1389, 1390, 1, 0, 0, 0, 1390, 1391, 1, 0, 0, 0, 1391, 1392, 5, 8, 0, 0, 1392, 1393, 3, 224, 112, 0, 1393, 1394, 5, 10, 0, 0, 1394, 239, 1, 0, 0, 0, 1395, 1396, 3, 284, 142, 0, 1396, 1399, 5, 6, 0, 0, 1397, 1400, 5, 124, 0, 0, 1398, 1400, 3, 2, 1, 0, 1399, 1397, 1, 0, 0, 0, 1399, 1398, 1, 0, 0, 0, 1400, 1402, 1, 0, 0, 0, 1401, 1403, 3, 60, 30, 0, 1402, 1401, 1, 0, 0, 0, 1402, 1403, 1, 0, 0, 0, 1403, 1404, 1, 0, 0, 0, 1404, 1405, 5, 7, 0, 0, 1405, 1406, 5, 8, 0, 0, 1406, 1407, 3, 224, 112, 0, 1407, 1408, 5, 10, 0, 0, 1408, 241, 1, 0, 0, 0, 1409, 1413, 3, 274, 137, 0, 1410, 1413, 5, 125, 0, 0, 1411, 1413, 3, 272, 136, 0, 1412, 1409, 1, 0, 0, 0, 1412, 1410, 1, 0, 0, 0, 1412, 1411, 1, 0, 0, 0, 1413, 243, 1, 0, 0, 0, 1414, 1419, 5, 6, 0, 0, 1415, 1417, 3, 246, 123, 0, 1416, 1418, 5, 12, 0, 0, 1417, 1416, 1, 0, 0, 0, 1417, 1418, 1, 0, 0, 0, 1418, 1420, 1, 0, 0, 0, 1419, 1415, 1, 0, 0, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1421, 1, 0, 0, 0, 1421, 1422, 5, 7, 0, 0, 1422, 245, 1, 0, 0, 0, 1423, 1428, 3, 248, 124, 0, 1424, 1425, 5, 12, 0, 0, 1425, 1427, 3, 248, 124, 0, 1426, 1424, 1, 0, 0, 0, 1427, 1430, 1, 0, 0, 0, 1428, 1426, 1, 0, 0, 0, 1428, 1429, 1, 0, 0, 0, 1429, 247, 1, 0, 0, 0, 1430, 1428, 1, 0, 0, 0, 1431, 1433, 5, 16, 0, 0, 1432, 1431, 1, 0, 0, 0, 1432, 1433, 1, 0, 0, 0, 1433, 1436, 1, 0, 0, 0, 1434, 1437, 3, 254, 127, 0, 1435, 1437, 5, 124, 0, 0, 1436, 1434, 1, 0, 0, 0, 1436, 1435, 1, 0, 0, 0, 1437, 249, 1, 0, 0, 0, 1438, 1443, 3, 254, 127, 0, 1439, 1440, 5, 12, 0, 0, 1440, 1442, 3, 254, 127, 0, 1441, 1439, 1, 0, 0, 0, 1442, 1445, 1, 0, 0, 0, 1443, 1441, 1, 0, 0, 0, 1443, 1444, 1, 0, 0, 0, 1444, 251, 1, 0, 0, 0, 1445, 1443, 1, 0, 0, 0, 1446, 1448, 5, 79, 0, 0, 1447, 1449, 5, 124, 0, 0, 1448, 1447, 1, 0, 0, 0, 1448, 1449, 1, 0, 0, 0, 1449, 1450, 1, 0, 0, 0, 1450, 1452, 5, 6, 0, 0, 1451, 1453, 3, 218, 109, 0, 1452, 1451, 1, 0, 0, 0, 1452, 1453, 1, 0, 0, 0, 1453, 1454, 1, 0, 0, 0, 1454, 1456, 5, 7, 0, 0, 1455, 1457, 3, 60, 30, 0, 1456, 1455, 1, 0, 0, 0, 1456, 1457, 1, 0, 0, 0, 1457, 1458, 1, 0, 0, 0, 1458, 1459, 5, 8, 0, 0, 1459, 1460, 3, 224, 112, 0, 1460, 1461, 5, 10, 0, 0, 1461, 253, 1, 0, 0, 0, 1462, 1463, 6, 127, -1, 0, 1463, 1517, 3, 252, 126, 0, 1464, 1517, 3, 258, 129, 0, 1465, 1466, 5, 68, 0, 0, 1466, 1468, 3, 254, 127, 0, 1467, 1469, 3, 12, 6, 0, 1468, 1467, 1, 0, 0, 0, 1468, 1469, 1, 0, 0, 0, 1469, 1470, 1, 0, 0, 0, 1470, 1471, 3, 244, 122, 0, 1471, 1517, 1, 0, 0, 0, 1472, 1473, 5, 68, 0, 0, 1473, 1475, 3, 254, 127, 0, 1474, 1476, 3, 12, 6, 0, 1475, 1474, 1, 0, 0, 0, 1475, 1476, 1, 0, 0, 0, 1476, 1517, 1, 0, 0, 0, 1477, 1478, 5, 85, 0, 0, 1478, 1517, 3, 254, 127, 38, 1479, 1480, 5, 73, 0, 0, 1480, 1517, 3, 254, 127, 37, 1481, 1482, 5, 65, 0, 0, 1482, 1517, 3, 254, 127, 36, 1483, 1484, 5, 18, 0, 0, 1484, 1517, 3, 254, 127, 35, 1485, 1486, 5, 19, 0, 0, 1486, 1517, 3, 254, 127, 34, 1487, 1488, 5, 20, 0, 0, 1488, 1517, 3, 254, 127, 33, 1489, 1490, 5, 21, 0, 0, 1490, 1517, 3, 254, 127, 32, 1491, 1492, 5, 22, 0, 0, 1492, 1517, 3, 254, 127, 31, 1493, 1494, 5, 23, 0, 0, 1494, 1517, 3, 254, 127, 30, 1495, 1517, 3, 214, 107, 0, 1496, 1517, 3, 210, 105, 0, 1497, 1517, 3, 208, 104, 0, 1498, 1517, 3, 160, 80, 0, 1499, 1517, 5, 80, 0, 0, 1500, 1502, 3, 274, 137, 0, 1501, 1503, 3, 254, 127, 0, 1502, 1501, 1, 0, 0, 0, 1502, 1503, 1, 0, 0, 0, 1503, 1517, 1, 0, 0, 0, 1504, 1517, 5, 95, 0, 0, 1505, 1517, 3, 266, 133, 0, 1506, 1517, 3, 228, 114, 0, 1507, 1517, 3, 234, 117, 0, 1508, 1509, 5, 6, 0, 0, 1509, 1510, 3, 250, 125, 0, 1510, 1511, 5, 7, 0, 0, 1511, 1517, 1, 0, 0, 0, 1512, 1514, 3, 12, 6, 0, 1513, 1515, 3, 250, 125, 0, 1514, 1513, 1, 0, 0, 0, 1514, 1515, 1, 0, 0, 0, 1515, 1517, 1, 0, 0, 0, 1516, 1462, 1, 0, 0, 0, 1516, 1464, 1, 0, 0, 0, 1516, 1465, 1, 0, 0, 0, 1516, 1472, 1, 0, 0, 0, 1516, 1477, 1, 0, 0, 0, 1516, 1479, 1, 0, 0, 0, 1516, 1481, 1, 0, 0, 0, 1516, 1483, 1, 0, 0, 0, 1516, 1485, 1, 0, 0, 0, 1516, 1487, 1, 0, 0, 0, 1516, 1489, 1, 0, 0, 0, 1516, 1491, 1, 0, 0, 0, 1516, 1493, 1, 0, 0, 0, 1516, 1495, 1, 0, 0, 0, 1516, 1496, 1, 0, 0, 0, 1516, 1497, 1, 0, 0, 0, 1516, 1498, 1, 0, 0, 0, 1516, 1499, 1, 0, 0, 0, 1516, 1500, 1, 0, 0, 0, 1516, 1504, 1, 0, 0, 0, 1516, 1505, 1, 0, 0, 0, 1516, 1506, 1, 0, 0, 0, 1516, 1507, 1, 0, 0, 0, 1516, 1508, 1, 0, 0, 0, 1516, 1512, 1, 0, 0, 0, 1517, 1596, 1, 0, 0, 0, 1518, 1519, 10, 29, 0, 0, 1519, 1520, 7, 6, 0, 0, 1520, 1595, 3, 254, 127, 30, 1521, 1522, 10, 28, 0, 0, 1522, 1523, 7, 7, 0, 0, 1523, 1595, 3, 254, 127, 29, 1524, 1525, 10, 27, 0, 0, 1525, 1526, 7, 8, 0, 0, 1526, 1595, 3, 254, 127, 28, 1527, 1528, 10, 26, 0, 0, 1528, 1529, 7, 9, 0, 0, 1529, 1595, 3, 254, 127, 27, 1530, 1531, 10, 25, 0, 0, 1531, 1532, 5, 64, 0, 0, 1532, 1595, 3, 254, 127, 26, 1533, 1534, 10, 24, 0, 0, 1534, 1535, 5, 86, 0, 0, 1535, 1595, 3, 254, 127, 25, 1536, 1537, 10, 23, 0, 0, 1537, 1538, 7, 10, 0, 0, 1538, 1595, 3, 254, 127, 24, 1539, 1540, 10, 22, 0, 0, 1540, 1541, 5, 38, 0, 0, 1541, 1595, 3, 254, 127, 23, 1542, 1543, 10, 21, 0, 0, 1543, 1544, 5, 39, 0, 0, 1544, 1595, 3, 254, 127, 22, 1545, 1546, 10, 20, 0, 0, 1546, 1547, 5, 40, 0, 0, 1547, 1595, 3, 254, 127, 21, 1548, 1549, 10, 19, 0, 0, 1549, 1550, 5, 41, 0, 0, 1550, 1595, 3, 254, 127, 20, 1551, 1552, 10, 18, 0, 0, 1552, 1553, 5, 42, 0, 0, 1553, 1595, 3, 254, 127, 19, 1554, 1555, 10, 17, 0, 0, 1555, 1556, 5, 14, 0, 0, 1556, 1557, 3, 254, 127, 0, 1557, 1558, 5, 15, 0, 0, 1558, 1559, 3, 254, 127, 18, 1559, 1595, 1, 0, 0, 0, 1560, 1561, 10, 16, 0, 0, 1561, 1562, 5, 13, 0, 0, 1562, 1595, 3, 254, 127, 17, 1563, 1564, 10, 15, 0, 0, 1564, 1565, 3, 264, 132, 0, 1565, 1566, 3, 254, 127, 16, 1566, 1595, 1, 0, 0, 0, 1567, 1568, 10, 45, 0, 0, 1568, 1569, 5, 4, 0, 0, 1569, 1570, 3, 250, 125, 0, 1570, 1571, 5, 5, 0, 0, 1571, 1595, 1, 0, 0, 0, 1572, 1574, 10, 44, 0, 0, 1573, 1575, 5, 23, 0, 0, 1574, 1573, 1, 0, 0, 0, 1574, 1575, 1, 0, 0, 0, 1575, 1576, 1, 0, 0, 0, 1576, 1577, 5, 17, 0, 0, 1577, 1579, 3, 274, 137, 0, 1578, 1580, 3, 28, 14, 0, 1579, 1578, 1, 0, 0, 0, 1579, 1580, 1, 0, 0, 0, 1580, 1595, 1, 0, 0, 0, 1581, 1582, 10, 41, 0, 0, 1582, 1595, 3, 244, 122, 0, 1583, 1584, 10, 40, 0, 0, 1584, 1585, 4, 127, 33, 0, 1585, 1595, 5, 18, 0, 0, 1586, 1587, 10, 39, 0, 0, 1587, 1588, 4, 127, 35, 0, 1588, 1595, 5, 19, 0, 0, 1589, 1590, 10, 14, 0, 0, 1590, 1595, 3, 268, 134, 0, 1591, 1592, 10, 1, 0, 0, 1592, 1593, 5, 88, 0, 0, 1593, 1595, 3, 256, 128, 0, 1594, 1518, 1, 0, 0, 0, 1594, 1521, 1, 0, 0, 0, 1594, 1524, 1, 0, 0, 0, 1594, 1527, 1, 0, 0, 0, 1594, 1530, 1, 0, 0, 0, 1594, 1533, 1, 0, 0, 0, 1594, 1536, 1, 0, 0, 0, 1594, 1539, 1, 0, 0, 0, 1594, 1542, 1, 0, 0, 0, 1594, 1545, 1, 0, 0, 0, 1594, 1548, 1, 0, 0, 0, 1594, 1551, 1, 0, 0, 0, 1594, 1554, 1, 0, 0, 0, 1594, 1560, 1, 0, 0, 0, 1594, 1563, 1, 0, 0, 0, 1594, 1567, 1, 0, 0, 0, 1594, 1572, 1, 0, 0, 0, 1594, 1581, 1, 0, 0, 0, 1594, 1583, 1, 0, 0, 0, 1594, 1586, 1, 0, 0, 0, 1594, 1589, 1, 0, 0, 0, 1594, 1591, 1, 0, 0, 0, 1595, 1598, 1, 0, 0, 0, 1596, 1594, 1, 0, 0, 0, 1596, 1597, 1, 0, 0, 0, 1597, 255, 1, 0, 0, 0, 1598, 1596, 1, 0, 0, 0, 1599, 1602, 3, 24, 12, 0, 1600, 1601, 5, 4, 0, 0, 1601, 1603, 5, 5, 0, 0, 1602, 1600, 1, 0, 0, 0, 1602, 1603, 1, 0, 0, 0, 1603, 1606, 1, 0, 0, 0, 1604, 1606, 3, 254, 127, 0, 1605, 1599, 1, 0, 0, 0, 1605, 1604, 1, 0, 0, 0, 1606, 257, 1, 0, 0, 0, 1607, 1609, 5, 91, 0, 0, 1608, 1607, 1, 0, 0, 0, 1608, 1609, 1, 0, 0, 0, 1609, 1610, 1, 0, 0, 0, 1610, 1612, 3, 260, 130, 0, 1611, 1613, 3, 60, 30, 0, 1612, 1611, 1, 0, 0, 0, 1612, 1613, 1, 0, 0, 0, 1613, 1614, 1, 0, 0, 0, 1614, 1615, 5, 54, 0, 0, 1615, 1616, 3, 262, 131, 0, 1616, 259, 1, 0, 0, 0, 1617, 1624, 5, 124, 0, 0, 1618, 1620, 5, 6, 0, 0, 1619, 1621, 3, 218, 109, 0, 1620, 1619, 1, 0, 0, 0, 1620, 1621, 1, 0, 0, 0, 1621, 1622, 1, 0, 0, 0, 1622, 1624, 5, 7, 0, 0, 1623, 1617, 1, 0, 0, 0, 1623, 1618, 1, 0, 0, 0, 1624, 261, 1, 0, 0, 0, 1625, 1631, 3, 254, 127, 0, 1626, 1627, 5, 8, 0, 0, 1627, 1628, 3, 224, 112, 0, 1628, 1629, 5, 10, 0, 0, 1629, 1631, 1, 0, 0, 0, 1630, 1625, 1, 0, 0, 0, 1630, 1626, 1, 0, 0, 0, 1631, 263, 1, 0, 0, 0, 1632, 1633, 7, 11, 0, 0, 1633, 265, 1, 0, 0, 0, 1634, 1641, 5, 55, 0, 0, 1635, 1641, 5, 56, 0, 0, 1636, 1641, 5, 125, 0, 0, 1637, 1641, 3, 268, 134, 0, 1638, 1641, 5, 3, 0, 0, 1639, 1641, 3, 272, 136, 0, 1640, 1634, 1, 0, 0, 0, 1640, 1635, 1, 0, 0, 0, 1640, 1636, 1, 0, 0, 0, 1640, 1637, 1, 0, 0, 0, 1640, 1638, 1, 0, 0, 0, 1640, 1639, 1, 0, 0, 0, 1641, 267, 1, 0, 0, 0, 1642, 1646, 5, 126, 0, 0, 1643, 1645, 3, 270, 135, 0, 1644, 1643, 1, 0, 0, 0, 1645, 1648, 1, 0, 0, 0, 1646, 1644, 1, 0, 0, 0, 1646, 1647, 1, 0, 0, 0, 1647, 1649, 1, 0, 0, 0, 1648, 1646, 1, 0, 0, 0, 1649, 1650, 5, 126, 0, 0, 1650, 269, 1, 0, 0, 0, 1651, 1658, 5, 134, 0, 0, 1652, 1653, 5, 133, 0, 0, 1653, 1654, 3, 254, 127, 0, 1654, 1655, 5, 9, 0, 0, 1655, 1658, 1, 0, 0, 0, 1656, 1658, 5, 132, 0, 0, 1657, 1651, 1, 0, 0, 0, 1657, 1652, 1, 0, 0, 0, 1657, 1656, 1, 0, 0, 0, 1658, 271, 1, 0, 0, 0, 1659, 1660, 7, 12, 0, 0, 1660, 273, 1, 0, 0, 0, 1661, 1664, 5, 124, 0, 0, 1662, 1664, 3, 278, 139, 0, 1663, 1661, 1, 0, 0, 0, 1663, 1662, 1, 0, 0, 0, 1664, 275, 1, 0, 0, 0, 1665, 1666, 7, 13, 0, 0, 1666, 277, 1, 0, 0, 0, 1667, 1671, 3, 280, 140, 0, 1668, 1671, 5, 55, 0, 0, 1669, 1671, 5, 56, 0, 0, 1670, 1667, 1, 0, 0, 0, 1670, 1668, 1, 0, 0, 0, 1670, 1669, 1, 0, 0, 0, 1671, 279, 1, 0, 0, 0, 1672, 1673, 7, 14, 0, 0, 1673, 281, 1, 0, 0, 0, 1674, 1675, 5, 114, 0, 0, 1675, 1676, 3, 242, 121, 0, 1676, 283, 1, 0, 0, 0, 1677, 1678, 5, 115, 0, 0, 1678, 1679, 3, 242, 121, 0, 1679, 285, 1, 0, 0, 0, 1680, 1685, 5, 11, 0, 0, 1681, 1685, 5, 0, 0, 1, 1682, 1685, 4, 143, 38, 0, 1683, 1685, 4, 143, 39, 0, 1684, 1680, 1, 0, 0, 0, 1684, 1681, 1, 0, 0, 0, 1684, 1682, 1, 0, 0, 0, 1684, 1683, 1, 0, 0, 0, 1685, 287, 1, 0, 0, 0, 213, 293, 297, 306, 311, 314, 321, 330, 340, 351, 353, 374, 382, 389, 393, 408, 412, 416, 422, 429, 439, 441, 457, 461, 465, 473, 477, 492, 496, 499, 503, 506, 510, 516, 520, 524, 532, 537, 539, 546, 551, 554, 557, 562, 565, 568, 573, 576, 579, 583, 589, 593, 597, 601, 612, 619, 626, 631, 639, 642, 645, 650, 653, 657, 667, 671, 677, 683, 690, 696, 702, 710, 715, 726, 731, 739, 746, 753, 758, 791, 795, 802, 808, 815, 819, 823, 832, 840, 847, 851, 855, 859, 862, 865, 868, 872, 876, 880, 882, 889, 895, 898, 901, 905, 908, 915, 924, 943, 947, 951, 961, 965, 976, 989, 995, 1002, 1009, 1016, 1023, 1041, 1045, 1047, 1054, 1060, 1065, 1080, 1083, 1105, 1108, 1112, 1114, 1117, 1122, 1128, 1131, 1137, 1150, 1155, 1160, 1163, 1166, 1178, 1183, 1186, 1189, 1192, 1195, 1198, 1204, 1209, 1219, 1223, 1236, 1240, 1253, 1257, 1266, 1278, 1283, 1290, 1292, 1295, 1298, 1302, 1305, 1309, 1314, 1317, 1322, 1326, 1334, 1339, 1343, 1347, 1350, 1358, 1362, 1364, 1383, 1389, 1399, 1402, 1412, 1417, 1419, 1428, 1432, 1436, 1443, 1448, 1452, 1456, 1468, 1475, 1502, 1514, 1516, 1574, 1579, 1594, 1596, 1602, 1605, 1608, 1612, 1620, 1623, 1630, 1640, 1646, 1657, 1663, 1670, 1684] \ No newline at end of file diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.java b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.java new file mode 100644 index 0000000..5c767ed --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.java @@ -0,0 +1,15238 @@ +// Generated from /www/p_java/babylon/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.g4 by ANTLR 4.13.1 +package one.edee.babylon.export.ts.gen; +import one.edee.babylon.export.ts.TypeScriptParserBase; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) +public class TypeScriptParser extends TypeScriptParserBase { + static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + MultiLineComment=1, SingleLineComment=2, RegularExpressionLiteral=3, OpenBracket=4, + CloseBracket=5, OpenParen=6, CloseParen=7, OpenBrace=8, TemplateCloseBrace=9, + CloseBrace=10, SemiColon=11, Comma=12, Assign=13, QuestionMark=14, Colon=15, + Ellipsis=16, Dot=17, PlusPlus=18, MinusMinus=19, Plus=20, Minus=21, BitNot=22, + Not=23, Multiply=24, Divide=25, Modulus=26, RightShiftArithmetic=27, LeftShiftArithmetic=28, + RightShiftLogical=29, LessThan=30, MoreThan=31, LessThanEquals=32, GreaterThanEquals=33, + Equals_=34, NotEquals=35, IdentityEquals=36, IdentityNotEquals=37, BitAnd=38, + BitXOr=39, BitOr=40, And=41, Or=42, MultiplyAssign=43, DivideAssign=44, + ModulusAssign=45, PlusAssign=46, MinusAssign=47, LeftShiftArithmeticAssign=48, + RightShiftArithmeticAssign=49, RightShiftLogicalAssign=50, BitAndAssign=51, + BitXorAssign=52, BitOrAssign=53, ARROW=54, NullLiteral=55, BooleanLiteral=56, + DecimalLiteral=57, HexIntegerLiteral=58, OctalIntegerLiteral=59, OctalIntegerLiteral2=60, + BinaryIntegerLiteral=61, Break=62, Do=63, Instanceof=64, Typeof=65, Case=66, + Else=67, New=68, Var=69, Catch=70, Finally=71, Return=72, Void=73, Continue=74, + For=75, Switch=76, While=77, Debugger=78, Function_=79, This=80, With=81, + Default=82, If=83, Throw=84, Delete=85, In=86, Try=87, As=88, From=89, + ReadOnly=90, Async=91, Class=92, Enum=93, Extends=94, Super=95, Const=96, + Export=97, Import=98, Implements=99, Let=100, Private=101, Public=102, + Interface=103, Package=104, Protected=105, Static=106, Yield=107, Any=108, + Number=109, Boolean=110, String=111, Symbol=112, TypeAlias=113, Get=114, + Set=115, Constructor=116, Namespace=117, Require=118, Module=119, Declare=120, + Abstract=121, Is=122, At=123, Identifier=124, StringLiteral=125, BackTick=126, + WhiteSpaces=127, LineTerminator=128, HtmlComment=129, CDataComment=130, + UnexpectedCharacter=131, TemplateStringEscapeAtom=132, TemplateStringStartExpression=133, + TemplateStringAtom=134; + public static final int + RULE_initializer = 0, RULE_bindingPattern = 1, RULE_typeParameters = 2, + RULE_typeParameterList = 3, RULE_typeParameter = 4, RULE_constraint = 5, + RULE_typeArguments = 6, RULE_typeArgumentList = 7, RULE_typeArgument = 8, + RULE_type_ = 9, RULE_unionOrIntersectionOrPrimaryType = 10, RULE_primaryType = 11, + RULE_predefinedType = 12, RULE_typeReference = 13, RULE_nestedTypeGeneric = 14, + RULE_typeGeneric = 15, RULE_typeIncludeGeneric = 16, RULE_typeName = 17, + RULE_objectType = 18, RULE_typeBody = 19, RULE_typeMemberList = 20, RULE_typeMember = 21, + RULE_arrayType = 22, RULE_tupleType = 23, RULE_tupleElementTypes = 24, + RULE_functionType = 25, RULE_constructorType = 26, RULE_typeQuery = 27, + RULE_typeQueryExpression = 28, RULE_propertySignatur = 29, RULE_typeAnnotation = 30, + RULE_callSignature = 31, RULE_parameterList = 32, RULE_requiredParameterList = 33, + RULE_parameter = 34, RULE_optionalParameter = 35, RULE_restParameter = 36, + RULE_requiredParameter = 37, RULE_accessibilityModifier = 38, RULE_identifierOrPattern = 39, + RULE_constructSignature = 40, RULE_indexSignature = 41, RULE_methodSignature = 42, + RULE_typeAliasDeclaration = 43, RULE_constructorDeclaration = 44, RULE_interfaceDeclaration = 45, + RULE_interfaceExtendsClause = 46, RULE_classOrInterfaceTypeList = 47, + RULE_enumDeclaration = 48, RULE_enumBody = 49, RULE_enumMemberList = 50, + RULE_enumMember = 51, RULE_namespaceDeclaration = 52, RULE_namespaceName = 53, + RULE_importAliasDeclaration = 54, RULE_decoratorList = 55, RULE_decorator = 56, + RULE_decoratorMemberExpression = 57, RULE_decoratorCallExpression = 58, + RULE_program = 59, RULE_sourceElement = 60, RULE_statement = 61, RULE_block = 62, + RULE_statementList = 63, RULE_abstractDeclaration = 64, RULE_importStatement = 65, + RULE_fromBlock = 66, RULE_multipleImportStatement = 67, RULE_exportStatement = 68, + RULE_variableStatement = 69, RULE_variableDeclarationList = 70, RULE_variableDeclaration = 71, + RULE_emptyStatement_ = 72, RULE_expressionStatement = 73, RULE_ifStatement = 74, + RULE_iterationStatement = 75, RULE_varModifier = 76, RULE_continueStatement = 77, + RULE_breakStatement = 78, RULE_returnStatement = 79, RULE_yieldStatement = 80, + RULE_withStatement = 81, RULE_switchStatement = 82, RULE_caseBlock = 83, + RULE_caseClauses = 84, RULE_caseClause = 85, RULE_defaultClause = 86, + RULE_labelledStatement = 87, RULE_throwStatement = 88, RULE_tryStatement = 89, + RULE_catchProduction = 90, RULE_finallyProduction = 91, RULE_debuggerStatement = 92, + RULE_functionDeclaration = 93, RULE_classDeclaration = 94, RULE_classHeritage = 95, + RULE_classTail = 96, RULE_classExtendsClause = 97, RULE_implementsClause = 98, + RULE_classElement = 99, RULE_propertyMemberDeclaration = 100, RULE_propertyMemberBase = 101, + RULE_indexMemberDeclaration = 102, RULE_generatorMethod = 103, RULE_generatorFunctionDeclaration = 104, + RULE_generatorBlock = 105, RULE_generatorDefinition = 106, RULE_iteratorBlock = 107, + RULE_iteratorDefinition = 108, RULE_formalParameterList = 109, RULE_formalParameterArg = 110, + RULE_lastFormalParameterArg = 111, RULE_functionBody = 112, RULE_sourceElements = 113, + RULE_arrayLiteral = 114, RULE_elementList = 115, RULE_arrayElement = 116, + RULE_objectLiteral = 117, RULE_propertyAssignment = 118, RULE_getAccessor = 119, + RULE_setAccessor = 120, RULE_propertyName = 121, RULE_arguments = 122, + RULE_argumentList = 123, RULE_argument = 124, RULE_expressionSequence = 125, + RULE_functionExpressionDeclaration = 126, RULE_singleExpression = 127, + RULE_asExpression = 128, RULE_arrowFunctionDeclaration = 129, RULE_arrowFunctionParameters = 130, + RULE_arrowFunctionBody = 131, RULE_assignmentOperator = 132, RULE_literal = 133, + RULE_templateStringLiteral = 134, RULE_templateStringAtom = 135, RULE_numericLiteral = 136, + RULE_identifierName = 137, RULE_identifierOrKeyWord = 138, RULE_reservedWord = 139, + RULE_keyword = 140, RULE_getter = 141, RULE_setter = 142, RULE_eos = 143; + private static String[] makeRuleNames() { + return new String[] { + "initializer", "bindingPattern", "typeParameters", "typeParameterList", + "typeParameter", "constraint", "typeArguments", "typeArgumentList", "typeArgument", + "type_", "unionOrIntersectionOrPrimaryType", "primaryType", "predefinedType", + "typeReference", "nestedTypeGeneric", "typeGeneric", "typeIncludeGeneric", + "typeName", "objectType", "typeBody", "typeMemberList", "typeMember", + "arrayType", "tupleType", "tupleElementTypes", "functionType", "constructorType", + "typeQuery", "typeQueryExpression", "propertySignatur", "typeAnnotation", + "callSignature", "parameterList", "requiredParameterList", "parameter", + "optionalParameter", "restParameter", "requiredParameter", "accessibilityModifier", + "identifierOrPattern", "constructSignature", "indexSignature", "methodSignature", + "typeAliasDeclaration", "constructorDeclaration", "interfaceDeclaration", + "interfaceExtendsClause", "classOrInterfaceTypeList", "enumDeclaration", + "enumBody", "enumMemberList", "enumMember", "namespaceDeclaration", "namespaceName", + "importAliasDeclaration", "decoratorList", "decorator", "decoratorMemberExpression", + "decoratorCallExpression", "program", "sourceElement", "statement", "block", + "statementList", "abstractDeclaration", "importStatement", "fromBlock", + "multipleImportStatement", "exportStatement", "variableStatement", "variableDeclarationList", + "variableDeclaration", "emptyStatement_", "expressionStatement", "ifStatement", + "iterationStatement", "varModifier", "continueStatement", "breakStatement", + "returnStatement", "yieldStatement", "withStatement", "switchStatement", + "caseBlock", "caseClauses", "caseClause", "defaultClause", "labelledStatement", + "throwStatement", "tryStatement", "catchProduction", "finallyProduction", + "debuggerStatement", "functionDeclaration", "classDeclaration", "classHeritage", + "classTail", "classExtendsClause", "implementsClause", "classElement", + "propertyMemberDeclaration", "propertyMemberBase", "indexMemberDeclaration", + "generatorMethod", "generatorFunctionDeclaration", "generatorBlock", + "generatorDefinition", "iteratorBlock", "iteratorDefinition", "formalParameterList", + "formalParameterArg", "lastFormalParameterArg", "functionBody", "sourceElements", + "arrayLiteral", "elementList", "arrayElement", "objectLiteral", "propertyAssignment", + "getAccessor", "setAccessor", "propertyName", "arguments", "argumentList", + "argument", "expressionSequence", "functionExpressionDeclaration", "singleExpression", + "asExpression", "arrowFunctionDeclaration", "arrowFunctionParameters", + "arrowFunctionBody", "assignmentOperator", "literal", "templateStringLiteral", + "templateStringAtom", "numericLiteral", "identifierName", "identifierOrKeyWord", + "reservedWord", "keyword", "getter", "setter", "eos" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, null, null, null, "'['", "']'", "'('", "')'", "'{'", null, "'}'", + "';'", "','", "'='", "'?'", "':'", "'...'", "'.'", "'++'", "'--'", "'+'", + "'-'", "'~'", "'!'", "'*'", "'/'", "'%'", "'>>'", "'<<'", "'>>>'", "'<'", + "'>'", "'<='", "'>='", "'=='", "'!='", "'==='", "'!=='", "'&'", "'^'", + "'|'", "'&&'", "'||'", "'*='", "'/='", "'%='", "'+='", "'-='", "'<<='", + "'>>='", "'>>>='", "'&='", "'^='", "'|='", "'=>'", "'null'", null, null, + null, null, null, null, "'break'", "'do'", "'instanceof'", "'typeof'", + "'case'", "'else'", "'new'", "'var'", "'catch'", "'finally'", "'return'", + "'void'", "'continue'", "'for'", "'switch'", "'while'", "'debugger'", + "'function'", "'this'", "'with'", "'default'", "'if'", "'throw'", "'delete'", + "'in'", "'try'", "'as'", "'from'", "'readonly'", "'async'", "'class'", + "'enum'", "'extends'", "'super'", "'const'", "'export'", "'import'", + "'implements'", "'let'", "'private'", "'public'", "'interface'", "'package'", + "'protected'", "'static'", "'yield'", "'any'", "'number'", "'boolean'", + "'string'", "'symbol'", "'type'", "'get'", "'set'", "'constructor'", + "'namespace'", "'require'", "'module'", "'declare'", "'abstract'", "'is'", + "'@'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "MultiLineComment", "SingleLineComment", "RegularExpressionLiteral", + "OpenBracket", "CloseBracket", "OpenParen", "CloseParen", "OpenBrace", + "TemplateCloseBrace", "CloseBrace", "SemiColon", "Comma", "Assign", "QuestionMark", + "Colon", "Ellipsis", "Dot", "PlusPlus", "MinusMinus", "Plus", "Minus", + "BitNot", "Not", "Multiply", "Divide", "Modulus", "RightShiftArithmetic", + "LeftShiftArithmetic", "RightShiftLogical", "LessThan", "MoreThan", "LessThanEquals", + "GreaterThanEquals", "Equals_", "NotEquals", "IdentityEquals", "IdentityNotEquals", + "BitAnd", "BitXOr", "BitOr", "And", "Or", "MultiplyAssign", "DivideAssign", + "ModulusAssign", "PlusAssign", "MinusAssign", "LeftShiftArithmeticAssign", + "RightShiftArithmeticAssign", "RightShiftLogicalAssign", "BitAndAssign", + "BitXorAssign", "BitOrAssign", "ARROW", "NullLiteral", "BooleanLiteral", + "DecimalLiteral", "HexIntegerLiteral", "OctalIntegerLiteral", "OctalIntegerLiteral2", + "BinaryIntegerLiteral", "Break", "Do", "Instanceof", "Typeof", "Case", + "Else", "New", "Var", "Catch", "Finally", "Return", "Void", "Continue", + "For", "Switch", "While", "Debugger", "Function_", "This", "With", "Default", + "If", "Throw", "Delete", "In", "Try", "As", "From", "ReadOnly", "Async", + "Class", "Enum", "Extends", "Super", "Const", "Export", "Import", "Implements", + "Let", "Private", "Public", "Interface", "Package", "Protected", "Static", + "Yield", "Any", "Number", "Boolean", "String", "Symbol", "TypeAlias", + "Get", "Set", "Constructor", "Namespace", "Require", "Module", "Declare", + "Abstract", "Is", "At", "Identifier", "StringLiteral", "BackTick", "WhiteSpaces", + "LineTerminator", "HtmlComment", "CDataComment", "UnexpectedCharacter", + "TemplateStringEscapeAtom", "TemplateStringStartExpression", "TemplateStringAtom" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { return "TypeScriptParser.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public TypeScriptParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @SuppressWarnings("CheckReturnValue") + public static class InitializerContext extends ParserRuleContext { + public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public InitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterInitializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitInitializer(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final InitializerContext initializer() throws RecognitionException { + InitializerContext _localctx = new InitializerContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_initializer); + try { + enterOuterAlt(_localctx, 1); + { + setState(288); + match(Assign); + setState(289); + singleExpression(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BindingPatternContext extends ParserRuleContext { + public ArrayLiteralContext arrayLiteral() { + return getRuleContext(ArrayLiteralContext.class,0); + } + public ObjectLiteralContext objectLiteral() { + return getRuleContext(ObjectLiteralContext.class,0); + } + public BindingPatternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_bindingPattern; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBindingPattern(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBindingPattern(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitBindingPattern(this); + else return visitor.visitChildren(this); + } + } + + public final BindingPatternContext bindingPattern() throws RecognitionException { + BindingPatternContext _localctx = new BindingPatternContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_bindingPattern); + try { + enterOuterAlt(_localctx, 1); + { + setState(293); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OpenBracket: + { + setState(291); + arrayLiteral(); + } + break; + case OpenBrace: + { + setState(292); + objectLiteral(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeParametersContext extends ParserRuleContext { + public TerminalNode LessThan() { return getToken(TypeScriptParser.LessThan, 0); } + public TerminalNode MoreThan() { return getToken(TypeScriptParser.MoreThan, 0); } + public TypeParameterListContext typeParameterList() { + return getRuleContext(TypeParameterListContext.class,0); + } + public TypeParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameters; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeParameters(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeParameters(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeParameters(this); + else return visitor.visitChildren(this); + } + } + + public final TypeParametersContext typeParameters() throws RecognitionException { + TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_typeParameters); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(295); + match(LessThan); + setState(297); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LessThan || _la==Identifier) { + { + setState(296); + typeParameterList(); + } + } + + setState(299); + match(MoreThan); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeParameterListContext extends ParserRuleContext { + public List typeParameter() { + return getRuleContexts(TypeParameterContext.class); + } + public TypeParameterContext typeParameter(int i) { + return getRuleContext(TypeParameterContext.class,i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public TypeParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameterList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeParameterList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeParameterList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeParameterList(this); + else return visitor.visitChildren(this); + } + } + + public final TypeParameterListContext typeParameterList() throws RecognitionException { + TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_typeParameterList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(301); + typeParameter(); + setState(306); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(302); + match(Comma); + setState(303); + typeParameter(); + } + } + setState(308); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeParameterContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public ConstraintContext constraint() { + return getRuleContext(ConstraintContext.class,0); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public TypeParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeParameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeParameter(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeParameter(this); + else return visitor.visitChildren(this); + } + } + + public final TypeParameterContext typeParameter() throws RecognitionException { + TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_typeParameter); + int _la; + try { + setState(314); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(309); + match(Identifier); + setState(311); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Extends) { + { + setState(310); + constraint(); + } + } + + } + break; + case LessThan: + enterOuterAlt(_localctx, 2); + { + setState(313); + typeParameters(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstraintContext extends ParserRuleContext { + public TerminalNode Extends() { return getToken(TypeScriptParser.Extends, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public ConstraintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constraint; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitConstraint(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitConstraint(this); + else return visitor.visitChildren(this); + } + } + + public final ConstraintContext constraint() throws RecognitionException { + ConstraintContext _localctx = new ConstraintContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_constraint); + try { + enterOuterAlt(_localctx, 1); + { + setState(316); + match(Extends); + setState(317); + type_(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeArgumentsContext extends ParserRuleContext { + public TerminalNode LessThan() { return getToken(TypeScriptParser.LessThan, 0); } + public TerminalNode MoreThan() { return getToken(TypeScriptParser.MoreThan, 0); } + public TypeArgumentListContext typeArgumentList() { + return getRuleContext(TypeArgumentListContext.class,0); + } + public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArguments; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeArguments(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeArguments(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeArguments(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentsContext typeArguments() throws RecognitionException { + TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_typeArguments); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(319); + match(LessThan); + setState(321); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1073742160L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 1729654935793991945L) != 0)) { + { + setState(320); + typeArgumentList(); + } + } + + setState(323); + match(MoreThan); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeArgumentListContext extends ParserRuleContext { + public List typeArgument() { + return getRuleContexts(TypeArgumentContext.class); + } + public TypeArgumentContext typeArgument(int i) { + return getRuleContext(TypeArgumentContext.class,i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public TypeArgumentListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArgumentList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeArgumentList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeArgumentList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeArgumentList(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentListContext typeArgumentList() throws RecognitionException { + TypeArgumentListContext _localctx = new TypeArgumentListContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_typeArgumentList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(325); + typeArgument(); + setState(330); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(326); + match(Comma); + setState(327); + typeArgument(); + } + } + setState(332); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeArgumentContext extends ParserRuleContext { + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TypeArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArgument; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeArgument(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeArgument(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeArgument(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentContext typeArgument() throws RecognitionException { + TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_typeArgument); + try { + enterOuterAlt(_localctx, 1); + { + setState(333); + type_(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_Context extends ParserRuleContext { + public UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType() { + return getRuleContext(UnionOrIntersectionOrPrimaryTypeContext.class,0); + } + public FunctionTypeContext functionType() { + return getRuleContext(FunctionTypeContext.class,0); + } + public ConstructorTypeContext constructorType() { + return getRuleContext(ConstructorTypeContext.class,0); + } + public TypeGenericContext typeGeneric() { + return getRuleContext(TypeGenericContext.class,0); + } + public TerminalNode StringLiteral() { return getToken(TypeScriptParser.StringLiteral, 0); } + public Type_Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type_; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterType_(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitType_(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitType_(this); + else return visitor.visitChildren(this); + } + } + + public final Type_Context type_() throws RecognitionException { + Type_Context _localctx = new Type_Context(_ctx, getState()); + enterRule(_localctx, 18, RULE_type_); + try { + setState(340); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(335); + unionOrIntersectionOrPrimaryType(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(336); + functionType(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(337); + constructorType(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(338); + typeGeneric(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(339); + match(StringLiteral); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UnionOrIntersectionOrPrimaryTypeContext extends ParserRuleContext { + public UnionOrIntersectionOrPrimaryTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unionOrIntersectionOrPrimaryType; } + + public UnionOrIntersectionOrPrimaryTypeContext() { } + public void copyFrom(UnionOrIntersectionOrPrimaryTypeContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class IntersectionContext extends UnionOrIntersectionOrPrimaryTypeContext { + public List unionOrIntersectionOrPrimaryType() { + return getRuleContexts(UnionOrIntersectionOrPrimaryTypeContext.class); + } + public UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType(int i) { + return getRuleContext(UnionOrIntersectionOrPrimaryTypeContext.class,i); + } + public TerminalNode BitAnd() { return getToken(TypeScriptParser.BitAnd, 0); } + public IntersectionContext(UnionOrIntersectionOrPrimaryTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIntersection(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIntersection(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIntersection(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PrimaryContext extends UnionOrIntersectionOrPrimaryTypeContext { + public PrimaryTypeContext primaryType() { + return getRuleContext(PrimaryTypeContext.class,0); + } + public PrimaryContext(UnionOrIntersectionOrPrimaryTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPrimary(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPrimary(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPrimary(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class UnionContext extends UnionOrIntersectionOrPrimaryTypeContext { + public List unionOrIntersectionOrPrimaryType() { + return getRuleContexts(UnionOrIntersectionOrPrimaryTypeContext.class); + } + public UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType(int i) { + return getRuleContext(UnionOrIntersectionOrPrimaryTypeContext.class,i); + } + public TerminalNode BitOr() { return getToken(TypeScriptParser.BitOr, 0); } + public UnionContext(UnionOrIntersectionOrPrimaryTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterUnion(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitUnion(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitUnion(this); + else return visitor.visitChildren(this); + } + } + + public final UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType() throws RecognitionException { + return unionOrIntersectionOrPrimaryType(0); + } + + private UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + UnionOrIntersectionOrPrimaryTypeContext _localctx = new UnionOrIntersectionOrPrimaryTypeContext(_ctx, _parentState); + UnionOrIntersectionOrPrimaryTypeContext _prevctx = _localctx; + int _startState = 20; + enterRecursionRule(_localctx, 20, RULE_unionOrIntersectionOrPrimaryType, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + _localctx = new PrimaryContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + + setState(343); + primaryType(0); + } + _ctx.stop = _input.LT(-1); + setState(353); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,9,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(351); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) { + case 1: + { + _localctx = new UnionContext(new UnionOrIntersectionOrPrimaryTypeContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_unionOrIntersectionOrPrimaryType); + setState(345); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(346); + match(BitOr); + setState(347); + unionOrIntersectionOrPrimaryType(4); + } + break; + case 2: + { + _localctx = new IntersectionContext(new UnionOrIntersectionOrPrimaryTypeContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_unionOrIntersectionOrPrimaryType); + setState(348); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(349); + match(BitAnd); + setState(350); + unionOrIntersectionOrPrimaryType(3); + } + break; + } + } + } + setState(355); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,9,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PrimaryTypeContext extends ParserRuleContext { + public PrimaryTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryType; } + + public PrimaryTypeContext() { } + public void copyFrom(PrimaryTypeContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class RedefinitionOfTypeContext extends PrimaryTypeContext { + public TypeReferenceContext typeReference() { + return getRuleContext(TypeReferenceContext.class,0); + } + public TerminalNode Is() { return getToken(TypeScriptParser.Is, 0); } + public PrimaryTypeContext primaryType() { + return getRuleContext(PrimaryTypeContext.class,0); + } + public RedefinitionOfTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRedefinitionOfType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRedefinitionOfType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitRedefinitionOfType(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PredefinedPrimTypeContext extends PrimaryTypeContext { + public PredefinedTypeContext predefinedType() { + return getRuleContext(PredefinedTypeContext.class,0); + } + public PredefinedPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPredefinedPrimType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPredefinedPrimType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPredefinedPrimType(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ArrayPrimTypeContext extends PrimaryTypeContext { + public PrimaryTypeContext primaryType() { + return getRuleContext(PrimaryTypeContext.class,0); + } + public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); } + public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); } + public ArrayPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrayPrimType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrayPrimType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArrayPrimType(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ParenthesizedPrimTypeContext extends PrimaryTypeContext { + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public ParenthesizedPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterParenthesizedPrimType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitParenthesizedPrimType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitParenthesizedPrimType(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ThisPrimTypeContext extends PrimaryTypeContext { + public TerminalNode This() { return getToken(TypeScriptParser.This, 0); } + public ThisPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterThisPrimType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitThisPrimType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitThisPrimType(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TuplePrimTypeContext extends PrimaryTypeContext { + public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); } + public TupleElementTypesContext tupleElementTypes() { + return getRuleContext(TupleElementTypesContext.class,0); + } + public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); } + public TuplePrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTuplePrimType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTuplePrimType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTuplePrimType(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ObjectPrimTypeContext extends PrimaryTypeContext { + public ObjectTypeContext objectType() { + return getRuleContext(ObjectTypeContext.class,0); + } + public ObjectPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterObjectPrimType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitObjectPrimType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitObjectPrimType(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ReferencePrimTypeContext extends PrimaryTypeContext { + public TypeReferenceContext typeReference() { + return getRuleContext(TypeReferenceContext.class,0); + } + public ReferencePrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterReferencePrimType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitReferencePrimType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitReferencePrimType(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class QueryPrimTypeContext extends PrimaryTypeContext { + public TypeQueryContext typeQuery() { + return getRuleContext(TypeQueryContext.class,0); + } + public QueryPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterQueryPrimType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitQueryPrimType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitQueryPrimType(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryTypeContext primaryType() throws RecognitionException { + return primaryType(0); + } + + private PrimaryTypeContext primaryType(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + PrimaryTypeContext _localctx = new PrimaryTypeContext(_ctx, _parentState); + PrimaryTypeContext _prevctx = _localctx; + int _startState = 22; + enterRecursionRule(_localctx, 22, RULE_primaryType, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(374); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) { + case 1: + { + _localctx = new ParenthesizedPrimTypeContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + + setState(357); + match(OpenParen); + setState(358); + type_(); + setState(359); + match(CloseParen); + } + break; + case 2: + { + _localctx = new PredefinedPrimTypeContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(361); + predefinedType(); + } + break; + case 3: + { + _localctx = new ReferencePrimTypeContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(362); + typeReference(); + } + break; + case 4: + { + _localctx = new ObjectPrimTypeContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(363); + objectType(); + } + break; + case 5: + { + _localctx = new TuplePrimTypeContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(364); + match(OpenBracket); + setState(365); + tupleElementTypes(); + setState(366); + match(CloseBracket); + } + break; + case 6: + { + _localctx = new QueryPrimTypeContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(368); + typeQuery(); + } + break; + case 7: + { + _localctx = new ThisPrimTypeContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(369); + match(This); + } + break; + case 8: + { + _localctx = new RedefinitionOfTypeContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(370); + typeReference(); + setState(371); + match(Is); + setState(372); + primaryType(1); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(382); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,11,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new ArrayPrimTypeContext(new PrimaryTypeContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_primaryType); + setState(376); + if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); + setState(377); + if (!(notLineTerminator())) throw new FailedPredicateException(this, "notLineTerminator()"); + setState(378); + match(OpenBracket); + setState(379); + match(CloseBracket); + } + } + } + setState(384); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,11,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PredefinedTypeContext extends ParserRuleContext { + public TerminalNode Any() { return getToken(TypeScriptParser.Any, 0); } + public TerminalNode Number() { return getToken(TypeScriptParser.Number, 0); } + public TerminalNode Boolean() { return getToken(TypeScriptParser.Boolean, 0); } + public TerminalNode String() { return getToken(TypeScriptParser.String, 0); } + public TerminalNode Symbol() { return getToken(TypeScriptParser.Symbol, 0); } + public TerminalNode Void() { return getToken(TypeScriptParser.Void, 0); } + public PredefinedTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_predefinedType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPredefinedType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPredefinedType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPredefinedType(this); + else return visitor.visitChildren(this); + } + } + + public final PredefinedTypeContext predefinedType() throws RecognitionException { + PredefinedTypeContext _localctx = new PredefinedTypeContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_predefinedType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(385); + _la = _input.LA(1); + if ( !(((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1065151889409L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeReferenceContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public NestedTypeGenericContext nestedTypeGeneric() { + return getRuleContext(NestedTypeGenericContext.class,0); + } + public TypeReferenceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeReference; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeReference(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeReference(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeReference(this); + else return visitor.visitChildren(this); + } + } + + public final TypeReferenceContext typeReference() throws RecognitionException { + TypeReferenceContext _localctx = new TypeReferenceContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_typeReference); + try { + enterOuterAlt(_localctx, 1); + { + setState(387); + typeName(); + setState(389); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { + case 1: + { + setState(388); + nestedTypeGeneric(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NestedTypeGenericContext extends ParserRuleContext { + public TypeIncludeGenericContext typeIncludeGeneric() { + return getRuleContext(TypeIncludeGenericContext.class,0); + } + public TypeGenericContext typeGeneric() { + return getRuleContext(TypeGenericContext.class,0); + } + public NestedTypeGenericContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_nestedTypeGeneric; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterNestedTypeGeneric(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitNestedTypeGeneric(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitNestedTypeGeneric(this); + else return visitor.visitChildren(this); + } + } + + public final NestedTypeGenericContext nestedTypeGeneric() throws RecognitionException { + NestedTypeGenericContext _localctx = new NestedTypeGenericContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_nestedTypeGeneric); + try { + setState(393); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(391); + typeIncludeGeneric(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(392); + typeGeneric(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeGenericContext extends ParserRuleContext { + public TerminalNode LessThan() { return getToken(TypeScriptParser.LessThan, 0); } + public TypeArgumentListContext typeArgumentList() { + return getRuleContext(TypeArgumentListContext.class,0); + } + public TerminalNode MoreThan() { return getToken(TypeScriptParser.MoreThan, 0); } + public TypeGenericContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeGeneric; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeGeneric(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeGeneric(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeGeneric(this); + else return visitor.visitChildren(this); + } + } + + public final TypeGenericContext typeGeneric() throws RecognitionException { + TypeGenericContext _localctx = new TypeGenericContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_typeGeneric); + try { + enterOuterAlt(_localctx, 1); + { + setState(395); + match(LessThan); + setState(396); + typeArgumentList(); + setState(397); + match(MoreThan); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeIncludeGenericContext extends ParserRuleContext { + public List LessThan() { return getTokens(TypeScriptParser.LessThan); } + public TerminalNode LessThan(int i) { + return getToken(TypeScriptParser.LessThan, i); + } + public List typeArgumentList() { + return getRuleContexts(TypeArgumentListContext.class); + } + public TypeArgumentListContext typeArgumentList(int i) { + return getRuleContext(TypeArgumentListContext.class,i); + } + public List MoreThan() { return getTokens(TypeScriptParser.MoreThan); } + public TerminalNode MoreThan(int i) { + return getToken(TypeScriptParser.MoreThan, i); + } + public BindingPatternContext bindingPattern() { + return getRuleContext(BindingPatternContext.class,0); + } + public TerminalNode RightShiftArithmetic() { return getToken(TypeScriptParser.RightShiftArithmetic, 0); } + public TypeIncludeGenericContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeIncludeGeneric; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeIncludeGeneric(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeIncludeGeneric(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeIncludeGeneric(this); + else return visitor.visitChildren(this); + } + } + + public final TypeIncludeGenericContext typeIncludeGeneric() throws RecognitionException { + TypeIncludeGenericContext _localctx = new TypeIncludeGenericContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_typeIncludeGeneric); + try { + enterOuterAlt(_localctx, 1); + { + setState(399); + match(LessThan); + setState(400); + typeArgumentList(); + setState(401); + match(LessThan); + setState(402); + typeArgumentList(); + setState(408); + _errHandler.sync(this); + switch (_input.LA(1)) { + case MoreThan: + { + setState(403); + match(MoreThan); + setState(404); + bindingPattern(); + setState(405); + match(MoreThan); + } + break; + case RightShiftArithmetic: + { + setState(407); + match(RightShiftArithmetic); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public NamespaceNameContext namespaceName() { + return getRuleContext(NamespaceNameContext.class,0); + } + public TypeNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeName(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeName(this); + else return visitor.visitChildren(this); + } + } + + public final TypeNameContext typeName() throws RecognitionException { + TypeNameContext _localctx = new TypeNameContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_typeName); + try { + setState(412); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(410); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(411); + namespaceName(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ObjectTypeContext extends ParserRuleContext { + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public TypeBodyContext typeBody() { + return getRuleContext(TypeBodyContext.class,0); + } + public ObjectTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_objectType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterObjectType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitObjectType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitObjectType(this); + else return visitor.visitChildren(this); + } + } + + public final ObjectTypeContext objectType() throws RecognitionException { + ObjectTypeContext _localctx = new ObjectTypeContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_objectType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(414); + match(OpenBrace); + setState(416); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795945222064L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 3517012241796825087L) != 0)) { + { + setState(415); + typeBody(); + } + } + + setState(418); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeBodyContext extends ParserRuleContext { + public TypeMemberListContext typeMemberList() { + return getRuleContext(TypeMemberListContext.class,0); + } + public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); } + public TerminalNode Comma() { return getToken(TypeScriptParser.Comma, 0); } + public TypeBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeBody; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeBody(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeBody(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeBody(this); + else return visitor.visitChildren(this); + } + } + + public final TypeBodyContext typeBody() throws RecognitionException { + TypeBodyContext _localctx = new TypeBodyContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_typeBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(420); + typeMemberList(); + setState(422); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SemiColon || _la==Comma) { + { + setState(421); + _la = _input.LA(1); + if ( !(_la==SemiColon || _la==Comma) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeMemberListContext extends ParserRuleContext { + public List typeMember() { + return getRuleContexts(TypeMemberContext.class); + } + public TypeMemberContext typeMember(int i) { + return getRuleContext(TypeMemberContext.class,i); + } + public List SemiColon() { return getTokens(TypeScriptParser.SemiColon); } + public TerminalNode SemiColon(int i) { + return getToken(TypeScriptParser.SemiColon, i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public TypeMemberListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeMemberList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeMemberList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeMemberList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeMemberList(this); + else return visitor.visitChildren(this); + } + } + + public final TypeMemberListContext typeMemberList() throws RecognitionException { + TypeMemberListContext _localctx = new TypeMemberListContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_typeMemberList); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(424); + typeMember(); + setState(429); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,18,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(425); + _la = _input.LA(1); + if ( !(_la==SemiColon || _la==Comma) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(426); + typeMember(); + } + } + } + setState(431); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,18,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeMemberContext extends ParserRuleContext { + public PropertySignaturContext propertySignatur() { + return getRuleContext(PropertySignaturContext.class,0); + } + public CallSignatureContext callSignature() { + return getRuleContext(CallSignatureContext.class,0); + } + public ConstructSignatureContext constructSignature() { + return getRuleContext(ConstructSignatureContext.class,0); + } + public IndexSignatureContext indexSignature() { + return getRuleContext(IndexSignatureContext.class,0); + } + public MethodSignatureContext methodSignature() { + return getRuleContext(MethodSignatureContext.class,0); + } + public TerminalNode ARROW() { return getToken(TypeScriptParser.ARROW, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TypeMemberContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeMember; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeMember(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeMember(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeMember(this); + else return visitor.visitChildren(this); + } + } + + public final TypeMemberContext typeMember() throws RecognitionException { + TypeMemberContext _localctx = new TypeMemberContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_typeMember); + int _la; + try { + setState(441); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(432); + propertySignatur(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(433); + callSignature(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(434); + constructSignature(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(435); + indexSignature(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(436); + methodSignature(); + setState(439); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ARROW) { + { + setState(437); + match(ARROW); + setState(438); + type_(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArrayTypeContext extends ParserRuleContext { + public PrimaryTypeContext primaryType() { + return getRuleContext(PrimaryTypeContext.class,0); + } + public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); } + public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); } + public ArrayTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrayType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrayType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArrayType(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayTypeContext arrayType() throws RecognitionException { + ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_arrayType); + try { + enterOuterAlt(_localctx, 1); + { + setState(443); + primaryType(0); + setState(444); + if (!(notLineTerminator())) throw new FailedPredicateException(this, "notLineTerminator()"); + setState(445); + match(OpenBracket); + setState(446); + match(CloseBracket); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TupleTypeContext extends ParserRuleContext { + public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); } + public TupleElementTypesContext tupleElementTypes() { + return getRuleContext(TupleElementTypesContext.class,0); + } + public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); } + public TupleTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tupleType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTupleType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTupleType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTupleType(this); + else return visitor.visitChildren(this); + } + } + + public final TupleTypeContext tupleType() throws RecognitionException { + TupleTypeContext _localctx = new TupleTypeContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_tupleType); + try { + enterOuterAlt(_localctx, 1); + { + setState(448); + match(OpenBracket); + setState(449); + tupleElementTypes(); + setState(450); + match(CloseBracket); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TupleElementTypesContext extends ParserRuleContext { + public List type_() { + return getRuleContexts(Type_Context.class); + } + public Type_Context type_(int i) { + return getRuleContext(Type_Context.class,i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public TupleElementTypesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tupleElementTypes; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTupleElementTypes(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTupleElementTypes(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTupleElementTypes(this); + else return visitor.visitChildren(this); + } + } + + public final TupleElementTypesContext tupleElementTypes() throws RecognitionException { + TupleElementTypesContext _localctx = new TupleElementTypesContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_tupleElementTypes); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(452); + type_(); + setState(457); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(453); + match(Comma); + setState(454); + type_(); + } + } + setState(459); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionTypeContext extends ParserRuleContext { + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public TerminalNode ARROW() { return getToken(TypeScriptParser.ARROW, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public ParameterListContext parameterList() { + return getRuleContext(ParameterListContext.class,0); + } + public FunctionTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFunctionType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFunctionType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFunctionType(this); + else return visitor.visitChildren(this); + } + } + + public final FunctionTypeContext functionType() throws RecognitionException { + FunctionTypeContext _localctx = new FunctionTypeContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_functionType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(461); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LessThan) { + { + setState(460); + typeParameters(); + } + } + + setState(463); + match(OpenParen); + setState(465); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4503599627370430192L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1787629984886554623L) != 0)) { + { + setState(464); + parameterList(); + } + } + + setState(467); + match(CloseParen); + setState(468); + match(ARROW); + setState(469); + type_(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstructorTypeContext extends ParserRuleContext { + public TerminalNode New() { return getToken(TypeScriptParser.New, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public TerminalNode ARROW() { return getToken(TypeScriptParser.ARROW, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public ParameterListContext parameterList() { + return getRuleContext(ParameterListContext.class,0); + } + public ConstructorTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructorType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterConstructorType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitConstructorType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitConstructorType(this); + else return visitor.visitChildren(this); + } + } + + public final ConstructorTypeContext constructorType() throws RecognitionException { + ConstructorTypeContext _localctx = new ConstructorTypeContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_constructorType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(471); + match(New); + setState(473); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LessThan) { + { + setState(472); + typeParameters(); + } + } + + setState(475); + match(OpenParen); + setState(477); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4503599627370430192L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1787629984886554623L) != 0)) { + { + setState(476); + parameterList(); + } + } + + setState(479); + match(CloseParen); + setState(480); + match(ARROW); + setState(481); + type_(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeQueryContext extends ParserRuleContext { + public TerminalNode Typeof() { return getToken(TypeScriptParser.Typeof, 0); } + public TypeQueryExpressionContext typeQueryExpression() { + return getRuleContext(TypeQueryExpressionContext.class,0); + } + public TypeQueryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeQuery; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeQuery(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeQuery(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeQuery(this); + else return visitor.visitChildren(this); + } + } + + public final TypeQueryContext typeQuery() throws RecognitionException { + TypeQueryContext _localctx = new TypeQueryContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_typeQuery); + try { + enterOuterAlt(_localctx, 1); + { + setState(483); + match(Typeof); + setState(484); + typeQueryExpression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeQueryExpressionContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public List identifierName() { + return getRuleContexts(IdentifierNameContext.class); + } + public IdentifierNameContext identifierName(int i) { + return getRuleContext(IdentifierNameContext.class,i); + } + public List Dot() { return getTokens(TypeScriptParser.Dot); } + public TerminalNode Dot(int i) { + return getToken(TypeScriptParser.Dot, i); + } + public TypeQueryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeQueryExpression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeQueryExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeQueryExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeQueryExpression(this); + else return visitor.visitChildren(this); + } + } + + public final TypeQueryExpressionContext typeQueryExpression() throws RecognitionException { + TypeQueryExpressionContext _localctx = new TypeQueryExpressionContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_typeQueryExpression); + try { + int _alt; + setState(496); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(486); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(490); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(487); + identifierName(); + setState(488); + match(Dot); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(492); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,26,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(494); + identifierName(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PropertySignaturContext extends ParserRuleContext { + public PropertyNameContext propertyName() { + return getRuleContext(PropertyNameContext.class,0); + } + public TerminalNode ReadOnly() { return getToken(TypeScriptParser.ReadOnly, 0); } + public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public TerminalNode ARROW() { return getToken(TypeScriptParser.ARROW, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public PropertySignaturContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_propertySignatur; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertySignatur(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertySignatur(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertySignatur(this); + else return visitor.visitChildren(this); + } + } + + public final PropertySignaturContext propertySignatur() throws RecognitionException { + PropertySignaturContext _localctx = new PropertySignaturContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_propertySignatur); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(499); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) { + case 1: + { + setState(498); + match(ReadOnly); + } + break; + } + setState(501); + propertyName(); + setState(503); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==QuestionMark) { + { + setState(502); + match(QuestionMark); + } + } + + setState(506); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(505); + typeAnnotation(); + } + } + + setState(510); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ARROW) { + { + setState(508); + match(ARROW); + setState(509); + type_(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeAnnotationContext extends ParserRuleContext { + public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TypeAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeAnnotation; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeAnnotation(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeAnnotation(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeAnnotation(this); + else return visitor.visitChildren(this); + } + } + + public final TypeAnnotationContext typeAnnotation() throws RecognitionException { + TypeAnnotationContext _localctx = new TypeAnnotationContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_typeAnnotation); + try { + enterOuterAlt(_localctx, 1); + { + setState(512); + match(Colon); + setState(513); + type_(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CallSignatureContext extends ParserRuleContext { + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public ParameterListContext parameterList() { + return getRuleContext(ParameterListContext.class,0); + } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public CallSignatureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_callSignature; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCallSignature(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCallSignature(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitCallSignature(this); + else return visitor.visitChildren(this); + } + } + + public final CallSignatureContext callSignature() throws RecognitionException { + CallSignatureContext _localctx = new CallSignatureContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_callSignature); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(516); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LessThan) { + { + setState(515); + typeParameters(); + } + } + + setState(518); + match(OpenParen); + setState(520); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4503599627370430192L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1787629984886554623L) != 0)) { + { + setState(519); + parameterList(); + } + } + + setState(522); + match(CloseParen); + setState(524); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) { + case 1: + { + setState(523); + typeAnnotation(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ParameterListContext extends ParserRuleContext { + public RestParameterContext restParameter() { + return getRuleContext(RestParameterContext.class,0); + } + public List parameter() { + return getRuleContexts(ParameterContext.class); + } + public ParameterContext parameter(int i) { + return getRuleContext(ParameterContext.class,i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public ParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parameterList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterParameterList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitParameterList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitParameterList(this); + else return visitor.visitChildren(this); + } + } + + public final ParameterListContext parameterList() throws RecognitionException { + ParameterListContext _localctx = new ParameterListContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_parameterList); + int _la; + try { + int _alt; + setState(539); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Ellipsis: + enterOuterAlt(_localctx, 1); + { + setState(526); + restParameter(); + } + break; + case OpenBracket: + case OpenBrace: + case NullLiteral: + case BooleanLiteral: + case Break: + case Do: + case Instanceof: + case Typeof: + case Case: + case Else: + case New: + case Var: + case Catch: + case Finally: + case Return: + case Void: + case Continue: + case For: + case Switch: + case While: + case Debugger: + case Function_: + case This: + case With: + case Default: + case If: + case Throw: + case Delete: + case In: + case Try: + case From: + case ReadOnly: + case Async: + case Class: + case Enum: + case Extends: + case Super: + case Const: + case Export: + case Import: + case Implements: + case Let: + case Private: + case Public: + case Interface: + case Package: + case Protected: + case Static: + case Yield: + case Number: + case Boolean: + case String: + case TypeAlias: + case Get: + case Set: + case Require: + case Module: + case At: + case Identifier: + enterOuterAlt(_localctx, 2); + { + setState(527); + parameter(); + setState(532); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,35,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(528); + match(Comma); + setState(529); + parameter(); + } + } + } + setState(534); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,35,_ctx); + } + setState(537); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(535); + match(Comma); + setState(536); + restParameter(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RequiredParameterListContext extends ParserRuleContext { + public List requiredParameter() { + return getRuleContexts(RequiredParameterContext.class); + } + public RequiredParameterContext requiredParameter(int i) { + return getRuleContext(RequiredParameterContext.class,i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public RequiredParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_requiredParameterList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRequiredParameterList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRequiredParameterList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitRequiredParameterList(this); + else return visitor.visitChildren(this); + } + } + + public final RequiredParameterListContext requiredParameterList() throws RecognitionException { + RequiredParameterListContext _localctx = new RequiredParameterListContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_requiredParameterList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(541); + requiredParameter(); + setState(546); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(542); + match(Comma); + setState(543); + requiredParameter(); + } + } + setState(548); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ParameterContext extends ParserRuleContext { + public RequiredParameterContext requiredParameter() { + return getRuleContext(RequiredParameterContext.class,0); + } + public OptionalParameterContext optionalParameter() { + return getRuleContext(OptionalParameterContext.class,0); + } + public ParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterParameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitParameter(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitParameter(this); + else return visitor.visitChildren(this); + } + } + + public final ParameterContext parameter() throws RecognitionException { + ParameterContext _localctx = new ParameterContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_parameter); + try { + setState(551); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(549); + requiredParameter(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(550); + optionalParameter(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OptionalParameterContext extends ParserRuleContext { + public IdentifierOrPatternContext identifierOrPattern() { + return getRuleContext(IdentifierOrPatternContext.class,0); + } + public DecoratorListContext decoratorList() { + return getRuleContext(DecoratorListContext.class,0); + } + public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); } + public InitializerContext initializer() { + return getRuleContext(InitializerContext.class,0); + } + public AccessibilityModifierContext accessibilityModifier() { + return getRuleContext(AccessibilityModifierContext.class,0); + } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public OptionalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_optionalParameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterOptionalParameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitOptionalParameter(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitOptionalParameter(this); + else return visitor.visitChildren(this); + } + } + + public final OptionalParameterContext optionalParameter() throws RecognitionException { + OptionalParameterContext _localctx = new OptionalParameterContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_optionalParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(554); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==At) { + { + setState(553); + decoratorList(); + } + } + + { + setState(557); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) { + case 1: + { + setState(556); + accessibilityModifier(); + } + break; + } + setState(559); + identifierOrPattern(); + setState(568); + _errHandler.sync(this); + switch (_input.LA(1)) { + case QuestionMark: + { + setState(560); + match(QuestionMark); + setState(562); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(561); + typeAnnotation(); + } + } + + } + break; + case Assign: + case Colon: + { + setState(565); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(564); + typeAnnotation(); + } + } + + setState(567); + initializer(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RestParameterContext extends ParserRuleContext { + public TerminalNode Ellipsis() { return getToken(TypeScriptParser.Ellipsis, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public RestParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_restParameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRestParameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRestParameter(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitRestParameter(this); + else return visitor.visitChildren(this); + } + } + + public final RestParameterContext restParameter() throws RecognitionException { + RestParameterContext _localctx = new RestParameterContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_restParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(570); + match(Ellipsis); + setState(571); + singleExpression(0); + setState(573); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(572); + typeAnnotation(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RequiredParameterContext extends ParserRuleContext { + public IdentifierOrPatternContext identifierOrPattern() { + return getRuleContext(IdentifierOrPatternContext.class,0); + } + public DecoratorListContext decoratorList() { + return getRuleContext(DecoratorListContext.class,0); + } + public AccessibilityModifierContext accessibilityModifier() { + return getRuleContext(AccessibilityModifierContext.class,0); + } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public RequiredParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_requiredParameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRequiredParameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRequiredParameter(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitRequiredParameter(this); + else return visitor.visitChildren(this); + } + } + + public final RequiredParameterContext requiredParameter() throws RecognitionException { + RequiredParameterContext _localctx = new RequiredParameterContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_requiredParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(576); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==At) { + { + setState(575); + decoratorList(); + } + } + + setState(579); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { + case 1: + { + setState(578); + accessibilityModifier(); + } + break; + } + setState(581); + identifierOrPattern(); + setState(583); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(582); + typeAnnotation(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AccessibilityModifierContext extends ParserRuleContext { + public TerminalNode Public() { return getToken(TypeScriptParser.Public, 0); } + public TerminalNode Private() { return getToken(TypeScriptParser.Private, 0); } + public TerminalNode Protected() { return getToken(TypeScriptParser.Protected, 0); } + public AccessibilityModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_accessibilityModifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAccessibilityModifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAccessibilityModifier(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitAccessibilityModifier(this); + else return visitor.visitChildren(this); + } + } + + public final AccessibilityModifierContext accessibilityModifier() throws RecognitionException { + AccessibilityModifierContext _localctx = new AccessibilityModifierContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_accessibilityModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(585); + _la = _input.LA(1); + if ( !(((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 19L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IdentifierOrPatternContext extends ParserRuleContext { + public IdentifierNameContext identifierName() { + return getRuleContext(IdentifierNameContext.class,0); + } + public BindingPatternContext bindingPattern() { + return getRuleContext(BindingPatternContext.class,0); + } + public IdentifierOrPatternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_identifierOrPattern; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIdentifierOrPattern(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIdentifierOrPattern(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIdentifierOrPattern(this); + else return visitor.visitChildren(this); + } + } + + public final IdentifierOrPatternContext identifierOrPattern() throws RecognitionException { + IdentifierOrPatternContext _localctx = new IdentifierOrPatternContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_identifierOrPattern); + try { + setState(589); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NullLiteral: + case BooleanLiteral: + case Break: + case Do: + case Instanceof: + case Typeof: + case Case: + case Else: + case New: + case Var: + case Catch: + case Finally: + case Return: + case Void: + case Continue: + case For: + case Switch: + case While: + case Debugger: + case Function_: + case This: + case With: + case Default: + case If: + case Throw: + case Delete: + case In: + case Try: + case From: + case ReadOnly: + case Async: + case Class: + case Enum: + case Extends: + case Super: + case Const: + case Export: + case Import: + case Implements: + case Let: + case Private: + case Public: + case Interface: + case Package: + case Protected: + case Static: + case Yield: + case Number: + case Boolean: + case String: + case TypeAlias: + case Get: + case Set: + case Require: + case Module: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(587); + identifierName(); + } + break; + case OpenBracket: + case OpenBrace: + enterOuterAlt(_localctx, 2); + { + setState(588); + bindingPattern(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstructSignatureContext extends ParserRuleContext { + public TerminalNode New() { return getToken(TypeScriptParser.New, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public ParameterListContext parameterList() { + return getRuleContext(ParameterListContext.class,0); + } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public ConstructSignatureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructSignature; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterConstructSignature(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitConstructSignature(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitConstructSignature(this); + else return visitor.visitChildren(this); + } + } + + public final ConstructSignatureContext constructSignature() throws RecognitionException { + ConstructSignatureContext _localctx = new ConstructSignatureContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_constructSignature); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(591); + match(New); + setState(593); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LessThan) { + { + setState(592); + typeParameters(); + } + } + + setState(595); + match(OpenParen); + setState(597); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4503599627370430192L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1787629984886554623L) != 0)) { + { + setState(596); + parameterList(); + } + } + + setState(599); + match(CloseParen); + setState(601); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(600); + typeAnnotation(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IndexSignatureContext extends ParserRuleContext { + public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); } + public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public TerminalNode Number() { return getToken(TypeScriptParser.Number, 0); } + public TerminalNode String() { return getToken(TypeScriptParser.String, 0); } + public IndexSignatureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indexSignature; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIndexSignature(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIndexSignature(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIndexSignature(this); + else return visitor.visitChildren(this); + } + } + + public final IndexSignatureContext indexSignature() throws RecognitionException { + IndexSignatureContext _localctx = new IndexSignatureContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_indexSignature); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(603); + match(OpenBracket); + setState(604); + match(Identifier); + setState(605); + match(Colon); + setState(606); + _la = _input.LA(1); + if ( !(_la==Number || _la==String) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(607); + match(CloseBracket); + setState(608); + typeAnnotation(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MethodSignatureContext extends ParserRuleContext { + public PropertyNameContext propertyName() { + return getRuleContext(PropertyNameContext.class,0); + } + public CallSignatureContext callSignature() { + return getRuleContext(CallSignatureContext.class,0); + } + public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); } + public MethodSignatureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodSignature; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterMethodSignature(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitMethodSignature(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitMethodSignature(this); + else return visitor.visitChildren(this); + } + } + + public final MethodSignatureContext methodSignature() throws RecognitionException { + MethodSignatureContext _localctx = new MethodSignatureContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_methodSignature); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(610); + propertyName(); + setState(612); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==QuestionMark) { + { + setState(611); + match(QuestionMark); + } + } + + setState(614); + callSignature(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeAliasDeclarationContext extends ParserRuleContext { + public TerminalNode TypeAlias() { return getToken(TypeScriptParser.TypeAlias, 0); } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public TypeAliasDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeAliasDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeAliasDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeAliasDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeAliasDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final TypeAliasDeclarationContext typeAliasDeclaration() throws RecognitionException { + TypeAliasDeclarationContext _localctx = new TypeAliasDeclarationContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_typeAliasDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(616); + match(TypeAlias); + setState(617); + match(Identifier); + setState(619); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LessThan) { + { + setState(618); + typeParameters(); + } + } + + setState(621); + match(Assign); + setState(622); + type_(); + setState(623); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstructorDeclarationContext extends ParserRuleContext { + public TerminalNode Constructor() { return getToken(TypeScriptParser.Constructor, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public AccessibilityModifierContext accessibilityModifier() { + return getRuleContext(AccessibilityModifierContext.class,0); + } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); } + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class,0); + } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructorDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterConstructorDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitConstructorDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitConstructorDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException { + ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_constructorDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(626); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 19L) != 0)) { + { + setState(625); + accessibilityModifier(); + } + } + + setState(628); + match(Constructor); + setState(629); + match(OpenParen); + setState(631); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65808L) != 0) || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 12718099L) != 0)) { + { + setState(630); + formalParameterList(); + } + } + + setState(633); + match(CloseParen); + setState(639); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { + case 1: + { + { + setState(634); + match(OpenBrace); + setState(635); + functionBody(); + setState(636); + match(CloseBrace); + } + } + break; + case 2: + { + setState(638); + match(SemiColon); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InterfaceDeclarationContext extends ParserRuleContext { + public TerminalNode Interface() { return getToken(TypeScriptParser.Interface, 0); } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public ObjectTypeContext objectType() { + return getRuleContext(ObjectTypeContext.class,0); + } + public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); } + public TerminalNode Declare() { return getToken(TypeScriptParser.Declare, 0); } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public InterfaceExtendsClauseContext interfaceExtendsClause() { + return getRuleContext(InterfaceExtendsClauseContext.class,0); + } + public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); } + public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterInterfaceDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitInterfaceDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitInterfaceDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException { + InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_interfaceDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(642); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Export) { + { + setState(641); + match(Export); + } + } + + setState(645); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Declare) { + { + setState(644); + match(Declare); + } + } + + setState(647); + match(Interface); + setState(648); + match(Identifier); + setState(650); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LessThan) { + { + setState(649); + typeParameters(); + } + } + + setState(653); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Extends) { + { + setState(652); + interfaceExtendsClause(); + } + } + + setState(655); + objectType(); + setState(657); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { + case 1: + { + setState(656); + match(SemiColon); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InterfaceExtendsClauseContext extends ParserRuleContext { + public TerminalNode Extends() { return getToken(TypeScriptParser.Extends, 0); } + public ClassOrInterfaceTypeListContext classOrInterfaceTypeList() { + return getRuleContext(ClassOrInterfaceTypeListContext.class,0); + } + public InterfaceExtendsClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceExtendsClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterInterfaceExtendsClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitInterfaceExtendsClause(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitInterfaceExtendsClause(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceExtendsClauseContext interfaceExtendsClause() throws RecognitionException { + InterfaceExtendsClauseContext _localctx = new InterfaceExtendsClauseContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_interfaceExtendsClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(659); + match(Extends); + setState(660); + classOrInterfaceTypeList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClassOrInterfaceTypeListContext extends ParserRuleContext { + public List typeReference() { + return getRuleContexts(TypeReferenceContext.class); + } + public TypeReferenceContext typeReference(int i) { + return getRuleContext(TypeReferenceContext.class,i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public ClassOrInterfaceTypeListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classOrInterfaceTypeList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassOrInterfaceTypeList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassOrInterfaceTypeList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitClassOrInterfaceTypeList(this); + else return visitor.visitChildren(this); + } + } + + public final ClassOrInterfaceTypeListContext classOrInterfaceTypeList() throws RecognitionException { + ClassOrInterfaceTypeListContext _localctx = new ClassOrInterfaceTypeListContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_classOrInterfaceTypeList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(662); + typeReference(); + setState(667); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(663); + match(Comma); + setState(664); + typeReference(); + } + } + setState(669); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EnumDeclarationContext extends ParserRuleContext { + public TerminalNode Enum() { return getToken(TypeScriptParser.Enum, 0); } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public TerminalNode Const() { return getToken(TypeScriptParser.Const, 0); } + public EnumBodyContext enumBody() { + return getRuleContext(EnumBodyContext.class,0); + } + public EnumDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEnumDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEnumDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitEnumDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final EnumDeclarationContext enumDeclaration() throws RecognitionException { + EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_enumDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(671); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Const) { + { + setState(670); + match(Const); + } + } + + setState(673); + match(Enum); + setState(674); + match(Identifier); + setState(675); + match(OpenBrace); + setState(677); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028797018963968L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 3517012241796825087L) != 0)) { + { + setState(676); + enumBody(); + } + } + + setState(679); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EnumBodyContext extends ParserRuleContext { + public EnumMemberListContext enumMemberList() { + return getRuleContext(EnumMemberListContext.class,0); + } + public TerminalNode Comma() { return getToken(TypeScriptParser.Comma, 0); } + public EnumBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumBody; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEnumBody(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEnumBody(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitEnumBody(this); + else return visitor.visitChildren(this); + } + } + + public final EnumBodyContext enumBody() throws RecognitionException { + EnumBodyContext _localctx = new EnumBodyContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_enumBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(681); + enumMemberList(); + setState(683); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(682); + match(Comma); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EnumMemberListContext extends ParserRuleContext { + public List enumMember() { + return getRuleContexts(EnumMemberContext.class); + } + public EnumMemberContext enumMember(int i) { + return getRuleContext(EnumMemberContext.class,i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public EnumMemberListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumMemberList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEnumMemberList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEnumMemberList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitEnumMemberList(this); + else return visitor.visitChildren(this); + } + } + + public final EnumMemberListContext enumMemberList() throws RecognitionException { + EnumMemberListContext _localctx = new EnumMemberListContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_enumMemberList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(685); + enumMember(); + setState(690); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,67,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(686); + match(Comma); + setState(687); + enumMember(); + } + } + } + setState(692); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,67,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EnumMemberContext extends ParserRuleContext { + public PropertyNameContext propertyName() { + return getRuleContext(PropertyNameContext.class,0); + } + public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public EnumMemberContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumMember; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEnumMember(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEnumMember(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitEnumMember(this); + else return visitor.visitChildren(this); + } + } + + public final EnumMemberContext enumMember() throws RecognitionException { + EnumMemberContext _localctx = new EnumMemberContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_enumMember); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(693); + propertyName(); + setState(696); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Assign) { + { + setState(694); + match(Assign); + setState(695); + singleExpression(0); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NamespaceDeclarationContext extends ParserRuleContext { + public TerminalNode Namespace() { return getToken(TypeScriptParser.Namespace, 0); } + public NamespaceNameContext namespaceName() { + return getRuleContext(NamespaceNameContext.class,0); + } + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public StatementListContext statementList() { + return getRuleContext(StatementListContext.class,0); + } + public NamespaceDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespaceDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterNamespaceDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitNamespaceDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitNamespaceDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final NamespaceDeclarationContext namespaceDeclaration() throws RecognitionException { + NamespaceDeclarationContext _localctx = new NamespaceDeclarationContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_namespaceDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(698); + match(Namespace); + setState(699); + namespaceName(); + setState(700); + match(OpenBrace); + setState(702); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) { + case 1: + { + setState(701); + statementList(); + } + break; + } + setState(704); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NamespaceNameContext extends ParserRuleContext { + public List Identifier() { return getTokens(TypeScriptParser.Identifier); } + public TerminalNode Identifier(int i) { + return getToken(TypeScriptParser.Identifier, i); + } + public List Dot() { return getTokens(TypeScriptParser.Dot); } + public TerminalNode Dot(int i) { + return getToken(TypeScriptParser.Dot, i); + } + public NamespaceNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespaceName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterNamespaceName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitNamespaceName(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitNamespaceName(this); + else return visitor.visitChildren(this); + } + } + + public final NamespaceNameContext namespaceName() throws RecognitionException { + NamespaceNameContext _localctx = new NamespaceNameContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_namespaceName); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(706); + match(Identifier); + setState(715); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,71,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(708); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(707); + match(Dot); + } + } + setState(710); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==Dot ); + setState(712); + match(Identifier); + } + } + } + setState(717); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,71,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ImportAliasDeclarationContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); } + public NamespaceNameContext namespaceName() { + return getRuleContext(NamespaceNameContext.class,0); + } + public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); } + public ImportAliasDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_importAliasDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterImportAliasDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitImportAliasDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitImportAliasDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ImportAliasDeclarationContext importAliasDeclaration() throws RecognitionException { + ImportAliasDeclarationContext _localctx = new ImportAliasDeclarationContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_importAliasDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(718); + match(Identifier); + setState(719); + match(Assign); + setState(720); + namespaceName(); + setState(721); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DecoratorListContext extends ParserRuleContext { + public List decorator() { + return getRuleContexts(DecoratorContext.class); + } + public DecoratorContext decorator(int i) { + return getRuleContext(DecoratorContext.class,i); + } + public DecoratorListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decoratorList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDecoratorList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDecoratorList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDecoratorList(this); + else return visitor.visitChildren(this); + } + } + + public final DecoratorListContext decoratorList() throws RecognitionException { + DecoratorListContext _localctx = new DecoratorListContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_decoratorList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(724); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(723); + decorator(); + } + } + setState(726); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==At ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DecoratorContext extends ParserRuleContext { + public TerminalNode At() { return getToken(TypeScriptParser.At, 0); } + public DecoratorMemberExpressionContext decoratorMemberExpression() { + return getRuleContext(DecoratorMemberExpressionContext.class,0); + } + public DecoratorCallExpressionContext decoratorCallExpression() { + return getRuleContext(DecoratorCallExpressionContext.class,0); + } + public DecoratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decorator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDecorator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDecorator(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDecorator(this); + else return visitor.visitChildren(this); + } + } + + public final DecoratorContext decorator() throws RecognitionException { + DecoratorContext _localctx = new DecoratorContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_decorator); + try { + enterOuterAlt(_localctx, 1); + { + setState(728); + match(At); + setState(731); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) { + case 1: + { + setState(729); + decoratorMemberExpression(0); + } + break; + case 2: + { + setState(730); + decoratorCallExpression(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DecoratorMemberExpressionContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public DecoratorMemberExpressionContext decoratorMemberExpression() { + return getRuleContext(DecoratorMemberExpressionContext.class,0); + } + public TerminalNode Dot() { return getToken(TypeScriptParser.Dot, 0); } + public IdentifierNameContext identifierName() { + return getRuleContext(IdentifierNameContext.class,0); + } + public DecoratorMemberExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decoratorMemberExpression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDecoratorMemberExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDecoratorMemberExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDecoratorMemberExpression(this); + else return visitor.visitChildren(this); + } + } + + public final DecoratorMemberExpressionContext decoratorMemberExpression() throws RecognitionException { + return decoratorMemberExpression(0); + } + + private DecoratorMemberExpressionContext decoratorMemberExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + DecoratorMemberExpressionContext _localctx = new DecoratorMemberExpressionContext(_ctx, _parentState); + DecoratorMemberExpressionContext _prevctx = _localctx; + int _startState = 114; + enterRecursionRule(_localctx, 114, RULE_decoratorMemberExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(739); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Identifier: + { + setState(734); + match(Identifier); + } + break; + case OpenParen: + { + setState(735); + match(OpenParen); + setState(736); + singleExpression(0); + setState(737); + match(CloseParen); + } + break; + default: + throw new NoViableAltException(this); + } + _ctx.stop = _input.LT(-1); + setState(746); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,75,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new DecoratorMemberExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_decoratorMemberExpression); + setState(741); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(742); + match(Dot); + setState(743); + identifierName(); + } + } + } + setState(748); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,75,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DecoratorCallExpressionContext extends ParserRuleContext { + public DecoratorMemberExpressionContext decoratorMemberExpression() { + return getRuleContext(DecoratorMemberExpressionContext.class,0); + } + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class,0); + } + public DecoratorCallExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decoratorCallExpression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDecoratorCallExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDecoratorCallExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDecoratorCallExpression(this); + else return visitor.visitChildren(this); + } + } + + public final DecoratorCallExpressionContext decoratorCallExpression() throws RecognitionException { + DecoratorCallExpressionContext _localctx = new DecoratorCallExpressionContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_decoratorCallExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(749); + decoratorMemberExpression(0); + setState(750); + arguments(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ProgramContext extends ParserRuleContext { + public TerminalNode EOF() { return getToken(TypeScriptParser.EOF, 0); } + public SourceElementsContext sourceElements() { + return getRuleContext(SourceElementsContext.class,0); + } + public ProgramContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_program; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterProgram(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitProgram(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitProgram(this); + else return visitor.visitChildren(this); + } + } + + public final ProgramContext program() throws RecognitionException { + ProgramContext _localctx = new ProgramContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_program); + try { + enterOuterAlt(_localctx, 1); + { + setState(753); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) { + case 1: + { + setState(752); + sourceElements(); + } + break; + } + setState(755); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SourceElementContext extends ParserRuleContext { + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); } + public SourceElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sourceElement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterSourceElement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitSourceElement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitSourceElement(this); + else return visitor.visitChildren(this); + } + } + + public final SourceElementContext sourceElement() throws RecognitionException { + SourceElementContext _localctx = new SourceElementContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_sourceElement); + try { + enterOuterAlt(_localctx, 1); + { + setState(758); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { + case 1: + { + setState(757); + match(Export); + } + break; + } + setState(760); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StatementContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public ImportStatementContext importStatement() { + return getRuleContext(ImportStatementContext.class,0); + } + public ExportStatementContext exportStatement() { + return getRuleContext(ExportStatementContext.class,0); + } + public EmptyStatement_Context emptyStatement_() { + return getRuleContext(EmptyStatement_Context.class,0); + } + public AbstractDeclarationContext abstractDeclaration() { + return getRuleContext(AbstractDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public NamespaceDeclarationContext namespaceDeclaration() { + return getRuleContext(NamespaceDeclarationContext.class,0); + } + public IfStatementContext ifStatement() { + return getRuleContext(IfStatementContext.class,0); + } + public IterationStatementContext iterationStatement() { + return getRuleContext(IterationStatementContext.class,0); + } + public ContinueStatementContext continueStatement() { + return getRuleContext(ContinueStatementContext.class,0); + } + public BreakStatementContext breakStatement() { + return getRuleContext(BreakStatementContext.class,0); + } + public ReturnStatementContext returnStatement() { + return getRuleContext(ReturnStatementContext.class,0); + } + public YieldStatementContext yieldStatement() { + return getRuleContext(YieldStatementContext.class,0); + } + public WithStatementContext withStatement() { + return getRuleContext(WithStatementContext.class,0); + } + public LabelledStatementContext labelledStatement() { + return getRuleContext(LabelledStatementContext.class,0); + } + public SwitchStatementContext switchStatement() { + return getRuleContext(SwitchStatementContext.class,0); + } + public ThrowStatementContext throwStatement() { + return getRuleContext(ThrowStatementContext.class,0); + } + public TryStatementContext tryStatement() { + return getRuleContext(TryStatementContext.class,0); + } + public DebuggerStatementContext debuggerStatement() { + return getRuleContext(DebuggerStatementContext.class,0); + } + public FunctionDeclarationContext functionDeclaration() { + return getRuleContext(FunctionDeclarationContext.class,0); + } + public ArrowFunctionDeclarationContext arrowFunctionDeclaration() { + return getRuleContext(ArrowFunctionDeclarationContext.class,0); + } + public GeneratorFunctionDeclarationContext generatorFunctionDeclaration() { + return getRuleContext(GeneratorFunctionDeclarationContext.class,0); + } + public VariableStatementContext variableStatement() { + return getRuleContext(VariableStatementContext.class,0); + } + public TypeAliasDeclarationContext typeAliasDeclaration() { + return getRuleContext(TypeAliasDeclarationContext.class,0); + } + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class,0); + } + public ExpressionStatementContext expressionStatement() { + return getRuleContext(ExpressionStatementContext.class,0); + } + public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitStatement(this); + else return visitor.visitChildren(this); + } + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_statement); + try { + setState(791); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(762); + block(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(763); + importStatement(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(764); + exportStatement(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(765); + emptyStatement_(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(766); + abstractDeclaration(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(767); + classDeclaration(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(768); + interfaceDeclaration(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(769); + namespaceDeclaration(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(770); + ifStatement(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(771); + iterationStatement(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(772); + continueStatement(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(773); + breakStatement(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(774); + returnStatement(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(775); + yieldStatement(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(776); + withStatement(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(777); + labelledStatement(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(778); + switchStatement(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(779); + throwStatement(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(780); + tryStatement(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(781); + debuggerStatement(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(782); + functionDeclaration(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(783); + arrowFunctionDeclaration(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(784); + generatorFunctionDeclaration(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(785); + variableStatement(); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(786); + typeAliasDeclaration(); + } + break; + case 26: + enterOuterAlt(_localctx, 26); + { + setState(787); + enumDeclaration(); + } + break; + case 27: + enterOuterAlt(_localctx, 27); + { + setState(788); + expressionStatement(); + } + break; + case 28: + enterOuterAlt(_localctx, 28); + { + setState(789); + match(Export); + setState(790); + statement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BlockContext extends ParserRuleContext { + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public StatementListContext statementList() { + return getRuleContext(StatementListContext.class,0); + } + public BlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_block; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBlock(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBlock(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitBlock(this); + else return visitor.visitChildren(this); + } + } + + public final BlockContext block() throws RecognitionException { + BlockContext _localctx = new BlockContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_block); + try { + enterOuterAlt(_localctx, 1); + { + setState(793); + match(OpenBrace); + setState(795); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) { + case 1: + { + setState(794); + statementList(); + } + break; + } + setState(797); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StatementListContext extends ParserRuleContext { + public List statement() { + return getRuleContexts(StatementContext.class); + } + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class,i); + } + public StatementListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statementList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterStatementList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitStatementList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitStatementList(this); + else return visitor.visitChildren(this); + } + } + + public final StatementListContext statementList() throws RecognitionException { + StatementListContext _localctx = new StatementListContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_statementList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(800); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(799); + statement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(802); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,80,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AbstractDeclarationContext extends ParserRuleContext { + public TerminalNode Abstract() { return getToken(TypeScriptParser.Abstract, 0); } + public EosContext eos() { + return getRuleContext(EosContext.class,0); + } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public CallSignatureContext callSignature() { + return getRuleContext(CallSignatureContext.class,0); + } + public VariableStatementContext variableStatement() { + return getRuleContext(VariableStatementContext.class,0); + } + public AbstractDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_abstractDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAbstractDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAbstractDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitAbstractDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final AbstractDeclarationContext abstractDeclaration() throws RecognitionException { + AbstractDeclarationContext _localctx = new AbstractDeclarationContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_abstractDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(804); + match(Abstract); + setState(808); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) { + case 1: + { + setState(805); + match(Identifier); + setState(806); + callSignature(); + } + break; + case 2: + { + setState(807); + variableStatement(); + } + break; + } + setState(810); + eos(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ImportStatementContext extends ParserRuleContext { + public TerminalNode Import() { return getToken(TypeScriptParser.Import, 0); } + public FromBlockContext fromBlock() { + return getRuleContext(FromBlockContext.class,0); + } + public ImportAliasDeclarationContext importAliasDeclaration() { + return getRuleContext(ImportAliasDeclarationContext.class,0); + } + public ImportStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_importStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterImportStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitImportStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitImportStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ImportStatementContext importStatement() throws RecognitionException { + ImportStatementContext _localctx = new ImportStatementContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_importStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(812); + match(Import); + setState(815); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) { + case 1: + { + setState(813); + fromBlock(); + } + break; + case 2: + { + setState(814); + importAliasDeclaration(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FromBlockContext extends ParserRuleContext { + public TerminalNode From() { return getToken(TypeScriptParser.From, 0); } + public TerminalNode StringLiteral() { return getToken(TypeScriptParser.StringLiteral, 0); } + public EosContext eos() { + return getRuleContext(EosContext.class,0); + } + public TerminalNode Multiply() { return getToken(TypeScriptParser.Multiply, 0); } + public MultipleImportStatementContext multipleImportStatement() { + return getRuleContext(MultipleImportStatementContext.class,0); + } + public TerminalNode As() { return getToken(TypeScriptParser.As, 0); } + public IdentifierNameContext identifierName() { + return getRuleContext(IdentifierNameContext.class,0); + } + public FromBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fromBlock; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFromBlock(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFromBlock(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFromBlock(this); + else return visitor.visitChildren(this); + } + } + + public final FromBlockContext fromBlock() throws RecognitionException { + FromBlockContext _localctx = new FromBlockContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_fromBlock); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(819); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Multiply: + { + setState(817); + match(Multiply); + } + break; + case OpenBrace: + case NullLiteral: + case BooleanLiteral: + case Break: + case Do: + case Instanceof: + case Typeof: + case Case: + case Else: + case New: + case Var: + case Catch: + case Finally: + case Return: + case Void: + case Continue: + case For: + case Switch: + case While: + case Debugger: + case Function_: + case This: + case With: + case Default: + case If: + case Throw: + case Delete: + case In: + case Try: + case From: + case ReadOnly: + case Async: + case Class: + case Enum: + case Extends: + case Super: + case Const: + case Export: + case Import: + case Implements: + case Let: + case Private: + case Public: + case Interface: + case Package: + case Protected: + case Static: + case Yield: + case Number: + case Boolean: + case String: + case TypeAlias: + case Get: + case Set: + case Require: + case Module: + case Identifier: + { + setState(818); + multipleImportStatement(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(823); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==As) { + { + setState(821); + match(As); + setState(822); + identifierName(); + } + } + + setState(825); + match(From); + setState(826); + match(StringLiteral); + setState(827); + eos(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MultipleImportStatementContext extends ParserRuleContext { + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public List identifierName() { + return getRuleContexts(IdentifierNameContext.class); + } + public IdentifierNameContext identifierName(int i) { + return getRuleContext(IdentifierNameContext.class,i); + } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public MultipleImportStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_multipleImportStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterMultipleImportStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitMultipleImportStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitMultipleImportStatement(this); + else return visitor.visitChildren(this); + } + } + + public final MultipleImportStatementContext multipleImportStatement() throws RecognitionException { + MultipleImportStatementContext _localctx = new MultipleImportStatementContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_multipleImportStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(832); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4503599627370496000L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1211169232583131135L) != 0)) { + { + setState(829); + identifierName(); + setState(830); + match(Comma); + } + } + + setState(834); + match(OpenBrace); + setState(835); + identifierName(); + setState(840); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(836); + match(Comma); + setState(837); + identifierName(); + } + } + setState(842); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(843); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExportStatementContext extends ParserRuleContext { + public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); } + public FromBlockContext fromBlock() { + return getRuleContext(FromBlockContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public TerminalNode Default() { return getToken(TypeScriptParser.Default, 0); } + public ExportStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exportStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterExportStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitExportStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitExportStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ExportStatementContext exportStatement() throws RecognitionException { + ExportStatementContext _localctx = new ExportStatementContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_exportStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(845); + match(Export); + setState(847); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { + case 1: + { + setState(846); + match(Default); + } + break; + } + setState(851); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) { + case 1: + { + setState(849); + fromBlock(); + } + break; + case 2: + { + setState(850); + statement(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VariableStatementContext extends ParserRuleContext { + public BindingPatternContext bindingPattern() { + return getRuleContext(BindingPatternContext.class,0); + } + public InitializerContext initializer() { + return getRuleContext(InitializerContext.class,0); + } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); } + public VariableDeclarationListContext variableDeclarationList() { + return getRuleContext(VariableDeclarationListContext.class,0); + } + public AccessibilityModifierContext accessibilityModifier() { + return getRuleContext(AccessibilityModifierContext.class,0); + } + public VarModifierContext varModifier() { + return getRuleContext(VarModifierContext.class,0); + } + public TerminalNode ReadOnly() { return getToken(TypeScriptParser.ReadOnly, 0); } + public TerminalNode Declare() { return getToken(TypeScriptParser.Declare, 0); } + public VariableStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterVariableStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitVariableStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitVariableStatement(this); + else return visitor.visitChildren(this); + } + } + + public final VariableStatementContext variableStatement() throws RecognitionException { + VariableStatementContext _localctx = new VariableStatementContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_variableStatement); + int _la; + try { + setState(882); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(853); + bindingPattern(); + setState(855); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(854); + typeAnnotation(); + } + } + + setState(857); + initializer(); + setState(859); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { + case 1: + { + setState(858); + match(SemiColon); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(862); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 19L) != 0)) { + { + setState(861); + accessibilityModifier(); + } + } + + setState(865); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 2281701377L) != 0)) { + { + setState(864); + varModifier(); + } + } + + setState(868); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ReadOnly) { + { + setState(867); + match(ReadOnly); + } + } + + setState(870); + variableDeclarationList(); + setState(872); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) { + case 1: + { + setState(871); + match(SemiColon); + } + break; + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(874); + match(Declare); + setState(876); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 2281701377L) != 0)) { + { + setState(875); + varModifier(); + } + } + + setState(878); + variableDeclarationList(); + setState(880); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) { + case 1: + { + setState(879); + match(SemiColon); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VariableDeclarationListContext extends ParserRuleContext { + public List variableDeclaration() { + return getRuleContexts(VariableDeclarationContext.class); + } + public VariableDeclarationContext variableDeclaration(int i) { + return getRuleContext(VariableDeclarationContext.class,i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public VariableDeclarationListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclarationList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterVariableDeclarationList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitVariableDeclarationList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitVariableDeclarationList(this); + else return visitor.visitChildren(this); + } + } + + public final VariableDeclarationListContext variableDeclarationList() throws RecognitionException { + VariableDeclarationListContext _localctx = new VariableDeclarationListContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_variableDeclarationList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(884); + variableDeclaration(); + setState(889); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,98,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(885); + match(Comma); + setState(886); + variableDeclaration(); + } + } + } + setState(891); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,98,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VariableDeclarationContext extends ParserRuleContext { + public IdentifierOrKeyWordContext identifierOrKeyWord() { + return getRuleContext(IdentifierOrKeyWordContext.class,0); + } + public ArrayLiteralContext arrayLiteral() { + return getRuleContext(ArrayLiteralContext.class,0); + } + public ObjectLiteralContext objectLiteral() { + return getRuleContext(ObjectLiteralContext.class,0); + } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public VariableDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterVariableDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitVariableDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitVariableDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final VariableDeclarationContext variableDeclaration() throws RecognitionException { + VariableDeclarationContext _localctx = new VariableDeclarationContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_variableDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(895); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TypeAlias: + case Require: + case Identifier: + { + setState(892); + identifierOrKeyWord(); + } + break; + case OpenBracket: + { + setState(893); + arrayLiteral(); + } + break; + case OpenBrace: + { + setState(894); + objectLiteral(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(898); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) { + case 1: + { + setState(897); + typeAnnotation(); + } + break; + } + setState(901); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) { + case 1: + { + setState(900); + singleExpression(0); + } + break; + } + setState(908); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) { + case 1: + { + setState(903); + match(Assign); + setState(905); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) { + case 1: + { + setState(904); + typeParameters(); + } + break; + } + setState(907); + singleExpression(0); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EmptyStatement_Context extends ParserRuleContext { + public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); } + public EmptyStatement_Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_emptyStatement_; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEmptyStatement_(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEmptyStatement_(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitEmptyStatement_(this); + else return visitor.visitChildren(this); + } + } + + public final EmptyStatement_Context emptyStatement_() throws RecognitionException { + EmptyStatement_Context _localctx = new EmptyStatement_Context(_ctx, getState()); + enterRule(_localctx, 144, RULE_emptyStatement_); + try { + enterOuterAlt(_localctx, 1); + { + setState(910); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionStatementContext extends ParserRuleContext { + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); } + public ExpressionStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterExpressionStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitExpressionStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitExpressionStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ExpressionStatementContext expressionStatement() throws RecognitionException { + ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_expressionStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(912); + if (!(this.notOpenBraceAndNotFunction())) throw new FailedPredicateException(this, "this.notOpenBraceAndNotFunction()"); + setState(913); + expressionSequence(); + setState(915); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) { + case 1: + { + setState(914); + match(SemiColon); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IfStatementContext extends ParserRuleContext { + public TerminalNode If() { return getToken(TypeScriptParser.If, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public List statement() { + return getRuleContexts(StatementContext.class); + } + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class,i); + } + public TerminalNode Else() { return getToken(TypeScriptParser.Else, 0); } + public IfStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ifStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIfStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIfStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIfStatement(this); + else return visitor.visitChildren(this); + } + } + + public final IfStatementContext ifStatement() throws RecognitionException { + IfStatementContext _localctx = new IfStatementContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_ifStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(917); + match(If); + setState(918); + match(OpenParen); + setState(919); + expressionSequence(); + setState(920); + match(CloseParen); + setState(921); + statement(); + setState(924); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) { + case 1: + { + setState(922); + match(Else); + setState(923); + statement(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IterationStatementContext extends ParserRuleContext { + public IterationStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_iterationStatement; } + + public IterationStatementContext() { } + public void copyFrom(IterationStatementContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DoStatementContext extends IterationStatementContext { + public TerminalNode Do() { return getToken(TypeScriptParser.Do, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public TerminalNode While() { return getToken(TypeScriptParser.While, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public EosContext eos() { + return getRuleContext(EosContext.class,0); + } + public DoStatementContext(IterationStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDoStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDoStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDoStatement(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ForVarStatementContext extends IterationStatementContext { + public TerminalNode For() { return getToken(TypeScriptParser.For, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public VarModifierContext varModifier() { + return getRuleContext(VarModifierContext.class,0); + } + public VariableDeclarationListContext variableDeclarationList() { + return getRuleContext(VariableDeclarationListContext.class,0); + } + public List SemiColon() { return getTokens(TypeScriptParser.SemiColon); } + public TerminalNode SemiColon(int i) { + return getToken(TypeScriptParser.SemiColon, i); + } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public List expressionSequence() { + return getRuleContexts(ExpressionSequenceContext.class); + } + public ExpressionSequenceContext expressionSequence(int i) { + return getRuleContext(ExpressionSequenceContext.class,i); + } + public ForVarStatementContext(IterationStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterForVarStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitForVarStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitForVarStatement(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ForVarInStatementContext extends IterationStatementContext { + public TerminalNode For() { return getToken(TypeScriptParser.For, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public VarModifierContext varModifier() { + return getRuleContext(VarModifierContext.class,0); + } + public VariableDeclarationContext variableDeclaration() { + return getRuleContext(VariableDeclarationContext.class,0); + } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public TerminalNode In() { return getToken(TypeScriptParser.In, 0); } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public ForVarInStatementContext(IterationStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterForVarInStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitForVarInStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitForVarInStatement(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class WhileStatementContext extends IterationStatementContext { + public TerminalNode While() { return getToken(TypeScriptParser.While, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public WhileStatementContext(IterationStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterWhileStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitWhileStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitWhileStatement(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ForStatementContext extends IterationStatementContext { + public TerminalNode For() { return getToken(TypeScriptParser.For, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public List SemiColon() { return getTokens(TypeScriptParser.SemiColon); } + public TerminalNode SemiColon(int i) { + return getToken(TypeScriptParser.SemiColon, i); + } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public List expressionSequence() { + return getRuleContexts(ExpressionSequenceContext.class); + } + public ExpressionSequenceContext expressionSequence(int i) { + return getRuleContext(ExpressionSequenceContext.class,i); + } + public ForStatementContext(IterationStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterForStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitForStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitForStatement(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ForInStatementContext extends IterationStatementContext { + public TerminalNode For() { return getToken(TypeScriptParser.For, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public TerminalNode In() { return getToken(TypeScriptParser.In, 0); } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public ForInStatementContext(IterationStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterForInStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitForInStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitForInStatement(this); + else return visitor.visitChildren(this); + } + } + + public final IterationStatementContext iterationStatement() throws RecognitionException { + IterationStatementContext _localctx = new IterationStatementContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_iterationStatement); + int _la; + try { + setState(995); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) { + case 1: + _localctx = new DoStatementContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(926); + match(Do); + setState(927); + statement(); + setState(928); + match(While); + setState(929); + match(OpenParen); + setState(930); + expressionSequence(); + setState(931); + match(CloseParen); + setState(932); + eos(); + } + break; + case 2: + _localctx = new WhileStatementContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(934); + match(While); + setState(935); + match(OpenParen); + setState(936); + expressionSequence(); + setState(937); + match(CloseParen); + setState(938); + statement(); + } + break; + case 3: + _localctx = new ForStatementContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(940); + match(For); + setState(941); + match(OpenParen); + setState(943); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795928706728L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 8128698260224212991L) != 0)) { + { + setState(942); + expressionSequence(); + } + } + + setState(945); + match(SemiColon); + setState(947); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795928706728L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 8128698260224212991L) != 0)) { + { + setState(946); + expressionSequence(); + } + } + + setState(949); + match(SemiColon); + setState(951); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795928706728L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 8128698260224212991L) != 0)) { + { + setState(950); + expressionSequence(); + } + } + + setState(953); + match(CloseParen); + setState(954); + statement(); + } + break; + case 4: + _localctx = new ForVarStatementContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(955); + match(For); + setState(956); + match(OpenParen); + setState(957); + varModifier(); + setState(958); + variableDeclarationList(); + setState(959); + match(SemiColon); + setState(961); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795928706728L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 8128698260224212991L) != 0)) { + { + setState(960); + expressionSequence(); + } + } + + setState(963); + match(SemiColon); + setState(965); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795928706728L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 8128698260224212991L) != 0)) { + { + setState(964); + expressionSequence(); + } + } + + setState(967); + match(CloseParen); + setState(968); + statement(); + } + break; + case 5: + _localctx = new ForInStatementContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(970); + match(For); + setState(971); + match(OpenParen); + setState(972); + singleExpression(0); + setState(976); + _errHandler.sync(this); + switch (_input.LA(1)) { + case In: + { + setState(973); + match(In); + } + break; + case Identifier: + { + setState(974); + match(Identifier); + setState(975); + if (!(this.p("of"))) throw new FailedPredicateException(this, "this.p(\"of\")"); + } + break; + default: + throw new NoViableAltException(this); + } + setState(978); + expressionSequence(); + setState(979); + match(CloseParen); + setState(980); + statement(); + } + break; + case 6: + _localctx = new ForVarInStatementContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(982); + match(For); + setState(983); + match(OpenParen); + setState(984); + varModifier(); + setState(985); + variableDeclaration(); + setState(989); + _errHandler.sync(this); + switch (_input.LA(1)) { + case In: + { + setState(986); + match(In); + } + break; + case Identifier: + { + setState(987); + match(Identifier); + setState(988); + if (!(this.p("of"))) throw new FailedPredicateException(this, "this.p(\"of\")"); + } + break; + default: + throw new NoViableAltException(this); + } + setState(991); + expressionSequence(); + setState(992); + match(CloseParen); + setState(993); + statement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VarModifierContext extends ParserRuleContext { + public TerminalNode Var() { return getToken(TypeScriptParser.Var, 0); } + public TerminalNode Let() { return getToken(TypeScriptParser.Let, 0); } + public TerminalNode Const() { return getToken(TypeScriptParser.Const, 0); } + public VarModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_varModifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterVarModifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitVarModifier(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitVarModifier(this); + else return visitor.visitChildren(this); + } + } + + public final VarModifierContext varModifier() throws RecognitionException { + VarModifierContext _localctx = new VarModifierContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_varModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(997); + _la = _input.LA(1); + if ( !(((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 2281701377L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ContinueStatementContext extends ParserRuleContext { + public TerminalNode Continue() { return getToken(TypeScriptParser.Continue, 0); } + public EosContext eos() { + return getRuleContext(EosContext.class,0); + } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public ContinueStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_continueStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterContinueStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitContinueStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitContinueStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ContinueStatementContext continueStatement() throws RecognitionException { + ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_continueStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(999); + match(Continue); + setState(1002); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) { + case 1: + { + setState(1000); + if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()"); + setState(1001); + match(Identifier); + } + break; + } + setState(1004); + eos(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BreakStatementContext extends ParserRuleContext { + public TerminalNode Break() { return getToken(TypeScriptParser.Break, 0); } + public EosContext eos() { + return getRuleContext(EosContext.class,0); + } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public BreakStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_breakStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBreakStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBreakStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitBreakStatement(this); + else return visitor.visitChildren(this); + } + } + + public final BreakStatementContext breakStatement() throws RecognitionException { + BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_breakStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1006); + match(Break); + setState(1009); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) { + case 1: + { + setState(1007); + if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()"); + setState(1008); + match(Identifier); + } + break; + } + setState(1011); + eos(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReturnStatementContext extends ParserRuleContext { + public TerminalNode Return() { return getToken(TypeScriptParser.Return, 0); } + public EosContext eos() { + return getRuleContext(EosContext.class,0); + } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public ReturnStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_returnStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterReturnStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitReturnStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitReturnStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ReturnStatementContext returnStatement() throws RecognitionException { + ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_returnStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1013); + match(Return); + setState(1016); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) { + case 1: + { + setState(1014); + if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()"); + setState(1015); + expressionSequence(); + } + break; + } + setState(1018); + eos(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class YieldStatementContext extends ParserRuleContext { + public TerminalNode Yield() { return getToken(TypeScriptParser.Yield, 0); } + public EosContext eos() { + return getRuleContext(EosContext.class,0); + } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public YieldStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_yieldStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterYieldStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitYieldStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitYieldStatement(this); + else return visitor.visitChildren(this); + } + } + + public final YieldStatementContext yieldStatement() throws RecognitionException { + YieldStatementContext _localctx = new YieldStatementContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_yieldStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1020); + match(Yield); + setState(1023); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) { + case 1: + { + setState(1021); + if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()"); + setState(1022); + expressionSequence(); + } + break; + } + setState(1025); + eos(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class WithStatementContext extends ParserRuleContext { + public TerminalNode With() { return getToken(TypeScriptParser.With, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public WithStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_withStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterWithStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitWithStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitWithStatement(this); + else return visitor.visitChildren(this); + } + } + + public final WithStatementContext withStatement() throws RecognitionException { + WithStatementContext _localctx = new WithStatementContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_withStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1027); + match(With); + setState(1028); + match(OpenParen); + setState(1029); + expressionSequence(); + setState(1030); + match(CloseParen); + setState(1031); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SwitchStatementContext extends ParserRuleContext { + public TerminalNode Switch() { return getToken(TypeScriptParser.Switch, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public CaseBlockContext caseBlock() { + return getRuleContext(CaseBlockContext.class,0); + } + public SwitchStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterSwitchStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitSwitchStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitSwitchStatement(this); + else return visitor.visitChildren(this); + } + } + + public final SwitchStatementContext switchStatement() throws RecognitionException { + SwitchStatementContext _localctx = new SwitchStatementContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_switchStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1033); + match(Switch); + setState(1034); + match(OpenParen); + setState(1035); + expressionSequence(); + setState(1036); + match(CloseParen); + setState(1037); + caseBlock(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CaseBlockContext extends ParserRuleContext { + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public List caseClauses() { + return getRuleContexts(CaseClausesContext.class); + } + public CaseClausesContext caseClauses(int i) { + return getRuleContext(CaseClausesContext.class,i); + } + public DefaultClauseContext defaultClause() { + return getRuleContext(DefaultClauseContext.class,0); + } + public CaseBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_caseBlock; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCaseBlock(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCaseBlock(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitCaseBlock(this); + else return visitor.visitChildren(this); + } + } + + public final CaseBlockContext caseBlock() throws RecognitionException { + CaseBlockContext _localctx = new CaseBlockContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_caseBlock); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1039); + match(OpenBrace); + setState(1041); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Case) { + { + setState(1040); + caseClauses(); + } + } + + setState(1047); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Default) { + { + setState(1043); + defaultClause(); + setState(1045); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Case) { + { + setState(1044); + caseClauses(); + } + } + + } + } + + setState(1049); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CaseClausesContext extends ParserRuleContext { + public List caseClause() { + return getRuleContexts(CaseClauseContext.class); + } + public CaseClauseContext caseClause(int i) { + return getRuleContext(CaseClauseContext.class,i); + } + public CaseClausesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_caseClauses; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCaseClauses(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCaseClauses(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitCaseClauses(this); + else return visitor.visitChildren(this); + } + } + + public final CaseClausesContext caseClauses() throws RecognitionException { + CaseClausesContext _localctx = new CaseClausesContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_caseClauses); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1052); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1051); + caseClause(); + } + } + setState(1054); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==Case ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CaseClauseContext extends ParserRuleContext { + public TerminalNode Case() { return getToken(TypeScriptParser.Case, 0); } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); } + public StatementListContext statementList() { + return getRuleContext(StatementListContext.class,0); + } + public CaseClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_caseClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCaseClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCaseClause(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitCaseClause(this); + else return visitor.visitChildren(this); + } + } + + public final CaseClauseContext caseClause() throws RecognitionException { + CaseClauseContext _localctx = new CaseClauseContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_caseClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1056); + match(Case); + setState(1057); + expressionSequence(); + setState(1058); + match(Colon); + setState(1060); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) { + case 1: + { + setState(1059); + statementList(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DefaultClauseContext extends ParserRuleContext { + public TerminalNode Default() { return getToken(TypeScriptParser.Default, 0); } + public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); } + public StatementListContext statementList() { + return getRuleContext(StatementListContext.class,0); + } + public DefaultClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_defaultClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDefaultClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDefaultClause(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDefaultClause(this); + else return visitor.visitChildren(this); + } + } + + public final DefaultClauseContext defaultClause() throws RecognitionException { + DefaultClauseContext _localctx = new DefaultClauseContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_defaultClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1062); + match(Default); + setState(1063); + match(Colon); + setState(1065); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) { + case 1: + { + setState(1064); + statementList(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LabelledStatementContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public LabelledStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_labelledStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterLabelledStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitLabelledStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitLabelledStatement(this); + else return visitor.visitChildren(this); + } + } + + public final LabelledStatementContext labelledStatement() throws RecognitionException { + LabelledStatementContext _localctx = new LabelledStatementContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_labelledStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1067); + match(Identifier); + setState(1068); + match(Colon); + setState(1069); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ThrowStatementContext extends ParserRuleContext { + public TerminalNode Throw() { return getToken(TypeScriptParser.Throw, 0); } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public EosContext eos() { + return getRuleContext(EosContext.class,0); + } + public ThrowStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_throwStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterThrowStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitThrowStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitThrowStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ThrowStatementContext throwStatement() throws RecognitionException { + ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_throwStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1071); + match(Throw); + setState(1072); + if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()"); + setState(1073); + expressionSequence(); + setState(1074); + eos(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TryStatementContext extends ParserRuleContext { + public TerminalNode Try() { return getToken(TypeScriptParser.Try, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public CatchProductionContext catchProduction() { + return getRuleContext(CatchProductionContext.class,0); + } + public FinallyProductionContext finallyProduction() { + return getRuleContext(FinallyProductionContext.class,0); + } + public TryStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tryStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTryStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTryStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTryStatement(this); + else return visitor.visitChildren(this); + } + } + + public final TryStatementContext tryStatement() throws RecognitionException { + TryStatementContext _localctx = new TryStatementContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_tryStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1076); + match(Try); + setState(1077); + block(); + setState(1083); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Catch: + { + setState(1078); + catchProduction(); + setState(1080); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { + case 1: + { + setState(1079); + finallyProduction(); + } + break; + } + } + break; + case Finally: + { + setState(1082); + finallyProduction(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CatchProductionContext extends ParserRuleContext { + public TerminalNode Catch() { return getToken(TypeScriptParser.Catch, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public CatchProductionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catchProduction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCatchProduction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCatchProduction(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitCatchProduction(this); + else return visitor.visitChildren(this); + } + } + + public final CatchProductionContext catchProduction() throws RecognitionException { + CatchProductionContext _localctx = new CatchProductionContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_catchProduction); + try { + enterOuterAlt(_localctx, 1); + { + setState(1085); + match(Catch); + setState(1086); + match(OpenParen); + setState(1087); + match(Identifier); + setState(1088); + match(CloseParen); + setState(1089); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FinallyProductionContext extends ParserRuleContext { + public TerminalNode Finally() { return getToken(TypeScriptParser.Finally, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public FinallyProductionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_finallyProduction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFinallyProduction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFinallyProduction(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFinallyProduction(this); + else return visitor.visitChildren(this); + } + } + + public final FinallyProductionContext finallyProduction() throws RecognitionException { + FinallyProductionContext _localctx = new FinallyProductionContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_finallyProduction); + try { + enterOuterAlt(_localctx, 1); + { + setState(1091); + match(Finally); + setState(1092); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DebuggerStatementContext extends ParserRuleContext { + public TerminalNode Debugger() { return getToken(TypeScriptParser.Debugger, 0); } + public EosContext eos() { + return getRuleContext(EosContext.class,0); + } + public DebuggerStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_debuggerStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDebuggerStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDebuggerStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDebuggerStatement(this); + else return visitor.visitChildren(this); + } + } + + public final DebuggerStatementContext debuggerStatement() throws RecognitionException { + DebuggerStatementContext _localctx = new DebuggerStatementContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_debuggerStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1094); + match(Debugger); + setState(1095); + eos(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionDeclarationContext extends ParserRuleContext { + public TerminalNode Function_() { return getToken(TypeScriptParser.Function_, 0); } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public CallSignatureContext callSignature() { + return getRuleContext(CallSignatureContext.class,0); + } + public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); } + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class,0); + } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public FunctionDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFunctionDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFunctionDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFunctionDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final FunctionDeclarationContext functionDeclaration() throws RecognitionException { + FunctionDeclarationContext _localctx = new FunctionDeclarationContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_functionDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1097); + match(Function_); + setState(1098); + match(Identifier); + setState(1099); + callSignature(); + setState(1105); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OpenBrace: + { + { + setState(1100); + match(OpenBrace); + setState(1101); + functionBody(); + setState(1102); + match(CloseBrace); + } + } + break; + case SemiColon: + { + setState(1104); + match(SemiColon); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClassDeclarationContext extends ParserRuleContext { + public TerminalNode Class() { return getToken(TypeScriptParser.Class, 0); } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public ClassHeritageContext classHeritage() { + return getRuleContext(ClassHeritageContext.class,0); + } + public ClassTailContext classTail() { + return getRuleContext(ClassTailContext.class,0); + } + public DecoratorListContext decoratorList() { + return getRuleContext(DecoratorListContext.class,0); + } + public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); } + public TerminalNode Abstract() { return getToken(TypeScriptParser.Abstract, 0); } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public TerminalNode Default() { return getToken(TypeScriptParser.Default, 0); } + public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitClassDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ClassDeclarationContext classDeclaration() throws RecognitionException { + ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_classDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1108); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==At) { + { + setState(1107); + decoratorList(); + } + } + + setState(1114); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Export) { + { + setState(1110); + match(Export); + setState(1112); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Default) { + { + setState(1111); + match(Default); + } + } + + } + } + + setState(1117); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Abstract) { + { + setState(1116); + match(Abstract); + } + } + + setState(1119); + match(Class); + setState(1120); + match(Identifier); + setState(1122); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LessThan) { + { + setState(1121); + typeParameters(); + } + } + + setState(1124); + classHeritage(); + setState(1125); + classTail(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClassHeritageContext extends ParserRuleContext { + public ClassExtendsClauseContext classExtendsClause() { + return getRuleContext(ClassExtendsClauseContext.class,0); + } + public ImplementsClauseContext implementsClause() { + return getRuleContext(ImplementsClauseContext.class,0); + } + public ClassHeritageContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classHeritage; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassHeritage(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassHeritage(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitClassHeritage(this); + else return visitor.visitChildren(this); + } + } + + public final ClassHeritageContext classHeritage() throws RecognitionException { + ClassHeritageContext _localctx = new ClassHeritageContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_classHeritage); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1128); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Extends) { + { + setState(1127); + classExtendsClause(); + } + } + + setState(1131); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Implements) { + { + setState(1130); + implementsClause(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClassTailContext extends ParserRuleContext { + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public List classElement() { + return getRuleContexts(ClassElementContext.class); + } + public ClassElementContext classElement(int i) { + return getRuleContext(ClassElementContext.class,i); + } + public ClassTailContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classTail; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassTail(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassTail(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitClassTail(this); + else return visitor.visitChildren(this); + } + } + + public final ClassTailContext classTail() throws RecognitionException { + ClassTailContext _localctx = new ClassTailContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_classTail); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1133); + match(OpenBrace); + setState(1137); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,134,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1134); + classElement(); + } + } + } + setState(1139); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,134,_ctx); + } + setState(1140); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClassExtendsClauseContext extends ParserRuleContext { + public TerminalNode Extends() { return getToken(TypeScriptParser.Extends, 0); } + public TypeReferenceContext typeReference() { + return getRuleContext(TypeReferenceContext.class,0); + } + public ClassExtendsClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classExtendsClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassExtendsClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassExtendsClause(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitClassExtendsClause(this); + else return visitor.visitChildren(this); + } + } + + public final ClassExtendsClauseContext classExtendsClause() throws RecognitionException { + ClassExtendsClauseContext _localctx = new ClassExtendsClauseContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_classExtendsClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1142); + match(Extends); + setState(1143); + typeReference(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ImplementsClauseContext extends ParserRuleContext { + public TerminalNode Implements() { return getToken(TypeScriptParser.Implements, 0); } + public ClassOrInterfaceTypeListContext classOrInterfaceTypeList() { + return getRuleContext(ClassOrInterfaceTypeListContext.class,0); + } + public ImplementsClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_implementsClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterImplementsClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitImplementsClause(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitImplementsClause(this); + else return visitor.visitChildren(this); + } + } + + public final ImplementsClauseContext implementsClause() throws RecognitionException { + ImplementsClauseContext _localctx = new ImplementsClauseContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_implementsClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1145); + match(Implements); + setState(1146); + classOrInterfaceTypeList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClassElementContext extends ParserRuleContext { + public ConstructorDeclarationContext constructorDeclaration() { + return getRuleContext(ConstructorDeclarationContext.class,0); + } + public PropertyMemberDeclarationContext propertyMemberDeclaration() { + return getRuleContext(PropertyMemberDeclarationContext.class,0); + } + public DecoratorListContext decoratorList() { + return getRuleContext(DecoratorListContext.class,0); + } + public IndexMemberDeclarationContext indexMemberDeclaration() { + return getRuleContext(IndexMemberDeclarationContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public ClassElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classElement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassElement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassElement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitClassElement(this); + else return visitor.visitChildren(this); + } + } + + public final ClassElementContext classElement() throws RecognitionException { + ClassElementContext _localctx = new ClassElementContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_classElement); + int _la; + try { + setState(1155); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1148); + constructorDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1150); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==At) { + { + setState(1149); + decoratorList(); + } + } + + setState(1152); + propertyMemberDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1153); + indexMemberDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1154); + statement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PropertyMemberDeclarationContext extends ParserRuleContext { + public PropertyMemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_propertyMemberDeclaration; } + + public PropertyMemberDeclarationContext() { } + public void copyFrom(PropertyMemberDeclarationContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PropertyDeclarationExpressionContext extends PropertyMemberDeclarationContext { + public PropertyMemberBaseContext propertyMemberBase() { + return getRuleContext(PropertyMemberBaseContext.class,0); + } + public PropertyNameContext propertyName() { + return getRuleContext(PropertyNameContext.class,0); + } + public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); } + public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public InitializerContext initializer() { + return getRuleContext(InitializerContext.class,0); + } + public PropertyDeclarationExpressionContext(PropertyMemberDeclarationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyDeclarationExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyDeclarationExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertyDeclarationExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class MethodDeclarationExpressionContext extends PropertyMemberDeclarationContext { + public PropertyMemberBaseContext propertyMemberBase() { + return getRuleContext(PropertyMemberBaseContext.class,0); + } + public PropertyNameContext propertyName() { + return getRuleContext(PropertyNameContext.class,0); + } + public CallSignatureContext callSignature() { + return getRuleContext(CallSignatureContext.class,0); + } + public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); } + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class,0); + } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public MethodDeclarationExpressionContext(PropertyMemberDeclarationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterMethodDeclarationExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitMethodDeclarationExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitMethodDeclarationExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class GetterSetterDeclarationExpressionContext extends PropertyMemberDeclarationContext { + public PropertyMemberBaseContext propertyMemberBase() { + return getRuleContext(PropertyMemberBaseContext.class,0); + } + public GetAccessorContext getAccessor() { + return getRuleContext(GetAccessorContext.class,0); + } + public SetAccessorContext setAccessor() { + return getRuleContext(SetAccessorContext.class,0); + } + public GetterSetterDeclarationExpressionContext(PropertyMemberDeclarationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGetterSetterDeclarationExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGetterSetterDeclarationExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGetterSetterDeclarationExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AbstractMemberDeclarationContext extends PropertyMemberDeclarationContext { + public AbstractDeclarationContext abstractDeclaration() { + return getRuleContext(AbstractDeclarationContext.class,0); + } + public AbstractMemberDeclarationContext(PropertyMemberDeclarationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAbstractMemberDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAbstractMemberDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitAbstractMemberDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final PropertyMemberDeclarationContext propertyMemberDeclaration() throws RecognitionException { + PropertyMemberDeclarationContext _localctx = new PropertyMemberDeclarationContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_propertyMemberDeclaration); + int _la; + try { + setState(1186); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { + case 1: + _localctx = new PropertyDeclarationExpressionContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1157); + propertyMemberBase(); + setState(1158); + propertyName(); + setState(1160); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==QuestionMark) { + { + setState(1159); + match(QuestionMark); + } + } + + setState(1163); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1162); + typeAnnotation(); + } + } + + setState(1166); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Assign) { + { + setState(1165); + initializer(); + } + } + + setState(1168); + match(SemiColon); + } + break; + case 2: + _localctx = new MethodDeclarationExpressionContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1170); + propertyMemberBase(); + setState(1171); + propertyName(); + setState(1172); + callSignature(); + setState(1178); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OpenBrace: + { + { + setState(1173); + match(OpenBrace); + setState(1174); + functionBody(); + setState(1175); + match(CloseBrace); + } + } + break; + case SemiColon: + { + setState(1177); + match(SemiColon); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 3: + _localctx = new GetterSetterDeclarationExpressionContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(1180); + propertyMemberBase(); + setState(1183); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Get: + { + setState(1181); + getAccessor(); + } + break; + case Set: + { + setState(1182); + setAccessor(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 4: + _localctx = new AbstractMemberDeclarationContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(1185); + abstractDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PropertyMemberBaseContext extends ParserRuleContext { + public AccessibilityModifierContext accessibilityModifier() { + return getRuleContext(AccessibilityModifierContext.class,0); + } + public TerminalNode Async() { return getToken(TypeScriptParser.Async, 0); } + public TerminalNode Static() { return getToken(TypeScriptParser.Static, 0); } + public TerminalNode ReadOnly() { return getToken(TypeScriptParser.ReadOnly, 0); } + public PropertyMemberBaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_propertyMemberBase; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyMemberBase(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyMemberBase(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertyMemberBase(this); + else return visitor.visitChildren(this); + } + } + + public final PropertyMemberBaseContext propertyMemberBase() throws RecognitionException { + PropertyMemberBaseContext _localctx = new PropertyMemberBaseContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_propertyMemberBase); + try { + enterOuterAlt(_localctx, 1); + { + setState(1189); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { + case 1: + { + setState(1188); + accessibilityModifier(); + } + break; + } + setState(1192); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { + case 1: + { + setState(1191); + match(Async); + } + break; + } + setState(1195); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) { + case 1: + { + setState(1194); + match(Static); + } + break; + } + setState(1198); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { + case 1: + { + setState(1197); + match(ReadOnly); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IndexMemberDeclarationContext extends ParserRuleContext { + public IndexSignatureContext indexSignature() { + return getRuleContext(IndexSignatureContext.class,0); + } + public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); } + public IndexMemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indexMemberDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIndexMemberDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIndexMemberDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIndexMemberDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final IndexMemberDeclarationContext indexMemberDeclaration() throws RecognitionException { + IndexMemberDeclarationContext _localctx = new IndexMemberDeclarationContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_indexMemberDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1200); + indexSignature(); + setState(1201); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GeneratorMethodContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class,0); + } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public TerminalNode Multiply() { return getToken(TypeScriptParser.Multiply, 0); } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public GeneratorMethodContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_generatorMethod; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorMethod(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorMethod(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGeneratorMethod(this); + else return visitor.visitChildren(this); + } + } + + public final GeneratorMethodContext generatorMethod() throws RecognitionException { + GeneratorMethodContext _localctx = new GeneratorMethodContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_generatorMethod); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1204); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Multiply) { + { + setState(1203); + match(Multiply); + } + } + + setState(1206); + match(Identifier); + setState(1207); + match(OpenParen); + setState(1209); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65808L) != 0) || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 12718099L) != 0)) { + { + setState(1208); + formalParameterList(); + } + } + + setState(1211); + match(CloseParen); + setState(1212); + match(OpenBrace); + setState(1213); + functionBody(); + setState(1214); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GeneratorFunctionDeclarationContext extends ParserRuleContext { + public TerminalNode Function_() { return getToken(TypeScriptParser.Function_, 0); } + public TerminalNode Multiply() { return getToken(TypeScriptParser.Multiply, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class,0); + } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public GeneratorFunctionDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_generatorFunctionDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorFunctionDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorFunctionDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGeneratorFunctionDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final GeneratorFunctionDeclarationContext generatorFunctionDeclaration() throws RecognitionException { + GeneratorFunctionDeclarationContext _localctx = new GeneratorFunctionDeclarationContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_generatorFunctionDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1216); + match(Function_); + setState(1217); + match(Multiply); + setState(1219); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1218); + match(Identifier); + } + } + + setState(1221); + match(OpenParen); + setState(1223); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65808L) != 0) || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 12718099L) != 0)) { + { + setState(1222); + formalParameterList(); + } + } + + setState(1225); + match(CloseParen); + setState(1226); + match(OpenBrace); + setState(1227); + functionBody(); + setState(1228); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GeneratorBlockContext extends ParserRuleContext { + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public List generatorDefinition() { + return getRuleContexts(GeneratorDefinitionContext.class); + } + public GeneratorDefinitionContext generatorDefinition(int i) { + return getRuleContext(GeneratorDefinitionContext.class,i); + } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public GeneratorBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_generatorBlock; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorBlock(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorBlock(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGeneratorBlock(this); + else return visitor.visitChildren(this); + } + } + + public final GeneratorBlockContext generatorBlock() throws RecognitionException { + GeneratorBlockContext _localctx = new GeneratorBlockContext(_ctx, getState()); + enterRule(_localctx, 210, RULE_generatorBlock); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1230); + match(OpenBrace); + setState(1231); + generatorDefinition(); + setState(1236); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,151,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1232); + match(Comma); + setState(1233); + generatorDefinition(); + } + } + } + setState(1238); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,151,_ctx); + } + setState(1240); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1239); + match(Comma); + } + } + + setState(1242); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GeneratorDefinitionContext extends ParserRuleContext { + public TerminalNode Multiply() { return getToken(TypeScriptParser.Multiply, 0); } + public IteratorDefinitionContext iteratorDefinition() { + return getRuleContext(IteratorDefinitionContext.class,0); + } + public GeneratorDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_generatorDefinition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorDefinition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorDefinition(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGeneratorDefinition(this); + else return visitor.visitChildren(this); + } + } + + public final GeneratorDefinitionContext generatorDefinition() throws RecognitionException { + GeneratorDefinitionContext _localctx = new GeneratorDefinitionContext(_ctx, getState()); + enterRule(_localctx, 212, RULE_generatorDefinition); + try { + enterOuterAlt(_localctx, 1); + { + setState(1244); + match(Multiply); + setState(1245); + iteratorDefinition(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IteratorBlockContext extends ParserRuleContext { + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public List iteratorDefinition() { + return getRuleContexts(IteratorDefinitionContext.class); + } + public IteratorDefinitionContext iteratorDefinition(int i) { + return getRuleContext(IteratorDefinitionContext.class,i); + } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public IteratorBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_iteratorBlock; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIteratorBlock(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIteratorBlock(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIteratorBlock(this); + else return visitor.visitChildren(this); + } + } + + public final IteratorBlockContext iteratorBlock() throws RecognitionException { + IteratorBlockContext _localctx = new IteratorBlockContext(_ctx, getState()); + enterRule(_localctx, 214, RULE_iteratorBlock); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1247); + match(OpenBrace); + setState(1248); + iteratorDefinition(); + setState(1253); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,153,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1249); + match(Comma); + setState(1250); + iteratorDefinition(); + } + } + } + setState(1255); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,153,_ctx); + } + setState(1257); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1256); + match(Comma); + } + } + + setState(1259); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IteratorDefinitionContext extends ParserRuleContext { + public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class,0); + } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public IteratorDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_iteratorDefinition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIteratorDefinition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIteratorDefinition(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIteratorDefinition(this); + else return visitor.visitChildren(this); + } + } + + public final IteratorDefinitionContext iteratorDefinition() throws RecognitionException { + IteratorDefinitionContext _localctx = new IteratorDefinitionContext(_ctx, getState()); + enterRule(_localctx, 216, RULE_iteratorDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1261); + match(OpenBracket); + setState(1262); + singleExpression(0); + setState(1263); + match(CloseBracket); + setState(1264); + match(OpenParen); + setState(1266); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65808L) != 0) || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 12718099L) != 0)) { + { + setState(1265); + formalParameterList(); + } + } + + setState(1268); + match(CloseParen); + setState(1269); + match(OpenBrace); + setState(1270); + functionBody(); + setState(1271); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FormalParameterListContext extends ParserRuleContext { + public List formalParameterArg() { + return getRuleContexts(FormalParameterArgContext.class); + } + public FormalParameterArgContext formalParameterArg(int i) { + return getRuleContext(FormalParameterArgContext.class,i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public LastFormalParameterArgContext lastFormalParameterArg() { + return getRuleContext(LastFormalParameterArgContext.class,0); + } + public ArrayLiteralContext arrayLiteral() { + return getRuleContext(ArrayLiteralContext.class,0); + } + public ObjectLiteralContext objectLiteral() { + return getRuleContext(ObjectLiteralContext.class,0); + } + public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public FormalParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameterList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFormalParameterList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFormalParameterList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFormalParameterList(this); + else return visitor.visitChildren(this); + } + } + + public final FormalParameterListContext formalParameterList() throws RecognitionException { + FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState()); + enterRule(_localctx, 218, RULE_formalParameterList); + int _la; + try { + int _alt; + setState(1292); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Private: + case Public: + case Protected: + case TypeAlias: + case Require: + case At: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1273); + formalParameterArg(); + setState(1278); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,156,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1274); + match(Comma); + setState(1275); + formalParameterArg(); + } + } + } + setState(1280); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,156,_ctx); + } + setState(1283); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1281); + match(Comma); + setState(1282); + lastFormalParameterArg(); + } + } + + } + break; + case Ellipsis: + enterOuterAlt(_localctx, 2); + { + setState(1285); + lastFormalParameterArg(); + } + break; + case OpenBracket: + enterOuterAlt(_localctx, 3); + { + setState(1286); + arrayLiteral(); + } + break; + case OpenBrace: + enterOuterAlt(_localctx, 4); + { + setState(1287); + objectLiteral(); + setState(1290); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1288); + match(Colon); + setState(1289); + formalParameterList(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FormalParameterArgContext extends ParserRuleContext { + public IdentifierOrKeyWordContext identifierOrKeyWord() { + return getRuleContext(IdentifierOrKeyWordContext.class,0); + } + public DecoratorContext decorator() { + return getRuleContext(DecoratorContext.class,0); + } + public AccessibilityModifierContext accessibilityModifier() { + return getRuleContext(AccessibilityModifierContext.class,0); + } + public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public FormalParameterArgContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameterArg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFormalParameterArg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFormalParameterArg(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFormalParameterArg(this); + else return visitor.visitChildren(this); + } + } + + public final FormalParameterArgContext formalParameterArg() throws RecognitionException { + FormalParameterArgContext _localctx = new FormalParameterArgContext(_ctx, getState()); + enterRule(_localctx, 220, RULE_formalParameterArg); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1295); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==At) { + { + setState(1294); + decorator(); + } + } + + setState(1298); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 19L) != 0)) { + { + setState(1297); + accessibilityModifier(); + } + } + + setState(1300); + identifierOrKeyWord(); + setState(1302); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==QuestionMark) { + { + setState(1301); + match(QuestionMark); + } + } + + setState(1305); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1304); + typeAnnotation(); + } + } + + setState(1309); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Assign) { + { + setState(1307); + match(Assign); + setState(1308); + singleExpression(0); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LastFormalParameterArgContext extends ParserRuleContext { + public TerminalNode Ellipsis() { return getToken(TypeScriptParser.Ellipsis, 0); } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public LastFormalParameterArgContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lastFormalParameterArg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterLastFormalParameterArg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitLastFormalParameterArg(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitLastFormalParameterArg(this); + else return visitor.visitChildren(this); + } + } + + public final LastFormalParameterArgContext lastFormalParameterArg() throws RecognitionException { + LastFormalParameterArgContext _localctx = new LastFormalParameterArgContext(_ctx, getState()); + enterRule(_localctx, 222, RULE_lastFormalParameterArg); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1311); + match(Ellipsis); + setState(1312); + match(Identifier); + setState(1314); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1313); + typeAnnotation(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionBodyContext extends ParserRuleContext { + public SourceElementsContext sourceElements() { + return getRuleContext(SourceElementsContext.class,0); + } + public FunctionBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionBody; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFunctionBody(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFunctionBody(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFunctionBody(this); + else return visitor.visitChildren(this); + } + } + + public final FunctionBodyContext functionBody() throws RecognitionException { + FunctionBodyContext _localctx = new FunctionBodyContext(_ctx, getState()); + enterRule(_localctx, 224, RULE_functionBody); + try { + enterOuterAlt(_localctx, 1); + { + setState(1317); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) { + case 1: + { + setState(1316); + sourceElements(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SourceElementsContext extends ParserRuleContext { + public List sourceElement() { + return getRuleContexts(SourceElementContext.class); + } + public SourceElementContext sourceElement(int i) { + return getRuleContext(SourceElementContext.class,i); + } + public SourceElementsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sourceElements; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterSourceElements(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitSourceElements(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitSourceElements(this); + else return visitor.visitChildren(this); + } + } + + public final SourceElementsContext sourceElements() throws RecognitionException { + SourceElementsContext _localctx = new SourceElementsContext(_ctx, getState()); + enterRule(_localctx, 226, RULE_sourceElements); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1320); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1319); + sourceElement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1322); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,167,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArrayLiteralContext extends ParserRuleContext { + public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); } + public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); } + public ElementListContext elementList() { + return getRuleContext(ElementListContext.class,0); + } + public ArrayLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayLiteral; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrayLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrayLiteral(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArrayLiteral(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayLiteralContext arrayLiteral() throws RecognitionException { + ArrayLiteralContext _localctx = new ArrayLiteralContext(_ctx, getState()); + enterRule(_localctx, 228, RULE_arrayLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + { + setState(1324); + match(OpenBracket); + setState(1326); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795928641192L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 8128698260224212991L) != 0)) { + { + setState(1325); + elementList(); + } + } + + setState(1328); + match(CloseBracket); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ElementListContext extends ParserRuleContext { + public List arrayElement() { + return getRuleContexts(ArrayElementContext.class); + } + public ArrayElementContext arrayElement(int i) { + return getRuleContext(ArrayElementContext.class,i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public ElementListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterElementList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitElementList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitElementList(this); + else return visitor.visitChildren(this); + } + } + + public final ElementListContext elementList() throws RecognitionException { + ElementListContext _localctx = new ElementListContext(_ctx, getState()); + enterRule(_localctx, 230, RULE_elementList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1330); + arrayElement(); + setState(1339); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1332); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1331); + match(Comma); + } + } + setState(1334); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==Comma ); + setState(1336); + arrayElement(); + } + } + setState(1341); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArrayElementContext extends ParserRuleContext { + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public TerminalNode Ellipsis() { return getToken(TypeScriptParser.Ellipsis, 0); } + public TerminalNode Comma() { return getToken(TypeScriptParser.Comma, 0); } + public ArrayElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayElement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrayElement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrayElement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArrayElement(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayElementContext arrayElement() throws RecognitionException { + ArrayElementContext _localctx = new ArrayElementContext(_ctx, getState()); + enterRule(_localctx, 232, RULE_arrayElement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1343); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1342); + match(Ellipsis); + } + } + + setState(1347); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) { + case 1: + { + setState(1345); + singleExpression(0); + } + break; + case 2: + { + setState(1346); + match(Identifier); + } + break; + } + setState(1350); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) { + case 1: + { + setState(1349); + match(Comma); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ObjectLiteralContext extends ParserRuleContext { + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public List propertyAssignment() { + return getRuleContexts(PropertyAssignmentContext.class); + } + public PropertyAssignmentContext propertyAssignment(int i) { + return getRuleContext(PropertyAssignmentContext.class,i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public ObjectLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_objectLiteral; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterObjectLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitObjectLiteral(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitObjectLiteral(this); + else return visitor.visitChildren(this); + } + } + + public final ObjectLiteralContext objectLiteral() throws RecognitionException { + ObjectLiteralContext _localctx = new ObjectLiteralContext(_ctx, getState()); + enterRule(_localctx, 234, RULE_objectLiteral); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1352); + match(OpenBrace); + setState(1364); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028797002121200L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 3517012241796825087L) != 0)) { + { + setState(1353); + propertyAssignment(); + setState(1358); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,174,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1354); + match(Comma); + setState(1355); + propertyAssignment(); + } + } + } + setState(1360); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,174,_ctx); + } + setState(1362); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1361); + match(Comma); + } + } + + } + } + + setState(1366); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PropertyAssignmentContext extends ParserRuleContext { + public PropertyAssignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_propertyAssignment; } + + public PropertyAssignmentContext() { } + public void copyFrom(PropertyAssignmentContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PropertyExpressionAssignmentContext extends PropertyAssignmentContext { + public PropertyNameContext propertyName() { + return getRuleContext(PropertyNameContext.class,0); + } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); } + public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); } + public PropertyExpressionAssignmentContext(PropertyAssignmentContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyExpressionAssignment(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyExpressionAssignment(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertyExpressionAssignment(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ComputedPropertyExpressionAssignmentContext extends PropertyAssignmentContext { + public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); } + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); } + public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); } + public ComputedPropertyExpressionAssignmentContext(PropertyAssignmentContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterComputedPropertyExpressionAssignment(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitComputedPropertyExpressionAssignment(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitComputedPropertyExpressionAssignment(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PropertyShorthandContext extends PropertyAssignmentContext { + public IdentifierOrKeyWordContext identifierOrKeyWord() { + return getRuleContext(IdentifierOrKeyWordContext.class,0); + } + public PropertyShorthandContext(PropertyAssignmentContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyShorthand(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyShorthand(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertyShorthand(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PropertySetterContext extends PropertyAssignmentContext { + public SetAccessorContext setAccessor() { + return getRuleContext(SetAccessorContext.class,0); + } + public PropertySetterContext(PropertyAssignmentContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertySetter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertySetter(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertySetter(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PropertyGetterContext extends PropertyAssignmentContext { + public GetAccessorContext getAccessor() { + return getRuleContext(GetAccessorContext.class,0); + } + public PropertyGetterContext(PropertyAssignmentContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyGetter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyGetter(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertyGetter(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class RestParameterInObjectContext extends PropertyAssignmentContext { + public RestParameterContext restParameter() { + return getRuleContext(RestParameterContext.class,0); + } + public RestParameterInObjectContext(PropertyAssignmentContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRestParameterInObject(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRestParameterInObject(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitRestParameterInObject(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class MethodPropertyContext extends PropertyAssignmentContext { + public GeneratorMethodContext generatorMethod() { + return getRuleContext(GeneratorMethodContext.class,0); + } + public MethodPropertyContext(PropertyAssignmentContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterMethodProperty(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitMethodProperty(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitMethodProperty(this); + else return visitor.visitChildren(this); + } + } + + public final PropertyAssignmentContext propertyAssignment() throws RecognitionException { + PropertyAssignmentContext _localctx = new PropertyAssignmentContext(_ctx, getState()); + enterRule(_localctx, 236, RULE_propertyAssignment); + int _la; + try { + setState(1383); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) { + case 1: + _localctx = new PropertyExpressionAssignmentContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1368); + propertyName(); + setState(1369); + _la = _input.LA(1); + if ( !(_la==Assign || _la==Colon) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1370); + singleExpression(0); + } + break; + case 2: + _localctx = new ComputedPropertyExpressionAssignmentContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1372); + match(OpenBracket); + setState(1373); + singleExpression(0); + setState(1374); + match(CloseBracket); + setState(1375); + match(Colon); + setState(1376); + singleExpression(0); + } + break; + case 3: + _localctx = new PropertyGetterContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(1378); + getAccessor(); + } + break; + case 4: + _localctx = new PropertySetterContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(1379); + setAccessor(); + } + break; + case 5: + _localctx = new MethodPropertyContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(1380); + generatorMethod(); + } + break; + case 6: + _localctx = new PropertyShorthandContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(1381); + identifierOrKeyWord(); + } + break; + case 7: + _localctx = new RestParameterInObjectContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(1382); + restParameter(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GetAccessorContext extends ParserRuleContext { + public GetterContext getter() { + return getRuleContext(GetterContext.class,0); + } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class,0); + } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public GetAccessorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_getAccessor; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGetAccessor(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGetAccessor(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGetAccessor(this); + else return visitor.visitChildren(this); + } + } + + public final GetAccessorContext getAccessor() throws RecognitionException { + GetAccessorContext _localctx = new GetAccessorContext(_ctx, getState()); + enterRule(_localctx, 238, RULE_getAccessor); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1385); + getter(); + setState(1386); + match(OpenParen); + setState(1387); + match(CloseParen); + setState(1389); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1388); + typeAnnotation(); + } + } + + setState(1391); + match(OpenBrace); + setState(1392); + functionBody(); + setState(1393); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SetAccessorContext extends ParserRuleContext { + public SetterContext setter() { + return getRuleContext(SetterContext.class,0); + } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class,0); + } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public BindingPatternContext bindingPattern() { + return getRuleContext(BindingPatternContext.class,0); + } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public SetAccessorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_setAccessor; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterSetAccessor(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitSetAccessor(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitSetAccessor(this); + else return visitor.visitChildren(this); + } + } + + public final SetAccessorContext setAccessor() throws RecognitionException { + SetAccessorContext _localctx = new SetAccessorContext(_ctx, getState()); + enterRule(_localctx, 240, RULE_setAccessor); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1395); + setter(); + setState(1396); + match(OpenParen); + setState(1399); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Identifier: + { + setState(1397); + match(Identifier); + } + break; + case OpenBracket: + case OpenBrace: + { + setState(1398); + bindingPattern(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1402); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1401); + typeAnnotation(); + } + } + + setState(1404); + match(CloseParen); + setState(1405); + match(OpenBrace); + setState(1406); + functionBody(); + setState(1407); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PropertyNameContext extends ParserRuleContext { + public IdentifierNameContext identifierName() { + return getRuleContext(IdentifierNameContext.class,0); + } + public TerminalNode StringLiteral() { return getToken(TypeScriptParser.StringLiteral, 0); } + public NumericLiteralContext numericLiteral() { + return getRuleContext(NumericLiteralContext.class,0); + } + public PropertyNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_propertyName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyName(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertyName(this); + else return visitor.visitChildren(this); + } + } + + public final PropertyNameContext propertyName() throws RecognitionException { + PropertyNameContext _localctx = new PropertyNameContext(_ctx, getState()); + enterRule(_localctx, 242, RULE_propertyName); + try { + setState(1412); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NullLiteral: + case BooleanLiteral: + case Break: + case Do: + case Instanceof: + case Typeof: + case Case: + case Else: + case New: + case Var: + case Catch: + case Finally: + case Return: + case Void: + case Continue: + case For: + case Switch: + case While: + case Debugger: + case Function_: + case This: + case With: + case Default: + case If: + case Throw: + case Delete: + case In: + case Try: + case From: + case ReadOnly: + case Async: + case Class: + case Enum: + case Extends: + case Super: + case Const: + case Export: + case Import: + case Implements: + case Let: + case Private: + case Public: + case Interface: + case Package: + case Protected: + case Static: + case Yield: + case Number: + case Boolean: + case String: + case TypeAlias: + case Get: + case Set: + case Require: + case Module: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1409); + identifierName(); + } + break; + case StringLiteral: + enterOuterAlt(_localctx, 2); + { + setState(1410); + match(StringLiteral); + } + break; + case DecimalLiteral: + case HexIntegerLiteral: + case OctalIntegerLiteral: + case OctalIntegerLiteral2: + case BinaryIntegerLiteral: + enterOuterAlt(_localctx, 3); + { + setState(1411); + numericLiteral(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArgumentsContext extends ParserRuleContext { + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public TerminalNode Comma() { return getToken(TypeScriptParser.Comma, 0); } + public ArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arguments; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArguments(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArguments(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArguments(this); + else return visitor.visitChildren(this); + } + } + + public final ArgumentsContext arguments() throws RecognitionException { + ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState()); + enterRule(_localctx, 244, RULE_arguments); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1414); + match(OpenParen); + setState(1419); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795928641192L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 8128698260224212991L) != 0)) { + { + setState(1415); + argumentList(); + setState(1417); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1416); + match(Comma); + } + } + + } + } + + setState(1421); + match(CloseParen); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArgumentListContext extends ParserRuleContext { + public List argument() { + return getRuleContexts(ArgumentContext.class); + } + public ArgumentContext argument(int i) { + return getRuleContext(ArgumentContext.class,i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public ArgumentListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_argumentList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArgumentList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArgumentList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArgumentList(this); + else return visitor.visitChildren(this); + } + } + + public final ArgumentListContext argumentList() throws RecognitionException { + ArgumentListContext _localctx = new ArgumentListContext(_ctx, getState()); + enterRule(_localctx, 246, RULE_argumentList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1423); + argument(); + setState(1428); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,184,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1424); + match(Comma); + setState(1425); + argument(); + } + } + } + setState(1430); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,184,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArgumentContext extends ParserRuleContext { + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public TerminalNode Ellipsis() { return getToken(TypeScriptParser.Ellipsis, 0); } + public ArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_argument; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArgument(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArgument(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArgument(this); + else return visitor.visitChildren(this); + } + } + + public final ArgumentContext argument() throws RecognitionException { + ArgumentContext _localctx = new ArgumentContext(_ctx, getState()); + enterRule(_localctx, 248, RULE_argument); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1432); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1431); + match(Ellipsis); + } + } + + setState(1436); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) { + case 1: + { + setState(1434); + singleExpression(0); + } + break; + case 2: + { + setState(1435); + match(Identifier); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionSequenceContext extends ParserRuleContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public List Comma() { return getTokens(TypeScriptParser.Comma); } + public TerminalNode Comma(int i) { + return getToken(TypeScriptParser.Comma, i); + } + public ExpressionSequenceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionSequence; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterExpressionSequence(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitExpressionSequence(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitExpressionSequence(this); + else return visitor.visitChildren(this); + } + } + + public final ExpressionSequenceContext expressionSequence() throws RecognitionException { + ExpressionSequenceContext _localctx = new ExpressionSequenceContext(_ctx, getState()); + enterRule(_localctx, 250, RULE_expressionSequence); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1438); + singleExpression(0); + setState(1443); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,187,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1439); + match(Comma); + setState(1440); + singleExpression(0); + } + } + } + setState(1445); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,187,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionExpressionDeclarationContext extends ParserRuleContext { + public TerminalNode Function_() { return getToken(TypeScriptParser.Function_, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class,0); + } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public FunctionExpressionDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionExpressionDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFunctionExpressionDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFunctionExpressionDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFunctionExpressionDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final FunctionExpressionDeclarationContext functionExpressionDeclaration() throws RecognitionException { + FunctionExpressionDeclarationContext _localctx = new FunctionExpressionDeclarationContext(_ctx, getState()); + enterRule(_localctx, 252, RULE_functionExpressionDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1446); + match(Function_); + setState(1448); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1447); + match(Identifier); + } + } + + setState(1450); + match(OpenParen); + setState(1452); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65808L) != 0) || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 12718099L) != 0)) { + { + setState(1451); + formalParameterList(); + } + } + + setState(1454); + match(CloseParen); + setState(1456); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1455); + typeAnnotation(); + } + } + + setState(1458); + match(OpenBrace); + setState(1459); + functionBody(); + setState(1460); + match(CloseBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SingleExpressionContext extends ParserRuleContext { + public SingleExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_singleExpression; } + + public SingleExpressionContext() { } + public void copyFrom(SingleExpressionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TemplateStringExpressionContext extends SingleExpressionContext { + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TemplateStringLiteralContext templateStringLiteral() { + return getRuleContext(TemplateStringLiteralContext.class,0); + } + public TemplateStringExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTemplateStringExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTemplateStringExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTemplateStringExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TernaryExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); } + public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); } + public TernaryExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTernaryExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTernaryExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTernaryExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class LogicalAndExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode And() { return getToken(TypeScriptParser.And, 0); } + public LogicalAndExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterLogicalAndExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitLogicalAndExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitLogicalAndExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class GeneratorsExpressionContext extends SingleExpressionContext { + public GeneratorBlockContext generatorBlock() { + return getRuleContext(GeneratorBlockContext.class,0); + } + public GeneratorsExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorsExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorsExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGeneratorsExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PreIncrementExpressionContext extends SingleExpressionContext { + public TerminalNode PlusPlus() { return getToken(TypeScriptParser.PlusPlus, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public PreIncrementExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPreIncrementExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPreIncrementExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPreIncrementExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ObjectLiteralExpressionContext extends SingleExpressionContext { + public ObjectLiteralContext objectLiteral() { + return getRuleContext(ObjectLiteralContext.class,0); + } + public ObjectLiteralExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterObjectLiteralExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitObjectLiteralExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitObjectLiteralExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class InExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode In() { return getToken(TypeScriptParser.In, 0); } + public InExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterInExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitInExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitInExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class LogicalOrExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode Or() { return getToken(TypeScriptParser.Or, 0); } + public LogicalOrExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterLogicalOrExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitLogicalOrExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitLogicalOrExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class GenericTypesContext extends SingleExpressionContext { + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public GenericTypesContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGenericTypes(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGenericTypes(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGenericTypes(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class NotExpressionContext extends SingleExpressionContext { + public TerminalNode Not() { return getToken(TypeScriptParser.Not, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public NotExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterNotExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitNotExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitNotExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PreDecreaseExpressionContext extends SingleExpressionContext { + public TerminalNode MinusMinus() { return getToken(TypeScriptParser.MinusMinus, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public PreDecreaseExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPreDecreaseExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPreDecreaseExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPreDecreaseExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ArgumentsExpressionContext extends SingleExpressionContext { + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class,0); + } + public ArgumentsExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArgumentsExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArgumentsExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArgumentsExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ThisExpressionContext extends SingleExpressionContext { + public TerminalNode This() { return getToken(TypeScriptParser.This, 0); } + public ThisExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterThisExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitThisExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitThisExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class FunctionExpressionContext extends SingleExpressionContext { + public FunctionExpressionDeclarationContext functionExpressionDeclaration() { + return getRuleContext(FunctionExpressionDeclarationContext.class,0); + } + public FunctionExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFunctionExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFunctionExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFunctionExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class UnaryMinusExpressionContext extends SingleExpressionContext { + public TerminalNode Minus() { return getToken(TypeScriptParser.Minus, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public UnaryMinusExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterUnaryMinusExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitUnaryMinusExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitUnaryMinusExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AssignmentExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); } + public AssignmentExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAssignmentExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAssignmentExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitAssignmentExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PostDecreaseExpressionContext extends SingleExpressionContext { + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TerminalNode MinusMinus() { return getToken(TypeScriptParser.MinusMinus, 0); } + public PostDecreaseExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPostDecreaseExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPostDecreaseExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPostDecreaseExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TypeofExpressionContext extends SingleExpressionContext { + public TerminalNode Typeof() { return getToken(TypeScriptParser.Typeof, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TypeofExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeofExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeofExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeofExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class InstanceofExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode Instanceof() { return getToken(TypeScriptParser.Instanceof, 0); } + public InstanceofExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterInstanceofExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitInstanceofExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitInstanceofExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class UnaryPlusExpressionContext extends SingleExpressionContext { + public TerminalNode Plus() { return getToken(TypeScriptParser.Plus, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public UnaryPlusExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterUnaryPlusExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitUnaryPlusExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitUnaryPlusExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DeleteExpressionContext extends SingleExpressionContext { + public TerminalNode Delete() { return getToken(TypeScriptParser.Delete, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public DeleteExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDeleteExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDeleteExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDeleteExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class GeneratorsFunctionExpressionContext extends SingleExpressionContext { + public GeneratorFunctionDeclarationContext generatorFunctionDeclaration() { + return getRuleContext(GeneratorFunctionDeclarationContext.class,0); + } + public GeneratorsFunctionExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorsFunctionExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorsFunctionExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGeneratorsFunctionExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ArrowFunctionExpressionContext extends SingleExpressionContext { + public ArrowFunctionDeclarationContext arrowFunctionDeclaration() { + return getRuleContext(ArrowFunctionDeclarationContext.class,0); + } + public ArrowFunctionExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrowFunctionExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrowFunctionExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArrowFunctionExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class IteratorsExpressionContext extends SingleExpressionContext { + public IteratorBlockContext iteratorBlock() { + return getRuleContext(IteratorBlockContext.class,0); + } + public IteratorsExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIteratorsExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIteratorsExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIteratorsExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class EqualityExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode Equals_() { return getToken(TypeScriptParser.Equals_, 0); } + public TerminalNode NotEquals() { return getToken(TypeScriptParser.NotEquals, 0); } + public TerminalNode IdentityEquals() { return getToken(TypeScriptParser.IdentityEquals, 0); } + public TerminalNode IdentityNotEquals() { return getToken(TypeScriptParser.IdentityNotEquals, 0); } + public EqualityExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEqualityExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEqualityExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitEqualityExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class BitXOrExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode BitXOr() { return getToken(TypeScriptParser.BitXOr, 0); } + public BitXOrExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBitXOrExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBitXOrExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitBitXOrExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CastAsExpressionContext extends SingleExpressionContext { + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TerminalNode As() { return getToken(TypeScriptParser.As, 0); } + public AsExpressionContext asExpression() { + return getRuleContext(AsExpressionContext.class,0); + } + public CastAsExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCastAsExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCastAsExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitCastAsExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SuperExpressionContext extends SingleExpressionContext { + public TerminalNode Super() { return getToken(TypeScriptParser.Super, 0); } + public SuperExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterSuperExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitSuperExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitSuperExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class MultiplicativeExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode Multiply() { return getToken(TypeScriptParser.Multiply, 0); } + public TerminalNode Divide() { return getToken(TypeScriptParser.Divide, 0); } + public TerminalNode Modulus() { return getToken(TypeScriptParser.Modulus, 0); } + public MultiplicativeExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterMultiplicativeExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitMultiplicativeExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitMultiplicativeExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class BitShiftExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode LeftShiftArithmetic() { return getToken(TypeScriptParser.LeftShiftArithmetic, 0); } + public TerminalNode RightShiftArithmetic() { return getToken(TypeScriptParser.RightShiftArithmetic, 0); } + public TerminalNode RightShiftLogical() { return getToken(TypeScriptParser.RightShiftLogical, 0); } + public BitShiftExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBitShiftExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBitShiftExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitBitShiftExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ParenthesizedExpressionContext extends SingleExpressionContext { + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public ParenthesizedExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterParenthesizedExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitParenthesizedExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitParenthesizedExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AdditiveExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode Plus() { return getToken(TypeScriptParser.Plus, 0); } + public TerminalNode Minus() { return getToken(TypeScriptParser.Minus, 0); } + public AdditiveExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAdditiveExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAdditiveExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitAdditiveExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class RelationalExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode LessThan() { return getToken(TypeScriptParser.LessThan, 0); } + public TerminalNode MoreThan() { return getToken(TypeScriptParser.MoreThan, 0); } + public TerminalNode LessThanEquals() { return getToken(TypeScriptParser.LessThanEquals, 0); } + public TerminalNode GreaterThanEquals() { return getToken(TypeScriptParser.GreaterThanEquals, 0); } + public RelationalExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRelationalExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRelationalExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitRelationalExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PostIncrementExpressionContext extends SingleExpressionContext { + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TerminalNode PlusPlus() { return getToken(TypeScriptParser.PlusPlus, 0); } + public PostIncrementExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPostIncrementExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPostIncrementExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPostIncrementExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class YieldExpressionContext extends SingleExpressionContext { + public YieldStatementContext yieldStatement() { + return getRuleContext(YieldStatementContext.class,0); + } + public YieldExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterYieldExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitYieldExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitYieldExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class BitNotExpressionContext extends SingleExpressionContext { + public TerminalNode BitNot() { return getToken(TypeScriptParser.BitNot, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public BitNotExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBitNotExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBitNotExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitBitNotExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class NewExpressionContext extends SingleExpressionContext { + public TerminalNode New() { return getToken(TypeScriptParser.New, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class,0); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public NewExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterNewExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitNewExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitNewExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class LiteralExpressionContext extends SingleExpressionContext { + public LiteralContext literal() { + return getRuleContext(LiteralContext.class,0); + } + public LiteralExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterLiteralExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitLiteralExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitLiteralExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ArrayLiteralExpressionContext extends SingleExpressionContext { + public ArrayLiteralContext arrayLiteral() { + return getRuleContext(ArrayLiteralContext.class,0); + } + public ArrayLiteralExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrayLiteralExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrayLiteralExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArrayLiteralExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class MemberDotExpressionContext extends SingleExpressionContext { + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TerminalNode Dot() { return getToken(TypeScriptParser.Dot, 0); } + public IdentifierNameContext identifierName() { + return getRuleContext(IdentifierNameContext.class,0); + } + public TerminalNode Not() { return getToken(TypeScriptParser.Not, 0); } + public NestedTypeGenericContext nestedTypeGeneric() { + return getRuleContext(NestedTypeGenericContext.class,0); + } + public MemberDotExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterMemberDotExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitMemberDotExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitMemberDotExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class MemberIndexExpressionContext extends SingleExpressionContext { + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); } + public ExpressionSequenceContext expressionSequence() { + return getRuleContext(ExpressionSequenceContext.class,0); + } + public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); } + public MemberIndexExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterMemberIndexExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitMemberIndexExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitMemberIndexExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class IdentifierExpressionContext extends SingleExpressionContext { + public IdentifierNameContext identifierName() { + return getRuleContext(IdentifierNameContext.class,0); + } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public IdentifierExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIdentifierExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIdentifierExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIdentifierExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class BitAndExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode BitAnd() { return getToken(TypeScriptParser.BitAnd, 0); } + public BitAndExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBitAndExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBitAndExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitBitAndExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class BitOrExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public TerminalNode BitOr() { return getToken(TypeScriptParser.BitOr, 0); } + public BitOrExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBitOrExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBitOrExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitBitOrExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AssignmentOperatorExpressionContext extends SingleExpressionContext { + public List singleExpression() { + return getRuleContexts(SingleExpressionContext.class); + } + public SingleExpressionContext singleExpression(int i) { + return getRuleContext(SingleExpressionContext.class,i); + } + public AssignmentOperatorContext assignmentOperator() { + return getRuleContext(AssignmentOperatorContext.class,0); + } + public AssignmentOperatorExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAssignmentOperatorExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAssignmentOperatorExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitAssignmentOperatorExpression(this); + else return visitor.visitChildren(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class VoidExpressionContext extends SingleExpressionContext { + public TerminalNode Void() { return getToken(TypeScriptParser.Void, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public VoidExpressionContext(SingleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterVoidExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitVoidExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitVoidExpression(this); + else return visitor.visitChildren(this); + } + } + + public final SingleExpressionContext singleExpression() throws RecognitionException { + return singleExpression(0); + } + + private SingleExpressionContext singleExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + SingleExpressionContext _localctx = new SingleExpressionContext(_ctx, _parentState); + SingleExpressionContext _prevctx = _localctx; + int _startState = 254; + enterRecursionRule(_localctx, 254, RULE_singleExpression, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1516); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) { + case 1: + { + _localctx = new FunctionExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + + setState(1463); + functionExpressionDeclaration(); + } + break; + case 2: + { + _localctx = new ArrowFunctionExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1464); + arrowFunctionDeclaration(); + } + break; + case 3: + { + _localctx = new NewExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1465); + match(New); + setState(1466); + singleExpression(0); + setState(1468); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LessThan) { + { + setState(1467); + typeArguments(); + } + } + + setState(1470); + arguments(); + } + break; + case 4: + { + _localctx = new NewExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1472); + match(New); + setState(1473); + singleExpression(0); + setState(1475); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) { + case 1: + { + setState(1474); + typeArguments(); + } + break; + } + } + break; + case 5: + { + _localctx = new DeleteExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1477); + match(Delete); + setState(1478); + singleExpression(38); + } + break; + case 6: + { + _localctx = new VoidExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1479); + match(Void); + setState(1480); + singleExpression(37); + } + break; + case 7: + { + _localctx = new TypeofExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1481); + match(Typeof); + setState(1482); + singleExpression(36); + } + break; + case 8: + { + _localctx = new PreIncrementExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1483); + match(PlusPlus); + setState(1484); + singleExpression(35); + } + break; + case 9: + { + _localctx = new PreDecreaseExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1485); + match(MinusMinus); + setState(1486); + singleExpression(34); + } + break; + case 10: + { + _localctx = new UnaryPlusExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1487); + match(Plus); + setState(1488); + singleExpression(33); + } + break; + case 11: + { + _localctx = new UnaryMinusExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1489); + match(Minus); + setState(1490); + singleExpression(32); + } + break; + case 12: + { + _localctx = new BitNotExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1491); + match(BitNot); + setState(1492); + singleExpression(31); + } + break; + case 13: + { + _localctx = new NotExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1493); + match(Not); + setState(1494); + singleExpression(30); + } + break; + case 14: + { + _localctx = new IteratorsExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1495); + iteratorBlock(); + } + break; + case 15: + { + _localctx = new GeneratorsExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1496); + generatorBlock(); + } + break; + case 16: + { + _localctx = new GeneratorsFunctionExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1497); + generatorFunctionDeclaration(); + } + break; + case 17: + { + _localctx = new YieldExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1498); + yieldStatement(); + } + break; + case 18: + { + _localctx = new ThisExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1499); + match(This); + } + break; + case 19: + { + _localctx = new IdentifierExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1500); + identifierName(); + setState(1502); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) { + case 1: + { + setState(1501); + singleExpression(0); + } + break; + } + } + break; + case 20: + { + _localctx = new SuperExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1504); + match(Super); + } + break; + case 21: + { + _localctx = new LiteralExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1505); + literal(); + } + break; + case 22: + { + _localctx = new ArrayLiteralExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1506); + arrayLiteral(); + } + break; + case 23: + { + _localctx = new ObjectLiteralExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1507); + objectLiteral(); + } + break; + case 24: + { + _localctx = new ParenthesizedExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1508); + match(OpenParen); + setState(1509); + expressionSequence(); + setState(1510); + match(CloseParen); + } + break; + case 25: + { + _localctx = new GenericTypesContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1512); + typeArguments(); + setState(1514); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) { + case 1: + { + setState(1513); + expressionSequence(); + } + break; + } + } + break; + } + _ctx.stop = _input.LT(-1); + setState(1596); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,199,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(1594); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) { + case 1: + { + _localctx = new MultiplicativeExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1518); + if (!(precpred(_ctx, 29))) throw new FailedPredicateException(this, "precpred(_ctx, 29)"); + setState(1519); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 117440512L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1520); + singleExpression(30); + } + break; + case 2: + { + _localctx = new AdditiveExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1521); + if (!(precpred(_ctx, 28))) throw new FailedPredicateException(this, "precpred(_ctx, 28)"); + setState(1522); + _la = _input.LA(1); + if ( !(_la==Plus || _la==Minus) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1523); + singleExpression(29); + } + break; + case 3: + { + _localctx = new BitShiftExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1524); + if (!(precpred(_ctx, 27))) throw new FailedPredicateException(this, "precpred(_ctx, 27)"); + setState(1525); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 939524096L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1526); + singleExpression(28); + } + break; + case 4: + { + _localctx = new RelationalExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1527); + if (!(precpred(_ctx, 26))) throw new FailedPredicateException(this, "precpred(_ctx, 26)"); + setState(1528); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 16106127360L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1529); + singleExpression(27); + } + break; + case 5: + { + _localctx = new InstanceofExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1530); + if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)"); + setState(1531); + match(Instanceof); + setState(1532); + singleExpression(26); + } + break; + case 6: + { + _localctx = new InExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1533); + if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)"); + setState(1534); + match(In); + setState(1535); + singleExpression(25); + } + break; + case 7: + { + _localctx = new EqualityExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1536); + if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)"); + setState(1537); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 257698037760L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1538); + singleExpression(24); + } + break; + case 8: + { + _localctx = new BitAndExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1539); + if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)"); + setState(1540); + match(BitAnd); + setState(1541); + singleExpression(23); + } + break; + case 9: + { + _localctx = new BitXOrExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1542); + if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)"); + setState(1543); + match(BitXOr); + setState(1544); + singleExpression(22); + } + break; + case 10: + { + _localctx = new BitOrExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1545); + if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)"); + setState(1546); + match(BitOr); + setState(1547); + singleExpression(21); + } + break; + case 11: + { + _localctx = new LogicalAndExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1548); + if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)"); + setState(1549); + match(And); + setState(1550); + singleExpression(20); + } + break; + case 12: + { + _localctx = new LogicalOrExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1551); + if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)"); + setState(1552); + match(Or); + setState(1553); + singleExpression(19); + } + break; + case 13: + { + _localctx = new TernaryExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1554); + if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)"); + setState(1555); + match(QuestionMark); + setState(1556); + singleExpression(0); + setState(1557); + match(Colon); + setState(1558); + singleExpression(18); + } + break; + case 14: + { + _localctx = new AssignmentExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1560); + if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)"); + setState(1561); + match(Assign); + setState(1562); + singleExpression(17); + } + break; + case 15: + { + _localctx = new AssignmentOperatorExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1563); + if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)"); + setState(1564); + assignmentOperator(); + setState(1565); + singleExpression(16); + } + break; + case 16: + { + _localctx = new MemberIndexExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1567); + if (!(precpred(_ctx, 45))) throw new FailedPredicateException(this, "precpred(_ctx, 45)"); + setState(1568); + match(OpenBracket); + setState(1569); + expressionSequence(); + setState(1570); + match(CloseBracket); + } + break; + case 17: + { + _localctx = new MemberDotExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1572); + if (!(precpred(_ctx, 44))) throw new FailedPredicateException(this, "precpred(_ctx, 44)"); + setState(1574); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Not) { + { + setState(1573); + match(Not); + } + } + + setState(1576); + match(Dot); + setState(1577); + identifierName(); + setState(1579); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,197,_ctx) ) { + case 1: + { + setState(1578); + nestedTypeGeneric(); + } + break; + } + } + break; + case 18: + { + _localctx = new ArgumentsExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1581); + if (!(precpred(_ctx, 41))) throw new FailedPredicateException(this, "precpred(_ctx, 41)"); + setState(1582); + arguments(); + } + break; + case 19: + { + _localctx = new PostIncrementExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1583); + if (!(precpred(_ctx, 40))) throw new FailedPredicateException(this, "precpred(_ctx, 40)"); + setState(1584); + if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()"); + setState(1585); + match(PlusPlus); + } + break; + case 20: + { + _localctx = new PostDecreaseExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1586); + if (!(precpred(_ctx, 39))) throw new FailedPredicateException(this, "precpred(_ctx, 39)"); + setState(1587); + if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()"); + setState(1588); + match(MinusMinus); + } + break; + case 21: + { + _localctx = new TemplateStringExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1589); + if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)"); + setState(1590); + templateStringLiteral(); + } + break; + case 22: + { + _localctx = new CastAsExpressionContext(new SingleExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_singleExpression); + setState(1591); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(1592); + match(As); + setState(1593); + asExpression(); + } + break; + } + } + } + setState(1598); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,199,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AsExpressionContext extends ParserRuleContext { + public PredefinedTypeContext predefinedType() { + return getRuleContext(PredefinedTypeContext.class,0); + } + public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); } + public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public AsExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_asExpression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAsExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAsExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitAsExpression(this); + else return visitor.visitChildren(this); + } + } + + public final AsExpressionContext asExpression() throws RecognitionException { + AsExpressionContext _localctx = new AsExpressionContext(_ctx, getState()); + enterRule(_localctx, 256, RULE_asExpression); + try { + setState(1605); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1599); + predefinedType(); + setState(1602); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) { + case 1: + { + setState(1600); + match(OpenBracket); + setState(1601); + match(CloseBracket); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1604); + singleExpression(0); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArrowFunctionDeclarationContext extends ParserRuleContext { + public ArrowFunctionParametersContext arrowFunctionParameters() { + return getRuleContext(ArrowFunctionParametersContext.class,0); + } + public TerminalNode ARROW() { return getToken(TypeScriptParser.ARROW, 0); } + public ArrowFunctionBodyContext arrowFunctionBody() { + return getRuleContext(ArrowFunctionBodyContext.class,0); + } + public TerminalNode Async() { return getToken(TypeScriptParser.Async, 0); } + public TypeAnnotationContext typeAnnotation() { + return getRuleContext(TypeAnnotationContext.class,0); + } + public ArrowFunctionDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrowFunctionDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrowFunctionDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrowFunctionDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArrowFunctionDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ArrowFunctionDeclarationContext arrowFunctionDeclaration() throws RecognitionException { + ArrowFunctionDeclarationContext _localctx = new ArrowFunctionDeclarationContext(_ctx, getState()); + enterRule(_localctx, 258, RULE_arrowFunctionDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1608); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Async) { + { + setState(1607); + match(Async); + } + } + + setState(1610); + arrowFunctionParameters(); + setState(1612); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1611); + typeAnnotation(); + } + } + + setState(1614); + match(ARROW); + setState(1615); + arrowFunctionBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArrowFunctionParametersContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); } + public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public ArrowFunctionParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrowFunctionParameters; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrowFunctionParameters(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrowFunctionParameters(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArrowFunctionParameters(this); + else return visitor.visitChildren(this); + } + } + + public final ArrowFunctionParametersContext arrowFunctionParameters() throws RecognitionException { + ArrowFunctionParametersContext _localctx = new ArrowFunctionParametersContext(_ctx, getState()); + enterRule(_localctx, 260, RULE_arrowFunctionParameters); + int _la; + try { + setState(1623); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1617); + match(Identifier); + } + break; + case OpenParen: + enterOuterAlt(_localctx, 2); + { + setState(1618); + match(OpenParen); + setState(1620); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65808L) != 0) || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 12718099L) != 0)) { + { + setState(1619); + formalParameterList(); + } + } + + setState(1622); + match(CloseParen); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArrowFunctionBodyContext extends ParserRuleContext { + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); } + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class,0); + } + public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); } + public ArrowFunctionBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrowFunctionBody; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrowFunctionBody(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrowFunctionBody(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArrowFunctionBody(this); + else return visitor.visitChildren(this); + } + } + + public final ArrowFunctionBodyContext arrowFunctionBody() throws RecognitionException { + ArrowFunctionBodyContext _localctx = new ArrowFunctionBodyContext(_ctx, getState()); + enterRule(_localctx, 262, RULE_arrowFunctionBody); + try { + setState(1630); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1625); + singleExpression(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1626); + match(OpenBrace); + setState(1627); + functionBody(); + setState(1628); + match(CloseBrace); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssignmentOperatorContext extends ParserRuleContext { + public TerminalNode MultiplyAssign() { return getToken(TypeScriptParser.MultiplyAssign, 0); } + public TerminalNode DivideAssign() { return getToken(TypeScriptParser.DivideAssign, 0); } + public TerminalNode ModulusAssign() { return getToken(TypeScriptParser.ModulusAssign, 0); } + public TerminalNode PlusAssign() { return getToken(TypeScriptParser.PlusAssign, 0); } + public TerminalNode MinusAssign() { return getToken(TypeScriptParser.MinusAssign, 0); } + public TerminalNode LeftShiftArithmeticAssign() { return getToken(TypeScriptParser.LeftShiftArithmeticAssign, 0); } + public TerminalNode RightShiftArithmeticAssign() { return getToken(TypeScriptParser.RightShiftArithmeticAssign, 0); } + public TerminalNode RightShiftLogicalAssign() { return getToken(TypeScriptParser.RightShiftLogicalAssign, 0); } + public TerminalNode BitAndAssign() { return getToken(TypeScriptParser.BitAndAssign, 0); } + public TerminalNode BitXorAssign() { return getToken(TypeScriptParser.BitXorAssign, 0); } + public TerminalNode BitOrAssign() { return getToken(TypeScriptParser.BitOrAssign, 0); } + public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignmentOperator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAssignmentOperator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAssignmentOperator(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitAssignmentOperator(this); + else return visitor.visitChildren(this); + } + } + + public final AssignmentOperatorContext assignmentOperator() throws RecognitionException { + AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState()); + enterRule(_localctx, 264, RULE_assignmentOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1632); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 18005602416459776L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LiteralContext extends ParserRuleContext { + public TerminalNode NullLiteral() { return getToken(TypeScriptParser.NullLiteral, 0); } + public TerminalNode BooleanLiteral() { return getToken(TypeScriptParser.BooleanLiteral, 0); } + public TerminalNode StringLiteral() { return getToken(TypeScriptParser.StringLiteral, 0); } + public TemplateStringLiteralContext templateStringLiteral() { + return getRuleContext(TemplateStringLiteralContext.class,0); + } + public TerminalNode RegularExpressionLiteral() { return getToken(TypeScriptParser.RegularExpressionLiteral, 0); } + public NumericLiteralContext numericLiteral() { + return getRuleContext(NumericLiteralContext.class,0); + } + public LiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_literal; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitLiteral(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitLiteral(this); + else return visitor.visitChildren(this); + } + } + + public final LiteralContext literal() throws RecognitionException { + LiteralContext _localctx = new LiteralContext(_ctx, getState()); + enterRule(_localctx, 266, RULE_literal); + try { + setState(1640); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NullLiteral: + enterOuterAlt(_localctx, 1); + { + setState(1634); + match(NullLiteral); + } + break; + case BooleanLiteral: + enterOuterAlt(_localctx, 2); + { + setState(1635); + match(BooleanLiteral); + } + break; + case StringLiteral: + enterOuterAlt(_localctx, 3); + { + setState(1636); + match(StringLiteral); + } + break; + case BackTick: + enterOuterAlt(_localctx, 4); + { + setState(1637); + templateStringLiteral(); + } + break; + case RegularExpressionLiteral: + enterOuterAlt(_localctx, 5); + { + setState(1638); + match(RegularExpressionLiteral); + } + break; + case DecimalLiteral: + case HexIntegerLiteral: + case OctalIntegerLiteral: + case OctalIntegerLiteral2: + case BinaryIntegerLiteral: + enterOuterAlt(_localctx, 6); + { + setState(1639); + numericLiteral(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TemplateStringLiteralContext extends ParserRuleContext { + public List BackTick() { return getTokens(TypeScriptParser.BackTick); } + public TerminalNode BackTick(int i) { + return getToken(TypeScriptParser.BackTick, i); + } + public List templateStringAtom() { + return getRuleContexts(TemplateStringAtomContext.class); + } + public TemplateStringAtomContext templateStringAtom(int i) { + return getRuleContext(TemplateStringAtomContext.class,i); + } + public TemplateStringLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_templateStringLiteral; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTemplateStringLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTemplateStringLiteral(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTemplateStringLiteral(this); + else return visitor.visitChildren(this); + } + } + + public final TemplateStringLiteralContext templateStringLiteral() throws RecognitionException { + TemplateStringLiteralContext _localctx = new TemplateStringLiteralContext(_ctx, getState()); + enterRule(_localctx, 268, RULE_templateStringLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1642); + match(BackTick); + setState(1646); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & 7L) != 0)) { + { + { + setState(1643); + templateStringAtom(); + } + } + setState(1648); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1649); + match(BackTick); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TemplateStringAtomContext extends ParserRuleContext { + public TerminalNode TemplateStringAtom() { return getToken(TypeScriptParser.TemplateStringAtom, 0); } + public TerminalNode TemplateStringStartExpression() { return getToken(TypeScriptParser.TemplateStringStartExpression, 0); } + public SingleExpressionContext singleExpression() { + return getRuleContext(SingleExpressionContext.class,0); + } + public TerminalNode TemplateCloseBrace() { return getToken(TypeScriptParser.TemplateCloseBrace, 0); } + public TerminalNode TemplateStringEscapeAtom() { return getToken(TypeScriptParser.TemplateStringEscapeAtom, 0); } + public TemplateStringAtomContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_templateStringAtom; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTemplateStringAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTemplateStringAtom(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTemplateStringAtom(this); + else return visitor.visitChildren(this); + } + } + + public final TemplateStringAtomContext templateStringAtom() throws RecognitionException { + TemplateStringAtomContext _localctx = new TemplateStringAtomContext(_ctx, getState()); + enterRule(_localctx, 270, RULE_templateStringAtom); + try { + setState(1657); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TemplateStringAtom: + enterOuterAlt(_localctx, 1); + { + setState(1651); + match(TemplateStringAtom); + } + break; + case TemplateStringStartExpression: + enterOuterAlt(_localctx, 2); + { + setState(1652); + match(TemplateStringStartExpression); + setState(1653); + singleExpression(0); + setState(1654); + match(TemplateCloseBrace); + } + break; + case TemplateStringEscapeAtom: + enterOuterAlt(_localctx, 3); + { + setState(1656); + match(TemplateStringEscapeAtom); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NumericLiteralContext extends ParserRuleContext { + public TerminalNode DecimalLiteral() { return getToken(TypeScriptParser.DecimalLiteral, 0); } + public TerminalNode HexIntegerLiteral() { return getToken(TypeScriptParser.HexIntegerLiteral, 0); } + public TerminalNode OctalIntegerLiteral() { return getToken(TypeScriptParser.OctalIntegerLiteral, 0); } + public TerminalNode OctalIntegerLiteral2() { return getToken(TypeScriptParser.OctalIntegerLiteral2, 0); } + public TerminalNode BinaryIntegerLiteral() { return getToken(TypeScriptParser.BinaryIntegerLiteral, 0); } + public NumericLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_numericLiteral; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterNumericLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitNumericLiteral(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitNumericLiteral(this); + else return visitor.visitChildren(this); + } + } + + public final NumericLiteralContext numericLiteral() throws RecognitionException { + NumericLiteralContext _localctx = new NumericLiteralContext(_ctx, getState()); + enterRule(_localctx, 272, RULE_numericLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1659); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 4467570830351532032L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IdentifierNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public ReservedWordContext reservedWord() { + return getRuleContext(ReservedWordContext.class,0); + } + public IdentifierNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_identifierName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIdentifierName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIdentifierName(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIdentifierName(this); + else return visitor.visitChildren(this); + } + } + + public final IdentifierNameContext identifierName() throws RecognitionException { + IdentifierNameContext _localctx = new IdentifierNameContext(_ctx, getState()); + enterRule(_localctx, 274, RULE_identifierName); + try { + setState(1663); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1661); + match(Identifier); + } + break; + case NullLiteral: + case BooleanLiteral: + case Break: + case Do: + case Instanceof: + case Typeof: + case Case: + case Else: + case New: + case Var: + case Catch: + case Finally: + case Return: + case Void: + case Continue: + case For: + case Switch: + case While: + case Debugger: + case Function_: + case This: + case With: + case Default: + case If: + case Throw: + case Delete: + case In: + case Try: + case From: + case ReadOnly: + case Async: + case Class: + case Enum: + case Extends: + case Super: + case Const: + case Export: + case Import: + case Implements: + case Let: + case Private: + case Public: + case Interface: + case Package: + case Protected: + case Static: + case Yield: + case Number: + case Boolean: + case String: + case TypeAlias: + case Get: + case Set: + case Require: + case Module: + enterOuterAlt(_localctx, 2); + { + setState(1662); + reservedWord(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IdentifierOrKeyWordContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); } + public TerminalNode TypeAlias() { return getToken(TypeScriptParser.TypeAlias, 0); } + public TerminalNode Require() { return getToken(TypeScriptParser.Require, 0); } + public IdentifierOrKeyWordContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_identifierOrKeyWord; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIdentifierOrKeyWord(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIdentifierOrKeyWord(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIdentifierOrKeyWord(this); + else return visitor.visitChildren(this); + } + } + + public final IdentifierOrKeyWordContext identifierOrKeyWord() throws RecognitionException { + IdentifierOrKeyWordContext _localctx = new IdentifierOrKeyWordContext(_ctx, getState()); + enterRule(_localctx, 276, RULE_identifierOrKeyWord); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1665); + _la = _input.LA(1); + if ( !(((((_la - 113)) & ~0x3f) == 0 && ((1L << (_la - 113)) & 2081L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReservedWordContext extends ParserRuleContext { + public KeywordContext keyword() { + return getRuleContext(KeywordContext.class,0); + } + public TerminalNode NullLiteral() { return getToken(TypeScriptParser.NullLiteral, 0); } + public TerminalNode BooleanLiteral() { return getToken(TypeScriptParser.BooleanLiteral, 0); } + public ReservedWordContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_reservedWord; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterReservedWord(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitReservedWord(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitReservedWord(this); + else return visitor.visitChildren(this); + } + } + + public final ReservedWordContext reservedWord() throws RecognitionException { + ReservedWordContext _localctx = new ReservedWordContext(_ctx, getState()); + enterRule(_localctx, 278, RULE_reservedWord); + try { + setState(1670); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Break: + case Do: + case Instanceof: + case Typeof: + case Case: + case Else: + case New: + case Var: + case Catch: + case Finally: + case Return: + case Void: + case Continue: + case For: + case Switch: + case While: + case Debugger: + case Function_: + case This: + case With: + case Default: + case If: + case Throw: + case Delete: + case In: + case Try: + case From: + case ReadOnly: + case Async: + case Class: + case Enum: + case Extends: + case Super: + case Const: + case Export: + case Import: + case Implements: + case Let: + case Private: + case Public: + case Interface: + case Package: + case Protected: + case Static: + case Yield: + case Number: + case Boolean: + case String: + case TypeAlias: + case Get: + case Set: + case Require: + case Module: + enterOuterAlt(_localctx, 1); + { + setState(1667); + keyword(); + } + break; + case NullLiteral: + enterOuterAlt(_localctx, 2); + { + setState(1668); + match(NullLiteral); + } + break; + case BooleanLiteral: + enterOuterAlt(_localctx, 3); + { + setState(1669); + match(BooleanLiteral); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class KeywordContext extends ParserRuleContext { + public TerminalNode Break() { return getToken(TypeScriptParser.Break, 0); } + public TerminalNode Do() { return getToken(TypeScriptParser.Do, 0); } + public TerminalNode Instanceof() { return getToken(TypeScriptParser.Instanceof, 0); } + public TerminalNode Typeof() { return getToken(TypeScriptParser.Typeof, 0); } + public TerminalNode Case() { return getToken(TypeScriptParser.Case, 0); } + public TerminalNode Else() { return getToken(TypeScriptParser.Else, 0); } + public TerminalNode New() { return getToken(TypeScriptParser.New, 0); } + public TerminalNode Var() { return getToken(TypeScriptParser.Var, 0); } + public TerminalNode Catch() { return getToken(TypeScriptParser.Catch, 0); } + public TerminalNode Finally() { return getToken(TypeScriptParser.Finally, 0); } + public TerminalNode Return() { return getToken(TypeScriptParser.Return, 0); } + public TerminalNode Void() { return getToken(TypeScriptParser.Void, 0); } + public TerminalNode Continue() { return getToken(TypeScriptParser.Continue, 0); } + public TerminalNode For() { return getToken(TypeScriptParser.For, 0); } + public TerminalNode Switch() { return getToken(TypeScriptParser.Switch, 0); } + public TerminalNode While() { return getToken(TypeScriptParser.While, 0); } + public TerminalNode Debugger() { return getToken(TypeScriptParser.Debugger, 0); } + public TerminalNode Function_() { return getToken(TypeScriptParser.Function_, 0); } + public TerminalNode This() { return getToken(TypeScriptParser.This, 0); } + public TerminalNode With() { return getToken(TypeScriptParser.With, 0); } + public TerminalNode Default() { return getToken(TypeScriptParser.Default, 0); } + public TerminalNode If() { return getToken(TypeScriptParser.If, 0); } + public TerminalNode Throw() { return getToken(TypeScriptParser.Throw, 0); } + public TerminalNode Delete() { return getToken(TypeScriptParser.Delete, 0); } + public TerminalNode In() { return getToken(TypeScriptParser.In, 0); } + public TerminalNode Try() { return getToken(TypeScriptParser.Try, 0); } + public TerminalNode ReadOnly() { return getToken(TypeScriptParser.ReadOnly, 0); } + public TerminalNode Async() { return getToken(TypeScriptParser.Async, 0); } + public TerminalNode From() { return getToken(TypeScriptParser.From, 0); } + public TerminalNode Class() { return getToken(TypeScriptParser.Class, 0); } + public TerminalNode Enum() { return getToken(TypeScriptParser.Enum, 0); } + public TerminalNode Extends() { return getToken(TypeScriptParser.Extends, 0); } + public TerminalNode Super() { return getToken(TypeScriptParser.Super, 0); } + public TerminalNode Const() { return getToken(TypeScriptParser.Const, 0); } + public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); } + public TerminalNode Import() { return getToken(TypeScriptParser.Import, 0); } + public TerminalNode Implements() { return getToken(TypeScriptParser.Implements, 0); } + public TerminalNode Let() { return getToken(TypeScriptParser.Let, 0); } + public TerminalNode Private() { return getToken(TypeScriptParser.Private, 0); } + public TerminalNode Public() { return getToken(TypeScriptParser.Public, 0); } + public TerminalNode Interface() { return getToken(TypeScriptParser.Interface, 0); } + public TerminalNode Package() { return getToken(TypeScriptParser.Package, 0); } + public TerminalNode Protected() { return getToken(TypeScriptParser.Protected, 0); } + public TerminalNode Static() { return getToken(TypeScriptParser.Static, 0); } + public TerminalNode Yield() { return getToken(TypeScriptParser.Yield, 0); } + public TerminalNode Get() { return getToken(TypeScriptParser.Get, 0); } + public TerminalNode Set() { return getToken(TypeScriptParser.Set, 0); } + public TerminalNode Require() { return getToken(TypeScriptParser.Require, 0); } + public TerminalNode TypeAlias() { return getToken(TypeScriptParser.TypeAlias, 0); } + public TerminalNode String() { return getToken(TypeScriptParser.String, 0); } + public TerminalNode Boolean() { return getToken(TypeScriptParser.Boolean, 0); } + public TerminalNode Number() { return getToken(TypeScriptParser.Number, 0); } + public TerminalNode Module() { return getToken(TypeScriptParser.Module, 0); } + public KeywordContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_keyword; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterKeyword(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitKeyword(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitKeyword(this); + else return visitor.visitChildren(this); + } + } + + public final KeywordContext keyword() throws RecognitionException { + KeywordContext _localctx = new KeywordContext(_ctx, getState()); + enterRule(_localctx, 280, RULE_keyword); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1672); + _la = _input.LA(1); + if ( !(((((_la - 62)) & ~0x3f) == 0 && ((1L << (_la - 62)) & 232990911905136639L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GetterContext extends ParserRuleContext { + public TerminalNode Get() { return getToken(TypeScriptParser.Get, 0); } + public PropertyNameContext propertyName() { + return getRuleContext(PropertyNameContext.class,0); + } + public GetterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_getter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGetter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGetter(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGetter(this); + else return visitor.visitChildren(this); + } + } + + public final GetterContext getter() throws RecognitionException { + GetterContext _localctx = new GetterContext(_ctx, getState()); + enterRule(_localctx, 282, RULE_getter); + try { + enterOuterAlt(_localctx, 1); + { + setState(1674); + match(Get); + setState(1675); + propertyName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SetterContext extends ParserRuleContext { + public TerminalNode Set() { return getToken(TypeScriptParser.Set, 0); } + public PropertyNameContext propertyName() { + return getRuleContext(PropertyNameContext.class,0); + } + public SetterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_setter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterSetter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitSetter(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitSetter(this); + else return visitor.visitChildren(this); + } + } + + public final SetterContext setter() throws RecognitionException { + SetterContext _localctx = new SetterContext(_ctx, getState()); + enterRule(_localctx, 284, RULE_setter); + try { + enterOuterAlt(_localctx, 1); + { + setState(1677); + match(Set); + setState(1678); + propertyName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EosContext extends ParserRuleContext { + public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); } + public TerminalNode EOF() { return getToken(TypeScriptParser.EOF, 0); } + public EosContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_eos; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEos(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEos(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitEos(this); + else return visitor.visitChildren(this); + } + } + + public final EosContext eos() throws RecognitionException { + EosContext _localctx = new EosContext(_ctx, getState()); + enterRule(_localctx, 286, RULE_eos); + try { + setState(1684); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,212,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1680); + match(SemiColon); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1681); + match(EOF); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1682); + if (!(this.lineTerminatorAhead())) throw new FailedPredicateException(this, "this.lineTerminatorAhead()"); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1683); + if (!(this.closeBrace())) throw new FailedPredicateException(this, "this.closeBrace()"); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 10: + return unionOrIntersectionOrPrimaryType_sempred((UnionOrIntersectionOrPrimaryTypeContext)_localctx, predIndex); + case 11: + return primaryType_sempred((PrimaryTypeContext)_localctx, predIndex); + case 22: + return arrayType_sempred((ArrayTypeContext)_localctx, predIndex); + case 57: + return decoratorMemberExpression_sempred((DecoratorMemberExpressionContext)_localctx, predIndex); + case 73: + return expressionStatement_sempred((ExpressionStatementContext)_localctx, predIndex); + case 75: + return iterationStatement_sempred((IterationStatementContext)_localctx, predIndex); + case 77: + return continueStatement_sempred((ContinueStatementContext)_localctx, predIndex); + case 78: + return breakStatement_sempred((BreakStatementContext)_localctx, predIndex); + case 79: + return returnStatement_sempred((ReturnStatementContext)_localctx, predIndex); + case 80: + return yieldStatement_sempred((YieldStatementContext)_localctx, predIndex); + case 88: + return throwStatement_sempred((ThrowStatementContext)_localctx, predIndex); + case 127: + return singleExpression_sempred((SingleExpressionContext)_localctx, predIndex); + case 143: + return eos_sempred((EosContext)_localctx, predIndex); + } + return true; + } + private boolean unionOrIntersectionOrPrimaryType_sempred(UnionOrIntersectionOrPrimaryTypeContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return precpred(_ctx, 3); + case 1: + return precpred(_ctx, 2); + } + return true; + } + private boolean primaryType_sempred(PrimaryTypeContext _localctx, int predIndex) { + switch (predIndex) { + case 2: + return precpred(_ctx, 5); + case 3: + return notLineTerminator(); + } + return true; + } + private boolean arrayType_sempred(ArrayTypeContext _localctx, int predIndex) { + switch (predIndex) { + case 4: + return notLineTerminator(); + } + return true; + } + private boolean decoratorMemberExpression_sempred(DecoratorMemberExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 5: + return precpred(_ctx, 2); + } + return true; + } + private boolean expressionStatement_sempred(ExpressionStatementContext _localctx, int predIndex) { + switch (predIndex) { + case 6: + return this.notOpenBraceAndNotFunction(); + } + return true; + } + private boolean iterationStatement_sempred(IterationStatementContext _localctx, int predIndex) { + switch (predIndex) { + case 7: + return this.p("of"); + case 8: + return this.p("of"); + } + return true; + } + private boolean continueStatement_sempred(ContinueStatementContext _localctx, int predIndex) { + switch (predIndex) { + case 9: + return this.notLineTerminator(); + } + return true; + } + private boolean breakStatement_sempred(BreakStatementContext _localctx, int predIndex) { + switch (predIndex) { + case 10: + return this.notLineTerminator(); + } + return true; + } + private boolean returnStatement_sempred(ReturnStatementContext _localctx, int predIndex) { + switch (predIndex) { + case 11: + return this.notLineTerminator(); + } + return true; + } + private boolean yieldStatement_sempred(YieldStatementContext _localctx, int predIndex) { + switch (predIndex) { + case 12: + return this.notLineTerminator(); + } + return true; + } + private boolean throwStatement_sempred(ThrowStatementContext _localctx, int predIndex) { + switch (predIndex) { + case 13: + return this.notLineTerminator(); + } + return true; + } + private boolean singleExpression_sempred(SingleExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 14: + return precpred(_ctx, 29); + case 15: + return precpred(_ctx, 28); + case 16: + return precpred(_ctx, 27); + case 17: + return precpred(_ctx, 26); + case 18: + return precpred(_ctx, 25); + case 19: + return precpred(_ctx, 24); + case 20: + return precpred(_ctx, 23); + case 21: + return precpred(_ctx, 22); + case 22: + return precpred(_ctx, 21); + case 23: + return precpred(_ctx, 20); + case 24: + return precpred(_ctx, 19); + case 25: + return precpred(_ctx, 18); + case 26: + return precpred(_ctx, 17); + case 27: + return precpred(_ctx, 16); + case 28: + return precpred(_ctx, 15); + case 29: + return precpred(_ctx, 45); + case 30: + return precpred(_ctx, 44); + case 31: + return precpred(_ctx, 41); + case 32: + return precpred(_ctx, 40); + case 33: + return this.notLineTerminator(); + case 34: + return precpred(_ctx, 39); + case 35: + return this.notLineTerminator(); + case 36: + return precpred(_ctx, 14); + case 37: + return precpred(_ctx, 1); + } + return true; + } + private boolean eos_sempred(EosContext _localctx, int predIndex) { + switch (predIndex) { + case 38: + return this.lineTerminatorAhead(); + case 39: + return this.closeBrace(); + } + return true; + } + + public static final String _serializedATN = + "\u0004\u0001\u0086\u0697\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+ + "\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+ + "\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+ + "\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+ + "\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+ + "\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+ + "\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+ + "\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007"+ + "\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007"+ + "\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007"+ + "\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007"+ + "\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007"+ + "\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007"+ + ",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007"+ + "1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+ + "6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+ + ";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007"+ + "@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007"+ + "E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007"+ + "J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007"+ + "O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007"+ + "T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007"+ + "Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007"+ + "^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007"+ + "c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007"+ + "h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007"+ + "m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007"+ + "r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007"+ + "w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007"+ + "|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f\u0002\u0080\u0007"+ + "\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082\u0002\u0083\u0007"+ + "\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085\u0002\u0086\u0007"+ + "\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088\u0002\u0089\u0007"+ + "\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b\u0002\u008c\u0007"+ + "\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e\u0002\u008f\u0007"+ + "\u008f\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0003"+ + "\u0001\u0126\b\u0001\u0001\u0002\u0001\u0002\u0003\u0002\u012a\b\u0002"+ + "\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0005\u0003"+ + "\u0131\b\u0003\n\u0003\f\u0003\u0134\t\u0003\u0001\u0004\u0001\u0004\u0003"+ + "\u0004\u0138\b\u0004\u0001\u0004\u0003\u0004\u013b\b\u0004\u0001\u0005"+ + "\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0003\u0006\u0142\b\u0006"+ + "\u0001\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0005\u0007"+ + "\u0149\b\u0007\n\u0007\f\u0007\u014c\t\u0007\u0001\b\u0001\b\u0001\t\u0001"+ + "\t\u0001\t\u0001\t\u0001\t\u0003\t\u0155\b\t\u0001\n\u0001\n\u0001\n\u0001"+ + "\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0005\n\u0160\b\n\n\n\f\n\u0163"+ + "\t\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ + "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ + "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ + "\u000b\u0003\u000b\u0177\b\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ + "\u000b\u0005\u000b\u017d\b\u000b\n\u000b\f\u000b\u0180\t\u000b\u0001\f"+ + "\u0001\f\u0001\r\u0001\r\u0003\r\u0186\b\r\u0001\u000e\u0001\u000e\u0003"+ + "\u000e\u018a\b\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+ + "\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+ + "\u0010\u0001\u0010\u0001\u0010\u0003\u0010\u0199\b\u0010\u0001\u0011\u0001"+ + "\u0011\u0003\u0011\u019d\b\u0011\u0001\u0012\u0001\u0012\u0003\u0012\u01a1"+ + "\b\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0003\u0013\u01a7"+ + "\b\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0005\u0014\u01ac\b\u0014"+ + "\n\u0014\f\u0014\u01af\t\u0014\u0001\u0015\u0001\u0015\u0001\u0015\u0001"+ + "\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0003\u0015\u01b8\b\u0015\u0003"+ + "\u0015\u01ba\b\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001"+ + "\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0018\u0001"+ + "\u0018\u0001\u0018\u0005\u0018\u01c8\b\u0018\n\u0018\f\u0018\u01cb\t\u0018"+ + "\u0001\u0019\u0003\u0019\u01ce\b\u0019\u0001\u0019\u0001\u0019\u0003\u0019"+ + "\u01d2\b\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u001a"+ + "\u0001\u001a\u0003\u001a\u01da\b\u001a\u0001\u001a\u0001\u001a\u0003\u001a"+ + "\u01de\b\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001b"+ + "\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ + "\u0004\u001c\u01eb\b\u001c\u000b\u001c\f\u001c\u01ec\u0001\u001c\u0001"+ + "\u001c\u0003\u001c\u01f1\b\u001c\u0001\u001d\u0003\u001d\u01f4\b\u001d"+ + "\u0001\u001d\u0001\u001d\u0003\u001d\u01f8\b\u001d\u0001\u001d\u0003\u001d"+ + "\u01fb\b\u001d\u0001\u001d\u0001\u001d\u0003\u001d\u01ff\b\u001d\u0001"+ + "\u001e\u0001\u001e\u0001\u001e\u0001\u001f\u0003\u001f\u0205\b\u001f\u0001"+ + "\u001f\u0001\u001f\u0003\u001f\u0209\b\u001f\u0001\u001f\u0001\u001f\u0003"+ + "\u001f\u020d\b\u001f\u0001 \u0001 \u0001 \u0001 \u0005 \u0213\b \n \f"+ + " \u0216\t \u0001 \u0001 \u0003 \u021a\b \u0003 \u021c\b \u0001!\u0001"+ + "!\u0001!\u0005!\u0221\b!\n!\f!\u0224\t!\u0001\"\u0001\"\u0003\"\u0228"+ + "\b\"\u0001#\u0003#\u022b\b#\u0001#\u0003#\u022e\b#\u0001#\u0001#\u0001"+ + "#\u0003#\u0233\b#\u0001#\u0003#\u0236\b#\u0001#\u0003#\u0239\b#\u0001"+ + "$\u0001$\u0001$\u0003$\u023e\b$\u0001%\u0003%\u0241\b%\u0001%\u0003%\u0244"+ + "\b%\u0001%\u0001%\u0003%\u0248\b%\u0001&\u0001&\u0001\'\u0001\'\u0003"+ + "\'\u024e\b\'\u0001(\u0001(\u0003(\u0252\b(\u0001(\u0001(\u0003(\u0256"+ + "\b(\u0001(\u0001(\u0003(\u025a\b(\u0001)\u0001)\u0001)\u0001)\u0001)\u0001"+ + ")\u0001)\u0001*\u0001*\u0003*\u0265\b*\u0001*\u0001*\u0001+\u0001+\u0001"+ + "+\u0003+\u026c\b+\u0001+\u0001+\u0001+\u0001+\u0001,\u0003,\u0273\b,\u0001"+ + ",\u0001,\u0001,\u0003,\u0278\b,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ + ",\u0003,\u0280\b,\u0001-\u0003-\u0283\b-\u0001-\u0003-\u0286\b-\u0001"+ + "-\u0001-\u0001-\u0003-\u028b\b-\u0001-\u0003-\u028e\b-\u0001-\u0001-\u0003"+ + "-\u0292\b-\u0001.\u0001.\u0001.\u0001/\u0001/\u0001/\u0005/\u029a\b/\n"+ + "/\f/\u029d\t/\u00010\u00030\u02a0\b0\u00010\u00010\u00010\u00010\u0003"+ + "0\u02a6\b0\u00010\u00010\u00011\u00011\u00031\u02ac\b1\u00012\u00012\u0001"+ + "2\u00052\u02b1\b2\n2\f2\u02b4\t2\u00013\u00013\u00013\u00033\u02b9\b3"+ + "\u00014\u00014\u00014\u00014\u00034\u02bf\b4\u00014\u00014\u00015\u0001"+ + "5\u00045\u02c5\b5\u000b5\f5\u02c6\u00015\u00055\u02ca\b5\n5\f5\u02cd\t"+ + "5\u00016\u00016\u00016\u00016\u00016\u00017\u00047\u02d5\b7\u000b7\f7"+ + "\u02d6\u00018\u00018\u00018\u00038\u02dc\b8\u00019\u00019\u00019\u0001"+ + "9\u00019\u00019\u00039\u02e4\b9\u00019\u00019\u00019\u00059\u02e9\b9\n"+ + "9\f9\u02ec\t9\u0001:\u0001:\u0001:\u0001;\u0003;\u02f2\b;\u0001;\u0001"+ + ";\u0001<\u0003<\u02f7\b<\u0001<\u0001<\u0001=\u0001=\u0001=\u0001=\u0001"+ + "=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001"+ + "=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001"+ + "=\u0001=\u0001=\u0001=\u0001=\u0003=\u0318\b=\u0001>\u0001>\u0003>\u031c"+ + "\b>\u0001>\u0001>\u0001?\u0004?\u0321\b?\u000b?\f?\u0322\u0001@\u0001"+ + "@\u0001@\u0001@\u0003@\u0329\b@\u0001@\u0001@\u0001A\u0001A\u0001A\u0003"+ + "A\u0330\bA\u0001B\u0001B\u0003B\u0334\bB\u0001B\u0001B\u0003B\u0338\b"+ + "B\u0001B\u0001B\u0001B\u0001B\u0001C\u0001C\u0001C\u0003C\u0341\bC\u0001"+ + "C\u0001C\u0001C\u0001C\u0005C\u0347\bC\nC\fC\u034a\tC\u0001C\u0001C\u0001"+ + "D\u0001D\u0003D\u0350\bD\u0001D\u0001D\u0003D\u0354\bD\u0001E\u0001E\u0003"+ + "E\u0358\bE\u0001E\u0001E\u0003E\u035c\bE\u0001E\u0003E\u035f\bE\u0001"+ + "E\u0003E\u0362\bE\u0001E\u0003E\u0365\bE\u0001E\u0001E\u0003E\u0369\b"+ + "E\u0001E\u0001E\u0003E\u036d\bE\u0001E\u0001E\u0003E\u0371\bE\u0003E\u0373"+ + "\bE\u0001F\u0001F\u0001F\u0005F\u0378\bF\nF\fF\u037b\tF\u0001G\u0001G"+ + "\u0001G\u0003G\u0380\bG\u0001G\u0003G\u0383\bG\u0001G\u0003G\u0386\bG"+ + "\u0001G\u0001G\u0003G\u038a\bG\u0001G\u0003G\u038d\bG\u0001H\u0001H\u0001"+ + "I\u0001I\u0001I\u0003I\u0394\bI\u0001J\u0001J\u0001J\u0001J\u0001J\u0001"+ + "J\u0001J\u0003J\u039d\bJ\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001"+ + "K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001"+ + "K\u0003K\u03b0\bK\u0001K\u0001K\u0003K\u03b4\bK\u0001K\u0001K\u0003K\u03b8"+ + "\bK\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0003K\u03c2"+ + "\bK\u0001K\u0001K\u0003K\u03c6\bK\u0001K\u0001K\u0001K\u0001K\u0001K\u0001"+ + "K\u0001K\u0001K\u0001K\u0003K\u03d1\bK\u0001K\u0001K\u0001K\u0001K\u0001"+ + "K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0003K\u03de\bK\u0001K\u0001"+ + "K\u0001K\u0001K\u0003K\u03e4\bK\u0001L\u0001L\u0001M\u0001M\u0001M\u0003"+ + "M\u03eb\bM\u0001M\u0001M\u0001N\u0001N\u0001N\u0003N\u03f2\bN\u0001N\u0001"+ + "N\u0001O\u0001O\u0001O\u0003O\u03f9\bO\u0001O\u0001O\u0001P\u0001P\u0001"+ + "P\u0003P\u0400\bP\u0001P\u0001P\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001"+ + "Q\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001S\u0001S\u0003S\u0412"+ + "\bS\u0001S\u0001S\u0003S\u0416\bS\u0003S\u0418\bS\u0001S\u0001S\u0001"+ + "T\u0004T\u041d\bT\u000bT\fT\u041e\u0001U\u0001U\u0001U\u0001U\u0003U\u0425"+ + "\bU\u0001V\u0001V\u0001V\u0003V\u042a\bV\u0001W\u0001W\u0001W\u0001W\u0001"+ + "X\u0001X\u0001X\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0001Y\u0003Y\u0439"+ + "\bY\u0001Y\u0003Y\u043c\bY\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001"+ + "[\u0001[\u0001[\u0001\\\u0001\\\u0001\\\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0003]\u0452\b]\u0001^\u0003^\u0455\b^\u0001^\u0001"+ + "^\u0003^\u0459\b^\u0003^\u045b\b^\u0001^\u0003^\u045e\b^\u0001^\u0001"+ + "^\u0001^\u0003^\u0463\b^\u0001^\u0001^\u0001^\u0001_\u0003_\u0469\b_\u0001"+ + "_\u0003_\u046c\b_\u0001`\u0001`\u0005`\u0470\b`\n`\f`\u0473\t`\u0001`"+ + "\u0001`\u0001a\u0001a\u0001a\u0001b\u0001b\u0001b\u0001c\u0001c\u0003"+ + "c\u047f\bc\u0001c\u0001c\u0001c\u0003c\u0484\bc\u0001d\u0001d\u0001d\u0003"+ + "d\u0489\bd\u0001d\u0003d\u048c\bd\u0001d\u0003d\u048f\bd\u0001d\u0001"+ + "d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0003d\u049b"+ + "\bd\u0001d\u0001d\u0001d\u0003d\u04a0\bd\u0001d\u0003d\u04a3\bd\u0001"+ + "e\u0003e\u04a6\be\u0001e\u0003e\u04a9\be\u0001e\u0003e\u04ac\be\u0001"+ + "e\u0003e\u04af\be\u0001f\u0001f\u0001f\u0001g\u0003g\u04b5\bg\u0001g\u0001"+ + "g\u0001g\u0003g\u04ba\bg\u0001g\u0001g\u0001g\u0001g\u0001g\u0001h\u0001"+ + "h\u0001h\u0003h\u04c4\bh\u0001h\u0001h\u0003h\u04c8\bh\u0001h\u0001h\u0001"+ + "h\u0001h\u0001h\u0001i\u0001i\u0001i\u0001i\u0005i\u04d3\bi\ni\fi\u04d6"+ + "\ti\u0001i\u0003i\u04d9\bi\u0001i\u0001i\u0001j\u0001j\u0001j\u0001k\u0001"+ + "k\u0001k\u0001k\u0005k\u04e4\bk\nk\fk\u04e7\tk\u0001k\u0003k\u04ea\bk"+ + "\u0001k\u0001k\u0001l\u0001l\u0001l\u0001l\u0001l\u0003l\u04f3\bl\u0001"+ + "l\u0001l\u0001l\u0001l\u0001l\u0001m\u0001m\u0001m\u0005m\u04fd\bm\nm"+ + "\fm\u0500\tm\u0001m\u0001m\u0003m\u0504\bm\u0001m\u0001m\u0001m\u0001"+ + "m\u0001m\u0003m\u050b\bm\u0003m\u050d\bm\u0001n\u0003n\u0510\bn\u0001"+ + "n\u0003n\u0513\bn\u0001n\u0001n\u0003n\u0517\bn\u0001n\u0003n\u051a\b"+ + "n\u0001n\u0001n\u0003n\u051e\bn\u0001o\u0001o\u0001o\u0003o\u0523\bo\u0001"+ + "p\u0003p\u0526\bp\u0001q\u0004q\u0529\bq\u000bq\fq\u052a\u0001r\u0001"+ + "r\u0003r\u052f\br\u0001r\u0001r\u0001s\u0001s\u0004s\u0535\bs\u000bs\f"+ + "s\u0536\u0001s\u0005s\u053a\bs\ns\fs\u053d\ts\u0001t\u0003t\u0540\bt\u0001"+ + "t\u0001t\u0003t\u0544\bt\u0001t\u0003t\u0547\bt\u0001u\u0001u\u0001u\u0001"+ + "u\u0005u\u054d\bu\nu\fu\u0550\tu\u0001u\u0003u\u0553\bu\u0003u\u0555\b"+ + "u\u0001u\u0001u\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0001"+ + "v\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0003v\u0568\bv\u0001"+ + "w\u0001w\u0001w\u0001w\u0003w\u056e\bw\u0001w\u0001w\u0001w\u0001w\u0001"+ + "x\u0001x\u0001x\u0001x\u0003x\u0578\bx\u0001x\u0003x\u057b\bx\u0001x\u0001"+ + "x\u0001x\u0001x\u0001x\u0001y\u0001y\u0001y\u0003y\u0585\by\u0001z\u0001"+ + "z\u0001z\u0003z\u058a\bz\u0003z\u058c\bz\u0001z\u0001z\u0001{\u0001{\u0001"+ + "{\u0005{\u0593\b{\n{\f{\u0596\t{\u0001|\u0003|\u0599\b|\u0001|\u0001|"+ + "\u0003|\u059d\b|\u0001}\u0001}\u0001}\u0005}\u05a2\b}\n}\f}\u05a5\t}\u0001"+ + "~\u0001~\u0003~\u05a9\b~\u0001~\u0001~\u0003~\u05ad\b~\u0001~\u0001~\u0003"+ + "~\u05b1\b~\u0001~\u0001~\u0001~\u0001~\u0001\u007f\u0001\u007f\u0001\u007f"+ + "\u0001\u007f\u0001\u007f\u0001\u007f\u0003\u007f\u05bd\b\u007f\u0001\u007f"+ + "\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0003\u007f\u05c4\b\u007f"+ + "\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f"+ + "\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f"+ + "\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f"+ + "\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f"+ + "\u0001\u007f\u0003\u007f\u05df\b\u007f\u0001\u007f\u0001\u007f\u0001\u007f"+ + "\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f"+ + "\u0001\u007f\u0003\u007f\u05eb\b\u007f\u0003\u007f\u05ed\b\u007f\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0001\u007f\u0003\u007f\u0627\b\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0003\u007f\u062c\b\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0005\u007f\u063b\b\u007f\n"+ + "\u007f\f\u007f\u063e\t\u007f\u0001\u0080\u0001\u0080\u0001\u0080\u0003"+ + "\u0080\u0643\b\u0080\u0001\u0080\u0003\u0080\u0646\b\u0080\u0001\u0081"+ + "\u0003\u0081\u0649\b\u0081\u0001\u0081\u0001\u0081\u0003\u0081\u064d\b"+ + "\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0082\u0001\u0082\u0001"+ + "\u0082\u0003\u0082\u0655\b\u0082\u0001\u0082\u0003\u0082\u0658\b\u0082"+ + "\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0003\u0083"+ + "\u065f\b\u0083\u0001\u0084\u0001\u0084\u0001\u0085\u0001\u0085\u0001\u0085"+ + "\u0001\u0085\u0001\u0085\u0001\u0085\u0003\u0085\u0669\b\u0085\u0001\u0086"+ + "\u0001\u0086\u0005\u0086\u066d\b\u0086\n\u0086\f\u0086\u0670\t\u0086\u0001"+ + "\u0086\u0001\u0086\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0001"+ + "\u0087\u0001\u0087\u0003\u0087\u067a\b\u0087\u0001\u0088\u0001\u0088\u0001"+ + "\u0089\u0001\u0089\u0003\u0089\u0680\b\u0089\u0001\u008a\u0001\u008a\u0001"+ + "\u008b\u0001\u008b\u0001\u008b\u0003\u008b\u0687\b\u008b\u0001\u008c\u0001"+ + "\u008c\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008e\u0001\u008e\u0001"+ + "\u008e\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0003\u008f\u0695"+ + "\b\u008f\u0001\u008f\u0000\u0004\u0014\u0016r\u00fe\u0090\u0000\u0002"+ + "\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e"+ + " \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086"+ + "\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e"+ + "\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6"+ + "\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce"+ + "\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6"+ + "\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe"+ + "\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116"+ + "\u0118\u011a\u011c\u011e\u0000\u000f\u0002\u0000IIlp\u0001\u0000\u000b"+ + "\f\u0002\u0000efii\u0002\u0000mmoo\u0003\u0000EE``dd\u0002\u0000\r\r\u000f"+ + "\u000f\u0001\u0000\u0018\u001a\u0001\u0000\u0014\u0015\u0001\u0000\u001b"+ + "\u001d\u0001\u0000\u001e!\u0001\u0000\"%\u0001\u0000+5\u0001\u00009=\u0003"+ + "\u0000qqvv||\u0005\u0000>WYkmoqsvw\u0747\u0000\u0120\u0001\u0000\u0000"+ + "\u0000\u0002\u0125\u0001\u0000\u0000\u0000\u0004\u0127\u0001\u0000\u0000"+ + "\u0000\u0006\u012d\u0001\u0000\u0000\u0000\b\u013a\u0001\u0000\u0000\u0000"+ + "\n\u013c\u0001\u0000\u0000\u0000\f\u013f\u0001\u0000\u0000\u0000\u000e"+ + "\u0145\u0001\u0000\u0000\u0000\u0010\u014d\u0001\u0000\u0000\u0000\u0012"+ + "\u0154\u0001\u0000\u0000\u0000\u0014\u0156\u0001\u0000\u0000\u0000\u0016"+ + "\u0176\u0001\u0000\u0000\u0000\u0018\u0181\u0001\u0000\u0000\u0000\u001a"+ + "\u0183\u0001\u0000\u0000\u0000\u001c\u0189\u0001\u0000\u0000\u0000\u001e"+ + "\u018b\u0001\u0000\u0000\u0000 \u018f\u0001\u0000\u0000\u0000\"\u019c"+ + "\u0001\u0000\u0000\u0000$\u019e\u0001\u0000\u0000\u0000&\u01a4\u0001\u0000"+ + "\u0000\u0000(\u01a8\u0001\u0000\u0000\u0000*\u01b9\u0001\u0000\u0000\u0000"+ + ",\u01bb\u0001\u0000\u0000\u0000.\u01c0\u0001\u0000\u0000\u00000\u01c4"+ + "\u0001\u0000\u0000\u00002\u01cd\u0001\u0000\u0000\u00004\u01d7\u0001\u0000"+ + "\u0000\u00006\u01e3\u0001\u0000\u0000\u00008\u01f0\u0001\u0000\u0000\u0000"+ + ":\u01f3\u0001\u0000\u0000\u0000<\u0200\u0001\u0000\u0000\u0000>\u0204"+ + "\u0001\u0000\u0000\u0000@\u021b\u0001\u0000\u0000\u0000B\u021d\u0001\u0000"+ + "\u0000\u0000D\u0227\u0001\u0000\u0000\u0000F\u022a\u0001\u0000\u0000\u0000"+ + "H\u023a\u0001\u0000\u0000\u0000J\u0240\u0001\u0000\u0000\u0000L\u0249"+ + "\u0001\u0000\u0000\u0000N\u024d\u0001\u0000\u0000\u0000P\u024f\u0001\u0000"+ + "\u0000\u0000R\u025b\u0001\u0000\u0000\u0000T\u0262\u0001\u0000\u0000\u0000"+ + "V\u0268\u0001\u0000\u0000\u0000X\u0272\u0001\u0000\u0000\u0000Z\u0282"+ + "\u0001\u0000\u0000\u0000\\\u0293\u0001\u0000\u0000\u0000^\u0296\u0001"+ + "\u0000\u0000\u0000`\u029f\u0001\u0000\u0000\u0000b\u02a9\u0001\u0000\u0000"+ + "\u0000d\u02ad\u0001\u0000\u0000\u0000f\u02b5\u0001\u0000\u0000\u0000h"+ + "\u02ba\u0001\u0000\u0000\u0000j\u02c2\u0001\u0000\u0000\u0000l\u02ce\u0001"+ + "\u0000\u0000\u0000n\u02d4\u0001\u0000\u0000\u0000p\u02d8\u0001\u0000\u0000"+ + "\u0000r\u02e3\u0001\u0000\u0000\u0000t\u02ed\u0001\u0000\u0000\u0000v"+ + "\u02f1\u0001\u0000\u0000\u0000x\u02f6\u0001\u0000\u0000\u0000z\u0317\u0001"+ + "\u0000\u0000\u0000|\u0319\u0001\u0000\u0000\u0000~\u0320\u0001\u0000\u0000"+ + "\u0000\u0080\u0324\u0001\u0000\u0000\u0000\u0082\u032c\u0001\u0000\u0000"+ + "\u0000\u0084\u0333\u0001\u0000\u0000\u0000\u0086\u0340\u0001\u0000\u0000"+ + "\u0000\u0088\u034d\u0001\u0000\u0000\u0000\u008a\u0372\u0001\u0000\u0000"+ + "\u0000\u008c\u0374\u0001\u0000\u0000\u0000\u008e\u037f\u0001\u0000\u0000"+ + "\u0000\u0090\u038e\u0001\u0000\u0000\u0000\u0092\u0390\u0001\u0000\u0000"+ + "\u0000\u0094\u0395\u0001\u0000\u0000\u0000\u0096\u03e3\u0001\u0000\u0000"+ + "\u0000\u0098\u03e5\u0001\u0000\u0000\u0000\u009a\u03e7\u0001\u0000\u0000"+ + "\u0000\u009c\u03ee\u0001\u0000\u0000\u0000\u009e\u03f5\u0001\u0000\u0000"+ + "\u0000\u00a0\u03fc\u0001\u0000\u0000\u0000\u00a2\u0403\u0001\u0000\u0000"+ + "\u0000\u00a4\u0409\u0001\u0000\u0000\u0000\u00a6\u040f\u0001\u0000\u0000"+ + "\u0000\u00a8\u041c\u0001\u0000\u0000\u0000\u00aa\u0420\u0001\u0000\u0000"+ + "\u0000\u00ac\u0426\u0001\u0000\u0000\u0000\u00ae\u042b\u0001\u0000\u0000"+ + "\u0000\u00b0\u042f\u0001\u0000\u0000\u0000\u00b2\u0434\u0001\u0000\u0000"+ + "\u0000\u00b4\u043d\u0001\u0000\u0000\u0000\u00b6\u0443\u0001\u0000\u0000"+ + "\u0000\u00b8\u0446\u0001\u0000\u0000\u0000\u00ba\u0449\u0001\u0000\u0000"+ + "\u0000\u00bc\u0454\u0001\u0000\u0000\u0000\u00be\u0468\u0001\u0000\u0000"+ + "\u0000\u00c0\u046d\u0001\u0000\u0000\u0000\u00c2\u0476\u0001\u0000\u0000"+ + "\u0000\u00c4\u0479\u0001\u0000\u0000\u0000\u00c6\u0483\u0001\u0000\u0000"+ + "\u0000\u00c8\u04a2\u0001\u0000\u0000\u0000\u00ca\u04a5\u0001\u0000\u0000"+ + "\u0000\u00cc\u04b0\u0001\u0000\u0000\u0000\u00ce\u04b4\u0001\u0000\u0000"+ + "\u0000\u00d0\u04c0\u0001\u0000\u0000\u0000\u00d2\u04ce\u0001\u0000\u0000"+ + "\u0000\u00d4\u04dc\u0001\u0000\u0000\u0000\u00d6\u04df\u0001\u0000\u0000"+ + "\u0000\u00d8\u04ed\u0001\u0000\u0000\u0000\u00da\u050c\u0001\u0000\u0000"+ + "\u0000\u00dc\u050f\u0001\u0000\u0000\u0000\u00de\u051f\u0001\u0000\u0000"+ + "\u0000\u00e0\u0525\u0001\u0000\u0000\u0000\u00e2\u0528\u0001\u0000\u0000"+ + "\u0000\u00e4\u052c\u0001\u0000\u0000\u0000\u00e6\u0532\u0001\u0000\u0000"+ + "\u0000\u00e8\u053f\u0001\u0000\u0000\u0000\u00ea\u0548\u0001\u0000\u0000"+ + "\u0000\u00ec\u0567\u0001\u0000\u0000\u0000\u00ee\u0569\u0001\u0000\u0000"+ + "\u0000\u00f0\u0573\u0001\u0000\u0000\u0000\u00f2\u0584\u0001\u0000\u0000"+ + "\u0000\u00f4\u0586\u0001\u0000\u0000\u0000\u00f6\u058f\u0001\u0000\u0000"+ + "\u0000\u00f8\u0598\u0001\u0000\u0000\u0000\u00fa\u059e\u0001\u0000\u0000"+ + "\u0000\u00fc\u05a6\u0001\u0000\u0000\u0000\u00fe\u05ec\u0001\u0000\u0000"+ + "\u0000\u0100\u0645\u0001\u0000\u0000\u0000\u0102\u0648\u0001\u0000\u0000"+ + "\u0000\u0104\u0657\u0001\u0000\u0000\u0000\u0106\u065e\u0001\u0000\u0000"+ + "\u0000\u0108\u0660\u0001\u0000\u0000\u0000\u010a\u0668\u0001\u0000\u0000"+ + "\u0000\u010c\u066a\u0001\u0000\u0000\u0000\u010e\u0679\u0001\u0000\u0000"+ + "\u0000\u0110\u067b\u0001\u0000\u0000\u0000\u0112\u067f\u0001\u0000\u0000"+ + "\u0000\u0114\u0681\u0001\u0000\u0000\u0000\u0116\u0686\u0001\u0000\u0000"+ + "\u0000\u0118\u0688\u0001\u0000\u0000\u0000\u011a\u068a\u0001\u0000\u0000"+ + "\u0000\u011c\u068d\u0001\u0000\u0000\u0000\u011e\u0694\u0001\u0000\u0000"+ + "\u0000\u0120\u0121\u0005\r\u0000\u0000\u0121\u0122\u0003\u00fe\u007f\u0000"+ + "\u0122\u0001\u0001\u0000\u0000\u0000\u0123\u0126\u0003\u00e4r\u0000\u0124"+ + "\u0126\u0003\u00eau\u0000\u0125\u0123\u0001\u0000\u0000\u0000\u0125\u0124"+ + "\u0001\u0000\u0000\u0000\u0126\u0003\u0001\u0000\u0000\u0000\u0127\u0129"+ + "\u0005\u001e\u0000\u0000\u0128\u012a\u0003\u0006\u0003\u0000\u0129\u0128"+ + "\u0001\u0000\u0000\u0000\u0129\u012a\u0001\u0000\u0000\u0000\u012a\u012b"+ + "\u0001\u0000\u0000\u0000\u012b\u012c\u0005\u001f\u0000\u0000\u012c\u0005"+ + "\u0001\u0000\u0000\u0000\u012d\u0132\u0003\b\u0004\u0000\u012e\u012f\u0005"+ + "\f\u0000\u0000\u012f\u0131\u0003\b\u0004\u0000\u0130\u012e\u0001\u0000"+ + "\u0000\u0000\u0131\u0134\u0001\u0000\u0000\u0000\u0132\u0130\u0001\u0000"+ + "\u0000\u0000\u0132\u0133\u0001\u0000\u0000\u0000\u0133\u0007\u0001\u0000"+ + "\u0000\u0000\u0134\u0132\u0001\u0000\u0000\u0000\u0135\u0137\u0005|\u0000"+ + "\u0000\u0136\u0138\u0003\n\u0005\u0000\u0137\u0136\u0001\u0000\u0000\u0000"+ + "\u0137\u0138\u0001\u0000\u0000\u0000\u0138\u013b\u0001\u0000\u0000\u0000"+ + "\u0139\u013b\u0003\u0004\u0002\u0000\u013a\u0135\u0001\u0000\u0000\u0000"+ + "\u013a\u0139\u0001\u0000\u0000\u0000\u013b\t\u0001\u0000\u0000\u0000\u013c"+ + "\u013d\u0005^\u0000\u0000\u013d\u013e\u0003\u0012\t\u0000\u013e\u000b"+ + "\u0001\u0000\u0000\u0000\u013f\u0141\u0005\u001e\u0000\u0000\u0140\u0142"+ + "\u0003\u000e\u0007\u0000\u0141\u0140\u0001\u0000\u0000\u0000\u0141\u0142"+ + "\u0001\u0000\u0000\u0000\u0142\u0143\u0001\u0000\u0000\u0000\u0143\u0144"+ + "\u0005\u001f\u0000\u0000\u0144\r\u0001\u0000\u0000\u0000\u0145\u014a\u0003"+ + "\u0010\b\u0000\u0146\u0147\u0005\f\u0000\u0000\u0147\u0149\u0003\u0010"+ + "\b\u0000\u0148\u0146\u0001\u0000\u0000\u0000\u0149\u014c\u0001\u0000\u0000"+ + "\u0000\u014a\u0148\u0001\u0000\u0000\u0000\u014a\u014b\u0001\u0000\u0000"+ + "\u0000\u014b\u000f\u0001\u0000\u0000\u0000\u014c\u014a\u0001\u0000\u0000"+ + "\u0000\u014d\u014e\u0003\u0012\t\u0000\u014e\u0011\u0001\u0000\u0000\u0000"+ + "\u014f\u0155\u0003\u0014\n\u0000\u0150\u0155\u00032\u0019\u0000\u0151"+ + "\u0155\u00034\u001a\u0000\u0152\u0155\u0003\u001e\u000f\u0000\u0153\u0155"+ + "\u0005}\u0000\u0000\u0154\u014f\u0001\u0000\u0000\u0000\u0154\u0150\u0001"+ + "\u0000\u0000\u0000\u0154\u0151\u0001\u0000\u0000\u0000\u0154\u0152\u0001"+ + "\u0000\u0000\u0000\u0154\u0153\u0001\u0000\u0000\u0000\u0155\u0013\u0001"+ + "\u0000\u0000\u0000\u0156\u0157\u0006\n\uffff\uffff\u0000\u0157\u0158\u0003"+ + "\u0016\u000b\u0000\u0158\u0161\u0001\u0000\u0000\u0000\u0159\u015a\n\u0003"+ + "\u0000\u0000\u015a\u015b\u0005(\u0000\u0000\u015b\u0160\u0003\u0014\n"+ + "\u0004\u015c\u015d\n\u0002\u0000\u0000\u015d\u015e\u0005&\u0000\u0000"+ + "\u015e\u0160\u0003\u0014\n\u0003\u015f\u0159\u0001\u0000\u0000\u0000\u015f"+ + "\u015c\u0001\u0000\u0000\u0000\u0160\u0163\u0001\u0000\u0000\u0000\u0161"+ + "\u015f\u0001\u0000\u0000\u0000\u0161\u0162\u0001\u0000\u0000\u0000\u0162"+ + "\u0015\u0001\u0000\u0000\u0000\u0163\u0161\u0001\u0000\u0000\u0000\u0164"+ + "\u0165\u0006\u000b\uffff\uffff\u0000\u0165\u0166\u0005\u0006\u0000\u0000"+ + "\u0166\u0167\u0003\u0012\t\u0000\u0167\u0168\u0005\u0007\u0000\u0000\u0168"+ + "\u0177\u0001\u0000\u0000\u0000\u0169\u0177\u0003\u0018\f\u0000\u016a\u0177"+ + "\u0003\u001a\r\u0000\u016b\u0177\u0003$\u0012\u0000\u016c\u016d\u0005"+ + "\u0004\u0000\u0000\u016d\u016e\u00030\u0018\u0000\u016e\u016f\u0005\u0005"+ + "\u0000\u0000\u016f\u0177\u0001\u0000\u0000\u0000\u0170\u0177\u00036\u001b"+ + "\u0000\u0171\u0177\u0005P\u0000\u0000\u0172\u0173\u0003\u001a\r\u0000"+ + "\u0173\u0174\u0005z\u0000\u0000\u0174\u0175\u0003\u0016\u000b\u0001\u0175"+ + "\u0177\u0001\u0000\u0000\u0000\u0176\u0164\u0001\u0000\u0000\u0000\u0176"+ + "\u0169\u0001\u0000\u0000\u0000\u0176\u016a\u0001\u0000\u0000\u0000\u0176"+ + "\u016b\u0001\u0000\u0000\u0000\u0176\u016c\u0001\u0000\u0000\u0000\u0176"+ + "\u0170\u0001\u0000\u0000\u0000\u0176\u0171\u0001\u0000\u0000\u0000\u0176"+ + "\u0172\u0001\u0000\u0000\u0000\u0177\u017e\u0001\u0000\u0000\u0000\u0178"+ + "\u0179\n\u0005\u0000\u0000\u0179\u017a\u0004\u000b\u0003\u0000\u017a\u017b"+ + "\u0005\u0004\u0000\u0000\u017b\u017d\u0005\u0005\u0000\u0000\u017c\u0178"+ + "\u0001\u0000\u0000\u0000\u017d\u0180\u0001\u0000\u0000\u0000\u017e\u017c"+ + "\u0001\u0000\u0000\u0000\u017e\u017f\u0001\u0000\u0000\u0000\u017f\u0017"+ + "\u0001\u0000\u0000\u0000\u0180\u017e\u0001\u0000\u0000\u0000\u0181\u0182"+ + "\u0007\u0000\u0000\u0000\u0182\u0019\u0001\u0000\u0000\u0000\u0183\u0185"+ + "\u0003\"\u0011\u0000\u0184\u0186\u0003\u001c\u000e\u0000\u0185\u0184\u0001"+ + "\u0000\u0000\u0000\u0185\u0186\u0001\u0000\u0000\u0000\u0186\u001b\u0001"+ + "\u0000\u0000\u0000\u0187\u018a\u0003 \u0010\u0000\u0188\u018a\u0003\u001e"+ + "\u000f\u0000\u0189\u0187\u0001\u0000\u0000\u0000\u0189\u0188\u0001\u0000"+ + "\u0000\u0000\u018a\u001d\u0001\u0000\u0000\u0000\u018b\u018c\u0005\u001e"+ + "\u0000\u0000\u018c\u018d\u0003\u000e\u0007\u0000\u018d\u018e\u0005\u001f"+ + "\u0000\u0000\u018e\u001f\u0001\u0000\u0000\u0000\u018f\u0190\u0005\u001e"+ + "\u0000\u0000\u0190\u0191\u0003\u000e\u0007\u0000\u0191\u0192\u0005\u001e"+ + "\u0000\u0000\u0192\u0198\u0003\u000e\u0007\u0000\u0193\u0194\u0005\u001f"+ + "\u0000\u0000\u0194\u0195\u0003\u0002\u0001\u0000\u0195\u0196\u0005\u001f"+ + "\u0000\u0000\u0196\u0199\u0001\u0000\u0000\u0000\u0197\u0199\u0005\u001b"+ + "\u0000\u0000\u0198\u0193\u0001\u0000\u0000\u0000\u0198\u0197\u0001\u0000"+ + "\u0000\u0000\u0199!\u0001\u0000\u0000\u0000\u019a\u019d\u0005|\u0000\u0000"+ + "\u019b\u019d\u0003j5\u0000\u019c\u019a\u0001\u0000\u0000\u0000\u019c\u019b"+ + "\u0001\u0000\u0000\u0000\u019d#\u0001\u0000\u0000\u0000\u019e\u01a0\u0005"+ + "\b\u0000\u0000\u019f\u01a1\u0003&\u0013\u0000\u01a0\u019f\u0001\u0000"+ + "\u0000\u0000\u01a0\u01a1\u0001\u0000\u0000\u0000\u01a1\u01a2\u0001\u0000"+ + "\u0000\u0000\u01a2\u01a3\u0005\n\u0000\u0000\u01a3%\u0001\u0000\u0000"+ + "\u0000\u01a4\u01a6\u0003(\u0014\u0000\u01a5\u01a7\u0007\u0001\u0000\u0000"+ + "\u01a6\u01a5\u0001\u0000\u0000\u0000\u01a6\u01a7\u0001\u0000\u0000\u0000"+ + "\u01a7\'\u0001\u0000\u0000\u0000\u01a8\u01ad\u0003*\u0015\u0000\u01a9"+ + "\u01aa\u0007\u0001\u0000\u0000\u01aa\u01ac\u0003*\u0015\u0000\u01ab\u01a9"+ + "\u0001\u0000\u0000\u0000\u01ac\u01af\u0001\u0000\u0000\u0000\u01ad\u01ab"+ + "\u0001\u0000\u0000\u0000\u01ad\u01ae\u0001\u0000\u0000\u0000\u01ae)\u0001"+ + "\u0000\u0000\u0000\u01af\u01ad\u0001\u0000\u0000\u0000\u01b0\u01ba\u0003"+ + ":\u001d\u0000\u01b1\u01ba\u0003>\u001f\u0000\u01b2\u01ba\u0003P(\u0000"+ + "\u01b3\u01ba\u0003R)\u0000\u01b4\u01b7\u0003T*\u0000\u01b5\u01b6\u0005"+ + "6\u0000\u0000\u01b6\u01b8\u0003\u0012\t\u0000\u01b7\u01b5\u0001\u0000"+ + "\u0000\u0000\u01b7\u01b8\u0001\u0000\u0000\u0000\u01b8\u01ba\u0001\u0000"+ + "\u0000\u0000\u01b9\u01b0\u0001\u0000\u0000\u0000\u01b9\u01b1\u0001\u0000"+ + "\u0000\u0000\u01b9\u01b2\u0001\u0000\u0000\u0000\u01b9\u01b3\u0001\u0000"+ + "\u0000\u0000\u01b9\u01b4\u0001\u0000\u0000\u0000\u01ba+\u0001\u0000\u0000"+ + "\u0000\u01bb\u01bc\u0003\u0016\u000b\u0000\u01bc\u01bd\u0004\u0016\u0004"+ + "\u0000\u01bd\u01be\u0005\u0004\u0000\u0000\u01be\u01bf\u0005\u0005\u0000"+ + "\u0000\u01bf-\u0001\u0000\u0000\u0000\u01c0\u01c1\u0005\u0004\u0000\u0000"+ + "\u01c1\u01c2\u00030\u0018\u0000\u01c2\u01c3\u0005\u0005\u0000\u0000\u01c3"+ + "/\u0001\u0000\u0000\u0000\u01c4\u01c9\u0003\u0012\t\u0000\u01c5\u01c6"+ + "\u0005\f\u0000\u0000\u01c6\u01c8\u0003\u0012\t\u0000\u01c7\u01c5\u0001"+ + "\u0000\u0000\u0000\u01c8\u01cb\u0001\u0000\u0000\u0000\u01c9\u01c7\u0001"+ + "\u0000\u0000\u0000\u01c9\u01ca\u0001\u0000\u0000\u0000\u01ca1\u0001\u0000"+ + "\u0000\u0000\u01cb\u01c9\u0001\u0000\u0000\u0000\u01cc\u01ce\u0003\u0004"+ + "\u0002\u0000\u01cd\u01cc\u0001\u0000\u0000\u0000\u01cd\u01ce\u0001\u0000"+ + "\u0000\u0000\u01ce\u01cf\u0001\u0000\u0000\u0000\u01cf\u01d1\u0005\u0006"+ + "\u0000\u0000\u01d0\u01d2\u0003@ \u0000\u01d1\u01d0\u0001\u0000\u0000\u0000"+ + "\u01d1\u01d2\u0001\u0000\u0000\u0000\u01d2\u01d3\u0001\u0000\u0000\u0000"+ + "\u01d3\u01d4\u0005\u0007\u0000\u0000\u01d4\u01d5\u00056\u0000\u0000\u01d5"+ + "\u01d6\u0003\u0012\t\u0000\u01d63\u0001\u0000\u0000\u0000\u01d7\u01d9"+ + "\u0005D\u0000\u0000\u01d8\u01da\u0003\u0004\u0002\u0000\u01d9\u01d8\u0001"+ + "\u0000\u0000\u0000\u01d9\u01da\u0001\u0000\u0000\u0000\u01da\u01db\u0001"+ + "\u0000\u0000\u0000\u01db\u01dd\u0005\u0006\u0000\u0000\u01dc\u01de\u0003"+ + "@ \u0000\u01dd\u01dc\u0001\u0000\u0000\u0000\u01dd\u01de\u0001\u0000\u0000"+ + "\u0000\u01de\u01df\u0001\u0000\u0000\u0000\u01df\u01e0\u0005\u0007\u0000"+ + "\u0000\u01e0\u01e1\u00056\u0000\u0000\u01e1\u01e2\u0003\u0012\t\u0000"+ + "\u01e25\u0001\u0000\u0000\u0000\u01e3\u01e4\u0005A\u0000\u0000\u01e4\u01e5"+ + "\u00038\u001c\u0000\u01e57\u0001\u0000\u0000\u0000\u01e6\u01f1\u0005|"+ + "\u0000\u0000\u01e7\u01e8\u0003\u0112\u0089\u0000\u01e8\u01e9\u0005\u0011"+ + "\u0000\u0000\u01e9\u01eb\u0001\u0000\u0000\u0000\u01ea\u01e7\u0001\u0000"+ + "\u0000\u0000\u01eb\u01ec\u0001\u0000\u0000\u0000\u01ec\u01ea\u0001\u0000"+ + "\u0000\u0000\u01ec\u01ed\u0001\u0000\u0000\u0000\u01ed\u01ee\u0001\u0000"+ + "\u0000\u0000\u01ee\u01ef\u0003\u0112\u0089\u0000\u01ef\u01f1\u0001\u0000"+ + "\u0000\u0000\u01f0\u01e6\u0001\u0000\u0000\u0000\u01f0\u01ea\u0001\u0000"+ + "\u0000\u0000\u01f19\u0001\u0000\u0000\u0000\u01f2\u01f4\u0005Z\u0000\u0000"+ + "\u01f3\u01f2\u0001\u0000\u0000\u0000\u01f3\u01f4\u0001\u0000\u0000\u0000"+ + "\u01f4\u01f5\u0001\u0000\u0000\u0000\u01f5\u01f7\u0003\u00f2y\u0000\u01f6"+ + "\u01f8\u0005\u000e\u0000\u0000\u01f7\u01f6\u0001\u0000\u0000\u0000\u01f7"+ + "\u01f8\u0001\u0000\u0000\u0000\u01f8\u01fa\u0001\u0000\u0000\u0000\u01f9"+ + "\u01fb\u0003<\u001e\u0000\u01fa\u01f9\u0001\u0000\u0000\u0000\u01fa\u01fb"+ + "\u0001\u0000\u0000\u0000\u01fb\u01fe\u0001\u0000\u0000\u0000\u01fc\u01fd"+ + "\u00056\u0000\u0000\u01fd\u01ff\u0003\u0012\t\u0000\u01fe\u01fc\u0001"+ + "\u0000\u0000\u0000\u01fe\u01ff\u0001\u0000\u0000\u0000\u01ff;\u0001\u0000"+ + "\u0000\u0000\u0200\u0201\u0005\u000f\u0000\u0000\u0201\u0202\u0003\u0012"+ + "\t\u0000\u0202=\u0001\u0000\u0000\u0000\u0203\u0205\u0003\u0004\u0002"+ + "\u0000\u0204\u0203\u0001\u0000\u0000\u0000\u0204\u0205\u0001\u0000\u0000"+ + "\u0000\u0205\u0206\u0001\u0000\u0000\u0000\u0206\u0208\u0005\u0006\u0000"+ + "\u0000\u0207\u0209\u0003@ \u0000\u0208\u0207\u0001\u0000\u0000\u0000\u0208"+ + "\u0209\u0001\u0000\u0000\u0000\u0209\u020a\u0001\u0000\u0000\u0000\u020a"+ + "\u020c\u0005\u0007\u0000\u0000\u020b\u020d\u0003<\u001e\u0000\u020c\u020b"+ + "\u0001\u0000\u0000\u0000\u020c\u020d\u0001\u0000\u0000\u0000\u020d?\u0001"+ + "\u0000\u0000\u0000\u020e\u021c\u0003H$\u0000\u020f\u0214\u0003D\"\u0000"+ + "\u0210\u0211\u0005\f\u0000\u0000\u0211\u0213\u0003D\"\u0000\u0212\u0210"+ + "\u0001\u0000\u0000\u0000\u0213\u0216\u0001\u0000\u0000\u0000\u0214\u0212"+ + "\u0001\u0000\u0000\u0000\u0214\u0215\u0001\u0000\u0000\u0000\u0215\u0219"+ + "\u0001\u0000\u0000\u0000\u0216\u0214\u0001\u0000\u0000\u0000\u0217\u0218"+ + "\u0005\f\u0000\u0000\u0218\u021a\u0003H$\u0000\u0219\u0217\u0001\u0000"+ + "\u0000\u0000\u0219\u021a\u0001\u0000\u0000\u0000\u021a\u021c\u0001\u0000"+ + "\u0000\u0000\u021b\u020e\u0001\u0000\u0000\u0000\u021b\u020f\u0001\u0000"+ + "\u0000\u0000\u021cA\u0001\u0000\u0000\u0000\u021d\u0222\u0003J%\u0000"+ + "\u021e\u021f\u0005\f\u0000\u0000\u021f\u0221\u0003J%\u0000\u0220\u021e"+ + "\u0001\u0000\u0000\u0000\u0221\u0224\u0001\u0000\u0000\u0000\u0222\u0220"+ + "\u0001\u0000\u0000\u0000\u0222\u0223\u0001\u0000\u0000\u0000\u0223C\u0001"+ + "\u0000\u0000\u0000\u0224\u0222\u0001\u0000\u0000\u0000\u0225\u0228\u0003"+ + "J%\u0000\u0226\u0228\u0003F#\u0000\u0227\u0225\u0001\u0000\u0000\u0000"+ + "\u0227\u0226\u0001\u0000\u0000\u0000\u0228E\u0001\u0000\u0000\u0000\u0229"+ + "\u022b\u0003n7\u0000\u022a\u0229\u0001\u0000\u0000\u0000\u022a\u022b\u0001"+ + "\u0000\u0000\u0000\u022b\u022d\u0001\u0000\u0000\u0000\u022c\u022e\u0003"+ + "L&\u0000\u022d\u022c\u0001\u0000\u0000\u0000\u022d\u022e\u0001\u0000\u0000"+ + "\u0000\u022e\u022f\u0001\u0000\u0000\u0000\u022f\u0238\u0003N\'\u0000"+ + "\u0230\u0232\u0005\u000e\u0000\u0000\u0231\u0233\u0003<\u001e\u0000\u0232"+ + "\u0231\u0001\u0000\u0000\u0000\u0232\u0233\u0001\u0000\u0000\u0000\u0233"+ + "\u0239\u0001\u0000\u0000\u0000\u0234\u0236\u0003<\u001e\u0000\u0235\u0234"+ + "\u0001\u0000\u0000\u0000\u0235\u0236\u0001\u0000\u0000\u0000\u0236\u0237"+ + "\u0001\u0000\u0000\u0000\u0237\u0239\u0003\u0000\u0000\u0000\u0238\u0230"+ + "\u0001\u0000\u0000\u0000\u0238\u0235\u0001\u0000\u0000\u0000\u0239G\u0001"+ + "\u0000\u0000\u0000\u023a\u023b\u0005\u0010\u0000\u0000\u023b\u023d\u0003"+ + "\u00fe\u007f\u0000\u023c\u023e\u0003<\u001e\u0000\u023d\u023c\u0001\u0000"+ + "\u0000\u0000\u023d\u023e\u0001\u0000\u0000\u0000\u023eI\u0001\u0000\u0000"+ + "\u0000\u023f\u0241\u0003n7\u0000\u0240\u023f\u0001\u0000\u0000\u0000\u0240"+ + "\u0241\u0001\u0000\u0000\u0000\u0241\u0243\u0001\u0000\u0000\u0000\u0242"+ + "\u0244\u0003L&\u0000\u0243\u0242\u0001\u0000\u0000\u0000\u0243\u0244\u0001"+ + "\u0000\u0000\u0000\u0244\u0245\u0001\u0000\u0000\u0000\u0245\u0247\u0003"+ + "N\'\u0000\u0246\u0248\u0003<\u001e\u0000\u0247\u0246\u0001\u0000\u0000"+ + "\u0000\u0247\u0248\u0001\u0000\u0000\u0000\u0248K\u0001\u0000\u0000\u0000"+ + "\u0249\u024a\u0007\u0002\u0000\u0000\u024aM\u0001\u0000\u0000\u0000\u024b"+ + "\u024e\u0003\u0112\u0089\u0000\u024c\u024e\u0003\u0002\u0001\u0000\u024d"+ + "\u024b\u0001\u0000\u0000\u0000\u024d\u024c\u0001\u0000\u0000\u0000\u024e"+ + "O\u0001\u0000\u0000\u0000\u024f\u0251\u0005D\u0000\u0000\u0250\u0252\u0003"+ + "\u0004\u0002\u0000\u0251\u0250\u0001\u0000\u0000\u0000\u0251\u0252\u0001"+ + "\u0000\u0000\u0000\u0252\u0253\u0001\u0000\u0000\u0000\u0253\u0255\u0005"+ + "\u0006\u0000\u0000\u0254\u0256\u0003@ \u0000\u0255\u0254\u0001\u0000\u0000"+ + "\u0000\u0255\u0256\u0001\u0000\u0000\u0000\u0256\u0257\u0001\u0000\u0000"+ + "\u0000\u0257\u0259\u0005\u0007\u0000\u0000\u0258\u025a\u0003<\u001e\u0000"+ + "\u0259\u0258\u0001\u0000\u0000\u0000\u0259\u025a\u0001\u0000\u0000\u0000"+ + "\u025aQ\u0001\u0000\u0000\u0000\u025b\u025c\u0005\u0004\u0000\u0000\u025c"+ + "\u025d\u0005|\u0000\u0000\u025d\u025e\u0005\u000f\u0000\u0000\u025e\u025f"+ + "\u0007\u0003\u0000\u0000\u025f\u0260\u0005\u0005\u0000\u0000\u0260\u0261"+ + "\u0003<\u001e\u0000\u0261S\u0001\u0000\u0000\u0000\u0262\u0264\u0003\u00f2"+ + "y\u0000\u0263\u0265\u0005\u000e\u0000\u0000\u0264\u0263\u0001\u0000\u0000"+ + "\u0000\u0264\u0265\u0001\u0000\u0000\u0000\u0265\u0266\u0001\u0000\u0000"+ + "\u0000\u0266\u0267\u0003>\u001f\u0000\u0267U\u0001\u0000\u0000\u0000\u0268"+ + "\u0269\u0005q\u0000\u0000\u0269\u026b\u0005|\u0000\u0000\u026a\u026c\u0003"+ + "\u0004\u0002\u0000\u026b\u026a\u0001\u0000\u0000\u0000\u026b\u026c\u0001"+ + "\u0000\u0000\u0000\u026c\u026d\u0001\u0000\u0000\u0000\u026d\u026e\u0005"+ + "\r\u0000\u0000\u026e\u026f\u0003\u0012\t\u0000\u026f\u0270\u0005\u000b"+ + "\u0000\u0000\u0270W\u0001\u0000\u0000\u0000\u0271\u0273\u0003L&\u0000"+ + "\u0272\u0271\u0001\u0000\u0000\u0000\u0272\u0273\u0001\u0000\u0000\u0000"+ + "\u0273\u0274\u0001\u0000\u0000\u0000\u0274\u0275\u0005t\u0000\u0000\u0275"+ + "\u0277\u0005\u0006\u0000\u0000\u0276\u0278\u0003\u00dam\u0000\u0277\u0276"+ + "\u0001\u0000\u0000\u0000\u0277\u0278\u0001\u0000\u0000\u0000\u0278\u0279"+ + "\u0001\u0000\u0000\u0000\u0279\u027f\u0005\u0007\u0000\u0000\u027a\u027b"+ + "\u0005\b\u0000\u0000\u027b\u027c\u0003\u00e0p\u0000\u027c\u027d\u0005"+ + "\n\u0000\u0000\u027d\u0280\u0001\u0000\u0000\u0000\u027e\u0280\u0005\u000b"+ + "\u0000\u0000\u027f\u027a\u0001\u0000\u0000\u0000\u027f\u027e\u0001\u0000"+ + "\u0000\u0000\u027f\u0280\u0001\u0000\u0000\u0000\u0280Y\u0001\u0000\u0000"+ + "\u0000\u0281\u0283\u0005a\u0000\u0000\u0282\u0281\u0001\u0000\u0000\u0000"+ + "\u0282\u0283\u0001\u0000\u0000\u0000\u0283\u0285\u0001\u0000\u0000\u0000"+ + "\u0284\u0286\u0005x\u0000\u0000\u0285\u0284\u0001\u0000\u0000\u0000\u0285"+ + "\u0286\u0001\u0000\u0000\u0000\u0286\u0287\u0001\u0000\u0000\u0000\u0287"+ + "\u0288\u0005g\u0000\u0000\u0288\u028a\u0005|\u0000\u0000\u0289\u028b\u0003"+ + "\u0004\u0002\u0000\u028a\u0289\u0001\u0000\u0000\u0000\u028a\u028b\u0001"+ + "\u0000\u0000\u0000\u028b\u028d\u0001\u0000\u0000\u0000\u028c\u028e\u0003"+ + "\\.\u0000\u028d\u028c\u0001\u0000\u0000\u0000\u028d\u028e\u0001\u0000"+ + "\u0000\u0000\u028e\u028f\u0001\u0000\u0000\u0000\u028f\u0291\u0003$\u0012"+ + "\u0000\u0290\u0292\u0005\u000b\u0000\u0000\u0291\u0290\u0001\u0000\u0000"+ + "\u0000\u0291\u0292\u0001\u0000\u0000\u0000\u0292[\u0001\u0000\u0000\u0000"+ + "\u0293\u0294\u0005^\u0000\u0000\u0294\u0295\u0003^/\u0000\u0295]\u0001"+ + "\u0000\u0000\u0000\u0296\u029b\u0003\u001a\r\u0000\u0297\u0298\u0005\f"+ + "\u0000\u0000\u0298\u029a\u0003\u001a\r\u0000\u0299\u0297\u0001\u0000\u0000"+ + "\u0000\u029a\u029d\u0001\u0000\u0000\u0000\u029b\u0299\u0001\u0000\u0000"+ + "\u0000\u029b\u029c\u0001\u0000\u0000\u0000\u029c_\u0001\u0000\u0000\u0000"+ + "\u029d\u029b\u0001\u0000\u0000\u0000\u029e\u02a0\u0005`\u0000\u0000\u029f"+ + "\u029e\u0001\u0000\u0000\u0000\u029f\u02a0\u0001\u0000\u0000\u0000\u02a0"+ + "\u02a1\u0001\u0000\u0000\u0000\u02a1\u02a2\u0005]\u0000\u0000\u02a2\u02a3"+ + "\u0005|\u0000\u0000\u02a3\u02a5\u0005\b\u0000\u0000\u02a4\u02a6\u0003"+ + "b1\u0000\u02a5\u02a4\u0001\u0000\u0000\u0000\u02a5\u02a6\u0001\u0000\u0000"+ + "\u0000\u02a6\u02a7\u0001\u0000\u0000\u0000\u02a7\u02a8\u0005\n\u0000\u0000"+ + "\u02a8a\u0001\u0000\u0000\u0000\u02a9\u02ab\u0003d2\u0000\u02aa\u02ac"+ + "\u0005\f\u0000\u0000\u02ab\u02aa\u0001\u0000\u0000\u0000\u02ab\u02ac\u0001"+ + "\u0000\u0000\u0000\u02acc\u0001\u0000\u0000\u0000\u02ad\u02b2\u0003f3"+ + "\u0000\u02ae\u02af\u0005\f\u0000\u0000\u02af\u02b1\u0003f3\u0000\u02b0"+ + "\u02ae\u0001\u0000\u0000\u0000\u02b1\u02b4\u0001\u0000\u0000\u0000\u02b2"+ + "\u02b0\u0001\u0000\u0000\u0000\u02b2\u02b3\u0001\u0000\u0000\u0000\u02b3"+ + "e\u0001\u0000\u0000\u0000\u02b4\u02b2\u0001\u0000\u0000\u0000\u02b5\u02b8"+ + "\u0003\u00f2y\u0000\u02b6\u02b7\u0005\r\u0000\u0000\u02b7\u02b9\u0003"+ + "\u00fe\u007f\u0000\u02b8\u02b6\u0001\u0000\u0000\u0000\u02b8\u02b9\u0001"+ + "\u0000\u0000\u0000\u02b9g\u0001\u0000\u0000\u0000\u02ba\u02bb\u0005u\u0000"+ + "\u0000\u02bb\u02bc\u0003j5\u0000\u02bc\u02be\u0005\b\u0000\u0000\u02bd"+ + "\u02bf\u0003~?\u0000\u02be\u02bd\u0001\u0000\u0000\u0000\u02be\u02bf\u0001"+ + "\u0000\u0000\u0000\u02bf\u02c0\u0001\u0000\u0000\u0000\u02c0\u02c1\u0005"+ + "\n\u0000\u0000\u02c1i\u0001\u0000\u0000\u0000\u02c2\u02cb\u0005|\u0000"+ + "\u0000\u02c3\u02c5\u0005\u0011\u0000\u0000\u02c4\u02c3\u0001\u0000\u0000"+ + "\u0000\u02c5\u02c6\u0001\u0000\u0000\u0000\u02c6\u02c4\u0001\u0000\u0000"+ + "\u0000\u02c6\u02c7\u0001\u0000\u0000\u0000\u02c7\u02c8\u0001\u0000\u0000"+ + "\u0000\u02c8\u02ca\u0005|\u0000\u0000\u02c9\u02c4\u0001\u0000\u0000\u0000"+ + "\u02ca\u02cd\u0001\u0000\u0000\u0000\u02cb\u02c9\u0001\u0000\u0000\u0000"+ + "\u02cb\u02cc\u0001\u0000\u0000\u0000\u02cck\u0001\u0000\u0000\u0000\u02cd"+ + "\u02cb\u0001\u0000\u0000\u0000\u02ce\u02cf\u0005|\u0000\u0000\u02cf\u02d0"+ + "\u0005\r\u0000\u0000\u02d0\u02d1\u0003j5\u0000\u02d1\u02d2\u0005\u000b"+ + "\u0000\u0000\u02d2m\u0001\u0000\u0000\u0000\u02d3\u02d5\u0003p8\u0000"+ + "\u02d4\u02d3\u0001\u0000\u0000\u0000\u02d5\u02d6\u0001\u0000\u0000\u0000"+ + "\u02d6\u02d4\u0001\u0000\u0000\u0000\u02d6\u02d7\u0001\u0000\u0000\u0000"+ + "\u02d7o\u0001\u0000\u0000\u0000\u02d8\u02db\u0005{\u0000\u0000\u02d9\u02dc"+ + "\u0003r9\u0000\u02da\u02dc\u0003t:\u0000\u02db\u02d9\u0001\u0000\u0000"+ + "\u0000\u02db\u02da\u0001\u0000\u0000\u0000\u02dcq\u0001\u0000\u0000\u0000"+ + "\u02dd\u02de\u00069\uffff\uffff\u0000\u02de\u02e4\u0005|\u0000\u0000\u02df"+ + "\u02e0\u0005\u0006\u0000\u0000\u02e0\u02e1\u0003\u00fe\u007f\u0000\u02e1"+ + "\u02e2\u0005\u0007\u0000\u0000\u02e2\u02e4\u0001\u0000\u0000\u0000\u02e3"+ + "\u02dd\u0001\u0000\u0000\u0000\u02e3\u02df\u0001\u0000\u0000\u0000\u02e4"+ + "\u02ea\u0001\u0000\u0000\u0000\u02e5\u02e6\n\u0002\u0000\u0000\u02e6\u02e7"+ + "\u0005\u0011\u0000\u0000\u02e7\u02e9\u0003\u0112\u0089\u0000\u02e8\u02e5"+ + "\u0001\u0000\u0000\u0000\u02e9\u02ec\u0001\u0000\u0000\u0000\u02ea\u02e8"+ + "\u0001\u0000\u0000\u0000\u02ea\u02eb\u0001\u0000\u0000\u0000\u02ebs\u0001"+ + "\u0000\u0000\u0000\u02ec\u02ea\u0001\u0000\u0000\u0000\u02ed\u02ee\u0003"+ + "r9\u0000\u02ee\u02ef\u0003\u00f4z\u0000\u02efu\u0001\u0000\u0000\u0000"+ + "\u02f0\u02f2\u0003\u00e2q\u0000\u02f1\u02f0\u0001\u0000\u0000\u0000\u02f1"+ + "\u02f2\u0001\u0000\u0000\u0000\u02f2\u02f3\u0001\u0000\u0000\u0000\u02f3"+ + "\u02f4\u0005\u0000\u0000\u0001\u02f4w\u0001\u0000\u0000\u0000\u02f5\u02f7"+ + "\u0005a\u0000\u0000\u02f6\u02f5\u0001\u0000\u0000\u0000\u02f6\u02f7\u0001"+ + "\u0000\u0000\u0000\u02f7\u02f8\u0001\u0000\u0000\u0000\u02f8\u02f9\u0003"+ + "z=\u0000\u02f9y\u0001\u0000\u0000\u0000\u02fa\u0318\u0003|>\u0000\u02fb"+ + "\u0318\u0003\u0082A\u0000\u02fc\u0318\u0003\u0088D\u0000\u02fd\u0318\u0003"+ + "\u0090H\u0000\u02fe\u0318\u0003\u0080@\u0000\u02ff\u0318\u0003\u00bc^"+ + "\u0000\u0300\u0318\u0003Z-\u0000\u0301\u0318\u0003h4\u0000\u0302\u0318"+ + "\u0003\u0094J\u0000\u0303\u0318\u0003\u0096K\u0000\u0304\u0318\u0003\u009a"+ + "M\u0000\u0305\u0318\u0003\u009cN\u0000\u0306\u0318\u0003\u009eO\u0000"+ + "\u0307\u0318\u0003\u00a0P\u0000\u0308\u0318\u0003\u00a2Q\u0000\u0309\u0318"+ + "\u0003\u00aeW\u0000\u030a\u0318\u0003\u00a4R\u0000\u030b\u0318\u0003\u00b0"+ + "X\u0000\u030c\u0318\u0003\u00b2Y\u0000\u030d\u0318\u0003\u00b8\\\u0000"+ + "\u030e\u0318\u0003\u00ba]\u0000\u030f\u0318\u0003\u0102\u0081\u0000\u0310"+ + "\u0318\u0003\u00d0h\u0000\u0311\u0318\u0003\u008aE\u0000\u0312\u0318\u0003"+ + "V+\u0000\u0313\u0318\u0003`0\u0000\u0314\u0318\u0003\u0092I\u0000\u0315"+ + "\u0316\u0005a\u0000\u0000\u0316\u0318\u0003z=\u0000\u0317\u02fa\u0001"+ + "\u0000\u0000\u0000\u0317\u02fb\u0001\u0000\u0000\u0000\u0317\u02fc\u0001"+ + "\u0000\u0000\u0000\u0317\u02fd\u0001\u0000\u0000\u0000\u0317\u02fe\u0001"+ + "\u0000\u0000\u0000\u0317\u02ff\u0001\u0000\u0000\u0000\u0317\u0300\u0001"+ + "\u0000\u0000\u0000\u0317\u0301\u0001\u0000\u0000\u0000\u0317\u0302\u0001"+ + "\u0000\u0000\u0000\u0317\u0303\u0001\u0000\u0000\u0000\u0317\u0304\u0001"+ + "\u0000\u0000\u0000\u0317\u0305\u0001\u0000\u0000\u0000\u0317\u0306\u0001"+ + "\u0000\u0000\u0000\u0317\u0307\u0001\u0000\u0000\u0000\u0317\u0308\u0001"+ + "\u0000\u0000\u0000\u0317\u0309\u0001\u0000\u0000\u0000\u0317\u030a\u0001"+ + "\u0000\u0000\u0000\u0317\u030b\u0001\u0000\u0000\u0000\u0317\u030c\u0001"+ + "\u0000\u0000\u0000\u0317\u030d\u0001\u0000\u0000\u0000\u0317\u030e\u0001"+ + "\u0000\u0000\u0000\u0317\u030f\u0001\u0000\u0000\u0000\u0317\u0310\u0001"+ + "\u0000\u0000\u0000\u0317\u0311\u0001\u0000\u0000\u0000\u0317\u0312\u0001"+ + "\u0000\u0000\u0000\u0317\u0313\u0001\u0000\u0000\u0000\u0317\u0314\u0001"+ + "\u0000\u0000\u0000\u0317\u0315\u0001\u0000\u0000\u0000\u0318{\u0001\u0000"+ + "\u0000\u0000\u0319\u031b\u0005\b\u0000\u0000\u031a\u031c\u0003~?\u0000"+ + "\u031b\u031a\u0001\u0000\u0000\u0000\u031b\u031c\u0001\u0000\u0000\u0000"+ + "\u031c\u031d\u0001\u0000\u0000\u0000\u031d\u031e\u0005\n\u0000\u0000\u031e"+ + "}\u0001\u0000\u0000\u0000\u031f\u0321\u0003z=\u0000\u0320\u031f\u0001"+ + "\u0000\u0000\u0000\u0321\u0322\u0001\u0000\u0000\u0000\u0322\u0320\u0001"+ + "\u0000\u0000\u0000\u0322\u0323\u0001\u0000\u0000\u0000\u0323\u007f\u0001"+ + "\u0000\u0000\u0000\u0324\u0328\u0005y\u0000\u0000\u0325\u0326\u0005|\u0000"+ + "\u0000\u0326\u0329\u0003>\u001f\u0000\u0327\u0329\u0003\u008aE\u0000\u0328"+ + "\u0325\u0001\u0000\u0000\u0000\u0328\u0327\u0001\u0000\u0000\u0000\u0329"+ + "\u032a\u0001\u0000\u0000\u0000\u032a\u032b\u0003\u011e\u008f\u0000\u032b"+ + "\u0081\u0001\u0000\u0000\u0000\u032c\u032f\u0005b\u0000\u0000\u032d\u0330"+ + "\u0003\u0084B\u0000\u032e\u0330\u0003l6\u0000\u032f\u032d\u0001\u0000"+ + "\u0000\u0000\u032f\u032e\u0001\u0000\u0000\u0000\u0330\u0083\u0001\u0000"+ + "\u0000\u0000\u0331\u0334\u0005\u0018\u0000\u0000\u0332\u0334\u0003\u0086"+ + "C\u0000\u0333\u0331\u0001\u0000\u0000\u0000\u0333\u0332\u0001\u0000\u0000"+ + "\u0000\u0334\u0337\u0001\u0000\u0000\u0000\u0335\u0336\u0005X\u0000\u0000"+ + "\u0336\u0338\u0003\u0112\u0089\u0000\u0337\u0335\u0001\u0000\u0000\u0000"+ + "\u0337\u0338\u0001\u0000\u0000\u0000\u0338\u0339\u0001\u0000\u0000\u0000"+ + "\u0339\u033a\u0005Y\u0000\u0000\u033a\u033b\u0005}\u0000\u0000\u033b\u033c"+ + "\u0003\u011e\u008f\u0000\u033c\u0085\u0001\u0000\u0000\u0000\u033d\u033e"+ + "\u0003\u0112\u0089\u0000\u033e\u033f\u0005\f\u0000\u0000\u033f\u0341\u0001"+ + "\u0000\u0000\u0000\u0340\u033d\u0001\u0000\u0000\u0000\u0340\u0341\u0001"+ + "\u0000\u0000\u0000\u0341\u0342\u0001\u0000\u0000\u0000\u0342\u0343\u0005"+ + "\b\u0000\u0000\u0343\u0348\u0003\u0112\u0089\u0000\u0344\u0345\u0005\f"+ + "\u0000\u0000\u0345\u0347\u0003\u0112\u0089\u0000\u0346\u0344\u0001\u0000"+ + "\u0000\u0000\u0347\u034a\u0001\u0000\u0000\u0000\u0348\u0346\u0001\u0000"+ + "\u0000\u0000\u0348\u0349\u0001\u0000\u0000\u0000\u0349\u034b\u0001\u0000"+ + "\u0000\u0000\u034a\u0348\u0001\u0000\u0000\u0000\u034b\u034c\u0005\n\u0000"+ + "\u0000\u034c\u0087\u0001\u0000\u0000\u0000\u034d\u034f\u0005a\u0000\u0000"+ + "\u034e\u0350\u0005R\u0000\u0000\u034f\u034e\u0001\u0000\u0000\u0000\u034f"+ + "\u0350\u0001\u0000\u0000\u0000\u0350\u0353\u0001\u0000\u0000\u0000\u0351"+ + "\u0354\u0003\u0084B\u0000\u0352\u0354\u0003z=\u0000\u0353\u0351\u0001"+ + "\u0000\u0000\u0000\u0353\u0352\u0001\u0000\u0000\u0000\u0354\u0089\u0001"+ + "\u0000\u0000\u0000\u0355\u0357\u0003\u0002\u0001\u0000\u0356\u0358\u0003"+ + "<\u001e\u0000\u0357\u0356\u0001\u0000\u0000\u0000\u0357\u0358\u0001\u0000"+ + "\u0000\u0000\u0358\u0359\u0001\u0000\u0000\u0000\u0359\u035b\u0003\u0000"+ + "\u0000\u0000\u035a\u035c\u0005\u000b\u0000\u0000\u035b\u035a\u0001\u0000"+ + "\u0000\u0000\u035b\u035c\u0001\u0000\u0000\u0000\u035c\u0373\u0001\u0000"+ + "\u0000\u0000\u035d\u035f\u0003L&\u0000\u035e\u035d\u0001\u0000\u0000\u0000"+ + "\u035e\u035f\u0001\u0000\u0000\u0000\u035f\u0361\u0001\u0000\u0000\u0000"+ + "\u0360\u0362\u0003\u0098L\u0000\u0361\u0360\u0001\u0000\u0000\u0000\u0361"+ + "\u0362\u0001\u0000\u0000\u0000\u0362\u0364\u0001\u0000\u0000\u0000\u0363"+ + "\u0365\u0005Z\u0000\u0000\u0364\u0363\u0001\u0000\u0000\u0000\u0364\u0365"+ + "\u0001\u0000\u0000\u0000\u0365\u0366\u0001\u0000\u0000\u0000\u0366\u0368"+ + "\u0003\u008cF\u0000\u0367\u0369\u0005\u000b\u0000\u0000\u0368\u0367\u0001"+ + "\u0000\u0000\u0000\u0368\u0369\u0001\u0000\u0000\u0000\u0369\u0373\u0001"+ + "\u0000\u0000\u0000\u036a\u036c\u0005x\u0000\u0000\u036b\u036d\u0003\u0098"+ + "L\u0000\u036c\u036b\u0001\u0000\u0000\u0000\u036c\u036d\u0001\u0000\u0000"+ + "\u0000\u036d\u036e\u0001\u0000\u0000\u0000\u036e\u0370\u0003\u008cF\u0000"+ + "\u036f\u0371\u0005\u000b\u0000\u0000\u0370\u036f\u0001\u0000\u0000\u0000"+ + "\u0370\u0371\u0001\u0000\u0000\u0000\u0371\u0373\u0001\u0000\u0000\u0000"+ + "\u0372\u0355\u0001\u0000\u0000\u0000\u0372\u035e\u0001\u0000\u0000\u0000"+ + "\u0372\u036a\u0001\u0000\u0000\u0000\u0373\u008b\u0001\u0000\u0000\u0000"+ + "\u0374\u0379\u0003\u008eG\u0000\u0375\u0376\u0005\f\u0000\u0000\u0376"+ + "\u0378\u0003\u008eG\u0000\u0377\u0375\u0001\u0000\u0000\u0000\u0378\u037b"+ + "\u0001\u0000\u0000\u0000\u0379\u0377\u0001\u0000\u0000\u0000\u0379\u037a"+ + "\u0001\u0000\u0000\u0000\u037a\u008d\u0001\u0000\u0000\u0000\u037b\u0379"+ + "\u0001\u0000\u0000\u0000\u037c\u0380\u0003\u0114\u008a\u0000\u037d\u0380"+ + "\u0003\u00e4r\u0000\u037e\u0380\u0003\u00eau\u0000\u037f\u037c\u0001\u0000"+ + "\u0000\u0000\u037f\u037d\u0001\u0000\u0000\u0000\u037f\u037e\u0001\u0000"+ + "\u0000\u0000\u0380\u0382\u0001\u0000\u0000\u0000\u0381\u0383\u0003<\u001e"+ + "\u0000\u0382\u0381\u0001\u0000\u0000\u0000\u0382\u0383\u0001\u0000\u0000"+ + "\u0000\u0383\u0385\u0001\u0000\u0000\u0000\u0384\u0386\u0003\u00fe\u007f"+ + "\u0000\u0385\u0384\u0001\u0000\u0000\u0000\u0385\u0386\u0001\u0000\u0000"+ + "\u0000\u0386\u038c\u0001\u0000\u0000\u0000\u0387\u0389\u0005\r\u0000\u0000"+ + "\u0388\u038a\u0003\u0004\u0002\u0000\u0389\u0388\u0001\u0000\u0000\u0000"+ + "\u0389\u038a\u0001\u0000\u0000\u0000\u038a\u038b\u0001\u0000\u0000\u0000"+ + "\u038b\u038d\u0003\u00fe\u007f\u0000\u038c\u0387\u0001\u0000\u0000\u0000"+ + "\u038c\u038d\u0001\u0000\u0000\u0000\u038d\u008f\u0001\u0000\u0000\u0000"+ + "\u038e\u038f\u0005\u000b\u0000\u0000\u038f\u0091\u0001\u0000\u0000\u0000"+ + "\u0390\u0391\u0004I\u0006\u0000\u0391\u0393\u0003\u00fa}\u0000\u0392\u0394"+ + "\u0005\u000b\u0000\u0000\u0393\u0392\u0001\u0000\u0000\u0000\u0393\u0394"+ + "\u0001\u0000\u0000\u0000\u0394\u0093\u0001\u0000\u0000\u0000\u0395\u0396"+ + "\u0005S\u0000\u0000\u0396\u0397\u0005\u0006\u0000\u0000\u0397\u0398\u0003"+ + "\u00fa}\u0000\u0398\u0399\u0005\u0007\u0000\u0000\u0399\u039c\u0003z="+ + "\u0000\u039a\u039b\u0005C\u0000\u0000\u039b\u039d\u0003z=\u0000\u039c"+ + "\u039a\u0001\u0000\u0000\u0000\u039c\u039d\u0001\u0000\u0000\u0000\u039d"+ + "\u0095\u0001\u0000\u0000\u0000\u039e\u039f\u0005?\u0000\u0000\u039f\u03a0"+ + "\u0003z=\u0000\u03a0\u03a1\u0005M\u0000\u0000\u03a1\u03a2\u0005\u0006"+ + "\u0000\u0000\u03a2\u03a3\u0003\u00fa}\u0000\u03a3\u03a4\u0005\u0007\u0000"+ + "\u0000\u03a4\u03a5\u0003\u011e\u008f\u0000\u03a5\u03e4\u0001\u0000\u0000"+ + "\u0000\u03a6\u03a7\u0005M\u0000\u0000\u03a7\u03a8\u0005\u0006\u0000\u0000"+ + "\u03a8\u03a9\u0003\u00fa}\u0000\u03a9\u03aa\u0005\u0007\u0000\u0000\u03aa"+ + "\u03ab\u0003z=\u0000\u03ab\u03e4\u0001\u0000\u0000\u0000\u03ac\u03ad\u0005"+ + "K\u0000\u0000\u03ad\u03af\u0005\u0006\u0000\u0000\u03ae\u03b0\u0003\u00fa"+ + "}\u0000\u03af\u03ae\u0001\u0000\u0000\u0000\u03af\u03b0\u0001\u0000\u0000"+ + "\u0000\u03b0\u03b1\u0001\u0000\u0000\u0000\u03b1\u03b3\u0005\u000b\u0000"+ + "\u0000\u03b2\u03b4\u0003\u00fa}\u0000\u03b3\u03b2\u0001\u0000\u0000\u0000"+ + "\u03b3\u03b4\u0001\u0000\u0000\u0000\u03b4\u03b5\u0001\u0000\u0000\u0000"+ + "\u03b5\u03b7\u0005\u000b\u0000\u0000\u03b6\u03b8\u0003\u00fa}\u0000\u03b7"+ + "\u03b6\u0001\u0000\u0000\u0000\u03b7\u03b8\u0001\u0000\u0000\u0000\u03b8"+ + "\u03b9\u0001\u0000\u0000\u0000\u03b9\u03ba\u0005\u0007\u0000\u0000\u03ba"+ + "\u03e4\u0003z=\u0000\u03bb\u03bc\u0005K\u0000\u0000\u03bc\u03bd\u0005"+ + "\u0006\u0000\u0000\u03bd\u03be\u0003\u0098L\u0000\u03be\u03bf\u0003\u008c"+ + "F\u0000\u03bf\u03c1\u0005\u000b\u0000\u0000\u03c0\u03c2\u0003\u00fa}\u0000"+ + "\u03c1\u03c0\u0001\u0000\u0000\u0000\u03c1\u03c2\u0001\u0000\u0000\u0000"+ + "\u03c2\u03c3\u0001\u0000\u0000\u0000\u03c3\u03c5\u0005\u000b\u0000\u0000"+ + "\u03c4\u03c6\u0003\u00fa}\u0000\u03c5\u03c4\u0001\u0000\u0000\u0000\u03c5"+ + "\u03c6\u0001\u0000\u0000\u0000\u03c6\u03c7\u0001\u0000\u0000\u0000\u03c7"+ + "\u03c8\u0005\u0007\u0000\u0000\u03c8\u03c9\u0003z=\u0000\u03c9\u03e4\u0001"+ + "\u0000\u0000\u0000\u03ca\u03cb\u0005K\u0000\u0000\u03cb\u03cc\u0005\u0006"+ + "\u0000\u0000\u03cc\u03d0\u0003\u00fe\u007f\u0000\u03cd\u03d1\u0005V\u0000"+ + "\u0000\u03ce\u03cf\u0005|\u0000\u0000\u03cf\u03d1\u0004K\u0007\u0000\u03d0"+ + "\u03cd\u0001\u0000\u0000\u0000\u03d0\u03ce\u0001\u0000\u0000\u0000\u03d1"+ + "\u03d2\u0001\u0000\u0000\u0000\u03d2\u03d3\u0003\u00fa}\u0000\u03d3\u03d4"+ + "\u0005\u0007\u0000\u0000\u03d4\u03d5\u0003z=\u0000\u03d5\u03e4\u0001\u0000"+ + "\u0000\u0000\u03d6\u03d7\u0005K\u0000\u0000\u03d7\u03d8\u0005\u0006\u0000"+ + "\u0000\u03d8\u03d9\u0003\u0098L\u0000\u03d9\u03dd\u0003\u008eG\u0000\u03da"+ + "\u03de\u0005V\u0000\u0000\u03db\u03dc\u0005|\u0000\u0000\u03dc\u03de\u0004"+ + "K\b\u0000\u03dd\u03da\u0001\u0000\u0000\u0000\u03dd\u03db\u0001\u0000"+ + "\u0000\u0000\u03de\u03df\u0001\u0000\u0000\u0000\u03df\u03e0\u0003\u00fa"+ + "}\u0000\u03e0\u03e1\u0005\u0007\u0000\u0000\u03e1\u03e2\u0003z=\u0000"+ + "\u03e2\u03e4\u0001\u0000\u0000\u0000\u03e3\u039e\u0001\u0000\u0000\u0000"+ + "\u03e3\u03a6\u0001\u0000\u0000\u0000\u03e3\u03ac\u0001\u0000\u0000\u0000"+ + "\u03e3\u03bb\u0001\u0000\u0000\u0000\u03e3\u03ca\u0001\u0000\u0000\u0000"+ + "\u03e3\u03d6\u0001\u0000\u0000\u0000\u03e4\u0097\u0001\u0000\u0000\u0000"+ + "\u03e5\u03e6\u0007\u0004\u0000\u0000\u03e6\u0099\u0001\u0000\u0000\u0000"+ + "\u03e7\u03ea\u0005J\u0000\u0000\u03e8\u03e9\u0004M\t\u0000\u03e9\u03eb"+ + "\u0005|\u0000\u0000\u03ea\u03e8\u0001\u0000\u0000\u0000\u03ea\u03eb\u0001"+ + "\u0000\u0000\u0000\u03eb\u03ec\u0001\u0000\u0000\u0000\u03ec\u03ed\u0003"+ + "\u011e\u008f\u0000\u03ed\u009b\u0001\u0000\u0000\u0000\u03ee\u03f1\u0005"+ + ">\u0000\u0000\u03ef\u03f0\u0004N\n\u0000\u03f0\u03f2\u0005|\u0000\u0000"+ + "\u03f1\u03ef\u0001\u0000\u0000\u0000\u03f1\u03f2\u0001\u0000\u0000\u0000"+ + "\u03f2\u03f3\u0001\u0000\u0000\u0000\u03f3\u03f4\u0003\u011e\u008f\u0000"+ + "\u03f4\u009d\u0001\u0000\u0000\u0000\u03f5\u03f8\u0005H\u0000\u0000\u03f6"+ + "\u03f7\u0004O\u000b\u0000\u03f7\u03f9\u0003\u00fa}\u0000\u03f8\u03f6\u0001"+ + "\u0000\u0000\u0000\u03f8\u03f9\u0001\u0000\u0000\u0000\u03f9\u03fa\u0001"+ + "\u0000\u0000\u0000\u03fa\u03fb\u0003\u011e\u008f\u0000\u03fb\u009f\u0001"+ + "\u0000\u0000\u0000\u03fc\u03ff\u0005k\u0000\u0000\u03fd\u03fe\u0004P\f"+ + "\u0000\u03fe\u0400\u0003\u00fa}\u0000\u03ff\u03fd\u0001\u0000\u0000\u0000"+ + "\u03ff\u0400\u0001\u0000\u0000\u0000\u0400\u0401\u0001\u0000\u0000\u0000"+ + "\u0401\u0402\u0003\u011e\u008f\u0000\u0402\u00a1\u0001\u0000\u0000\u0000"+ + "\u0403\u0404\u0005Q\u0000\u0000\u0404\u0405\u0005\u0006\u0000\u0000\u0405"+ + "\u0406\u0003\u00fa}\u0000\u0406\u0407\u0005\u0007\u0000\u0000\u0407\u0408"+ + "\u0003z=\u0000\u0408\u00a3\u0001\u0000\u0000\u0000\u0409\u040a\u0005L"+ + "\u0000\u0000\u040a\u040b\u0005\u0006\u0000\u0000\u040b\u040c\u0003\u00fa"+ + "}\u0000\u040c\u040d\u0005\u0007\u0000\u0000\u040d\u040e\u0003\u00a6S\u0000"+ + "\u040e\u00a5\u0001\u0000\u0000\u0000\u040f\u0411\u0005\b\u0000\u0000\u0410"+ + "\u0412\u0003\u00a8T\u0000\u0411\u0410\u0001\u0000\u0000\u0000\u0411\u0412"+ + "\u0001\u0000\u0000\u0000\u0412\u0417\u0001\u0000\u0000\u0000\u0413\u0415"+ + "\u0003\u00acV\u0000\u0414\u0416\u0003\u00a8T\u0000\u0415\u0414\u0001\u0000"+ + "\u0000\u0000\u0415\u0416\u0001\u0000\u0000\u0000\u0416\u0418\u0001\u0000"+ + "\u0000\u0000\u0417\u0413\u0001\u0000\u0000\u0000\u0417\u0418\u0001\u0000"+ + "\u0000\u0000\u0418\u0419\u0001\u0000\u0000\u0000\u0419\u041a\u0005\n\u0000"+ + "\u0000\u041a\u00a7\u0001\u0000\u0000\u0000\u041b\u041d\u0003\u00aaU\u0000"+ + "\u041c\u041b\u0001\u0000\u0000\u0000\u041d\u041e\u0001\u0000\u0000\u0000"+ + "\u041e\u041c\u0001\u0000\u0000\u0000\u041e\u041f\u0001\u0000\u0000\u0000"+ + "\u041f\u00a9\u0001\u0000\u0000\u0000\u0420\u0421\u0005B\u0000\u0000\u0421"+ + "\u0422\u0003\u00fa}\u0000\u0422\u0424\u0005\u000f\u0000\u0000\u0423\u0425"+ + "\u0003~?\u0000\u0424\u0423\u0001\u0000\u0000\u0000\u0424\u0425\u0001\u0000"+ + "\u0000\u0000\u0425\u00ab\u0001\u0000\u0000\u0000\u0426\u0427\u0005R\u0000"+ + "\u0000\u0427\u0429\u0005\u000f\u0000\u0000\u0428\u042a\u0003~?\u0000\u0429"+ + "\u0428\u0001\u0000\u0000\u0000\u0429\u042a\u0001\u0000\u0000\u0000\u042a"+ + "\u00ad\u0001\u0000\u0000\u0000\u042b\u042c\u0005|\u0000\u0000\u042c\u042d"+ + "\u0005\u000f\u0000\u0000\u042d\u042e\u0003z=\u0000\u042e\u00af\u0001\u0000"+ + "\u0000\u0000\u042f\u0430\u0005T\u0000\u0000\u0430\u0431\u0004X\r\u0000"+ + "\u0431\u0432\u0003\u00fa}\u0000\u0432\u0433\u0003\u011e\u008f\u0000\u0433"+ + "\u00b1\u0001\u0000\u0000\u0000\u0434\u0435\u0005W\u0000\u0000\u0435\u043b"+ + "\u0003|>\u0000\u0436\u0438\u0003\u00b4Z\u0000\u0437\u0439\u0003\u00b6"+ + "[\u0000\u0438\u0437\u0001\u0000\u0000\u0000\u0438\u0439\u0001\u0000\u0000"+ + "\u0000\u0439\u043c\u0001\u0000\u0000\u0000\u043a\u043c\u0003\u00b6[\u0000"+ + "\u043b\u0436\u0001\u0000\u0000\u0000\u043b\u043a\u0001\u0000\u0000\u0000"+ + "\u043c\u00b3\u0001\u0000\u0000\u0000\u043d\u043e\u0005F\u0000\u0000\u043e"+ + "\u043f\u0005\u0006\u0000\u0000\u043f\u0440\u0005|\u0000\u0000\u0440\u0441"+ + "\u0005\u0007\u0000\u0000\u0441\u0442\u0003|>\u0000\u0442\u00b5\u0001\u0000"+ + "\u0000\u0000\u0443\u0444\u0005G\u0000\u0000\u0444\u0445\u0003|>\u0000"+ + "\u0445\u00b7\u0001\u0000\u0000\u0000\u0446\u0447\u0005N\u0000\u0000\u0447"+ + "\u0448\u0003\u011e\u008f\u0000\u0448\u00b9\u0001\u0000\u0000\u0000\u0449"+ + "\u044a\u0005O\u0000\u0000\u044a\u044b\u0005|\u0000\u0000\u044b\u0451\u0003"+ + ">\u001f\u0000\u044c\u044d\u0005\b\u0000\u0000\u044d\u044e\u0003\u00e0"+ + "p\u0000\u044e\u044f\u0005\n\u0000\u0000\u044f\u0452\u0001\u0000\u0000"+ + "\u0000\u0450\u0452\u0005\u000b\u0000\u0000\u0451\u044c\u0001\u0000\u0000"+ + "\u0000\u0451\u0450\u0001\u0000\u0000\u0000\u0452\u00bb\u0001\u0000\u0000"+ + "\u0000\u0453\u0455\u0003n7\u0000\u0454\u0453\u0001\u0000\u0000\u0000\u0454"+ + "\u0455\u0001\u0000\u0000\u0000\u0455\u045a\u0001\u0000\u0000\u0000\u0456"+ + "\u0458\u0005a\u0000\u0000\u0457\u0459\u0005R\u0000\u0000\u0458\u0457\u0001"+ + "\u0000\u0000\u0000\u0458\u0459\u0001\u0000\u0000\u0000\u0459\u045b\u0001"+ + "\u0000\u0000\u0000\u045a\u0456\u0001\u0000\u0000\u0000\u045a\u045b\u0001"+ + "\u0000\u0000\u0000\u045b\u045d\u0001\u0000\u0000\u0000\u045c\u045e\u0005"+ + "y\u0000\u0000\u045d\u045c\u0001\u0000\u0000\u0000\u045d\u045e\u0001\u0000"+ + "\u0000\u0000\u045e\u045f\u0001\u0000\u0000\u0000\u045f\u0460\u0005\\\u0000"+ + "\u0000\u0460\u0462\u0005|\u0000\u0000\u0461\u0463\u0003\u0004\u0002\u0000"+ + "\u0462\u0461\u0001\u0000\u0000\u0000\u0462\u0463\u0001\u0000\u0000\u0000"+ + "\u0463\u0464\u0001\u0000\u0000\u0000\u0464\u0465\u0003\u00be_\u0000\u0465"+ + "\u0466\u0003\u00c0`\u0000\u0466\u00bd\u0001\u0000\u0000\u0000\u0467\u0469"+ + "\u0003\u00c2a\u0000\u0468\u0467\u0001\u0000\u0000\u0000\u0468\u0469\u0001"+ + "\u0000\u0000\u0000\u0469\u046b\u0001\u0000\u0000\u0000\u046a\u046c\u0003"+ + "\u00c4b\u0000\u046b\u046a\u0001\u0000\u0000\u0000\u046b\u046c\u0001\u0000"+ + "\u0000\u0000\u046c\u00bf\u0001\u0000\u0000\u0000\u046d\u0471\u0005\b\u0000"+ + "\u0000\u046e\u0470\u0003\u00c6c\u0000\u046f\u046e\u0001\u0000\u0000\u0000"+ + "\u0470\u0473\u0001\u0000\u0000\u0000\u0471\u046f\u0001\u0000\u0000\u0000"+ + "\u0471\u0472\u0001\u0000\u0000\u0000\u0472\u0474\u0001\u0000\u0000\u0000"+ + "\u0473\u0471\u0001\u0000\u0000\u0000\u0474\u0475\u0005\n\u0000\u0000\u0475"+ + "\u00c1\u0001\u0000\u0000\u0000\u0476\u0477\u0005^\u0000\u0000\u0477\u0478"+ + "\u0003\u001a\r\u0000\u0478\u00c3\u0001\u0000\u0000\u0000\u0479\u047a\u0005"+ + "c\u0000\u0000\u047a\u047b\u0003^/\u0000\u047b\u00c5\u0001\u0000\u0000"+ + "\u0000\u047c\u0484\u0003X,\u0000\u047d\u047f\u0003n7\u0000\u047e\u047d"+ + "\u0001\u0000\u0000\u0000\u047e\u047f\u0001\u0000\u0000\u0000\u047f\u0480"+ + "\u0001\u0000\u0000\u0000\u0480\u0484\u0003\u00c8d\u0000\u0481\u0484\u0003"+ + "\u00ccf\u0000\u0482\u0484\u0003z=\u0000\u0483\u047c\u0001\u0000\u0000"+ + "\u0000\u0483\u047e\u0001\u0000\u0000\u0000\u0483\u0481\u0001\u0000\u0000"+ + "\u0000\u0483\u0482\u0001\u0000\u0000\u0000\u0484\u00c7\u0001\u0000\u0000"+ + "\u0000\u0485\u0486\u0003\u00cae\u0000\u0486\u0488\u0003\u00f2y\u0000\u0487"+ + "\u0489\u0005\u000e\u0000\u0000\u0488\u0487\u0001\u0000\u0000\u0000\u0488"+ + "\u0489\u0001\u0000\u0000\u0000\u0489\u048b\u0001\u0000\u0000\u0000\u048a"+ + "\u048c\u0003<\u001e\u0000\u048b\u048a\u0001\u0000\u0000\u0000\u048b\u048c"+ + "\u0001\u0000\u0000\u0000\u048c\u048e\u0001\u0000\u0000\u0000\u048d\u048f"+ + "\u0003\u0000\u0000\u0000\u048e\u048d\u0001\u0000\u0000\u0000\u048e\u048f"+ + "\u0001\u0000\u0000\u0000\u048f\u0490\u0001\u0000\u0000\u0000\u0490\u0491"+ + "\u0005\u000b\u0000\u0000\u0491\u04a3\u0001\u0000\u0000\u0000\u0492\u0493"+ + "\u0003\u00cae\u0000\u0493\u0494\u0003\u00f2y\u0000\u0494\u049a\u0003>"+ + "\u001f\u0000\u0495\u0496\u0005\b\u0000\u0000\u0496\u0497\u0003\u00e0p"+ + "\u0000\u0497\u0498\u0005\n\u0000\u0000\u0498\u049b\u0001\u0000\u0000\u0000"+ + "\u0499\u049b\u0005\u000b\u0000\u0000\u049a\u0495\u0001\u0000\u0000\u0000"+ + "\u049a\u0499\u0001\u0000\u0000\u0000\u049b\u04a3\u0001\u0000\u0000\u0000"+ + "\u049c\u049f\u0003\u00cae\u0000\u049d\u04a0\u0003\u00eew\u0000\u049e\u04a0"+ + "\u0003\u00f0x\u0000\u049f\u049d\u0001\u0000\u0000\u0000\u049f\u049e\u0001"+ + "\u0000\u0000\u0000\u04a0\u04a3\u0001\u0000\u0000\u0000\u04a1\u04a3\u0003"+ + "\u0080@\u0000\u04a2\u0485\u0001\u0000\u0000\u0000\u04a2\u0492\u0001\u0000"+ + "\u0000\u0000\u04a2\u049c\u0001\u0000\u0000\u0000\u04a2\u04a1\u0001\u0000"+ + "\u0000\u0000\u04a3\u00c9\u0001\u0000\u0000\u0000\u04a4\u04a6\u0003L&\u0000"+ + "\u04a5\u04a4\u0001\u0000\u0000\u0000\u04a5\u04a6\u0001\u0000\u0000\u0000"+ + "\u04a6\u04a8\u0001\u0000\u0000\u0000\u04a7\u04a9\u0005[\u0000\u0000\u04a8"+ + "\u04a7\u0001\u0000\u0000\u0000\u04a8\u04a9\u0001\u0000\u0000\u0000\u04a9"+ + "\u04ab\u0001\u0000\u0000\u0000\u04aa\u04ac\u0005j\u0000\u0000\u04ab\u04aa"+ + "\u0001\u0000\u0000\u0000\u04ab\u04ac\u0001\u0000\u0000\u0000\u04ac\u04ae"+ + "\u0001\u0000\u0000\u0000\u04ad\u04af\u0005Z\u0000\u0000\u04ae\u04ad\u0001"+ + "\u0000\u0000\u0000\u04ae\u04af\u0001\u0000\u0000\u0000\u04af\u00cb\u0001"+ + "\u0000\u0000\u0000\u04b0\u04b1\u0003R)\u0000\u04b1\u04b2\u0005\u000b\u0000"+ + "\u0000\u04b2\u00cd\u0001\u0000\u0000\u0000\u04b3\u04b5\u0005\u0018\u0000"+ + "\u0000\u04b4\u04b3\u0001\u0000\u0000\u0000\u04b4\u04b5\u0001\u0000\u0000"+ + "\u0000\u04b5\u04b6\u0001\u0000\u0000\u0000\u04b6\u04b7\u0005|\u0000\u0000"+ + "\u04b7\u04b9\u0005\u0006\u0000\u0000\u04b8\u04ba\u0003\u00dam\u0000\u04b9"+ + "\u04b8\u0001\u0000\u0000\u0000\u04b9\u04ba\u0001\u0000\u0000\u0000\u04ba"+ + "\u04bb\u0001\u0000\u0000\u0000\u04bb\u04bc\u0005\u0007\u0000\u0000\u04bc"+ + "\u04bd\u0005\b\u0000\u0000\u04bd\u04be\u0003\u00e0p\u0000\u04be\u04bf"+ + "\u0005\n\u0000\u0000\u04bf\u00cf\u0001\u0000\u0000\u0000\u04c0\u04c1\u0005"+ + "O\u0000\u0000\u04c1\u04c3\u0005\u0018\u0000\u0000\u04c2\u04c4\u0005|\u0000"+ + "\u0000\u04c3\u04c2\u0001\u0000\u0000\u0000\u04c3\u04c4\u0001\u0000\u0000"+ + "\u0000\u04c4\u04c5\u0001\u0000\u0000\u0000\u04c5\u04c7\u0005\u0006\u0000"+ + "\u0000\u04c6\u04c8\u0003\u00dam\u0000\u04c7\u04c6\u0001\u0000\u0000\u0000"+ + "\u04c7\u04c8\u0001\u0000\u0000\u0000\u04c8\u04c9\u0001\u0000\u0000\u0000"+ + "\u04c9\u04ca\u0005\u0007\u0000\u0000\u04ca\u04cb\u0005\b\u0000\u0000\u04cb"+ + "\u04cc\u0003\u00e0p\u0000\u04cc\u04cd\u0005\n\u0000\u0000\u04cd\u00d1"+ + "\u0001\u0000\u0000\u0000\u04ce\u04cf\u0005\b\u0000\u0000\u04cf\u04d4\u0003"+ + "\u00d4j\u0000\u04d0\u04d1\u0005\f\u0000\u0000\u04d1\u04d3\u0003\u00d4"+ + "j\u0000\u04d2\u04d0\u0001\u0000\u0000\u0000\u04d3\u04d6\u0001\u0000\u0000"+ + "\u0000\u04d4\u04d2\u0001\u0000\u0000\u0000\u04d4\u04d5\u0001\u0000\u0000"+ + "\u0000\u04d5\u04d8\u0001\u0000\u0000\u0000\u04d6\u04d4\u0001\u0000\u0000"+ + "\u0000\u04d7\u04d9\u0005\f\u0000\u0000\u04d8\u04d7\u0001\u0000\u0000\u0000"+ + "\u04d8\u04d9\u0001\u0000\u0000\u0000\u04d9\u04da\u0001\u0000\u0000\u0000"+ + "\u04da\u04db\u0005\n\u0000\u0000\u04db\u00d3\u0001\u0000\u0000\u0000\u04dc"+ + "\u04dd\u0005\u0018\u0000\u0000\u04dd\u04de\u0003\u00d8l\u0000\u04de\u00d5"+ + "\u0001\u0000\u0000\u0000\u04df\u04e0\u0005\b\u0000\u0000\u04e0\u04e5\u0003"+ + "\u00d8l\u0000\u04e1\u04e2\u0005\f\u0000\u0000\u04e2\u04e4\u0003\u00d8"+ + "l\u0000\u04e3\u04e1\u0001\u0000\u0000\u0000\u04e4\u04e7\u0001\u0000\u0000"+ + "\u0000\u04e5\u04e3\u0001\u0000\u0000\u0000\u04e5\u04e6\u0001\u0000\u0000"+ + "\u0000\u04e6\u04e9\u0001\u0000\u0000\u0000\u04e7\u04e5\u0001\u0000\u0000"+ + "\u0000\u04e8\u04ea\u0005\f\u0000\u0000\u04e9\u04e8\u0001\u0000\u0000\u0000"+ + "\u04e9\u04ea\u0001\u0000\u0000\u0000\u04ea\u04eb\u0001\u0000\u0000\u0000"+ + "\u04eb\u04ec\u0005\n\u0000\u0000\u04ec\u00d7\u0001\u0000\u0000\u0000\u04ed"+ + "\u04ee\u0005\u0004\u0000\u0000\u04ee\u04ef\u0003\u00fe\u007f\u0000\u04ef"+ + "\u04f0\u0005\u0005\u0000\u0000\u04f0\u04f2\u0005\u0006\u0000\u0000\u04f1"+ + "\u04f3\u0003\u00dam\u0000\u04f2\u04f1\u0001\u0000\u0000\u0000\u04f2\u04f3"+ + "\u0001\u0000\u0000\u0000\u04f3\u04f4\u0001\u0000\u0000\u0000\u04f4\u04f5"+ + "\u0005\u0007\u0000\u0000\u04f5\u04f6\u0005\b\u0000\u0000\u04f6\u04f7\u0003"+ + "\u00e0p\u0000\u04f7\u04f8\u0005\n\u0000\u0000\u04f8\u00d9\u0001\u0000"+ + "\u0000\u0000\u04f9\u04fe\u0003\u00dcn\u0000\u04fa\u04fb\u0005\f\u0000"+ + "\u0000\u04fb\u04fd\u0003\u00dcn\u0000\u04fc\u04fa\u0001\u0000\u0000\u0000"+ + "\u04fd\u0500\u0001\u0000\u0000\u0000\u04fe\u04fc\u0001\u0000\u0000\u0000"+ + "\u04fe\u04ff\u0001\u0000\u0000\u0000\u04ff\u0503\u0001\u0000\u0000\u0000"+ + "\u0500\u04fe\u0001\u0000\u0000\u0000\u0501\u0502\u0005\f\u0000\u0000\u0502"+ + "\u0504\u0003\u00deo\u0000\u0503\u0501\u0001\u0000\u0000\u0000\u0503\u0504"+ + "\u0001\u0000\u0000\u0000\u0504\u050d\u0001\u0000\u0000\u0000\u0505\u050d"+ + "\u0003\u00deo\u0000\u0506\u050d\u0003\u00e4r\u0000\u0507\u050a\u0003\u00ea"+ + "u\u0000\u0508\u0509\u0005\u000f\u0000\u0000\u0509\u050b\u0003\u00dam\u0000"+ + "\u050a\u0508\u0001\u0000\u0000\u0000\u050a\u050b\u0001\u0000\u0000\u0000"+ + "\u050b\u050d\u0001\u0000\u0000\u0000\u050c\u04f9\u0001\u0000\u0000\u0000"+ + "\u050c\u0505\u0001\u0000\u0000\u0000\u050c\u0506\u0001\u0000\u0000\u0000"+ + "\u050c\u0507\u0001\u0000\u0000\u0000\u050d\u00db\u0001\u0000\u0000\u0000"+ + "\u050e\u0510\u0003p8\u0000\u050f\u050e\u0001\u0000\u0000\u0000\u050f\u0510"+ + "\u0001\u0000\u0000\u0000\u0510\u0512\u0001\u0000\u0000\u0000\u0511\u0513"+ + "\u0003L&\u0000\u0512\u0511\u0001\u0000\u0000\u0000\u0512\u0513\u0001\u0000"+ + "\u0000\u0000\u0513\u0514\u0001\u0000\u0000\u0000\u0514\u0516\u0003\u0114"+ + "\u008a\u0000\u0515\u0517\u0005\u000e\u0000\u0000\u0516\u0515\u0001\u0000"+ + "\u0000\u0000\u0516\u0517\u0001\u0000\u0000\u0000\u0517\u0519\u0001\u0000"+ + "\u0000\u0000\u0518\u051a\u0003<\u001e\u0000\u0519\u0518\u0001\u0000\u0000"+ + "\u0000\u0519\u051a\u0001\u0000\u0000\u0000\u051a\u051d\u0001\u0000\u0000"+ + "\u0000\u051b\u051c\u0005\r\u0000\u0000\u051c\u051e\u0003\u00fe\u007f\u0000"+ + "\u051d\u051b\u0001\u0000\u0000\u0000\u051d\u051e\u0001\u0000\u0000\u0000"+ + "\u051e\u00dd\u0001\u0000\u0000\u0000\u051f\u0520\u0005\u0010\u0000\u0000"+ + "\u0520\u0522\u0005|\u0000\u0000\u0521\u0523\u0003<\u001e\u0000\u0522\u0521"+ + "\u0001\u0000\u0000\u0000\u0522\u0523\u0001\u0000\u0000\u0000\u0523\u00df"+ + "\u0001\u0000\u0000\u0000\u0524\u0526\u0003\u00e2q\u0000\u0525\u0524\u0001"+ + "\u0000\u0000\u0000\u0525\u0526\u0001\u0000\u0000\u0000\u0526\u00e1\u0001"+ + "\u0000\u0000\u0000\u0527\u0529\u0003x<\u0000\u0528\u0527\u0001\u0000\u0000"+ + "\u0000\u0529\u052a\u0001\u0000\u0000\u0000\u052a\u0528\u0001\u0000\u0000"+ + "\u0000\u052a\u052b\u0001\u0000\u0000\u0000\u052b\u00e3\u0001\u0000\u0000"+ + "\u0000\u052c\u052e\u0005\u0004\u0000\u0000\u052d\u052f\u0003\u00e6s\u0000"+ + "\u052e\u052d\u0001\u0000\u0000\u0000\u052e\u052f\u0001\u0000\u0000\u0000"+ + "\u052f\u0530\u0001\u0000\u0000\u0000\u0530\u0531\u0005\u0005\u0000\u0000"+ + "\u0531\u00e5\u0001\u0000\u0000\u0000\u0532\u053b\u0003\u00e8t\u0000\u0533"+ + "\u0535\u0005\f\u0000\u0000\u0534\u0533\u0001\u0000\u0000\u0000\u0535\u0536"+ + "\u0001\u0000\u0000\u0000\u0536\u0534\u0001\u0000\u0000\u0000\u0536\u0537"+ + "\u0001\u0000\u0000\u0000\u0537\u0538\u0001\u0000\u0000\u0000\u0538\u053a"+ + "\u0003\u00e8t\u0000\u0539\u0534\u0001\u0000\u0000\u0000\u053a\u053d\u0001"+ + "\u0000\u0000\u0000\u053b\u0539\u0001\u0000\u0000\u0000\u053b\u053c\u0001"+ + "\u0000\u0000\u0000\u053c\u00e7\u0001\u0000\u0000\u0000\u053d\u053b\u0001"+ + "\u0000\u0000\u0000\u053e\u0540\u0005\u0010\u0000\u0000\u053f\u053e\u0001"+ + "\u0000\u0000\u0000\u053f\u0540\u0001\u0000\u0000\u0000\u0540\u0543\u0001"+ + "\u0000\u0000\u0000\u0541\u0544\u0003\u00fe\u007f\u0000\u0542\u0544\u0005"+ + "|\u0000\u0000\u0543\u0541\u0001\u0000\u0000\u0000\u0543\u0542\u0001\u0000"+ + "\u0000\u0000\u0544\u0546\u0001\u0000\u0000\u0000\u0545\u0547\u0005\f\u0000"+ + "\u0000\u0546\u0545\u0001\u0000\u0000\u0000\u0546\u0547\u0001\u0000\u0000"+ + "\u0000\u0547\u00e9\u0001\u0000\u0000\u0000\u0548\u0554\u0005\b\u0000\u0000"+ + "\u0549\u054e\u0003\u00ecv\u0000\u054a\u054b\u0005\f\u0000\u0000\u054b"+ + "\u054d\u0003\u00ecv\u0000\u054c\u054a\u0001\u0000\u0000\u0000\u054d\u0550"+ + "\u0001\u0000\u0000\u0000\u054e\u054c\u0001\u0000\u0000\u0000\u054e\u054f"+ + "\u0001\u0000\u0000\u0000\u054f\u0552\u0001\u0000\u0000\u0000\u0550\u054e"+ + "\u0001\u0000\u0000\u0000\u0551\u0553\u0005\f\u0000\u0000\u0552\u0551\u0001"+ + "\u0000\u0000\u0000\u0552\u0553\u0001\u0000\u0000\u0000\u0553\u0555\u0001"+ + "\u0000\u0000\u0000\u0554\u0549\u0001\u0000\u0000\u0000\u0554\u0555\u0001"+ + "\u0000\u0000\u0000\u0555\u0556\u0001\u0000\u0000\u0000\u0556\u0557\u0005"+ + "\n\u0000\u0000\u0557\u00eb\u0001\u0000\u0000\u0000\u0558\u0559\u0003\u00f2"+ + "y\u0000\u0559\u055a\u0007\u0005\u0000\u0000\u055a\u055b\u0003\u00fe\u007f"+ + "\u0000\u055b\u0568\u0001\u0000\u0000\u0000\u055c\u055d\u0005\u0004\u0000"+ + "\u0000\u055d\u055e\u0003\u00fe\u007f\u0000\u055e\u055f\u0005\u0005\u0000"+ + "\u0000\u055f\u0560\u0005\u000f\u0000\u0000\u0560\u0561\u0003\u00fe\u007f"+ + "\u0000\u0561\u0568\u0001\u0000\u0000\u0000\u0562\u0568\u0003\u00eew\u0000"+ + "\u0563\u0568\u0003\u00f0x\u0000\u0564\u0568\u0003\u00ceg\u0000\u0565\u0568"+ + "\u0003\u0114\u008a\u0000\u0566\u0568\u0003H$\u0000\u0567\u0558\u0001\u0000"+ + "\u0000\u0000\u0567\u055c\u0001\u0000\u0000\u0000\u0567\u0562\u0001\u0000"+ + "\u0000\u0000\u0567\u0563\u0001\u0000\u0000\u0000\u0567\u0564\u0001\u0000"+ + "\u0000\u0000\u0567\u0565\u0001\u0000\u0000\u0000\u0567\u0566\u0001\u0000"+ + "\u0000\u0000\u0568\u00ed\u0001\u0000\u0000\u0000\u0569\u056a\u0003\u011a"+ + "\u008d\u0000\u056a\u056b\u0005\u0006\u0000\u0000\u056b\u056d\u0005\u0007"+ + "\u0000\u0000\u056c\u056e\u0003<\u001e\u0000\u056d\u056c\u0001\u0000\u0000"+ + "\u0000\u056d\u056e\u0001\u0000\u0000\u0000\u056e\u056f\u0001\u0000\u0000"+ + "\u0000\u056f\u0570\u0005\b\u0000\u0000\u0570\u0571\u0003\u00e0p\u0000"+ + "\u0571\u0572\u0005\n\u0000\u0000\u0572\u00ef\u0001\u0000\u0000\u0000\u0573"+ + "\u0574\u0003\u011c\u008e\u0000\u0574\u0577\u0005\u0006\u0000\u0000\u0575"+ + "\u0578\u0005|\u0000\u0000\u0576\u0578\u0003\u0002\u0001\u0000\u0577\u0575"+ + "\u0001\u0000\u0000\u0000\u0577\u0576\u0001\u0000\u0000\u0000\u0578\u057a"+ + "\u0001\u0000\u0000\u0000\u0579\u057b\u0003<\u001e\u0000\u057a\u0579\u0001"+ + "\u0000\u0000\u0000\u057a\u057b\u0001\u0000\u0000\u0000\u057b\u057c\u0001"+ + "\u0000\u0000\u0000\u057c\u057d\u0005\u0007\u0000\u0000\u057d\u057e\u0005"+ + "\b\u0000\u0000\u057e\u057f\u0003\u00e0p\u0000\u057f\u0580\u0005\n\u0000"+ + "\u0000\u0580\u00f1\u0001\u0000\u0000\u0000\u0581\u0585\u0003\u0112\u0089"+ + "\u0000\u0582\u0585\u0005}\u0000\u0000\u0583\u0585\u0003\u0110\u0088\u0000"+ + "\u0584\u0581\u0001\u0000\u0000\u0000\u0584\u0582\u0001\u0000\u0000\u0000"+ + "\u0584\u0583\u0001\u0000\u0000\u0000\u0585\u00f3\u0001\u0000\u0000\u0000"+ + "\u0586\u058b\u0005\u0006\u0000\u0000\u0587\u0589\u0003\u00f6{\u0000\u0588"+ + "\u058a\u0005\f\u0000\u0000\u0589\u0588\u0001\u0000\u0000\u0000\u0589\u058a"+ + "\u0001\u0000\u0000\u0000\u058a\u058c\u0001\u0000\u0000\u0000\u058b\u0587"+ + "\u0001\u0000\u0000\u0000\u058b\u058c\u0001\u0000\u0000\u0000\u058c\u058d"+ + "\u0001\u0000\u0000\u0000\u058d\u058e\u0005\u0007\u0000\u0000\u058e\u00f5"+ + "\u0001\u0000\u0000\u0000\u058f\u0594\u0003\u00f8|\u0000\u0590\u0591\u0005"+ + "\f\u0000\u0000\u0591\u0593\u0003\u00f8|\u0000\u0592\u0590\u0001\u0000"+ + "\u0000\u0000\u0593\u0596\u0001\u0000\u0000\u0000\u0594\u0592\u0001\u0000"+ + "\u0000\u0000\u0594\u0595\u0001\u0000\u0000\u0000\u0595\u00f7\u0001\u0000"+ + "\u0000\u0000\u0596\u0594\u0001\u0000\u0000\u0000\u0597\u0599\u0005\u0010"+ + "\u0000\u0000\u0598\u0597\u0001\u0000\u0000\u0000\u0598\u0599\u0001\u0000"+ + "\u0000\u0000\u0599\u059c\u0001\u0000\u0000\u0000\u059a\u059d\u0003\u00fe"+ + "\u007f\u0000\u059b\u059d\u0005|\u0000\u0000\u059c\u059a\u0001\u0000\u0000"+ + "\u0000\u059c\u059b\u0001\u0000\u0000\u0000\u059d\u00f9\u0001\u0000\u0000"+ + "\u0000\u059e\u05a3\u0003\u00fe\u007f\u0000\u059f\u05a0\u0005\f\u0000\u0000"+ + "\u05a0\u05a2\u0003\u00fe\u007f\u0000\u05a1\u059f\u0001\u0000\u0000\u0000"+ + "\u05a2\u05a5\u0001\u0000\u0000\u0000\u05a3\u05a1\u0001\u0000\u0000\u0000"+ + "\u05a3\u05a4\u0001\u0000\u0000\u0000\u05a4\u00fb\u0001\u0000\u0000\u0000"+ + "\u05a5\u05a3\u0001\u0000\u0000\u0000\u05a6\u05a8\u0005O\u0000\u0000\u05a7"+ + "\u05a9\u0005|\u0000\u0000\u05a8\u05a7\u0001\u0000\u0000\u0000\u05a8\u05a9"+ + "\u0001\u0000\u0000\u0000\u05a9\u05aa\u0001\u0000\u0000\u0000\u05aa\u05ac"+ + "\u0005\u0006\u0000\u0000\u05ab\u05ad\u0003\u00dam\u0000\u05ac\u05ab\u0001"+ + "\u0000\u0000\u0000\u05ac\u05ad\u0001\u0000\u0000\u0000\u05ad\u05ae\u0001"+ + "\u0000\u0000\u0000\u05ae\u05b0\u0005\u0007\u0000\u0000\u05af\u05b1\u0003"+ + "<\u001e\u0000\u05b0\u05af\u0001\u0000\u0000\u0000\u05b0\u05b1\u0001\u0000"+ + "\u0000\u0000\u05b1\u05b2\u0001\u0000\u0000\u0000\u05b2\u05b3\u0005\b\u0000"+ + "\u0000\u05b3\u05b4\u0003\u00e0p\u0000\u05b4\u05b5\u0005\n\u0000\u0000"+ + "\u05b5\u00fd\u0001\u0000\u0000\u0000\u05b6\u05b7\u0006\u007f\uffff\uffff"+ + "\u0000\u05b7\u05ed\u0003\u00fc~\u0000\u05b8\u05ed\u0003\u0102\u0081\u0000"+ + "\u05b9\u05ba\u0005D\u0000\u0000\u05ba\u05bc\u0003\u00fe\u007f\u0000\u05bb"+ + "\u05bd\u0003\f\u0006\u0000\u05bc\u05bb\u0001\u0000\u0000\u0000\u05bc\u05bd"+ + "\u0001\u0000\u0000\u0000\u05bd\u05be\u0001\u0000\u0000\u0000\u05be\u05bf"+ + "\u0003\u00f4z\u0000\u05bf\u05ed\u0001\u0000\u0000\u0000\u05c0\u05c1\u0005"+ + "D\u0000\u0000\u05c1\u05c3\u0003\u00fe\u007f\u0000\u05c2\u05c4\u0003\f"+ + "\u0006\u0000\u05c3\u05c2\u0001\u0000\u0000\u0000\u05c3\u05c4\u0001\u0000"+ + "\u0000\u0000\u05c4\u05ed\u0001\u0000\u0000\u0000\u05c5\u05c6\u0005U\u0000"+ + "\u0000\u05c6\u05ed\u0003\u00fe\u007f&\u05c7\u05c8\u0005I\u0000\u0000\u05c8"+ + "\u05ed\u0003\u00fe\u007f%\u05c9\u05ca\u0005A\u0000\u0000\u05ca\u05ed\u0003"+ + "\u00fe\u007f$\u05cb\u05cc\u0005\u0012\u0000\u0000\u05cc\u05ed\u0003\u00fe"+ + "\u007f#\u05cd\u05ce\u0005\u0013\u0000\u0000\u05ce\u05ed\u0003\u00fe\u007f"+ + "\"\u05cf\u05d0\u0005\u0014\u0000\u0000\u05d0\u05ed\u0003\u00fe\u007f!"+ + "\u05d1\u05d2\u0005\u0015\u0000\u0000\u05d2\u05ed\u0003\u00fe\u007f \u05d3"+ + "\u05d4\u0005\u0016\u0000\u0000\u05d4\u05ed\u0003\u00fe\u007f\u001f\u05d5"+ + "\u05d6\u0005\u0017\u0000\u0000\u05d6\u05ed\u0003\u00fe\u007f\u001e\u05d7"+ + "\u05ed\u0003\u00d6k\u0000\u05d8\u05ed\u0003\u00d2i\u0000\u05d9\u05ed\u0003"+ + "\u00d0h\u0000\u05da\u05ed\u0003\u00a0P\u0000\u05db\u05ed\u0005P\u0000"+ + "\u0000\u05dc\u05de\u0003\u0112\u0089\u0000\u05dd\u05df\u0003\u00fe\u007f"+ + "\u0000\u05de\u05dd\u0001\u0000\u0000\u0000\u05de\u05df\u0001\u0000\u0000"+ + "\u0000\u05df\u05ed\u0001\u0000\u0000\u0000\u05e0\u05ed\u0005_\u0000\u0000"+ + "\u05e1\u05ed\u0003\u010a\u0085\u0000\u05e2\u05ed\u0003\u00e4r\u0000\u05e3"+ + "\u05ed\u0003\u00eau\u0000\u05e4\u05e5\u0005\u0006\u0000\u0000\u05e5\u05e6"+ + "\u0003\u00fa}\u0000\u05e6\u05e7\u0005\u0007\u0000\u0000\u05e7\u05ed\u0001"+ + "\u0000\u0000\u0000\u05e8\u05ea\u0003\f\u0006\u0000\u05e9\u05eb\u0003\u00fa"+ + "}\u0000\u05ea\u05e9\u0001\u0000\u0000\u0000\u05ea\u05eb\u0001\u0000\u0000"+ + "\u0000\u05eb\u05ed\u0001\u0000\u0000\u0000\u05ec\u05b6\u0001\u0000\u0000"+ + "\u0000\u05ec\u05b8\u0001\u0000\u0000\u0000\u05ec\u05b9\u0001\u0000\u0000"+ + "\u0000\u05ec\u05c0\u0001\u0000\u0000\u0000\u05ec\u05c5\u0001\u0000\u0000"+ + "\u0000\u05ec\u05c7\u0001\u0000\u0000\u0000\u05ec\u05c9\u0001\u0000\u0000"+ + "\u0000\u05ec\u05cb\u0001\u0000\u0000\u0000\u05ec\u05cd\u0001\u0000\u0000"+ + "\u0000\u05ec\u05cf\u0001\u0000\u0000\u0000\u05ec\u05d1\u0001\u0000\u0000"+ + "\u0000\u05ec\u05d3\u0001\u0000\u0000\u0000\u05ec\u05d5\u0001\u0000\u0000"+ + "\u0000\u05ec\u05d7\u0001\u0000\u0000\u0000\u05ec\u05d8\u0001\u0000\u0000"+ + "\u0000\u05ec\u05d9\u0001\u0000\u0000\u0000\u05ec\u05da\u0001\u0000\u0000"+ + "\u0000\u05ec\u05db\u0001\u0000\u0000\u0000\u05ec\u05dc\u0001\u0000\u0000"+ + "\u0000\u05ec\u05e0\u0001\u0000\u0000\u0000\u05ec\u05e1\u0001\u0000\u0000"+ + "\u0000\u05ec\u05e2\u0001\u0000\u0000\u0000\u05ec\u05e3\u0001\u0000\u0000"+ + "\u0000\u05ec\u05e4\u0001\u0000\u0000\u0000\u05ec\u05e8\u0001\u0000\u0000"+ + "\u0000\u05ed\u063c\u0001\u0000\u0000\u0000\u05ee\u05ef\n\u001d\u0000\u0000"+ + "\u05ef\u05f0\u0007\u0006\u0000\u0000\u05f0\u063b\u0003\u00fe\u007f\u001e"+ + "\u05f1\u05f2\n\u001c\u0000\u0000\u05f2\u05f3\u0007\u0007\u0000\u0000\u05f3"+ + "\u063b\u0003\u00fe\u007f\u001d\u05f4\u05f5\n\u001b\u0000\u0000\u05f5\u05f6"+ + "\u0007\b\u0000\u0000\u05f6\u063b\u0003\u00fe\u007f\u001c\u05f7\u05f8\n"+ + "\u001a\u0000\u0000\u05f8\u05f9\u0007\t\u0000\u0000\u05f9\u063b\u0003\u00fe"+ + "\u007f\u001b\u05fa\u05fb\n\u0019\u0000\u0000\u05fb\u05fc\u0005@\u0000"+ + "\u0000\u05fc\u063b\u0003\u00fe\u007f\u001a\u05fd\u05fe\n\u0018\u0000\u0000"+ + "\u05fe\u05ff\u0005V\u0000\u0000\u05ff\u063b\u0003\u00fe\u007f\u0019\u0600"+ + "\u0601\n\u0017\u0000\u0000\u0601\u0602\u0007\n\u0000\u0000\u0602\u063b"+ + "\u0003\u00fe\u007f\u0018\u0603\u0604\n\u0016\u0000\u0000\u0604\u0605\u0005"+ + "&\u0000\u0000\u0605\u063b\u0003\u00fe\u007f\u0017\u0606\u0607\n\u0015"+ + "\u0000\u0000\u0607\u0608\u0005\'\u0000\u0000\u0608\u063b\u0003\u00fe\u007f"+ + "\u0016\u0609\u060a\n\u0014\u0000\u0000\u060a\u060b\u0005(\u0000\u0000"+ + "\u060b\u063b\u0003\u00fe\u007f\u0015\u060c\u060d\n\u0013\u0000\u0000\u060d"+ + "\u060e\u0005)\u0000\u0000\u060e\u063b\u0003\u00fe\u007f\u0014\u060f\u0610"+ + "\n\u0012\u0000\u0000\u0610\u0611\u0005*\u0000\u0000\u0611\u063b\u0003"+ + "\u00fe\u007f\u0013\u0612\u0613\n\u0011\u0000\u0000\u0613\u0614\u0005\u000e"+ + "\u0000\u0000\u0614\u0615\u0003\u00fe\u007f\u0000\u0615\u0616\u0005\u000f"+ + "\u0000\u0000\u0616\u0617\u0003\u00fe\u007f\u0012\u0617\u063b\u0001\u0000"+ + "\u0000\u0000\u0618\u0619\n\u0010\u0000\u0000\u0619\u061a\u0005\r\u0000"+ + "\u0000\u061a\u063b\u0003\u00fe\u007f\u0011\u061b\u061c\n\u000f\u0000\u0000"+ + "\u061c\u061d\u0003\u0108\u0084\u0000\u061d\u061e\u0003\u00fe\u007f\u0010"+ + "\u061e\u063b\u0001\u0000\u0000\u0000\u061f\u0620\n-\u0000\u0000\u0620"+ + "\u0621\u0005\u0004\u0000\u0000\u0621\u0622\u0003\u00fa}\u0000\u0622\u0623"+ + "\u0005\u0005\u0000\u0000\u0623\u063b\u0001\u0000\u0000\u0000\u0624\u0626"+ + "\n,\u0000\u0000\u0625\u0627\u0005\u0017\u0000\u0000\u0626\u0625\u0001"+ + "\u0000\u0000\u0000\u0626\u0627\u0001\u0000\u0000\u0000\u0627\u0628\u0001"+ + "\u0000\u0000\u0000\u0628\u0629\u0005\u0011\u0000\u0000\u0629\u062b\u0003"+ + "\u0112\u0089\u0000\u062a\u062c\u0003\u001c\u000e\u0000\u062b\u062a\u0001"+ + "\u0000\u0000\u0000\u062b\u062c\u0001\u0000\u0000\u0000\u062c\u063b\u0001"+ + "\u0000\u0000\u0000\u062d\u062e\n)\u0000\u0000\u062e\u063b\u0003\u00f4"+ + "z\u0000\u062f\u0630\n(\u0000\u0000\u0630\u0631\u0004\u007f!\u0000\u0631"+ + "\u063b\u0005\u0012\u0000\u0000\u0632\u0633\n\'\u0000\u0000\u0633\u0634"+ + "\u0004\u007f#\u0000\u0634\u063b\u0005\u0013\u0000\u0000\u0635\u0636\n"+ + "\u000e\u0000\u0000\u0636\u063b\u0003\u010c\u0086\u0000\u0637\u0638\n\u0001"+ + "\u0000\u0000\u0638\u0639\u0005X\u0000\u0000\u0639\u063b\u0003\u0100\u0080"+ + "\u0000\u063a\u05ee\u0001\u0000\u0000\u0000\u063a\u05f1\u0001\u0000\u0000"+ + "\u0000\u063a\u05f4\u0001\u0000\u0000\u0000\u063a\u05f7\u0001\u0000\u0000"+ + "\u0000\u063a\u05fa\u0001\u0000\u0000\u0000\u063a\u05fd\u0001\u0000\u0000"+ + "\u0000\u063a\u0600\u0001\u0000\u0000\u0000\u063a\u0603\u0001\u0000\u0000"+ + "\u0000\u063a\u0606\u0001\u0000\u0000\u0000\u063a\u0609\u0001\u0000\u0000"+ + "\u0000\u063a\u060c\u0001\u0000\u0000\u0000\u063a\u060f\u0001\u0000\u0000"+ + "\u0000\u063a\u0612\u0001\u0000\u0000\u0000\u063a\u0618\u0001\u0000\u0000"+ + "\u0000\u063a\u061b\u0001\u0000\u0000\u0000\u063a\u061f\u0001\u0000\u0000"+ + "\u0000\u063a\u0624\u0001\u0000\u0000\u0000\u063a\u062d\u0001\u0000\u0000"+ + "\u0000\u063a\u062f\u0001\u0000\u0000\u0000\u063a\u0632\u0001\u0000\u0000"+ + "\u0000\u063a\u0635\u0001\u0000\u0000\u0000\u063a\u0637\u0001\u0000\u0000"+ + "\u0000\u063b\u063e\u0001\u0000\u0000\u0000\u063c\u063a\u0001\u0000\u0000"+ + "\u0000\u063c\u063d\u0001\u0000\u0000\u0000\u063d\u00ff\u0001\u0000\u0000"+ + "\u0000\u063e\u063c\u0001\u0000\u0000\u0000\u063f\u0642\u0003\u0018\f\u0000"+ + "\u0640\u0641\u0005\u0004\u0000\u0000\u0641\u0643\u0005\u0005\u0000\u0000"+ + "\u0642\u0640\u0001\u0000\u0000\u0000\u0642\u0643\u0001\u0000\u0000\u0000"+ + "\u0643\u0646\u0001\u0000\u0000\u0000\u0644\u0646\u0003\u00fe\u007f\u0000"+ + "\u0645\u063f\u0001\u0000\u0000\u0000\u0645\u0644\u0001\u0000\u0000\u0000"+ + "\u0646\u0101\u0001\u0000\u0000\u0000\u0647\u0649\u0005[\u0000\u0000\u0648"+ + "\u0647\u0001\u0000\u0000\u0000\u0648\u0649\u0001\u0000\u0000\u0000\u0649"+ + "\u064a\u0001\u0000\u0000\u0000\u064a\u064c\u0003\u0104\u0082\u0000\u064b"+ + "\u064d\u0003<\u001e\u0000\u064c\u064b\u0001\u0000\u0000\u0000\u064c\u064d"+ + "\u0001\u0000\u0000\u0000\u064d\u064e\u0001\u0000\u0000\u0000\u064e\u064f"+ + "\u00056\u0000\u0000\u064f\u0650\u0003\u0106\u0083\u0000\u0650\u0103\u0001"+ + "\u0000\u0000\u0000\u0651\u0658\u0005|\u0000\u0000\u0652\u0654\u0005\u0006"+ + "\u0000\u0000\u0653\u0655\u0003\u00dam\u0000\u0654\u0653\u0001\u0000\u0000"+ + "\u0000\u0654\u0655\u0001\u0000\u0000\u0000\u0655\u0656\u0001\u0000\u0000"+ + "\u0000\u0656\u0658\u0005\u0007\u0000\u0000\u0657\u0651\u0001\u0000\u0000"+ + "\u0000\u0657\u0652\u0001\u0000\u0000\u0000\u0658\u0105\u0001\u0000\u0000"+ + "\u0000\u0659\u065f\u0003\u00fe\u007f\u0000\u065a\u065b\u0005\b\u0000\u0000"+ + "\u065b\u065c\u0003\u00e0p\u0000\u065c\u065d\u0005\n\u0000\u0000\u065d"+ + "\u065f\u0001\u0000\u0000\u0000\u065e\u0659\u0001\u0000\u0000\u0000\u065e"+ + "\u065a\u0001\u0000\u0000\u0000\u065f\u0107\u0001\u0000\u0000\u0000\u0660"+ + "\u0661\u0007\u000b\u0000\u0000\u0661\u0109\u0001\u0000\u0000\u0000\u0662"+ + "\u0669\u00057\u0000\u0000\u0663\u0669\u00058\u0000\u0000\u0664\u0669\u0005"+ + "}\u0000\u0000\u0665\u0669\u0003\u010c\u0086\u0000\u0666\u0669\u0005\u0003"+ + "\u0000\u0000\u0667\u0669\u0003\u0110\u0088\u0000\u0668\u0662\u0001\u0000"+ + "\u0000\u0000\u0668\u0663\u0001\u0000\u0000\u0000\u0668\u0664\u0001\u0000"+ + "\u0000\u0000\u0668\u0665\u0001\u0000\u0000\u0000\u0668\u0666\u0001\u0000"+ + "\u0000\u0000\u0668\u0667\u0001\u0000\u0000\u0000\u0669\u010b\u0001\u0000"+ + "\u0000\u0000\u066a\u066e\u0005~\u0000\u0000\u066b\u066d\u0003\u010e\u0087"+ + "\u0000\u066c\u066b\u0001\u0000\u0000\u0000\u066d\u0670\u0001\u0000\u0000"+ + "\u0000\u066e\u066c\u0001\u0000\u0000\u0000\u066e\u066f\u0001\u0000\u0000"+ + "\u0000\u066f\u0671\u0001\u0000\u0000\u0000\u0670\u066e\u0001\u0000\u0000"+ + "\u0000\u0671\u0672\u0005~\u0000\u0000\u0672\u010d\u0001\u0000\u0000\u0000"+ + "\u0673\u067a\u0005\u0086\u0000\u0000\u0674\u0675\u0005\u0085\u0000\u0000"+ + "\u0675\u0676\u0003\u00fe\u007f\u0000\u0676\u0677\u0005\t\u0000\u0000\u0677"+ + "\u067a\u0001\u0000\u0000\u0000\u0678\u067a\u0005\u0084\u0000\u0000\u0679"+ + "\u0673\u0001\u0000\u0000\u0000\u0679\u0674\u0001\u0000\u0000\u0000\u0679"+ + "\u0678\u0001\u0000\u0000\u0000\u067a\u010f\u0001\u0000\u0000\u0000\u067b"+ + "\u067c\u0007\f\u0000\u0000\u067c\u0111\u0001\u0000\u0000\u0000\u067d\u0680"+ + "\u0005|\u0000\u0000\u067e\u0680\u0003\u0116\u008b\u0000\u067f\u067d\u0001"+ + "\u0000\u0000\u0000\u067f\u067e\u0001\u0000\u0000\u0000\u0680\u0113\u0001"+ + "\u0000\u0000\u0000\u0681\u0682\u0007\r\u0000\u0000\u0682\u0115\u0001\u0000"+ + "\u0000\u0000\u0683\u0687\u0003\u0118\u008c\u0000\u0684\u0687\u00057\u0000"+ + "\u0000\u0685\u0687\u00058\u0000\u0000\u0686\u0683\u0001\u0000\u0000\u0000"+ + "\u0686\u0684\u0001\u0000\u0000\u0000\u0686\u0685\u0001\u0000\u0000\u0000"+ + "\u0687\u0117\u0001\u0000\u0000\u0000\u0688\u0689\u0007\u000e\u0000\u0000"+ + "\u0689\u0119\u0001\u0000\u0000\u0000\u068a\u068b\u0005r\u0000\u0000\u068b"+ + "\u068c\u0003\u00f2y\u0000\u068c\u011b\u0001\u0000\u0000\u0000\u068d\u068e"+ + "\u0005s\u0000\u0000\u068e\u068f\u0003\u00f2y\u0000\u068f\u011d\u0001\u0000"+ + "\u0000\u0000\u0690\u0695\u0005\u000b\u0000\u0000\u0691\u0695\u0005\u0000"+ + "\u0000\u0001\u0692\u0695\u0004\u008f&\u0000\u0693\u0695\u0004\u008f\'"+ + "\u0000\u0694\u0690\u0001\u0000\u0000\u0000\u0694\u0691\u0001\u0000\u0000"+ + "\u0000\u0694\u0692\u0001\u0000\u0000\u0000\u0694\u0693\u0001\u0000\u0000"+ + "\u0000\u0695\u011f\u0001\u0000\u0000\u0000\u00d5\u0125\u0129\u0132\u0137"+ + "\u013a\u0141\u014a\u0154\u015f\u0161\u0176\u017e\u0185\u0189\u0198\u019c"+ + "\u01a0\u01a6\u01ad\u01b7\u01b9\u01c9\u01cd\u01d1\u01d9\u01dd\u01ec\u01f0"+ + "\u01f3\u01f7\u01fa\u01fe\u0204\u0208\u020c\u0214\u0219\u021b\u0222\u0227"+ + "\u022a\u022d\u0232\u0235\u0238\u023d\u0240\u0243\u0247\u024d\u0251\u0255"+ + "\u0259\u0264\u026b\u0272\u0277\u027f\u0282\u0285\u028a\u028d\u0291\u029b"+ + "\u029f\u02a5\u02ab\u02b2\u02b8\u02be\u02c6\u02cb\u02d6\u02db\u02e3\u02ea"+ + "\u02f1\u02f6\u0317\u031b\u0322\u0328\u032f\u0333\u0337\u0340\u0348\u034f"+ + "\u0353\u0357\u035b\u035e\u0361\u0364\u0368\u036c\u0370\u0372\u0379\u037f"+ + "\u0382\u0385\u0389\u038c\u0393\u039c\u03af\u03b3\u03b7\u03c1\u03c5\u03d0"+ + "\u03dd\u03e3\u03ea\u03f1\u03f8\u03ff\u0411\u0415\u0417\u041e\u0424\u0429"+ + "\u0438\u043b\u0451\u0454\u0458\u045a\u045d\u0462\u0468\u046b\u0471\u047e"+ + "\u0483\u0488\u048b\u048e\u049a\u049f\u04a2\u04a5\u04a8\u04ab\u04ae\u04b4"+ + "\u04b9\u04c3\u04c7\u04d4\u04d8\u04e5\u04e9\u04f2\u04fe\u0503\u050a\u050c"+ + "\u050f\u0512\u0516\u0519\u051d\u0522\u0525\u052a\u052e\u0536\u053b\u053f"+ + "\u0543\u0546\u054e\u0552\u0554\u0567\u056d\u0577\u057a\u0584\u0589\u058b"+ + "\u0594\u0598\u059c\u05a3\u05a8\u05ac\u05b0\u05bc\u05c3\u05de\u05ea\u05ec"+ + "\u0626\u062b\u063a\u063c\u0642\u0645\u0648\u064c\u0654\u0657\u065e\u0668"+ + "\u066e\u0679\u067f\u0686\u0694"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.tokens b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.tokens new file mode 100644 index 0000000..8679637 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.tokens @@ -0,0 +1,247 @@ +MultiLineComment=1 +SingleLineComment=2 +RegularExpressionLiteral=3 +OpenBracket=4 +CloseBracket=5 +OpenParen=6 +CloseParen=7 +OpenBrace=8 +TemplateCloseBrace=9 +CloseBrace=10 +SemiColon=11 +Comma=12 +Assign=13 +QuestionMark=14 +Colon=15 +Ellipsis=16 +Dot=17 +PlusPlus=18 +MinusMinus=19 +Plus=20 +Minus=21 +BitNot=22 +Not=23 +Multiply=24 +Divide=25 +Modulus=26 +RightShiftArithmetic=27 +LeftShiftArithmetic=28 +RightShiftLogical=29 +LessThan=30 +MoreThan=31 +LessThanEquals=32 +GreaterThanEquals=33 +Equals_=34 +NotEquals=35 +IdentityEquals=36 +IdentityNotEquals=37 +BitAnd=38 +BitXOr=39 +BitOr=40 +And=41 +Or=42 +MultiplyAssign=43 +DivideAssign=44 +ModulusAssign=45 +PlusAssign=46 +MinusAssign=47 +LeftShiftArithmeticAssign=48 +RightShiftArithmeticAssign=49 +RightShiftLogicalAssign=50 +BitAndAssign=51 +BitXorAssign=52 +BitOrAssign=53 +ARROW=54 +NullLiteral=55 +BooleanLiteral=56 +DecimalLiteral=57 +HexIntegerLiteral=58 +OctalIntegerLiteral=59 +OctalIntegerLiteral2=60 +BinaryIntegerLiteral=61 +Break=62 +Do=63 +Instanceof=64 +Typeof=65 +Case=66 +Else=67 +New=68 +Var=69 +Catch=70 +Finally=71 +Return=72 +Void=73 +Continue=74 +For=75 +Switch=76 +While=77 +Debugger=78 +Function_=79 +This=80 +With=81 +Default=82 +If=83 +Throw=84 +Delete=85 +In=86 +Try=87 +As=88 +From=89 +ReadOnly=90 +Async=91 +Class=92 +Enum=93 +Extends=94 +Super=95 +Const=96 +Export=97 +Import=98 +Implements=99 +Let=100 +Private=101 +Public=102 +Interface=103 +Package=104 +Protected=105 +Static=106 +Yield=107 +Any=108 +Number=109 +Boolean=110 +String=111 +Symbol=112 +TypeAlias=113 +Get=114 +Set=115 +Constructor=116 +Namespace=117 +Require=118 +Module=119 +Declare=120 +Abstract=121 +Is=122 +At=123 +Identifier=124 +StringLiteral=125 +BackTick=126 +WhiteSpaces=127 +LineTerminator=128 +HtmlComment=129 +CDataComment=130 +UnexpectedCharacter=131 +TemplateStringEscapeAtom=132 +TemplateStringStartExpression=133 +TemplateStringAtom=134 +'['=4 +']'=5 +'('=6 +')'=7 +'{'=8 +'}'=10 +';'=11 +','=12 +'='=13 +'?'=14 +':'=15 +'...'=16 +'.'=17 +'++'=18 +'--'=19 +'+'=20 +'-'=21 +'~'=22 +'!'=23 +'*'=24 +'/'=25 +'%'=26 +'>>'=27 +'<<'=28 +'>>>'=29 +'<'=30 +'>'=31 +'<='=32 +'>='=33 +'=='=34 +'!='=35 +'==='=36 +'!=='=37 +'&'=38 +'^'=39 +'|'=40 +'&&'=41 +'||'=42 +'*='=43 +'/='=44 +'%='=45 +'+='=46 +'-='=47 +'<<='=48 +'>>='=49 +'>>>='=50 +'&='=51 +'^='=52 +'|='=53 +'=>'=54 +'null'=55 +'break'=62 +'do'=63 +'instanceof'=64 +'typeof'=65 +'case'=66 +'else'=67 +'new'=68 +'var'=69 +'catch'=70 +'finally'=71 +'return'=72 +'void'=73 +'continue'=74 +'for'=75 +'switch'=76 +'while'=77 +'debugger'=78 +'function'=79 +'this'=80 +'with'=81 +'default'=82 +'if'=83 +'throw'=84 +'delete'=85 +'in'=86 +'try'=87 +'as'=88 +'from'=89 +'readonly'=90 +'async'=91 +'class'=92 +'enum'=93 +'extends'=94 +'super'=95 +'const'=96 +'export'=97 +'import'=98 +'implements'=99 +'let'=100 +'private'=101 +'public'=102 +'interface'=103 +'package'=104 +'protected'=105 +'static'=106 +'yield'=107 +'any'=108 +'number'=109 +'boolean'=110 +'string'=111 +'symbol'=112 +'type'=113 +'get'=114 +'set'=115 +'constructor'=116 +'namespace'=117 +'require'=118 +'module'=119 +'declare'=120 +'abstract'=121 +'is'=122 +'@'=123 diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParserBaseListener.java b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParserBaseListener.java new file mode 100644 index 0000000..20501ab --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParserBaseListener.java @@ -0,0 +1,3458 @@ +// Generated from /www/p_java/babylon/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.g4 by ANTLR 4.13.1 +package one.edee.babylon.export.ts.gen; + +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.tree.ErrorNode; +import org.antlr.v4.runtime.tree.TerminalNode; + +/** + * This class provides an empty implementation of {@link TypeScriptParserListener}, + * which can be extended to create a listener which only needs to handle a subset + * of the available methods. + */ +@SuppressWarnings("CheckReturnValue") +public class TypeScriptParserBaseListener implements TypeScriptParserListener { + private static boolean DEBUG_LISTENER_METHODS = false; + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInitializer(TypeScriptParser.InitializerContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInitializer(TypeScriptParser.InitializerContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBindingPattern(TypeScriptParser.BindingPatternContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBindingPattern(TypeScriptParser.BindingPatternContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeParameters(TypeScriptParser.TypeParametersContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeParameters(TypeScriptParser.TypeParametersContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeParameterList(TypeScriptParser.TypeParameterListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeParameterList(TypeScriptParser.TypeParameterListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeParameter(TypeScriptParser.TypeParameterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeParameter(TypeScriptParser.TypeParameterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstraint(TypeScriptParser.ConstraintContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstraint(TypeScriptParser.ConstraintContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeArguments(TypeScriptParser.TypeArgumentsContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeArguments(TypeScriptParser.TypeArgumentsContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeArgumentList(TypeScriptParser.TypeArgumentListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeArgumentList(TypeScriptParser.TypeArgumentListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeArgument(TypeScriptParser.TypeArgumentContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeArgument(TypeScriptParser.TypeArgumentContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterType_(TypeScriptParser.Type_Context ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitType_(TypeScriptParser.Type_Context ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIntersection(TypeScriptParser.IntersectionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIntersection(TypeScriptParser.IntersectionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrimary(TypeScriptParser.PrimaryContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrimary(TypeScriptParser.PrimaryContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnion(TypeScriptParser.UnionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnion(TypeScriptParser.UnionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRedefinitionOfType(TypeScriptParser.RedefinitionOfTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRedefinitionOfType(TypeScriptParser.RedefinitionOfTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPredefinedPrimType(TypeScriptParser.PredefinedPrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPredefinedPrimType(TypeScriptParser.PredefinedPrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArrayPrimType(TypeScriptParser.ArrayPrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArrayPrimType(TypeScriptParser.ArrayPrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterParenthesizedPrimType(TypeScriptParser.ParenthesizedPrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitParenthesizedPrimType(TypeScriptParser.ParenthesizedPrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterThisPrimType(TypeScriptParser.ThisPrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitThisPrimType(TypeScriptParser.ThisPrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTuplePrimType(TypeScriptParser.TuplePrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTuplePrimType(TypeScriptParser.TuplePrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterObjectPrimType(TypeScriptParser.ObjectPrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitObjectPrimType(TypeScriptParser.ObjectPrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReferencePrimType(TypeScriptParser.ReferencePrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReferencePrimType(TypeScriptParser.ReferencePrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQueryPrimType(TypeScriptParser.QueryPrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQueryPrimType(TypeScriptParser.QueryPrimTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPredefinedType(TypeScriptParser.PredefinedTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPredefinedType(TypeScriptParser.PredefinedTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeReference(TypeScriptParser.TypeReferenceContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeReference(TypeScriptParser.TypeReferenceContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNestedTypeGeneric(TypeScriptParser.NestedTypeGenericContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNestedTypeGeneric(TypeScriptParser.NestedTypeGenericContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeGeneric(TypeScriptParser.TypeGenericContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeGeneric(TypeScriptParser.TypeGenericContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeIncludeGeneric(TypeScriptParser.TypeIncludeGenericContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeIncludeGeneric(TypeScriptParser.TypeIncludeGenericContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeName(TypeScriptParser.TypeNameContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeName(TypeScriptParser.TypeNameContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterObjectType(TypeScriptParser.ObjectTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitObjectType(TypeScriptParser.ObjectTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeBody(TypeScriptParser.TypeBodyContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeBody(TypeScriptParser.TypeBodyContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeMemberList(TypeScriptParser.TypeMemberListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeMemberList(TypeScriptParser.TypeMemberListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeMember(TypeScriptParser.TypeMemberContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeMember(TypeScriptParser.TypeMemberContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArrayType(TypeScriptParser.ArrayTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArrayType(TypeScriptParser.ArrayTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTupleType(TypeScriptParser.TupleTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTupleType(TypeScriptParser.TupleTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTupleElementTypes(TypeScriptParser.TupleElementTypesContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTupleElementTypes(TypeScriptParser.TupleElementTypesContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunctionType(TypeScriptParser.FunctionTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunctionType(TypeScriptParser.FunctionTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstructorType(TypeScriptParser.ConstructorTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstructorType(TypeScriptParser.ConstructorTypeContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeQuery(TypeScriptParser.TypeQueryContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeQuery(TypeScriptParser.TypeQueryContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeQueryExpression(TypeScriptParser.TypeQueryExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeQueryExpression(TypeScriptParser.TypeQueryExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPropertySignatur(TypeScriptParser.PropertySignaturContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPropertySignatur(TypeScriptParser.PropertySignaturContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeAnnotation(TypeScriptParser.TypeAnnotationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeAnnotation(TypeScriptParser.TypeAnnotationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCallSignature(TypeScriptParser.CallSignatureContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCallSignature(TypeScriptParser.CallSignatureContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterParameterList(TypeScriptParser.ParameterListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitParameterList(TypeScriptParser.ParameterListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRequiredParameterList(TypeScriptParser.RequiredParameterListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRequiredParameterList(TypeScriptParser.RequiredParameterListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterParameter(TypeScriptParser.ParameterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitParameter(TypeScriptParser.ParameterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOptionalParameter(TypeScriptParser.OptionalParameterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOptionalParameter(TypeScriptParser.OptionalParameterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRestParameter(TypeScriptParser.RestParameterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRestParameter(TypeScriptParser.RestParameterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRequiredParameter(TypeScriptParser.RequiredParameterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRequiredParameter(TypeScriptParser.RequiredParameterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAccessibilityModifier(TypeScriptParser.AccessibilityModifierContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAccessibilityModifier(TypeScriptParser.AccessibilityModifierContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIdentifierOrPattern(TypeScriptParser.IdentifierOrPatternContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIdentifierOrPattern(TypeScriptParser.IdentifierOrPatternContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstructSignature(TypeScriptParser.ConstructSignatureContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstructSignature(TypeScriptParser.ConstructSignatureContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndexSignature(TypeScriptParser.IndexSignatureContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndexSignature(TypeScriptParser.IndexSignatureContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMethodSignature(TypeScriptParser.MethodSignatureContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMethodSignature(TypeScriptParser.MethodSignatureContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeAliasDeclaration(TypeScriptParser.TypeAliasDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeAliasDeclaration(TypeScriptParser.TypeAliasDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstructorDeclaration(TypeScriptParser.ConstructorDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstructorDeclaration(TypeScriptParser.ConstructorDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterfaceDeclaration(TypeScriptParser.InterfaceDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterfaceDeclaration(TypeScriptParser.InterfaceDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterfaceExtendsClause(TypeScriptParser.InterfaceExtendsClauseContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterfaceExtendsClause(TypeScriptParser.InterfaceExtendsClauseContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClassOrInterfaceTypeList(TypeScriptParser.ClassOrInterfaceTypeListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClassOrInterfaceTypeList(TypeScriptParser.ClassOrInterfaceTypeListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnumDeclaration(TypeScriptParser.EnumDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnumDeclaration(TypeScriptParser.EnumDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnumBody(TypeScriptParser.EnumBodyContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnumBody(TypeScriptParser.EnumBodyContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnumMemberList(TypeScriptParser.EnumMemberListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnumMemberList(TypeScriptParser.EnumMemberListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnumMember(TypeScriptParser.EnumMemberContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnumMember(TypeScriptParser.EnumMemberContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNamespaceDeclaration(TypeScriptParser.NamespaceDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNamespaceDeclaration(TypeScriptParser.NamespaceDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNamespaceName(TypeScriptParser.NamespaceNameContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNamespaceName(TypeScriptParser.NamespaceNameContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterImportAliasDeclaration(TypeScriptParser.ImportAliasDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitImportAliasDeclaration(TypeScriptParser.ImportAliasDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecoratorList(TypeScriptParser.DecoratorListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecoratorList(TypeScriptParser.DecoratorListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecorator(TypeScriptParser.DecoratorContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecorator(TypeScriptParser.DecoratorContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecoratorMemberExpression(TypeScriptParser.DecoratorMemberExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecoratorMemberExpression(TypeScriptParser.DecoratorMemberExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecoratorCallExpression(TypeScriptParser.DecoratorCallExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecoratorCallExpression(TypeScriptParser.DecoratorCallExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterProgram(TypeScriptParser.ProgramContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitProgram(TypeScriptParser.ProgramContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSourceElement(TypeScriptParser.SourceElementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSourceElement(TypeScriptParser.SourceElementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStatement(TypeScriptParser.StatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStatement(TypeScriptParser.StatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBlock(TypeScriptParser.BlockContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBlock(TypeScriptParser.BlockContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStatementList(TypeScriptParser.StatementListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStatementList(TypeScriptParser.StatementListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAbstractDeclaration(TypeScriptParser.AbstractDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAbstractDeclaration(TypeScriptParser.AbstractDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterImportStatement(TypeScriptParser.ImportStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitImportStatement(TypeScriptParser.ImportStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFromBlock(TypeScriptParser.FromBlockContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFromBlock(TypeScriptParser.FromBlockContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMultipleImportStatement(TypeScriptParser.MultipleImportStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMultipleImportStatement(TypeScriptParser.MultipleImportStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExportStatement(TypeScriptParser.ExportStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExportStatement(TypeScriptParser.ExportStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariableStatement(TypeScriptParser.VariableStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariableStatement(TypeScriptParser.VariableStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariableDeclarationList(TypeScriptParser.VariableDeclarationListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariableDeclarationList(TypeScriptParser.VariableDeclarationListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariableDeclaration(TypeScriptParser.VariableDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariableDeclaration(TypeScriptParser.VariableDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEmptyStatement_(TypeScriptParser.EmptyStatement_Context ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEmptyStatement_(TypeScriptParser.EmptyStatement_Context ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpressionStatement(TypeScriptParser.ExpressionStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpressionStatement(TypeScriptParser.ExpressionStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIfStatement(TypeScriptParser.IfStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIfStatement(TypeScriptParser.IfStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDoStatement(TypeScriptParser.DoStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDoStatement(TypeScriptParser.DoStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWhileStatement(TypeScriptParser.WhileStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWhileStatement(TypeScriptParser.WhileStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterForStatement(TypeScriptParser.ForStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitForStatement(TypeScriptParser.ForStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterForVarStatement(TypeScriptParser.ForVarStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitForVarStatement(TypeScriptParser.ForVarStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterForInStatement(TypeScriptParser.ForInStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitForInStatement(TypeScriptParser.ForInStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterForVarInStatement(TypeScriptParser.ForVarInStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitForVarInStatement(TypeScriptParser.ForVarInStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVarModifier(TypeScriptParser.VarModifierContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVarModifier(TypeScriptParser.VarModifierContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterContinueStatement(TypeScriptParser.ContinueStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitContinueStatement(TypeScriptParser.ContinueStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBreakStatement(TypeScriptParser.BreakStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBreakStatement(TypeScriptParser.BreakStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReturnStatement(TypeScriptParser.ReturnStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReturnStatement(TypeScriptParser.ReturnStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterYieldStatement(TypeScriptParser.YieldStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitYieldStatement(TypeScriptParser.YieldStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWithStatement(TypeScriptParser.WithStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWithStatement(TypeScriptParser.WithStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSwitchStatement(TypeScriptParser.SwitchStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSwitchStatement(TypeScriptParser.SwitchStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCaseBlock(TypeScriptParser.CaseBlockContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCaseBlock(TypeScriptParser.CaseBlockContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCaseClauses(TypeScriptParser.CaseClausesContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCaseClauses(TypeScriptParser.CaseClausesContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCaseClause(TypeScriptParser.CaseClauseContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCaseClause(TypeScriptParser.CaseClauseContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefaultClause(TypeScriptParser.DefaultClauseContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefaultClause(TypeScriptParser.DefaultClauseContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLabelledStatement(TypeScriptParser.LabelledStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLabelledStatement(TypeScriptParser.LabelledStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterThrowStatement(TypeScriptParser.ThrowStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitThrowStatement(TypeScriptParser.ThrowStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTryStatement(TypeScriptParser.TryStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTryStatement(TypeScriptParser.TryStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCatchProduction(TypeScriptParser.CatchProductionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCatchProduction(TypeScriptParser.CatchProductionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFinallyProduction(TypeScriptParser.FinallyProductionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFinallyProduction(TypeScriptParser.FinallyProductionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDebuggerStatement(TypeScriptParser.DebuggerStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDebuggerStatement(TypeScriptParser.DebuggerStatementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunctionDeclaration(TypeScriptParser.FunctionDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunctionDeclaration(TypeScriptParser.FunctionDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClassDeclaration(TypeScriptParser.ClassDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClassDeclaration(TypeScriptParser.ClassDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClassHeritage(TypeScriptParser.ClassHeritageContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClassHeritage(TypeScriptParser.ClassHeritageContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClassTail(TypeScriptParser.ClassTailContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClassTail(TypeScriptParser.ClassTailContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClassExtendsClause(TypeScriptParser.ClassExtendsClauseContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClassExtendsClause(TypeScriptParser.ClassExtendsClauseContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterImplementsClause(TypeScriptParser.ImplementsClauseContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitImplementsClause(TypeScriptParser.ImplementsClauseContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClassElement(TypeScriptParser.ClassElementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClassElement(TypeScriptParser.ClassElementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPropertyDeclarationExpression(TypeScriptParser.PropertyDeclarationExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPropertyDeclarationExpression(TypeScriptParser.PropertyDeclarationExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMethodDeclarationExpression(TypeScriptParser.MethodDeclarationExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMethodDeclarationExpression(TypeScriptParser.MethodDeclarationExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGetterSetterDeclarationExpression(TypeScriptParser.GetterSetterDeclarationExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGetterSetterDeclarationExpression(TypeScriptParser.GetterSetterDeclarationExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAbstractMemberDeclaration(TypeScriptParser.AbstractMemberDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAbstractMemberDeclaration(TypeScriptParser.AbstractMemberDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPropertyMemberBase(TypeScriptParser.PropertyMemberBaseContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPropertyMemberBase(TypeScriptParser.PropertyMemberBaseContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndexMemberDeclaration(TypeScriptParser.IndexMemberDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndexMemberDeclaration(TypeScriptParser.IndexMemberDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGeneratorMethod(TypeScriptParser.GeneratorMethodContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGeneratorMethod(TypeScriptParser.GeneratorMethodContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGeneratorFunctionDeclaration(TypeScriptParser.GeneratorFunctionDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGeneratorFunctionDeclaration(TypeScriptParser.GeneratorFunctionDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGeneratorBlock(TypeScriptParser.GeneratorBlockContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGeneratorBlock(TypeScriptParser.GeneratorBlockContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGeneratorDefinition(TypeScriptParser.GeneratorDefinitionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGeneratorDefinition(TypeScriptParser.GeneratorDefinitionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIteratorBlock(TypeScriptParser.IteratorBlockContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIteratorBlock(TypeScriptParser.IteratorBlockContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIteratorDefinition(TypeScriptParser.IteratorDefinitionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIteratorDefinition(TypeScriptParser.IteratorDefinitionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFormalParameterList(TypeScriptParser.FormalParameterListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFormalParameterList(TypeScriptParser.FormalParameterListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFormalParameterArg(TypeScriptParser.FormalParameterArgContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFormalParameterArg(TypeScriptParser.FormalParameterArgContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLastFormalParameterArg(TypeScriptParser.LastFormalParameterArgContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLastFormalParameterArg(TypeScriptParser.LastFormalParameterArgContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunctionBody(TypeScriptParser.FunctionBodyContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunctionBody(TypeScriptParser.FunctionBodyContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSourceElements(TypeScriptParser.SourceElementsContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSourceElements(TypeScriptParser.SourceElementsContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArrayLiteral(TypeScriptParser.ArrayLiteralContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArrayLiteral(TypeScriptParser.ArrayLiteralContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterElementList(TypeScriptParser.ElementListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitElementList(TypeScriptParser.ElementListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArrayElement(TypeScriptParser.ArrayElementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArrayElement(TypeScriptParser.ArrayElementContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterObjectLiteral(TypeScriptParser.ObjectLiteralContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitObjectLiteral(TypeScriptParser.ObjectLiteralContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPropertyExpressionAssignment(TypeScriptParser.PropertyExpressionAssignmentContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPropertyExpressionAssignment(TypeScriptParser.PropertyExpressionAssignmentContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterComputedPropertyExpressionAssignment(TypeScriptParser.ComputedPropertyExpressionAssignmentContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitComputedPropertyExpressionAssignment(TypeScriptParser.ComputedPropertyExpressionAssignmentContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPropertyGetter(TypeScriptParser.PropertyGetterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPropertyGetter(TypeScriptParser.PropertyGetterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPropertySetter(TypeScriptParser.PropertySetterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPropertySetter(TypeScriptParser.PropertySetterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMethodProperty(TypeScriptParser.MethodPropertyContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMethodProperty(TypeScriptParser.MethodPropertyContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPropertyShorthand(TypeScriptParser.PropertyShorthandContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPropertyShorthand(TypeScriptParser.PropertyShorthandContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRestParameterInObject(TypeScriptParser.RestParameterInObjectContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRestParameterInObject(TypeScriptParser.RestParameterInObjectContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGetAccessor(TypeScriptParser.GetAccessorContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGetAccessor(TypeScriptParser.GetAccessorContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSetAccessor(TypeScriptParser.SetAccessorContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSetAccessor(TypeScriptParser.SetAccessorContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPropertyName(TypeScriptParser.PropertyNameContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPropertyName(TypeScriptParser.PropertyNameContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArguments(TypeScriptParser.ArgumentsContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArguments(TypeScriptParser.ArgumentsContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArgumentList(TypeScriptParser.ArgumentListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArgumentList(TypeScriptParser.ArgumentListContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArgument(TypeScriptParser.ArgumentContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArgument(TypeScriptParser.ArgumentContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpressionSequence(TypeScriptParser.ExpressionSequenceContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpressionSequence(TypeScriptParser.ExpressionSequenceContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunctionExpressionDeclaration(TypeScriptParser.FunctionExpressionDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunctionExpressionDeclaration(TypeScriptParser.FunctionExpressionDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTemplateStringExpression(TypeScriptParser.TemplateStringExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTemplateStringExpression(TypeScriptParser.TemplateStringExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTernaryExpression(TypeScriptParser.TernaryExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTernaryExpression(TypeScriptParser.TernaryExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLogicalAndExpression(TypeScriptParser.LogicalAndExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLogicalAndExpression(TypeScriptParser.LogicalAndExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGeneratorsExpression(TypeScriptParser.GeneratorsExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGeneratorsExpression(TypeScriptParser.GeneratorsExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPreIncrementExpression(TypeScriptParser.PreIncrementExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPreIncrementExpression(TypeScriptParser.PreIncrementExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterObjectLiteralExpression(TypeScriptParser.ObjectLiteralExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitObjectLiteralExpression(TypeScriptParser.ObjectLiteralExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInExpression(TypeScriptParser.InExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInExpression(TypeScriptParser.InExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLogicalOrExpression(TypeScriptParser.LogicalOrExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLogicalOrExpression(TypeScriptParser.LogicalOrExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGenericTypes(TypeScriptParser.GenericTypesContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGenericTypes(TypeScriptParser.GenericTypesContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNotExpression(TypeScriptParser.NotExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNotExpression(TypeScriptParser.NotExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPreDecreaseExpression(TypeScriptParser.PreDecreaseExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPreDecreaseExpression(TypeScriptParser.PreDecreaseExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArgumentsExpression(TypeScriptParser.ArgumentsExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArgumentsExpression(TypeScriptParser.ArgumentsExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterThisExpression(TypeScriptParser.ThisExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitThisExpression(TypeScriptParser.ThisExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunctionExpression(TypeScriptParser.FunctionExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunctionExpression(TypeScriptParser.FunctionExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnaryMinusExpression(TypeScriptParser.UnaryMinusExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnaryMinusExpression(TypeScriptParser.UnaryMinusExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAssignmentExpression(TypeScriptParser.AssignmentExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAssignmentExpression(TypeScriptParser.AssignmentExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPostDecreaseExpression(TypeScriptParser.PostDecreaseExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPostDecreaseExpression(TypeScriptParser.PostDecreaseExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeofExpression(TypeScriptParser.TypeofExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeofExpression(TypeScriptParser.TypeofExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInstanceofExpression(TypeScriptParser.InstanceofExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInstanceofExpression(TypeScriptParser.InstanceofExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnaryPlusExpression(TypeScriptParser.UnaryPlusExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnaryPlusExpression(TypeScriptParser.UnaryPlusExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDeleteExpression(TypeScriptParser.DeleteExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDeleteExpression(TypeScriptParser.DeleteExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGeneratorsFunctionExpression(TypeScriptParser.GeneratorsFunctionExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGeneratorsFunctionExpression(TypeScriptParser.GeneratorsFunctionExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArrowFunctionExpression(TypeScriptParser.ArrowFunctionExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArrowFunctionExpression(TypeScriptParser.ArrowFunctionExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIteratorsExpression(TypeScriptParser.IteratorsExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIteratorsExpression(TypeScriptParser.IteratorsExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEqualityExpression(TypeScriptParser.EqualityExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEqualityExpression(TypeScriptParser.EqualityExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBitXOrExpression(TypeScriptParser.BitXOrExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBitXOrExpression(TypeScriptParser.BitXOrExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCastAsExpression(TypeScriptParser.CastAsExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCastAsExpression(TypeScriptParser.CastAsExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSuperExpression(TypeScriptParser.SuperExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSuperExpression(TypeScriptParser.SuperExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMultiplicativeExpression(TypeScriptParser.MultiplicativeExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMultiplicativeExpression(TypeScriptParser.MultiplicativeExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBitShiftExpression(TypeScriptParser.BitShiftExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBitShiftExpression(TypeScriptParser.BitShiftExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterParenthesizedExpression(TypeScriptParser.ParenthesizedExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitParenthesizedExpression(TypeScriptParser.ParenthesizedExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAdditiveExpression(TypeScriptParser.AdditiveExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAdditiveExpression(TypeScriptParser.AdditiveExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRelationalExpression(TypeScriptParser.RelationalExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRelationalExpression(TypeScriptParser.RelationalExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPostIncrementExpression(TypeScriptParser.PostIncrementExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPostIncrementExpression(TypeScriptParser.PostIncrementExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterYieldExpression(TypeScriptParser.YieldExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitYieldExpression(TypeScriptParser.YieldExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBitNotExpression(TypeScriptParser.BitNotExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBitNotExpression(TypeScriptParser.BitNotExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNewExpression(TypeScriptParser.NewExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNewExpression(TypeScriptParser.NewExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLiteralExpression(TypeScriptParser.LiteralExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLiteralExpression(TypeScriptParser.LiteralExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArrayLiteralExpression(TypeScriptParser.ArrayLiteralExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArrayLiteralExpression(TypeScriptParser.ArrayLiteralExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMemberDotExpression(TypeScriptParser.MemberDotExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMemberDotExpression(TypeScriptParser.MemberDotExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMemberIndexExpression(TypeScriptParser.MemberIndexExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMemberIndexExpression(TypeScriptParser.MemberIndexExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIdentifierExpression(TypeScriptParser.IdentifierExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIdentifierExpression(TypeScriptParser.IdentifierExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBitAndExpression(TypeScriptParser.BitAndExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBitAndExpression(TypeScriptParser.BitAndExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBitOrExpression(TypeScriptParser.BitOrExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBitOrExpression(TypeScriptParser.BitOrExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAssignmentOperatorExpression(TypeScriptParser.AssignmentOperatorExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAssignmentOperatorExpression(TypeScriptParser.AssignmentOperatorExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVoidExpression(TypeScriptParser.VoidExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVoidExpression(TypeScriptParser.VoidExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAsExpression(TypeScriptParser.AsExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAsExpression(TypeScriptParser.AsExpressionContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArrowFunctionDeclaration(TypeScriptParser.ArrowFunctionDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArrowFunctionDeclaration(TypeScriptParser.ArrowFunctionDeclarationContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArrowFunctionParameters(TypeScriptParser.ArrowFunctionParametersContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArrowFunctionParameters(TypeScriptParser.ArrowFunctionParametersContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArrowFunctionBody(TypeScriptParser.ArrowFunctionBodyContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArrowFunctionBody(TypeScriptParser.ArrowFunctionBodyContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAssignmentOperator(TypeScriptParser.AssignmentOperatorContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAssignmentOperator(TypeScriptParser.AssignmentOperatorContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLiteral(TypeScriptParser.LiteralContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLiteral(TypeScriptParser.LiteralContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTemplateStringLiteral(TypeScriptParser.TemplateStringLiteralContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTemplateStringLiteral(TypeScriptParser.TemplateStringLiteralContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTemplateStringAtom(TypeScriptParser.TemplateStringAtomContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTemplateStringAtom(TypeScriptParser.TemplateStringAtomContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNumericLiteral(TypeScriptParser.NumericLiteralContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNumericLiteral(TypeScriptParser.NumericLiteralContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIdentifierName(TypeScriptParser.IdentifierNameContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIdentifierName(TypeScriptParser.IdentifierNameContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIdentifierOrKeyWord(TypeScriptParser.IdentifierOrKeyWordContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIdentifierOrKeyWord(TypeScriptParser.IdentifierOrKeyWordContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReservedWord(TypeScriptParser.ReservedWordContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReservedWord(TypeScriptParser.ReservedWordContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterKeyword(TypeScriptParser.KeywordContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitKeyword(TypeScriptParser.KeywordContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGetter(TypeScriptParser.GetterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGetter(TypeScriptParser.GetterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSetter(TypeScriptParser.SetterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSetter(TypeScriptParser.SetterContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEos(TypeScriptParser.EosContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEos(TypeScriptParser.EosContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEveryRule(ParserRuleContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEveryRule(ParserRuleContext ctx) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + ctx.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void visitTerminal(TerminalNode node) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + node.getText()); + } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void visitErrorNode(ErrorNode node) { + if (DEBUG_LISTENER_METHODS) System.out.println(new RuntimeException().getStackTrace()[0].getMethodName() + " " + node.getText()); + } +} diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParserBaseVisitor.java b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParserBaseVisitor.java new file mode 100644 index 0000000..8490b3b --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParserBaseVisitor.java @@ -0,0 +1,1506 @@ +// Generated from /www/p_java/babylon/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.g4 by ANTLR 4.13.1 +package one.edee.babylon.export.ts.gen; +import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; + +/** + * This class provides an empty implementation of {@link TypeScriptParserVisitor}, + * which can be extended to create a visitor which only needs to handle a subset + * of the available methods. + * + * @param The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +@SuppressWarnings("CheckReturnValue") +public class TypeScriptParserBaseVisitor extends AbstractParseTreeVisitor implements TypeScriptParserVisitor { + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInitializer(TypeScriptParser.InitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitBindingPattern(TypeScriptParser.BindingPatternContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeParameters(TypeScriptParser.TypeParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeParameterList(TypeScriptParser.TypeParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeParameter(TypeScriptParser.TypeParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitConstraint(TypeScriptParser.ConstraintContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeArguments(TypeScriptParser.TypeArgumentsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeArgumentList(TypeScriptParser.TypeArgumentListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeArgument(TypeScriptParser.TypeArgumentContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitType_(TypeScriptParser.Type_Context ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitIntersection(TypeScriptParser.IntersectionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPrimary(TypeScriptParser.PrimaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitUnion(TypeScriptParser.UnionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitRedefinitionOfType(TypeScriptParser.RedefinitionOfTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPredefinedPrimType(TypeScriptParser.PredefinedPrimTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArrayPrimType(TypeScriptParser.ArrayPrimTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitParenthesizedPrimType(TypeScriptParser.ParenthesizedPrimTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitThisPrimType(TypeScriptParser.ThisPrimTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTuplePrimType(TypeScriptParser.TuplePrimTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitObjectPrimType(TypeScriptParser.ObjectPrimTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitReferencePrimType(TypeScriptParser.ReferencePrimTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitQueryPrimType(TypeScriptParser.QueryPrimTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPredefinedType(TypeScriptParser.PredefinedTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeReference(TypeScriptParser.TypeReferenceContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitNestedTypeGeneric(TypeScriptParser.NestedTypeGenericContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeGeneric(TypeScriptParser.TypeGenericContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeIncludeGeneric(TypeScriptParser.TypeIncludeGenericContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeName(TypeScriptParser.TypeNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitObjectType(TypeScriptParser.ObjectTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeBody(TypeScriptParser.TypeBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeMemberList(TypeScriptParser.TypeMemberListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeMember(TypeScriptParser.TypeMemberContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArrayType(TypeScriptParser.ArrayTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTupleType(TypeScriptParser.TupleTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTupleElementTypes(TypeScriptParser.TupleElementTypesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFunctionType(TypeScriptParser.FunctionTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitConstructorType(TypeScriptParser.ConstructorTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeQuery(TypeScriptParser.TypeQueryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeQueryExpression(TypeScriptParser.TypeQueryExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPropertySignatur(TypeScriptParser.PropertySignaturContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeAnnotation(TypeScriptParser.TypeAnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCallSignature(TypeScriptParser.CallSignatureContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitParameterList(TypeScriptParser.ParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitRequiredParameterList(TypeScriptParser.RequiredParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitParameter(TypeScriptParser.ParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitOptionalParameter(TypeScriptParser.OptionalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitRestParameter(TypeScriptParser.RestParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitRequiredParameter(TypeScriptParser.RequiredParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAccessibilityModifier(TypeScriptParser.AccessibilityModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitIdentifierOrPattern(TypeScriptParser.IdentifierOrPatternContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitConstructSignature(TypeScriptParser.ConstructSignatureContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitIndexSignature(TypeScriptParser.IndexSignatureContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMethodSignature(TypeScriptParser.MethodSignatureContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeAliasDeclaration(TypeScriptParser.TypeAliasDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitConstructorDeclaration(TypeScriptParser.ConstructorDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInterfaceDeclaration(TypeScriptParser.InterfaceDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInterfaceExtendsClause(TypeScriptParser.InterfaceExtendsClauseContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassOrInterfaceTypeList(TypeScriptParser.ClassOrInterfaceTypeListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnumDeclaration(TypeScriptParser.EnumDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnumBody(TypeScriptParser.EnumBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnumMemberList(TypeScriptParser.EnumMemberListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnumMember(TypeScriptParser.EnumMemberContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitNamespaceDeclaration(TypeScriptParser.NamespaceDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitNamespaceName(TypeScriptParser.NamespaceNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitImportAliasDeclaration(TypeScriptParser.ImportAliasDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitDecoratorList(TypeScriptParser.DecoratorListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitDecorator(TypeScriptParser.DecoratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitDecoratorMemberExpression(TypeScriptParser.DecoratorMemberExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitDecoratorCallExpression(TypeScriptParser.DecoratorCallExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitProgram(TypeScriptParser.ProgramContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitSourceElement(TypeScriptParser.SourceElementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitStatement(TypeScriptParser.StatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitBlock(TypeScriptParser.BlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitStatementList(TypeScriptParser.StatementListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAbstractDeclaration(TypeScriptParser.AbstractDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitImportStatement(TypeScriptParser.ImportStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFromBlock(TypeScriptParser.FromBlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMultipleImportStatement(TypeScriptParser.MultipleImportStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitExportStatement(TypeScriptParser.ExportStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVariableStatement(TypeScriptParser.VariableStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVariableDeclarationList(TypeScriptParser.VariableDeclarationListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVariableDeclaration(TypeScriptParser.VariableDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEmptyStatement_(TypeScriptParser.EmptyStatement_Context ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitExpressionStatement(TypeScriptParser.ExpressionStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitIfStatement(TypeScriptParser.IfStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitDoStatement(TypeScriptParser.DoStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitWhileStatement(TypeScriptParser.WhileStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitForStatement(TypeScriptParser.ForStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitForVarStatement(TypeScriptParser.ForVarStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitForInStatement(TypeScriptParser.ForInStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitForVarInStatement(TypeScriptParser.ForVarInStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVarModifier(TypeScriptParser.VarModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitContinueStatement(TypeScriptParser.ContinueStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitBreakStatement(TypeScriptParser.BreakStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitReturnStatement(TypeScriptParser.ReturnStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitYieldStatement(TypeScriptParser.YieldStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitWithStatement(TypeScriptParser.WithStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitSwitchStatement(TypeScriptParser.SwitchStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCaseBlock(TypeScriptParser.CaseBlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCaseClauses(TypeScriptParser.CaseClausesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCaseClause(TypeScriptParser.CaseClauseContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitDefaultClause(TypeScriptParser.DefaultClauseContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLabelledStatement(TypeScriptParser.LabelledStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitThrowStatement(TypeScriptParser.ThrowStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTryStatement(TypeScriptParser.TryStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCatchProduction(TypeScriptParser.CatchProductionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFinallyProduction(TypeScriptParser.FinallyProductionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitDebuggerStatement(TypeScriptParser.DebuggerStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFunctionDeclaration(TypeScriptParser.FunctionDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassDeclaration(TypeScriptParser.ClassDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassHeritage(TypeScriptParser.ClassHeritageContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassTail(TypeScriptParser.ClassTailContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassExtendsClause(TypeScriptParser.ClassExtendsClauseContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitImplementsClause(TypeScriptParser.ImplementsClauseContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassElement(TypeScriptParser.ClassElementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPropertyDeclarationExpression(TypeScriptParser.PropertyDeclarationExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMethodDeclarationExpression(TypeScriptParser.MethodDeclarationExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGetterSetterDeclarationExpression(TypeScriptParser.GetterSetterDeclarationExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAbstractMemberDeclaration(TypeScriptParser.AbstractMemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPropertyMemberBase(TypeScriptParser.PropertyMemberBaseContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitIndexMemberDeclaration(TypeScriptParser.IndexMemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGeneratorMethod(TypeScriptParser.GeneratorMethodContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGeneratorFunctionDeclaration(TypeScriptParser.GeneratorFunctionDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGeneratorBlock(TypeScriptParser.GeneratorBlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGeneratorDefinition(TypeScriptParser.GeneratorDefinitionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitIteratorBlock(TypeScriptParser.IteratorBlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitIteratorDefinition(TypeScriptParser.IteratorDefinitionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFormalParameterList(TypeScriptParser.FormalParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFormalParameterArg(TypeScriptParser.FormalParameterArgContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLastFormalParameterArg(TypeScriptParser.LastFormalParameterArgContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFunctionBody(TypeScriptParser.FunctionBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitSourceElements(TypeScriptParser.SourceElementsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArrayLiteral(TypeScriptParser.ArrayLiteralContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitElementList(TypeScriptParser.ElementListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArrayElement(TypeScriptParser.ArrayElementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitObjectLiteral(TypeScriptParser.ObjectLiteralContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPropertyExpressionAssignment(TypeScriptParser.PropertyExpressionAssignmentContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitComputedPropertyExpressionAssignment(TypeScriptParser.ComputedPropertyExpressionAssignmentContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPropertyGetter(TypeScriptParser.PropertyGetterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPropertySetter(TypeScriptParser.PropertySetterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMethodProperty(TypeScriptParser.MethodPropertyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPropertyShorthand(TypeScriptParser.PropertyShorthandContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitRestParameterInObject(TypeScriptParser.RestParameterInObjectContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGetAccessor(TypeScriptParser.GetAccessorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitSetAccessor(TypeScriptParser.SetAccessorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPropertyName(TypeScriptParser.PropertyNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArguments(TypeScriptParser.ArgumentsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArgumentList(TypeScriptParser.ArgumentListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArgument(TypeScriptParser.ArgumentContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitExpressionSequence(TypeScriptParser.ExpressionSequenceContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFunctionExpressionDeclaration(TypeScriptParser.FunctionExpressionDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTemplateStringExpression(TypeScriptParser.TemplateStringExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTernaryExpression(TypeScriptParser.TernaryExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLogicalAndExpression(TypeScriptParser.LogicalAndExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGeneratorsExpression(TypeScriptParser.GeneratorsExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPreIncrementExpression(TypeScriptParser.PreIncrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitObjectLiteralExpression(TypeScriptParser.ObjectLiteralExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInExpression(TypeScriptParser.InExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLogicalOrExpression(TypeScriptParser.LogicalOrExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGenericTypes(TypeScriptParser.GenericTypesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitNotExpression(TypeScriptParser.NotExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPreDecreaseExpression(TypeScriptParser.PreDecreaseExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArgumentsExpression(TypeScriptParser.ArgumentsExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitThisExpression(TypeScriptParser.ThisExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFunctionExpression(TypeScriptParser.FunctionExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitUnaryMinusExpression(TypeScriptParser.UnaryMinusExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAssignmentExpression(TypeScriptParser.AssignmentExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPostDecreaseExpression(TypeScriptParser.PostDecreaseExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeofExpression(TypeScriptParser.TypeofExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInstanceofExpression(TypeScriptParser.InstanceofExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitUnaryPlusExpression(TypeScriptParser.UnaryPlusExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitDeleteExpression(TypeScriptParser.DeleteExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGeneratorsFunctionExpression(TypeScriptParser.GeneratorsFunctionExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArrowFunctionExpression(TypeScriptParser.ArrowFunctionExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitIteratorsExpression(TypeScriptParser.IteratorsExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEqualityExpression(TypeScriptParser.EqualityExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitBitXOrExpression(TypeScriptParser.BitXOrExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCastAsExpression(TypeScriptParser.CastAsExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitSuperExpression(TypeScriptParser.SuperExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMultiplicativeExpression(TypeScriptParser.MultiplicativeExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitBitShiftExpression(TypeScriptParser.BitShiftExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitParenthesizedExpression(TypeScriptParser.ParenthesizedExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAdditiveExpression(TypeScriptParser.AdditiveExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitRelationalExpression(TypeScriptParser.RelationalExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPostIncrementExpression(TypeScriptParser.PostIncrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitYieldExpression(TypeScriptParser.YieldExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitBitNotExpression(TypeScriptParser.BitNotExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitNewExpression(TypeScriptParser.NewExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLiteralExpression(TypeScriptParser.LiteralExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArrayLiteralExpression(TypeScriptParser.ArrayLiteralExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMemberDotExpression(TypeScriptParser.MemberDotExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMemberIndexExpression(TypeScriptParser.MemberIndexExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitIdentifierExpression(TypeScriptParser.IdentifierExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitBitAndExpression(TypeScriptParser.BitAndExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitBitOrExpression(TypeScriptParser.BitOrExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAssignmentOperatorExpression(TypeScriptParser.AssignmentOperatorExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVoidExpression(TypeScriptParser.VoidExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAsExpression(TypeScriptParser.AsExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArrowFunctionDeclaration(TypeScriptParser.ArrowFunctionDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArrowFunctionParameters(TypeScriptParser.ArrowFunctionParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArrowFunctionBody(TypeScriptParser.ArrowFunctionBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAssignmentOperator(TypeScriptParser.AssignmentOperatorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLiteral(TypeScriptParser.LiteralContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTemplateStringLiteral(TypeScriptParser.TemplateStringLiteralContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTemplateStringAtom(TypeScriptParser.TemplateStringAtomContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitNumericLiteral(TypeScriptParser.NumericLiteralContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitIdentifierName(TypeScriptParser.IdentifierNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitIdentifierOrKeyWord(TypeScriptParser.IdentifierOrKeyWordContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitReservedWord(TypeScriptParser.ReservedWordContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitKeyword(TypeScriptParser.KeywordContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGetter(TypeScriptParser.GetterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitSetter(TypeScriptParser.SetterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEos(TypeScriptParser.EosContext ctx) { return visitChildren(ctx); } +} \ No newline at end of file diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParserListener.java b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParserListener.java new file mode 100644 index 0000000..fef2062 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParserListener.java @@ -0,0 +1,2290 @@ +// Generated from /www/p_java/babylon/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.g4 by ANTLR 4.13.1 +package one.edee.babylon.export.ts.gen; +import org.antlr.v4.runtime.tree.ParseTreeListener; + +/** + * This interface defines a complete listener for a parse tree produced by + * {@link TypeScriptParser}. + */ +public interface TypeScriptParserListener extends ParseTreeListener { + /** + * Enter a parse tree produced by {@link TypeScriptParser#initializer}. + * @param ctx the parse tree + */ + void enterInitializer(TypeScriptParser.InitializerContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#initializer}. + * @param ctx the parse tree + */ + void exitInitializer(TypeScriptParser.InitializerContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#bindingPattern}. + * @param ctx the parse tree + */ + void enterBindingPattern(TypeScriptParser.BindingPatternContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#bindingPattern}. + * @param ctx the parse tree + */ + void exitBindingPattern(TypeScriptParser.BindingPatternContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeParameters}. + * @param ctx the parse tree + */ + void enterTypeParameters(TypeScriptParser.TypeParametersContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeParameters}. + * @param ctx the parse tree + */ + void exitTypeParameters(TypeScriptParser.TypeParametersContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeParameterList}. + * @param ctx the parse tree + */ + void enterTypeParameterList(TypeScriptParser.TypeParameterListContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeParameterList}. + * @param ctx the parse tree + */ + void exitTypeParameterList(TypeScriptParser.TypeParameterListContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeParameter}. + * @param ctx the parse tree + */ + void enterTypeParameter(TypeScriptParser.TypeParameterContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeParameter}. + * @param ctx the parse tree + */ + void exitTypeParameter(TypeScriptParser.TypeParameterContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#constraint}. + * @param ctx the parse tree + */ + void enterConstraint(TypeScriptParser.ConstraintContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#constraint}. + * @param ctx the parse tree + */ + void exitConstraint(TypeScriptParser.ConstraintContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeArguments}. + * @param ctx the parse tree + */ + void enterTypeArguments(TypeScriptParser.TypeArgumentsContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeArguments}. + * @param ctx the parse tree + */ + void exitTypeArguments(TypeScriptParser.TypeArgumentsContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeArgumentList}. + * @param ctx the parse tree + */ + void enterTypeArgumentList(TypeScriptParser.TypeArgumentListContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeArgumentList}. + * @param ctx the parse tree + */ + void exitTypeArgumentList(TypeScriptParser.TypeArgumentListContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeArgument}. + * @param ctx the parse tree + */ + void enterTypeArgument(TypeScriptParser.TypeArgumentContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeArgument}. + * @param ctx the parse tree + */ + void exitTypeArgument(TypeScriptParser.TypeArgumentContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#type_}. + * @param ctx the parse tree + */ + void enterType_(TypeScriptParser.Type_Context ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#type_}. + * @param ctx the parse tree + */ + void exitType_(TypeScriptParser.Type_Context ctx); + /** + * Enter a parse tree produced by the {@code Intersection} + * labeled alternative in {@link TypeScriptParser#unionOrIntersectionOrPrimaryType}. + * @param ctx the parse tree + */ + void enterIntersection(TypeScriptParser.IntersectionContext ctx); + /** + * Exit a parse tree produced by the {@code Intersection} + * labeled alternative in {@link TypeScriptParser#unionOrIntersectionOrPrimaryType}. + * @param ctx the parse tree + */ + void exitIntersection(TypeScriptParser.IntersectionContext ctx); + /** + * Enter a parse tree produced by the {@code Primary} + * labeled alternative in {@link TypeScriptParser#unionOrIntersectionOrPrimaryType}. + * @param ctx the parse tree + */ + void enterPrimary(TypeScriptParser.PrimaryContext ctx); + /** + * Exit a parse tree produced by the {@code Primary} + * labeled alternative in {@link TypeScriptParser#unionOrIntersectionOrPrimaryType}. + * @param ctx the parse tree + */ + void exitPrimary(TypeScriptParser.PrimaryContext ctx); + /** + * Enter a parse tree produced by the {@code Union} + * labeled alternative in {@link TypeScriptParser#unionOrIntersectionOrPrimaryType}. + * @param ctx the parse tree + */ + void enterUnion(TypeScriptParser.UnionContext ctx); + /** + * Exit a parse tree produced by the {@code Union} + * labeled alternative in {@link TypeScriptParser#unionOrIntersectionOrPrimaryType}. + * @param ctx the parse tree + */ + void exitUnion(TypeScriptParser.UnionContext ctx); + /** + * Enter a parse tree produced by the {@code RedefinitionOfType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void enterRedefinitionOfType(TypeScriptParser.RedefinitionOfTypeContext ctx); + /** + * Exit a parse tree produced by the {@code RedefinitionOfType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void exitRedefinitionOfType(TypeScriptParser.RedefinitionOfTypeContext ctx); + /** + * Enter a parse tree produced by the {@code PredefinedPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void enterPredefinedPrimType(TypeScriptParser.PredefinedPrimTypeContext ctx); + /** + * Exit a parse tree produced by the {@code PredefinedPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void exitPredefinedPrimType(TypeScriptParser.PredefinedPrimTypeContext ctx); + /** + * Enter a parse tree produced by the {@code ArrayPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void enterArrayPrimType(TypeScriptParser.ArrayPrimTypeContext ctx); + /** + * Exit a parse tree produced by the {@code ArrayPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void exitArrayPrimType(TypeScriptParser.ArrayPrimTypeContext ctx); + /** + * Enter a parse tree produced by the {@code ParenthesizedPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void enterParenthesizedPrimType(TypeScriptParser.ParenthesizedPrimTypeContext ctx); + /** + * Exit a parse tree produced by the {@code ParenthesizedPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void exitParenthesizedPrimType(TypeScriptParser.ParenthesizedPrimTypeContext ctx); + /** + * Enter a parse tree produced by the {@code ThisPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void enterThisPrimType(TypeScriptParser.ThisPrimTypeContext ctx); + /** + * Exit a parse tree produced by the {@code ThisPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void exitThisPrimType(TypeScriptParser.ThisPrimTypeContext ctx); + /** + * Enter a parse tree produced by the {@code TuplePrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void enterTuplePrimType(TypeScriptParser.TuplePrimTypeContext ctx); + /** + * Exit a parse tree produced by the {@code TuplePrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void exitTuplePrimType(TypeScriptParser.TuplePrimTypeContext ctx); + /** + * Enter a parse tree produced by the {@code ObjectPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void enterObjectPrimType(TypeScriptParser.ObjectPrimTypeContext ctx); + /** + * Exit a parse tree produced by the {@code ObjectPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void exitObjectPrimType(TypeScriptParser.ObjectPrimTypeContext ctx); + /** + * Enter a parse tree produced by the {@code ReferencePrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void enterReferencePrimType(TypeScriptParser.ReferencePrimTypeContext ctx); + /** + * Exit a parse tree produced by the {@code ReferencePrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void exitReferencePrimType(TypeScriptParser.ReferencePrimTypeContext ctx); + /** + * Enter a parse tree produced by the {@code QueryPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void enterQueryPrimType(TypeScriptParser.QueryPrimTypeContext ctx); + /** + * Exit a parse tree produced by the {@code QueryPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + */ + void exitQueryPrimType(TypeScriptParser.QueryPrimTypeContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#predefinedType}. + * @param ctx the parse tree + */ + void enterPredefinedType(TypeScriptParser.PredefinedTypeContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#predefinedType}. + * @param ctx the parse tree + */ + void exitPredefinedType(TypeScriptParser.PredefinedTypeContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeReference}. + * @param ctx the parse tree + */ + void enterTypeReference(TypeScriptParser.TypeReferenceContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeReference}. + * @param ctx the parse tree + */ + void exitTypeReference(TypeScriptParser.TypeReferenceContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#nestedTypeGeneric}. + * @param ctx the parse tree + */ + void enterNestedTypeGeneric(TypeScriptParser.NestedTypeGenericContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#nestedTypeGeneric}. + * @param ctx the parse tree + */ + void exitNestedTypeGeneric(TypeScriptParser.NestedTypeGenericContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeGeneric}. + * @param ctx the parse tree + */ + void enterTypeGeneric(TypeScriptParser.TypeGenericContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeGeneric}. + * @param ctx the parse tree + */ + void exitTypeGeneric(TypeScriptParser.TypeGenericContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeIncludeGeneric}. + * @param ctx the parse tree + */ + void enterTypeIncludeGeneric(TypeScriptParser.TypeIncludeGenericContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeIncludeGeneric}. + * @param ctx the parse tree + */ + void exitTypeIncludeGeneric(TypeScriptParser.TypeIncludeGenericContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeName}. + * @param ctx the parse tree + */ + void enterTypeName(TypeScriptParser.TypeNameContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeName}. + * @param ctx the parse tree + */ + void exitTypeName(TypeScriptParser.TypeNameContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#objectType}. + * @param ctx the parse tree + */ + void enterObjectType(TypeScriptParser.ObjectTypeContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#objectType}. + * @param ctx the parse tree + */ + void exitObjectType(TypeScriptParser.ObjectTypeContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeBody}. + * @param ctx the parse tree + */ + void enterTypeBody(TypeScriptParser.TypeBodyContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeBody}. + * @param ctx the parse tree + */ + void exitTypeBody(TypeScriptParser.TypeBodyContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeMemberList}. + * @param ctx the parse tree + */ + void enterTypeMemberList(TypeScriptParser.TypeMemberListContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeMemberList}. + * @param ctx the parse tree + */ + void exitTypeMemberList(TypeScriptParser.TypeMemberListContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeMember}. + * @param ctx the parse tree + */ + void enterTypeMember(TypeScriptParser.TypeMemberContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeMember}. + * @param ctx the parse tree + */ + void exitTypeMember(TypeScriptParser.TypeMemberContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#arrayType}. + * @param ctx the parse tree + */ + void enterArrayType(TypeScriptParser.ArrayTypeContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#arrayType}. + * @param ctx the parse tree + */ + void exitArrayType(TypeScriptParser.ArrayTypeContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#tupleType}. + * @param ctx the parse tree + */ + void enterTupleType(TypeScriptParser.TupleTypeContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#tupleType}. + * @param ctx the parse tree + */ + void exitTupleType(TypeScriptParser.TupleTypeContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#tupleElementTypes}. + * @param ctx the parse tree + */ + void enterTupleElementTypes(TypeScriptParser.TupleElementTypesContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#tupleElementTypes}. + * @param ctx the parse tree + */ + void exitTupleElementTypes(TypeScriptParser.TupleElementTypesContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#functionType}. + * @param ctx the parse tree + */ + void enterFunctionType(TypeScriptParser.FunctionTypeContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#functionType}. + * @param ctx the parse tree + */ + void exitFunctionType(TypeScriptParser.FunctionTypeContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#constructorType}. + * @param ctx the parse tree + */ + void enterConstructorType(TypeScriptParser.ConstructorTypeContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#constructorType}. + * @param ctx the parse tree + */ + void exitConstructorType(TypeScriptParser.ConstructorTypeContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeQuery}. + * @param ctx the parse tree + */ + void enterTypeQuery(TypeScriptParser.TypeQueryContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeQuery}. + * @param ctx the parse tree + */ + void exitTypeQuery(TypeScriptParser.TypeQueryContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeQueryExpression}. + * @param ctx the parse tree + */ + void enterTypeQueryExpression(TypeScriptParser.TypeQueryExpressionContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeQueryExpression}. + * @param ctx the parse tree + */ + void exitTypeQueryExpression(TypeScriptParser.TypeQueryExpressionContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#propertySignatur}. + * @param ctx the parse tree + */ + void enterPropertySignatur(TypeScriptParser.PropertySignaturContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#propertySignatur}. + * @param ctx the parse tree + */ + void exitPropertySignatur(TypeScriptParser.PropertySignaturContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeAnnotation}. + * @param ctx the parse tree + */ + void enterTypeAnnotation(TypeScriptParser.TypeAnnotationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeAnnotation}. + * @param ctx the parse tree + */ + void exitTypeAnnotation(TypeScriptParser.TypeAnnotationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#callSignature}. + * @param ctx the parse tree + */ + void enterCallSignature(TypeScriptParser.CallSignatureContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#callSignature}. + * @param ctx the parse tree + */ + void exitCallSignature(TypeScriptParser.CallSignatureContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#parameterList}. + * @param ctx the parse tree + */ + void enterParameterList(TypeScriptParser.ParameterListContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#parameterList}. + * @param ctx the parse tree + */ + void exitParameterList(TypeScriptParser.ParameterListContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#requiredParameterList}. + * @param ctx the parse tree + */ + void enterRequiredParameterList(TypeScriptParser.RequiredParameterListContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#requiredParameterList}. + * @param ctx the parse tree + */ + void exitRequiredParameterList(TypeScriptParser.RequiredParameterListContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#parameter}. + * @param ctx the parse tree + */ + void enterParameter(TypeScriptParser.ParameterContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#parameter}. + * @param ctx the parse tree + */ + void exitParameter(TypeScriptParser.ParameterContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#optionalParameter}. + * @param ctx the parse tree + */ + void enterOptionalParameter(TypeScriptParser.OptionalParameterContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#optionalParameter}. + * @param ctx the parse tree + */ + void exitOptionalParameter(TypeScriptParser.OptionalParameterContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#restParameter}. + * @param ctx the parse tree + */ + void enterRestParameter(TypeScriptParser.RestParameterContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#restParameter}. + * @param ctx the parse tree + */ + void exitRestParameter(TypeScriptParser.RestParameterContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#requiredParameter}. + * @param ctx the parse tree + */ + void enterRequiredParameter(TypeScriptParser.RequiredParameterContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#requiredParameter}. + * @param ctx the parse tree + */ + void exitRequiredParameter(TypeScriptParser.RequiredParameterContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#accessibilityModifier}. + * @param ctx the parse tree + */ + void enterAccessibilityModifier(TypeScriptParser.AccessibilityModifierContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#accessibilityModifier}. + * @param ctx the parse tree + */ + void exitAccessibilityModifier(TypeScriptParser.AccessibilityModifierContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#identifierOrPattern}. + * @param ctx the parse tree + */ + void enterIdentifierOrPattern(TypeScriptParser.IdentifierOrPatternContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#identifierOrPattern}. + * @param ctx the parse tree + */ + void exitIdentifierOrPattern(TypeScriptParser.IdentifierOrPatternContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#constructSignature}. + * @param ctx the parse tree + */ + void enterConstructSignature(TypeScriptParser.ConstructSignatureContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#constructSignature}. + * @param ctx the parse tree + */ + void exitConstructSignature(TypeScriptParser.ConstructSignatureContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#indexSignature}. + * @param ctx the parse tree + */ + void enterIndexSignature(TypeScriptParser.IndexSignatureContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#indexSignature}. + * @param ctx the parse tree + */ + void exitIndexSignature(TypeScriptParser.IndexSignatureContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#methodSignature}. + * @param ctx the parse tree + */ + void enterMethodSignature(TypeScriptParser.MethodSignatureContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#methodSignature}. + * @param ctx the parse tree + */ + void exitMethodSignature(TypeScriptParser.MethodSignatureContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#typeAliasDeclaration}. + * @param ctx the parse tree + */ + void enterTypeAliasDeclaration(TypeScriptParser.TypeAliasDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#typeAliasDeclaration}. + * @param ctx the parse tree + */ + void exitTypeAliasDeclaration(TypeScriptParser.TypeAliasDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#constructorDeclaration}. + * @param ctx the parse tree + */ + void enterConstructorDeclaration(TypeScriptParser.ConstructorDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#constructorDeclaration}. + * @param ctx the parse tree + */ + void exitConstructorDeclaration(TypeScriptParser.ConstructorDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#interfaceDeclaration}. + * @param ctx the parse tree + */ + void enterInterfaceDeclaration(TypeScriptParser.InterfaceDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#interfaceDeclaration}. + * @param ctx the parse tree + */ + void exitInterfaceDeclaration(TypeScriptParser.InterfaceDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#interfaceExtendsClause}. + * @param ctx the parse tree + */ + void enterInterfaceExtendsClause(TypeScriptParser.InterfaceExtendsClauseContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#interfaceExtendsClause}. + * @param ctx the parse tree + */ + void exitInterfaceExtendsClause(TypeScriptParser.InterfaceExtendsClauseContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#classOrInterfaceTypeList}. + * @param ctx the parse tree + */ + void enterClassOrInterfaceTypeList(TypeScriptParser.ClassOrInterfaceTypeListContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#classOrInterfaceTypeList}. + * @param ctx the parse tree + */ + void exitClassOrInterfaceTypeList(TypeScriptParser.ClassOrInterfaceTypeListContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#enumDeclaration}. + * @param ctx the parse tree + */ + void enterEnumDeclaration(TypeScriptParser.EnumDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#enumDeclaration}. + * @param ctx the parse tree + */ + void exitEnumDeclaration(TypeScriptParser.EnumDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#enumBody}. + * @param ctx the parse tree + */ + void enterEnumBody(TypeScriptParser.EnumBodyContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#enumBody}. + * @param ctx the parse tree + */ + void exitEnumBody(TypeScriptParser.EnumBodyContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#enumMemberList}. + * @param ctx the parse tree + */ + void enterEnumMemberList(TypeScriptParser.EnumMemberListContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#enumMemberList}. + * @param ctx the parse tree + */ + void exitEnumMemberList(TypeScriptParser.EnumMemberListContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#enumMember}. + * @param ctx the parse tree + */ + void enterEnumMember(TypeScriptParser.EnumMemberContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#enumMember}. + * @param ctx the parse tree + */ + void exitEnumMember(TypeScriptParser.EnumMemberContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#namespaceDeclaration}. + * @param ctx the parse tree + */ + void enterNamespaceDeclaration(TypeScriptParser.NamespaceDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#namespaceDeclaration}. + * @param ctx the parse tree + */ + void exitNamespaceDeclaration(TypeScriptParser.NamespaceDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#namespaceName}. + * @param ctx the parse tree + */ + void enterNamespaceName(TypeScriptParser.NamespaceNameContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#namespaceName}. + * @param ctx the parse tree + */ + void exitNamespaceName(TypeScriptParser.NamespaceNameContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#importAliasDeclaration}. + * @param ctx the parse tree + */ + void enterImportAliasDeclaration(TypeScriptParser.ImportAliasDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#importAliasDeclaration}. + * @param ctx the parse tree + */ + void exitImportAliasDeclaration(TypeScriptParser.ImportAliasDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#decoratorList}. + * @param ctx the parse tree + */ + void enterDecoratorList(TypeScriptParser.DecoratorListContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#decoratorList}. + * @param ctx the parse tree + */ + void exitDecoratorList(TypeScriptParser.DecoratorListContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#decorator}. + * @param ctx the parse tree + */ + void enterDecorator(TypeScriptParser.DecoratorContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#decorator}. + * @param ctx the parse tree + */ + void exitDecorator(TypeScriptParser.DecoratorContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#decoratorMemberExpression}. + * @param ctx the parse tree + */ + void enterDecoratorMemberExpression(TypeScriptParser.DecoratorMemberExpressionContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#decoratorMemberExpression}. + * @param ctx the parse tree + */ + void exitDecoratorMemberExpression(TypeScriptParser.DecoratorMemberExpressionContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#decoratorCallExpression}. + * @param ctx the parse tree + */ + void enterDecoratorCallExpression(TypeScriptParser.DecoratorCallExpressionContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#decoratorCallExpression}. + * @param ctx the parse tree + */ + void exitDecoratorCallExpression(TypeScriptParser.DecoratorCallExpressionContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#program}. + * @param ctx the parse tree + */ + void enterProgram(TypeScriptParser.ProgramContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#program}. + * @param ctx the parse tree + */ + void exitProgram(TypeScriptParser.ProgramContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#sourceElement}. + * @param ctx the parse tree + */ + void enterSourceElement(TypeScriptParser.SourceElementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#sourceElement}. + * @param ctx the parse tree + */ + void exitSourceElement(TypeScriptParser.SourceElementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#statement}. + * @param ctx the parse tree + */ + void enterStatement(TypeScriptParser.StatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#statement}. + * @param ctx the parse tree + */ + void exitStatement(TypeScriptParser.StatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#block}. + * @param ctx the parse tree + */ + void enterBlock(TypeScriptParser.BlockContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#block}. + * @param ctx the parse tree + */ + void exitBlock(TypeScriptParser.BlockContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#statementList}. + * @param ctx the parse tree + */ + void enterStatementList(TypeScriptParser.StatementListContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#statementList}. + * @param ctx the parse tree + */ + void exitStatementList(TypeScriptParser.StatementListContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#abstractDeclaration}. + * @param ctx the parse tree + */ + void enterAbstractDeclaration(TypeScriptParser.AbstractDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#abstractDeclaration}. + * @param ctx the parse tree + */ + void exitAbstractDeclaration(TypeScriptParser.AbstractDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#importStatement}. + * @param ctx the parse tree + */ + void enterImportStatement(TypeScriptParser.ImportStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#importStatement}. + * @param ctx the parse tree + */ + void exitImportStatement(TypeScriptParser.ImportStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#fromBlock}. + * @param ctx the parse tree + */ + void enterFromBlock(TypeScriptParser.FromBlockContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#fromBlock}. + * @param ctx the parse tree + */ + void exitFromBlock(TypeScriptParser.FromBlockContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#multipleImportStatement}. + * @param ctx the parse tree + */ + void enterMultipleImportStatement(TypeScriptParser.MultipleImportStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#multipleImportStatement}. + * @param ctx the parse tree + */ + void exitMultipleImportStatement(TypeScriptParser.MultipleImportStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#exportStatement}. + * @param ctx the parse tree + */ + void enterExportStatement(TypeScriptParser.ExportStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#exportStatement}. + * @param ctx the parse tree + */ + void exitExportStatement(TypeScriptParser.ExportStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#variableStatement}. + * @param ctx the parse tree + */ + void enterVariableStatement(TypeScriptParser.VariableStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#variableStatement}. + * @param ctx the parse tree + */ + void exitVariableStatement(TypeScriptParser.VariableStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#variableDeclarationList}. + * @param ctx the parse tree + */ + void enterVariableDeclarationList(TypeScriptParser.VariableDeclarationListContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#variableDeclarationList}. + * @param ctx the parse tree + */ + void exitVariableDeclarationList(TypeScriptParser.VariableDeclarationListContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#variableDeclaration}. + * @param ctx the parse tree + */ + void enterVariableDeclaration(TypeScriptParser.VariableDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#variableDeclaration}. + * @param ctx the parse tree + */ + void exitVariableDeclaration(TypeScriptParser.VariableDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#emptyStatement_}. + * @param ctx the parse tree + */ + void enterEmptyStatement_(TypeScriptParser.EmptyStatement_Context ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#emptyStatement_}. + * @param ctx the parse tree + */ + void exitEmptyStatement_(TypeScriptParser.EmptyStatement_Context ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#expressionStatement}. + * @param ctx the parse tree + */ + void enterExpressionStatement(TypeScriptParser.ExpressionStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#expressionStatement}. + * @param ctx the parse tree + */ + void exitExpressionStatement(TypeScriptParser.ExpressionStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#ifStatement}. + * @param ctx the parse tree + */ + void enterIfStatement(TypeScriptParser.IfStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#ifStatement}. + * @param ctx the parse tree + */ + void exitIfStatement(TypeScriptParser.IfStatementContext ctx); + /** + * Enter a parse tree produced by the {@code DoStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + */ + void enterDoStatement(TypeScriptParser.DoStatementContext ctx); + /** + * Exit a parse tree produced by the {@code DoStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + */ + void exitDoStatement(TypeScriptParser.DoStatementContext ctx); + /** + * Enter a parse tree produced by the {@code WhileStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + */ + void enterWhileStatement(TypeScriptParser.WhileStatementContext ctx); + /** + * Exit a parse tree produced by the {@code WhileStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + */ + void exitWhileStatement(TypeScriptParser.WhileStatementContext ctx); + /** + * Enter a parse tree produced by the {@code ForStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + */ + void enterForStatement(TypeScriptParser.ForStatementContext ctx); + /** + * Exit a parse tree produced by the {@code ForStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + */ + void exitForStatement(TypeScriptParser.ForStatementContext ctx); + /** + * Enter a parse tree produced by the {@code ForVarStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + */ + void enterForVarStatement(TypeScriptParser.ForVarStatementContext ctx); + /** + * Exit a parse tree produced by the {@code ForVarStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + */ + void exitForVarStatement(TypeScriptParser.ForVarStatementContext ctx); + /** + * Enter a parse tree produced by the {@code ForInStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + */ + void enterForInStatement(TypeScriptParser.ForInStatementContext ctx); + /** + * Exit a parse tree produced by the {@code ForInStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + */ + void exitForInStatement(TypeScriptParser.ForInStatementContext ctx); + /** + * Enter a parse tree produced by the {@code ForVarInStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + */ + void enterForVarInStatement(TypeScriptParser.ForVarInStatementContext ctx); + /** + * Exit a parse tree produced by the {@code ForVarInStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + */ + void exitForVarInStatement(TypeScriptParser.ForVarInStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#varModifier}. + * @param ctx the parse tree + */ + void enterVarModifier(TypeScriptParser.VarModifierContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#varModifier}. + * @param ctx the parse tree + */ + void exitVarModifier(TypeScriptParser.VarModifierContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#continueStatement}. + * @param ctx the parse tree + */ + void enterContinueStatement(TypeScriptParser.ContinueStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#continueStatement}. + * @param ctx the parse tree + */ + void exitContinueStatement(TypeScriptParser.ContinueStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#breakStatement}. + * @param ctx the parse tree + */ + void enterBreakStatement(TypeScriptParser.BreakStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#breakStatement}. + * @param ctx the parse tree + */ + void exitBreakStatement(TypeScriptParser.BreakStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#returnStatement}. + * @param ctx the parse tree + */ + void enterReturnStatement(TypeScriptParser.ReturnStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#returnStatement}. + * @param ctx the parse tree + */ + void exitReturnStatement(TypeScriptParser.ReturnStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#yieldStatement}. + * @param ctx the parse tree + */ + void enterYieldStatement(TypeScriptParser.YieldStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#yieldStatement}. + * @param ctx the parse tree + */ + void exitYieldStatement(TypeScriptParser.YieldStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#withStatement}. + * @param ctx the parse tree + */ + void enterWithStatement(TypeScriptParser.WithStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#withStatement}. + * @param ctx the parse tree + */ + void exitWithStatement(TypeScriptParser.WithStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#switchStatement}. + * @param ctx the parse tree + */ + void enterSwitchStatement(TypeScriptParser.SwitchStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#switchStatement}. + * @param ctx the parse tree + */ + void exitSwitchStatement(TypeScriptParser.SwitchStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#caseBlock}. + * @param ctx the parse tree + */ + void enterCaseBlock(TypeScriptParser.CaseBlockContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#caseBlock}. + * @param ctx the parse tree + */ + void exitCaseBlock(TypeScriptParser.CaseBlockContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#caseClauses}. + * @param ctx the parse tree + */ + void enterCaseClauses(TypeScriptParser.CaseClausesContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#caseClauses}. + * @param ctx the parse tree + */ + void exitCaseClauses(TypeScriptParser.CaseClausesContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#caseClause}. + * @param ctx the parse tree + */ + void enterCaseClause(TypeScriptParser.CaseClauseContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#caseClause}. + * @param ctx the parse tree + */ + void exitCaseClause(TypeScriptParser.CaseClauseContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#defaultClause}. + * @param ctx the parse tree + */ + void enterDefaultClause(TypeScriptParser.DefaultClauseContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#defaultClause}. + * @param ctx the parse tree + */ + void exitDefaultClause(TypeScriptParser.DefaultClauseContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#labelledStatement}. + * @param ctx the parse tree + */ + void enterLabelledStatement(TypeScriptParser.LabelledStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#labelledStatement}. + * @param ctx the parse tree + */ + void exitLabelledStatement(TypeScriptParser.LabelledStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#throwStatement}. + * @param ctx the parse tree + */ + void enterThrowStatement(TypeScriptParser.ThrowStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#throwStatement}. + * @param ctx the parse tree + */ + void exitThrowStatement(TypeScriptParser.ThrowStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#tryStatement}. + * @param ctx the parse tree + */ + void enterTryStatement(TypeScriptParser.TryStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#tryStatement}. + * @param ctx the parse tree + */ + void exitTryStatement(TypeScriptParser.TryStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#catchProduction}. + * @param ctx the parse tree + */ + void enterCatchProduction(TypeScriptParser.CatchProductionContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#catchProduction}. + * @param ctx the parse tree + */ + void exitCatchProduction(TypeScriptParser.CatchProductionContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#finallyProduction}. + * @param ctx the parse tree + */ + void enterFinallyProduction(TypeScriptParser.FinallyProductionContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#finallyProduction}. + * @param ctx the parse tree + */ + void exitFinallyProduction(TypeScriptParser.FinallyProductionContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#debuggerStatement}. + * @param ctx the parse tree + */ + void enterDebuggerStatement(TypeScriptParser.DebuggerStatementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#debuggerStatement}. + * @param ctx the parse tree + */ + void exitDebuggerStatement(TypeScriptParser.DebuggerStatementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#functionDeclaration}. + * @param ctx the parse tree + */ + void enterFunctionDeclaration(TypeScriptParser.FunctionDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#functionDeclaration}. + * @param ctx the parse tree + */ + void exitFunctionDeclaration(TypeScriptParser.FunctionDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#classDeclaration}. + * @param ctx the parse tree + */ + void enterClassDeclaration(TypeScriptParser.ClassDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#classDeclaration}. + * @param ctx the parse tree + */ + void exitClassDeclaration(TypeScriptParser.ClassDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#classHeritage}. + * @param ctx the parse tree + */ + void enterClassHeritage(TypeScriptParser.ClassHeritageContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#classHeritage}. + * @param ctx the parse tree + */ + void exitClassHeritage(TypeScriptParser.ClassHeritageContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#classTail}. + * @param ctx the parse tree + */ + void enterClassTail(TypeScriptParser.ClassTailContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#classTail}. + * @param ctx the parse tree + */ + void exitClassTail(TypeScriptParser.ClassTailContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#classExtendsClause}. + * @param ctx the parse tree + */ + void enterClassExtendsClause(TypeScriptParser.ClassExtendsClauseContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#classExtendsClause}. + * @param ctx the parse tree + */ + void exitClassExtendsClause(TypeScriptParser.ClassExtendsClauseContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#implementsClause}. + * @param ctx the parse tree + */ + void enterImplementsClause(TypeScriptParser.ImplementsClauseContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#implementsClause}. + * @param ctx the parse tree + */ + void exitImplementsClause(TypeScriptParser.ImplementsClauseContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#classElement}. + * @param ctx the parse tree + */ + void enterClassElement(TypeScriptParser.ClassElementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#classElement}. + * @param ctx the parse tree + */ + void exitClassElement(TypeScriptParser.ClassElementContext ctx); + /** + * Enter a parse tree produced by the {@code PropertyDeclarationExpression} + * labeled alternative in {@link TypeScriptParser#propertyMemberDeclaration}. + * @param ctx the parse tree + */ + void enterPropertyDeclarationExpression(TypeScriptParser.PropertyDeclarationExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code PropertyDeclarationExpression} + * labeled alternative in {@link TypeScriptParser#propertyMemberDeclaration}. + * @param ctx the parse tree + */ + void exitPropertyDeclarationExpression(TypeScriptParser.PropertyDeclarationExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code MethodDeclarationExpression} + * labeled alternative in {@link TypeScriptParser#propertyMemberDeclaration}. + * @param ctx the parse tree + */ + void enterMethodDeclarationExpression(TypeScriptParser.MethodDeclarationExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code MethodDeclarationExpression} + * labeled alternative in {@link TypeScriptParser#propertyMemberDeclaration}. + * @param ctx the parse tree + */ + void exitMethodDeclarationExpression(TypeScriptParser.MethodDeclarationExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code GetterSetterDeclarationExpression} + * labeled alternative in {@link TypeScriptParser#propertyMemberDeclaration}. + * @param ctx the parse tree + */ + void enterGetterSetterDeclarationExpression(TypeScriptParser.GetterSetterDeclarationExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code GetterSetterDeclarationExpression} + * labeled alternative in {@link TypeScriptParser#propertyMemberDeclaration}. + * @param ctx the parse tree + */ + void exitGetterSetterDeclarationExpression(TypeScriptParser.GetterSetterDeclarationExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code AbstractMemberDeclaration} + * labeled alternative in {@link TypeScriptParser#propertyMemberDeclaration}. + * @param ctx the parse tree + */ + void enterAbstractMemberDeclaration(TypeScriptParser.AbstractMemberDeclarationContext ctx); + /** + * Exit a parse tree produced by the {@code AbstractMemberDeclaration} + * labeled alternative in {@link TypeScriptParser#propertyMemberDeclaration}. + * @param ctx the parse tree + */ + void exitAbstractMemberDeclaration(TypeScriptParser.AbstractMemberDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#propertyMemberBase}. + * @param ctx the parse tree + */ + void enterPropertyMemberBase(TypeScriptParser.PropertyMemberBaseContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#propertyMemberBase}. + * @param ctx the parse tree + */ + void exitPropertyMemberBase(TypeScriptParser.PropertyMemberBaseContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#indexMemberDeclaration}. + * @param ctx the parse tree + */ + void enterIndexMemberDeclaration(TypeScriptParser.IndexMemberDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#indexMemberDeclaration}. + * @param ctx the parse tree + */ + void exitIndexMemberDeclaration(TypeScriptParser.IndexMemberDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#generatorMethod}. + * @param ctx the parse tree + */ + void enterGeneratorMethod(TypeScriptParser.GeneratorMethodContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#generatorMethod}. + * @param ctx the parse tree + */ + void exitGeneratorMethod(TypeScriptParser.GeneratorMethodContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#generatorFunctionDeclaration}. + * @param ctx the parse tree + */ + void enterGeneratorFunctionDeclaration(TypeScriptParser.GeneratorFunctionDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#generatorFunctionDeclaration}. + * @param ctx the parse tree + */ + void exitGeneratorFunctionDeclaration(TypeScriptParser.GeneratorFunctionDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#generatorBlock}. + * @param ctx the parse tree + */ + void enterGeneratorBlock(TypeScriptParser.GeneratorBlockContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#generatorBlock}. + * @param ctx the parse tree + */ + void exitGeneratorBlock(TypeScriptParser.GeneratorBlockContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#generatorDefinition}. + * @param ctx the parse tree + */ + void enterGeneratorDefinition(TypeScriptParser.GeneratorDefinitionContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#generatorDefinition}. + * @param ctx the parse tree + */ + void exitGeneratorDefinition(TypeScriptParser.GeneratorDefinitionContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#iteratorBlock}. + * @param ctx the parse tree + */ + void enterIteratorBlock(TypeScriptParser.IteratorBlockContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#iteratorBlock}. + * @param ctx the parse tree + */ + void exitIteratorBlock(TypeScriptParser.IteratorBlockContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#iteratorDefinition}. + * @param ctx the parse tree + */ + void enterIteratorDefinition(TypeScriptParser.IteratorDefinitionContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#iteratorDefinition}. + * @param ctx the parse tree + */ + void exitIteratorDefinition(TypeScriptParser.IteratorDefinitionContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#formalParameterList}. + * @param ctx the parse tree + */ + void enterFormalParameterList(TypeScriptParser.FormalParameterListContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#formalParameterList}. + * @param ctx the parse tree + */ + void exitFormalParameterList(TypeScriptParser.FormalParameterListContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#formalParameterArg}. + * @param ctx the parse tree + */ + void enterFormalParameterArg(TypeScriptParser.FormalParameterArgContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#formalParameterArg}. + * @param ctx the parse tree + */ + void exitFormalParameterArg(TypeScriptParser.FormalParameterArgContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#lastFormalParameterArg}. + * @param ctx the parse tree + */ + void enterLastFormalParameterArg(TypeScriptParser.LastFormalParameterArgContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#lastFormalParameterArg}. + * @param ctx the parse tree + */ + void exitLastFormalParameterArg(TypeScriptParser.LastFormalParameterArgContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#functionBody}. + * @param ctx the parse tree + */ + void enterFunctionBody(TypeScriptParser.FunctionBodyContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#functionBody}. + * @param ctx the parse tree + */ + void exitFunctionBody(TypeScriptParser.FunctionBodyContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#sourceElements}. + * @param ctx the parse tree + */ + void enterSourceElements(TypeScriptParser.SourceElementsContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#sourceElements}. + * @param ctx the parse tree + */ + void exitSourceElements(TypeScriptParser.SourceElementsContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#arrayLiteral}. + * @param ctx the parse tree + */ + void enterArrayLiteral(TypeScriptParser.ArrayLiteralContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#arrayLiteral}. + * @param ctx the parse tree + */ + void exitArrayLiteral(TypeScriptParser.ArrayLiteralContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#elementList}. + * @param ctx the parse tree + */ + void enterElementList(TypeScriptParser.ElementListContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#elementList}. + * @param ctx the parse tree + */ + void exitElementList(TypeScriptParser.ElementListContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#arrayElement}. + * @param ctx the parse tree + */ + void enterArrayElement(TypeScriptParser.ArrayElementContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#arrayElement}. + * @param ctx the parse tree + */ + void exitArrayElement(TypeScriptParser.ArrayElementContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#objectLiteral}. + * @param ctx the parse tree + */ + void enterObjectLiteral(TypeScriptParser.ObjectLiteralContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#objectLiteral}. + * @param ctx the parse tree + */ + void exitObjectLiteral(TypeScriptParser.ObjectLiteralContext ctx); + /** + * Enter a parse tree produced by the {@code PropertyExpressionAssignment} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void enterPropertyExpressionAssignment(TypeScriptParser.PropertyExpressionAssignmentContext ctx); + /** + * Exit a parse tree produced by the {@code PropertyExpressionAssignment} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void exitPropertyExpressionAssignment(TypeScriptParser.PropertyExpressionAssignmentContext ctx); + /** + * Enter a parse tree produced by the {@code ComputedPropertyExpressionAssignment} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void enterComputedPropertyExpressionAssignment(TypeScriptParser.ComputedPropertyExpressionAssignmentContext ctx); + /** + * Exit a parse tree produced by the {@code ComputedPropertyExpressionAssignment} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void exitComputedPropertyExpressionAssignment(TypeScriptParser.ComputedPropertyExpressionAssignmentContext ctx); + /** + * Enter a parse tree produced by the {@code PropertyGetter} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void enterPropertyGetter(TypeScriptParser.PropertyGetterContext ctx); + /** + * Exit a parse tree produced by the {@code PropertyGetter} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void exitPropertyGetter(TypeScriptParser.PropertyGetterContext ctx); + /** + * Enter a parse tree produced by the {@code PropertySetter} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void enterPropertySetter(TypeScriptParser.PropertySetterContext ctx); + /** + * Exit a parse tree produced by the {@code PropertySetter} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void exitPropertySetter(TypeScriptParser.PropertySetterContext ctx); + /** + * Enter a parse tree produced by the {@code MethodProperty} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void enterMethodProperty(TypeScriptParser.MethodPropertyContext ctx); + /** + * Exit a parse tree produced by the {@code MethodProperty} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void exitMethodProperty(TypeScriptParser.MethodPropertyContext ctx); + /** + * Enter a parse tree produced by the {@code PropertyShorthand} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void enterPropertyShorthand(TypeScriptParser.PropertyShorthandContext ctx); + /** + * Exit a parse tree produced by the {@code PropertyShorthand} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void exitPropertyShorthand(TypeScriptParser.PropertyShorthandContext ctx); + /** + * Enter a parse tree produced by the {@code RestParameterInObject} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void enterRestParameterInObject(TypeScriptParser.RestParameterInObjectContext ctx); + /** + * Exit a parse tree produced by the {@code RestParameterInObject} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + */ + void exitRestParameterInObject(TypeScriptParser.RestParameterInObjectContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#getAccessor}. + * @param ctx the parse tree + */ + void enterGetAccessor(TypeScriptParser.GetAccessorContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#getAccessor}. + * @param ctx the parse tree + */ + void exitGetAccessor(TypeScriptParser.GetAccessorContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#setAccessor}. + * @param ctx the parse tree + */ + void enterSetAccessor(TypeScriptParser.SetAccessorContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#setAccessor}. + * @param ctx the parse tree + */ + void exitSetAccessor(TypeScriptParser.SetAccessorContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#propertyName}. + * @param ctx the parse tree + */ + void enterPropertyName(TypeScriptParser.PropertyNameContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#propertyName}. + * @param ctx the parse tree + */ + void exitPropertyName(TypeScriptParser.PropertyNameContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#arguments}. + * @param ctx the parse tree + */ + void enterArguments(TypeScriptParser.ArgumentsContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#arguments}. + * @param ctx the parse tree + */ + void exitArguments(TypeScriptParser.ArgumentsContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#argumentList}. + * @param ctx the parse tree + */ + void enterArgumentList(TypeScriptParser.ArgumentListContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#argumentList}. + * @param ctx the parse tree + */ + void exitArgumentList(TypeScriptParser.ArgumentListContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#argument}. + * @param ctx the parse tree + */ + void enterArgument(TypeScriptParser.ArgumentContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#argument}. + * @param ctx the parse tree + */ + void exitArgument(TypeScriptParser.ArgumentContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#expressionSequence}. + * @param ctx the parse tree + */ + void enterExpressionSequence(TypeScriptParser.ExpressionSequenceContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#expressionSequence}. + * @param ctx the parse tree + */ + void exitExpressionSequence(TypeScriptParser.ExpressionSequenceContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#functionExpressionDeclaration}. + * @param ctx the parse tree + */ + void enterFunctionExpressionDeclaration(TypeScriptParser.FunctionExpressionDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#functionExpressionDeclaration}. + * @param ctx the parse tree + */ + void exitFunctionExpressionDeclaration(TypeScriptParser.FunctionExpressionDeclarationContext ctx); + /** + * Enter a parse tree produced by the {@code TemplateStringExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterTemplateStringExpression(TypeScriptParser.TemplateStringExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code TemplateStringExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitTemplateStringExpression(TypeScriptParser.TemplateStringExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code TernaryExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterTernaryExpression(TypeScriptParser.TernaryExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code TernaryExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitTernaryExpression(TypeScriptParser.TernaryExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code LogicalAndExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterLogicalAndExpression(TypeScriptParser.LogicalAndExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code LogicalAndExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitLogicalAndExpression(TypeScriptParser.LogicalAndExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code GeneratorsExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterGeneratorsExpression(TypeScriptParser.GeneratorsExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code GeneratorsExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitGeneratorsExpression(TypeScriptParser.GeneratorsExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code PreIncrementExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterPreIncrementExpression(TypeScriptParser.PreIncrementExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code PreIncrementExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitPreIncrementExpression(TypeScriptParser.PreIncrementExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code ObjectLiteralExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterObjectLiteralExpression(TypeScriptParser.ObjectLiteralExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ObjectLiteralExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitObjectLiteralExpression(TypeScriptParser.ObjectLiteralExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code InExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterInExpression(TypeScriptParser.InExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code InExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitInExpression(TypeScriptParser.InExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code LogicalOrExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterLogicalOrExpression(TypeScriptParser.LogicalOrExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code LogicalOrExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitLogicalOrExpression(TypeScriptParser.LogicalOrExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code GenericTypes} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterGenericTypes(TypeScriptParser.GenericTypesContext ctx); + /** + * Exit a parse tree produced by the {@code GenericTypes} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitGenericTypes(TypeScriptParser.GenericTypesContext ctx); + /** + * Enter a parse tree produced by the {@code NotExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterNotExpression(TypeScriptParser.NotExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code NotExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitNotExpression(TypeScriptParser.NotExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code PreDecreaseExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterPreDecreaseExpression(TypeScriptParser.PreDecreaseExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code PreDecreaseExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitPreDecreaseExpression(TypeScriptParser.PreDecreaseExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code ArgumentsExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterArgumentsExpression(TypeScriptParser.ArgumentsExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ArgumentsExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitArgumentsExpression(TypeScriptParser.ArgumentsExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code ThisExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterThisExpression(TypeScriptParser.ThisExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ThisExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitThisExpression(TypeScriptParser.ThisExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code FunctionExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterFunctionExpression(TypeScriptParser.FunctionExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code FunctionExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitFunctionExpression(TypeScriptParser.FunctionExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code UnaryMinusExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterUnaryMinusExpression(TypeScriptParser.UnaryMinusExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code UnaryMinusExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitUnaryMinusExpression(TypeScriptParser.UnaryMinusExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code AssignmentExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterAssignmentExpression(TypeScriptParser.AssignmentExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code AssignmentExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitAssignmentExpression(TypeScriptParser.AssignmentExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code PostDecreaseExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterPostDecreaseExpression(TypeScriptParser.PostDecreaseExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code PostDecreaseExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitPostDecreaseExpression(TypeScriptParser.PostDecreaseExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code TypeofExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterTypeofExpression(TypeScriptParser.TypeofExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code TypeofExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitTypeofExpression(TypeScriptParser.TypeofExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code InstanceofExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterInstanceofExpression(TypeScriptParser.InstanceofExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code InstanceofExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitInstanceofExpression(TypeScriptParser.InstanceofExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code UnaryPlusExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterUnaryPlusExpression(TypeScriptParser.UnaryPlusExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code UnaryPlusExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitUnaryPlusExpression(TypeScriptParser.UnaryPlusExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code DeleteExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterDeleteExpression(TypeScriptParser.DeleteExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code DeleteExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitDeleteExpression(TypeScriptParser.DeleteExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code GeneratorsFunctionExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterGeneratorsFunctionExpression(TypeScriptParser.GeneratorsFunctionExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code GeneratorsFunctionExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitGeneratorsFunctionExpression(TypeScriptParser.GeneratorsFunctionExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code ArrowFunctionExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterArrowFunctionExpression(TypeScriptParser.ArrowFunctionExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ArrowFunctionExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitArrowFunctionExpression(TypeScriptParser.ArrowFunctionExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code IteratorsExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterIteratorsExpression(TypeScriptParser.IteratorsExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code IteratorsExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitIteratorsExpression(TypeScriptParser.IteratorsExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code EqualityExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterEqualityExpression(TypeScriptParser.EqualityExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code EqualityExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitEqualityExpression(TypeScriptParser.EqualityExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code BitXOrExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterBitXOrExpression(TypeScriptParser.BitXOrExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code BitXOrExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitBitXOrExpression(TypeScriptParser.BitXOrExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code CastAsExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterCastAsExpression(TypeScriptParser.CastAsExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code CastAsExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitCastAsExpression(TypeScriptParser.CastAsExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code SuperExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterSuperExpression(TypeScriptParser.SuperExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code SuperExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitSuperExpression(TypeScriptParser.SuperExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code MultiplicativeExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterMultiplicativeExpression(TypeScriptParser.MultiplicativeExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code MultiplicativeExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitMultiplicativeExpression(TypeScriptParser.MultiplicativeExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code BitShiftExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterBitShiftExpression(TypeScriptParser.BitShiftExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code BitShiftExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitBitShiftExpression(TypeScriptParser.BitShiftExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code ParenthesizedExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterParenthesizedExpression(TypeScriptParser.ParenthesizedExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ParenthesizedExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitParenthesizedExpression(TypeScriptParser.ParenthesizedExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code AdditiveExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterAdditiveExpression(TypeScriptParser.AdditiveExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code AdditiveExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitAdditiveExpression(TypeScriptParser.AdditiveExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code RelationalExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterRelationalExpression(TypeScriptParser.RelationalExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code RelationalExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitRelationalExpression(TypeScriptParser.RelationalExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code PostIncrementExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterPostIncrementExpression(TypeScriptParser.PostIncrementExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code PostIncrementExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitPostIncrementExpression(TypeScriptParser.PostIncrementExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code YieldExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterYieldExpression(TypeScriptParser.YieldExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code YieldExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitYieldExpression(TypeScriptParser.YieldExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code BitNotExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterBitNotExpression(TypeScriptParser.BitNotExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code BitNotExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitBitNotExpression(TypeScriptParser.BitNotExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code NewExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterNewExpression(TypeScriptParser.NewExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code NewExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitNewExpression(TypeScriptParser.NewExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code LiteralExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterLiteralExpression(TypeScriptParser.LiteralExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code LiteralExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitLiteralExpression(TypeScriptParser.LiteralExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code ArrayLiteralExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterArrayLiteralExpression(TypeScriptParser.ArrayLiteralExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ArrayLiteralExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitArrayLiteralExpression(TypeScriptParser.ArrayLiteralExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code MemberDotExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterMemberDotExpression(TypeScriptParser.MemberDotExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code MemberDotExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitMemberDotExpression(TypeScriptParser.MemberDotExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code MemberIndexExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterMemberIndexExpression(TypeScriptParser.MemberIndexExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code MemberIndexExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitMemberIndexExpression(TypeScriptParser.MemberIndexExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code IdentifierExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterIdentifierExpression(TypeScriptParser.IdentifierExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code IdentifierExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitIdentifierExpression(TypeScriptParser.IdentifierExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code BitAndExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterBitAndExpression(TypeScriptParser.BitAndExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code BitAndExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitBitAndExpression(TypeScriptParser.BitAndExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code BitOrExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterBitOrExpression(TypeScriptParser.BitOrExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code BitOrExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitBitOrExpression(TypeScriptParser.BitOrExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code AssignmentOperatorExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterAssignmentOperatorExpression(TypeScriptParser.AssignmentOperatorExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code AssignmentOperatorExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitAssignmentOperatorExpression(TypeScriptParser.AssignmentOperatorExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code VoidExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void enterVoidExpression(TypeScriptParser.VoidExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code VoidExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + */ + void exitVoidExpression(TypeScriptParser.VoidExpressionContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#asExpression}. + * @param ctx the parse tree + */ + void enterAsExpression(TypeScriptParser.AsExpressionContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#asExpression}. + * @param ctx the parse tree + */ + void exitAsExpression(TypeScriptParser.AsExpressionContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#arrowFunctionDeclaration}. + * @param ctx the parse tree + */ + void enterArrowFunctionDeclaration(TypeScriptParser.ArrowFunctionDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#arrowFunctionDeclaration}. + * @param ctx the parse tree + */ + void exitArrowFunctionDeclaration(TypeScriptParser.ArrowFunctionDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#arrowFunctionParameters}. + * @param ctx the parse tree + */ + void enterArrowFunctionParameters(TypeScriptParser.ArrowFunctionParametersContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#arrowFunctionParameters}. + * @param ctx the parse tree + */ + void exitArrowFunctionParameters(TypeScriptParser.ArrowFunctionParametersContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#arrowFunctionBody}. + * @param ctx the parse tree + */ + void enterArrowFunctionBody(TypeScriptParser.ArrowFunctionBodyContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#arrowFunctionBody}. + * @param ctx the parse tree + */ + void exitArrowFunctionBody(TypeScriptParser.ArrowFunctionBodyContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#assignmentOperator}. + * @param ctx the parse tree + */ + void enterAssignmentOperator(TypeScriptParser.AssignmentOperatorContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#assignmentOperator}. + * @param ctx the parse tree + */ + void exitAssignmentOperator(TypeScriptParser.AssignmentOperatorContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#literal}. + * @param ctx the parse tree + */ + void enterLiteral(TypeScriptParser.LiteralContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#literal}. + * @param ctx the parse tree + */ + void exitLiteral(TypeScriptParser.LiteralContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#templateStringLiteral}. + * @param ctx the parse tree + */ + void enterTemplateStringLiteral(TypeScriptParser.TemplateStringLiteralContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#templateStringLiteral}. + * @param ctx the parse tree + */ + void exitTemplateStringLiteral(TypeScriptParser.TemplateStringLiteralContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#templateStringAtom}. + * @param ctx the parse tree + */ + void enterTemplateStringAtom(TypeScriptParser.TemplateStringAtomContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#templateStringAtom}. + * @param ctx the parse tree + */ + void exitTemplateStringAtom(TypeScriptParser.TemplateStringAtomContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#numericLiteral}. + * @param ctx the parse tree + */ + void enterNumericLiteral(TypeScriptParser.NumericLiteralContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#numericLiteral}. + * @param ctx the parse tree + */ + void exitNumericLiteral(TypeScriptParser.NumericLiteralContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#identifierName}. + * @param ctx the parse tree + */ + void enterIdentifierName(TypeScriptParser.IdentifierNameContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#identifierName}. + * @param ctx the parse tree + */ + void exitIdentifierName(TypeScriptParser.IdentifierNameContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#identifierOrKeyWord}. + * @param ctx the parse tree + */ + void enterIdentifierOrKeyWord(TypeScriptParser.IdentifierOrKeyWordContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#identifierOrKeyWord}. + * @param ctx the parse tree + */ + void exitIdentifierOrKeyWord(TypeScriptParser.IdentifierOrKeyWordContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#reservedWord}. + * @param ctx the parse tree + */ + void enterReservedWord(TypeScriptParser.ReservedWordContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#reservedWord}. + * @param ctx the parse tree + */ + void exitReservedWord(TypeScriptParser.ReservedWordContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#keyword}. + * @param ctx the parse tree + */ + void enterKeyword(TypeScriptParser.KeywordContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#keyword}. + * @param ctx the parse tree + */ + void exitKeyword(TypeScriptParser.KeywordContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#getter}. + * @param ctx the parse tree + */ + void enterGetter(TypeScriptParser.GetterContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#getter}. + * @param ctx the parse tree + */ + void exitGetter(TypeScriptParser.GetterContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#setter}. + * @param ctx the parse tree + */ + void enterSetter(TypeScriptParser.SetterContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#setter}. + * @param ctx the parse tree + */ + void exitSetter(TypeScriptParser.SetterContext ctx); + /** + * Enter a parse tree produced by {@link TypeScriptParser#eos}. + * @param ctx the parse tree + */ + void enterEos(TypeScriptParser.EosContext ctx); + /** + * Exit a parse tree produced by {@link TypeScriptParser#eos}. + * @param ctx the parse tree + */ + void exitEos(TypeScriptParser.EosContext ctx); +} \ No newline at end of file diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParserVisitor.java b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParserVisitor.java new file mode 100644 index 0000000..a367113 --- /dev/null +++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParserVisitor.java @@ -0,0 +1,1366 @@ +// Generated from /www/p_java/babylon/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.g4 by ANTLR 4.13.1 +package one.edee.babylon.export.ts.gen; +import org.antlr.v4.runtime.tree.ParseTreeVisitor; + +/** + * This interface defines a complete generic visitor for a parse tree produced + * by {@link TypeScriptParser}. + * + * @param The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +public interface TypeScriptParserVisitor extends ParseTreeVisitor { + /** + * Visit a parse tree produced by {@link TypeScriptParser#initializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInitializer(TypeScriptParser.InitializerContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#bindingPattern}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBindingPattern(TypeScriptParser.BindingPatternContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeParameters}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameters(TypeScriptParser.TypeParametersContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeParameterList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameterList(TypeScriptParser.TypeParameterListContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameter(TypeScriptParser.TypeParameterContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#constraint}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstraint(TypeScriptParser.ConstraintContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeArguments}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArguments(TypeScriptParser.TypeArgumentsContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeArgumentList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArgumentList(TypeScriptParser.TypeArgumentListContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeArgument}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArgument(TypeScriptParser.TypeArgumentContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#type_}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitType_(TypeScriptParser.Type_Context ctx); + /** + * Visit a parse tree produced by the {@code Intersection} + * labeled alternative in {@link TypeScriptParser#unionOrIntersectionOrPrimaryType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIntersection(TypeScriptParser.IntersectionContext ctx); + /** + * Visit a parse tree produced by the {@code Primary} + * labeled alternative in {@link TypeScriptParser#unionOrIntersectionOrPrimaryType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimary(TypeScriptParser.PrimaryContext ctx); + /** + * Visit a parse tree produced by the {@code Union} + * labeled alternative in {@link TypeScriptParser#unionOrIntersectionOrPrimaryType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnion(TypeScriptParser.UnionContext ctx); + /** + * Visit a parse tree produced by the {@code RedefinitionOfType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitRedefinitionOfType(TypeScriptParser.RedefinitionOfTypeContext ctx); + /** + * Visit a parse tree produced by the {@code PredefinedPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPredefinedPrimType(TypeScriptParser.PredefinedPrimTypeContext ctx); + /** + * Visit a parse tree produced by the {@code ArrayPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayPrimType(TypeScriptParser.ArrayPrimTypeContext ctx); + /** + * Visit a parse tree produced by the {@code ParenthesizedPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitParenthesizedPrimType(TypeScriptParser.ParenthesizedPrimTypeContext ctx); + /** + * Visit a parse tree produced by the {@code ThisPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitThisPrimType(TypeScriptParser.ThisPrimTypeContext ctx); + /** + * Visit a parse tree produced by the {@code TuplePrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTuplePrimType(TypeScriptParser.TuplePrimTypeContext ctx); + /** + * Visit a parse tree produced by the {@code ObjectPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitObjectPrimType(TypeScriptParser.ObjectPrimTypeContext ctx); + /** + * Visit a parse tree produced by the {@code ReferencePrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitReferencePrimType(TypeScriptParser.ReferencePrimTypeContext ctx); + /** + * Visit a parse tree produced by the {@code QueryPrimType} + * labeled alternative in {@link TypeScriptParser#primaryType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitQueryPrimType(TypeScriptParser.QueryPrimTypeContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#predefinedType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPredefinedType(TypeScriptParser.PredefinedTypeContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeReference}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeReference(TypeScriptParser.TypeReferenceContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#nestedTypeGeneric}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNestedTypeGeneric(TypeScriptParser.NestedTypeGenericContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeGeneric}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeGeneric(TypeScriptParser.TypeGenericContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeIncludeGeneric}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeIncludeGeneric(TypeScriptParser.TypeIncludeGenericContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeName(TypeScriptParser.TypeNameContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#objectType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitObjectType(TypeScriptParser.ObjectTypeContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeBody(TypeScriptParser.TypeBodyContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeMemberList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeMemberList(TypeScriptParser.TypeMemberListContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeMember}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeMember(TypeScriptParser.TypeMemberContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#arrayType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayType(TypeScriptParser.ArrayTypeContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#tupleType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTupleType(TypeScriptParser.TupleTypeContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#tupleElementTypes}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTupleElementTypes(TypeScriptParser.TupleElementTypesContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#functionType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionType(TypeScriptParser.FunctionTypeContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#constructorType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorType(TypeScriptParser.ConstructorTypeContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeQuery}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeQuery(TypeScriptParser.TypeQueryContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeQueryExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeQueryExpression(TypeScriptParser.TypeQueryExpressionContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#propertySignatur}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPropertySignatur(TypeScriptParser.PropertySignaturContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeAnnotation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeAnnotation(TypeScriptParser.TypeAnnotationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#callSignature}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCallSignature(TypeScriptParser.CallSignatureContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#parameterList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitParameterList(TypeScriptParser.ParameterListContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#requiredParameterList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitRequiredParameterList(TypeScriptParser.RequiredParameterListContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#parameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitParameter(TypeScriptParser.ParameterContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#optionalParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitOptionalParameter(TypeScriptParser.OptionalParameterContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#restParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitRestParameter(TypeScriptParser.RestParameterContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#requiredParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitRequiredParameter(TypeScriptParser.RequiredParameterContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#accessibilityModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAccessibilityModifier(TypeScriptParser.AccessibilityModifierContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#identifierOrPattern}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIdentifierOrPattern(TypeScriptParser.IdentifierOrPatternContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#constructSignature}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructSignature(TypeScriptParser.ConstructSignatureContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#indexSignature}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIndexSignature(TypeScriptParser.IndexSignatureContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#methodSignature}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodSignature(TypeScriptParser.MethodSignatureContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#typeAliasDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeAliasDeclaration(TypeScriptParser.TypeAliasDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#constructorDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorDeclaration(TypeScriptParser.ConstructorDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#interfaceDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceDeclaration(TypeScriptParser.InterfaceDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#interfaceExtendsClause}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceExtendsClause(TypeScriptParser.InterfaceExtendsClauseContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#classOrInterfaceTypeList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassOrInterfaceTypeList(TypeScriptParser.ClassOrInterfaceTypeListContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#enumDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumDeclaration(TypeScriptParser.EnumDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#enumBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumBody(TypeScriptParser.EnumBodyContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#enumMemberList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumMemberList(TypeScriptParser.EnumMemberListContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#enumMember}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumMember(TypeScriptParser.EnumMemberContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#namespaceDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNamespaceDeclaration(TypeScriptParser.NamespaceDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#namespaceName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNamespaceName(TypeScriptParser.NamespaceNameContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#importAliasDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitImportAliasDeclaration(TypeScriptParser.ImportAliasDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#decoratorList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDecoratorList(TypeScriptParser.DecoratorListContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#decorator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDecorator(TypeScriptParser.DecoratorContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#decoratorMemberExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDecoratorMemberExpression(TypeScriptParser.DecoratorMemberExpressionContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#decoratorCallExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDecoratorCallExpression(TypeScriptParser.DecoratorCallExpressionContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#program}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitProgram(TypeScriptParser.ProgramContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#sourceElement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSourceElement(TypeScriptParser.SourceElementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#statement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatement(TypeScriptParser.StatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#block}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBlock(TypeScriptParser.BlockContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#statementList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatementList(TypeScriptParser.StatementListContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#abstractDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAbstractDeclaration(TypeScriptParser.AbstractDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#importStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitImportStatement(TypeScriptParser.ImportStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#fromBlock}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFromBlock(TypeScriptParser.FromBlockContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#multipleImportStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMultipleImportStatement(TypeScriptParser.MultipleImportStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#exportStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExportStatement(TypeScriptParser.ExportStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#variableStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableStatement(TypeScriptParser.VariableStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#variableDeclarationList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclarationList(TypeScriptParser.VariableDeclarationListContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#variableDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclaration(TypeScriptParser.VariableDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#emptyStatement_}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEmptyStatement_(TypeScriptParser.EmptyStatement_Context ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#expressionStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpressionStatement(TypeScriptParser.ExpressionStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#ifStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIfStatement(TypeScriptParser.IfStatementContext ctx); + /** + * Visit a parse tree produced by the {@code DoStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDoStatement(TypeScriptParser.DoStatementContext ctx); + /** + * Visit a parse tree produced by the {@code WhileStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitWhileStatement(TypeScriptParser.WhileStatementContext ctx); + /** + * Visit a parse tree produced by the {@code ForStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForStatement(TypeScriptParser.ForStatementContext ctx); + /** + * Visit a parse tree produced by the {@code ForVarStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForVarStatement(TypeScriptParser.ForVarStatementContext ctx); + /** + * Visit a parse tree produced by the {@code ForInStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForInStatement(TypeScriptParser.ForInStatementContext ctx); + /** + * Visit a parse tree produced by the {@code ForVarInStatement} + * labeled alternative in {@link TypeScriptParser#iterationStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForVarInStatement(TypeScriptParser.ForVarInStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#varModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVarModifier(TypeScriptParser.VarModifierContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#continueStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitContinueStatement(TypeScriptParser.ContinueStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#breakStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBreakStatement(TypeScriptParser.BreakStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#returnStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitReturnStatement(TypeScriptParser.ReturnStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#yieldStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitYieldStatement(TypeScriptParser.YieldStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#withStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitWithStatement(TypeScriptParser.WithStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#switchStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchStatement(TypeScriptParser.SwitchStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#caseBlock}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCaseBlock(TypeScriptParser.CaseBlockContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#caseClauses}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCaseClauses(TypeScriptParser.CaseClausesContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#caseClause}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCaseClause(TypeScriptParser.CaseClauseContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#defaultClause}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDefaultClause(TypeScriptParser.DefaultClauseContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#labelledStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLabelledStatement(TypeScriptParser.LabelledStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#throwStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitThrowStatement(TypeScriptParser.ThrowStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#tryStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTryStatement(TypeScriptParser.TryStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#catchProduction}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatchProduction(TypeScriptParser.CatchProductionContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#finallyProduction}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFinallyProduction(TypeScriptParser.FinallyProductionContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#debuggerStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDebuggerStatement(TypeScriptParser.DebuggerStatementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#functionDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionDeclaration(TypeScriptParser.FunctionDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#classDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassDeclaration(TypeScriptParser.ClassDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#classHeritage}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassHeritage(TypeScriptParser.ClassHeritageContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#classTail}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassTail(TypeScriptParser.ClassTailContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#classExtendsClause}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassExtendsClause(TypeScriptParser.ClassExtendsClauseContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#implementsClause}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitImplementsClause(TypeScriptParser.ImplementsClauseContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#classElement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassElement(TypeScriptParser.ClassElementContext ctx); + /** + * Visit a parse tree produced by the {@code PropertyDeclarationExpression} + * labeled alternative in {@link TypeScriptParser#propertyMemberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPropertyDeclarationExpression(TypeScriptParser.PropertyDeclarationExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code MethodDeclarationExpression} + * labeled alternative in {@link TypeScriptParser#propertyMemberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodDeclarationExpression(TypeScriptParser.MethodDeclarationExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code GetterSetterDeclarationExpression} + * labeled alternative in {@link TypeScriptParser#propertyMemberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGetterSetterDeclarationExpression(TypeScriptParser.GetterSetterDeclarationExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code AbstractMemberDeclaration} + * labeled alternative in {@link TypeScriptParser#propertyMemberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAbstractMemberDeclaration(TypeScriptParser.AbstractMemberDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#propertyMemberBase}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPropertyMemberBase(TypeScriptParser.PropertyMemberBaseContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#indexMemberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIndexMemberDeclaration(TypeScriptParser.IndexMemberDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#generatorMethod}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGeneratorMethod(TypeScriptParser.GeneratorMethodContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#generatorFunctionDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGeneratorFunctionDeclaration(TypeScriptParser.GeneratorFunctionDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#generatorBlock}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGeneratorBlock(TypeScriptParser.GeneratorBlockContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#generatorDefinition}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGeneratorDefinition(TypeScriptParser.GeneratorDefinitionContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#iteratorBlock}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIteratorBlock(TypeScriptParser.IteratorBlockContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#iteratorDefinition}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIteratorDefinition(TypeScriptParser.IteratorDefinitionContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#formalParameterList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameterList(TypeScriptParser.FormalParameterListContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#formalParameterArg}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameterArg(TypeScriptParser.FormalParameterArgContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#lastFormalParameterArg}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLastFormalParameterArg(TypeScriptParser.LastFormalParameterArgContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#functionBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionBody(TypeScriptParser.FunctionBodyContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#sourceElements}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSourceElements(TypeScriptParser.SourceElementsContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#arrayLiteral}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayLiteral(TypeScriptParser.ArrayLiteralContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#elementList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementList(TypeScriptParser.ElementListContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#arrayElement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayElement(TypeScriptParser.ArrayElementContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#objectLiteral}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitObjectLiteral(TypeScriptParser.ObjectLiteralContext ctx); + /** + * Visit a parse tree produced by the {@code PropertyExpressionAssignment} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPropertyExpressionAssignment(TypeScriptParser.PropertyExpressionAssignmentContext ctx); + /** + * Visit a parse tree produced by the {@code ComputedPropertyExpressionAssignment} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitComputedPropertyExpressionAssignment(TypeScriptParser.ComputedPropertyExpressionAssignmentContext ctx); + /** + * Visit a parse tree produced by the {@code PropertyGetter} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPropertyGetter(TypeScriptParser.PropertyGetterContext ctx); + /** + * Visit a parse tree produced by the {@code PropertySetter} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPropertySetter(TypeScriptParser.PropertySetterContext ctx); + /** + * Visit a parse tree produced by the {@code MethodProperty} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodProperty(TypeScriptParser.MethodPropertyContext ctx); + /** + * Visit a parse tree produced by the {@code PropertyShorthand} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPropertyShorthand(TypeScriptParser.PropertyShorthandContext ctx); + /** + * Visit a parse tree produced by the {@code RestParameterInObject} + * labeled alternative in {@link TypeScriptParser#propertyAssignment}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitRestParameterInObject(TypeScriptParser.RestParameterInObjectContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#getAccessor}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGetAccessor(TypeScriptParser.GetAccessorContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#setAccessor}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSetAccessor(TypeScriptParser.SetAccessorContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#propertyName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPropertyName(TypeScriptParser.PropertyNameContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#arguments}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArguments(TypeScriptParser.ArgumentsContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#argumentList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArgumentList(TypeScriptParser.ArgumentListContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#argument}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArgument(TypeScriptParser.ArgumentContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#expressionSequence}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpressionSequence(TypeScriptParser.ExpressionSequenceContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#functionExpressionDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionExpressionDeclaration(TypeScriptParser.FunctionExpressionDeclarationContext ctx); + /** + * Visit a parse tree produced by the {@code TemplateStringExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTemplateStringExpression(TypeScriptParser.TemplateStringExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code TernaryExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTernaryExpression(TypeScriptParser.TernaryExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code LogicalAndExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLogicalAndExpression(TypeScriptParser.LogicalAndExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code GeneratorsExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGeneratorsExpression(TypeScriptParser.GeneratorsExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code PreIncrementExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPreIncrementExpression(TypeScriptParser.PreIncrementExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code ObjectLiteralExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitObjectLiteralExpression(TypeScriptParser.ObjectLiteralExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code InExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInExpression(TypeScriptParser.InExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code LogicalOrExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLogicalOrExpression(TypeScriptParser.LogicalOrExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code GenericTypes} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGenericTypes(TypeScriptParser.GenericTypesContext ctx); + /** + * Visit a parse tree produced by the {@code NotExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNotExpression(TypeScriptParser.NotExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code PreDecreaseExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPreDecreaseExpression(TypeScriptParser.PreDecreaseExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code ArgumentsExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArgumentsExpression(TypeScriptParser.ArgumentsExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code ThisExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitThisExpression(TypeScriptParser.ThisExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code FunctionExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionExpression(TypeScriptParser.FunctionExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code UnaryMinusExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnaryMinusExpression(TypeScriptParser.UnaryMinusExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code AssignmentExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignmentExpression(TypeScriptParser.AssignmentExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code PostDecreaseExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostDecreaseExpression(TypeScriptParser.PostDecreaseExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code TypeofExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeofExpression(TypeScriptParser.TypeofExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code InstanceofExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInstanceofExpression(TypeScriptParser.InstanceofExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code UnaryPlusExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnaryPlusExpression(TypeScriptParser.UnaryPlusExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code DeleteExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDeleteExpression(TypeScriptParser.DeleteExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code GeneratorsFunctionExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGeneratorsFunctionExpression(TypeScriptParser.GeneratorsFunctionExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code ArrowFunctionExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrowFunctionExpression(TypeScriptParser.ArrowFunctionExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code IteratorsExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIteratorsExpression(TypeScriptParser.IteratorsExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code EqualityExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEqualityExpression(TypeScriptParser.EqualityExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code BitXOrExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBitXOrExpression(TypeScriptParser.BitXOrExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code CastAsExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCastAsExpression(TypeScriptParser.CastAsExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code SuperExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSuperExpression(TypeScriptParser.SuperExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code MultiplicativeExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMultiplicativeExpression(TypeScriptParser.MultiplicativeExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code BitShiftExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBitShiftExpression(TypeScriptParser.BitShiftExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code ParenthesizedExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitParenthesizedExpression(TypeScriptParser.ParenthesizedExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code AdditiveExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAdditiveExpression(TypeScriptParser.AdditiveExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code RelationalExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitRelationalExpression(TypeScriptParser.RelationalExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code PostIncrementExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostIncrementExpression(TypeScriptParser.PostIncrementExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code YieldExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitYieldExpression(TypeScriptParser.YieldExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code BitNotExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBitNotExpression(TypeScriptParser.BitNotExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code NewExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNewExpression(TypeScriptParser.NewExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code LiteralExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLiteralExpression(TypeScriptParser.LiteralExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code ArrayLiteralExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayLiteralExpression(TypeScriptParser.ArrayLiteralExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code MemberDotExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMemberDotExpression(TypeScriptParser.MemberDotExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code MemberIndexExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMemberIndexExpression(TypeScriptParser.MemberIndexExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code IdentifierExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIdentifierExpression(TypeScriptParser.IdentifierExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code BitAndExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBitAndExpression(TypeScriptParser.BitAndExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code BitOrExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBitOrExpression(TypeScriptParser.BitOrExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code AssignmentOperatorExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignmentOperatorExpression(TypeScriptParser.AssignmentOperatorExpressionContext ctx); + /** + * Visit a parse tree produced by the {@code VoidExpression} + * labeled alternative in {@link TypeScriptParser#singleExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVoidExpression(TypeScriptParser.VoidExpressionContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#asExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAsExpression(TypeScriptParser.AsExpressionContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#arrowFunctionDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrowFunctionDeclaration(TypeScriptParser.ArrowFunctionDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#arrowFunctionParameters}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrowFunctionParameters(TypeScriptParser.ArrowFunctionParametersContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#arrowFunctionBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrowFunctionBody(TypeScriptParser.ArrowFunctionBodyContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#assignmentOperator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignmentOperator(TypeScriptParser.AssignmentOperatorContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#literal}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLiteral(TypeScriptParser.LiteralContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#templateStringLiteral}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTemplateStringLiteral(TypeScriptParser.TemplateStringLiteralContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#templateStringAtom}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTemplateStringAtom(TypeScriptParser.TemplateStringAtomContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#numericLiteral}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNumericLiteral(TypeScriptParser.NumericLiteralContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#identifierName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIdentifierName(TypeScriptParser.IdentifierNameContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#identifierOrKeyWord}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIdentifierOrKeyWord(TypeScriptParser.IdentifierOrKeyWordContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#reservedWord}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitReservedWord(TypeScriptParser.ReservedWordContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#keyword}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitKeyword(TypeScriptParser.KeywordContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#getter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGetter(TypeScriptParser.GetterContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#setter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSetter(TypeScriptParser.SetterContext ctx); + /** + * Visit a parse tree produced by {@link TypeScriptParser#eos}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEos(TypeScriptParser.EosContext ctx); +} \ No newline at end of file diff --git a/src/main/java/one/edee/babylon/git/RuntimeExecGitAdd.java b/src/main/java/one/edee/babylon/git/RuntimeExecGitAdd.java index cf8d7c6..5d0757c 100644 --- a/src/main/java/one/edee/babylon/git/RuntimeExecGitAdd.java +++ b/src/main/java/one/edee/babylon/git/RuntimeExecGitAdd.java @@ -33,7 +33,7 @@ private void doGitAddFile(String pathFileName) throws IOException, InterruptedEx log.info("Result:"); BufferedReader reader = new BufferedReader(new InputStreamReader(p.getErrorStream())); - String line = ""; + String line; while ((line = reader.readLine()) != null) { log.warn(line); } diff --git a/src/main/java/one/edee/babylon/imp0rt/ImportProcessor.java b/src/main/java/one/edee/babylon/imp0rt/ImportProcessor.java index 5454b3f..24aa8dc 100644 --- a/src/main/java/one/edee/babylon/imp0rt/ImportProcessor.java +++ b/src/main/java/one/edee/babylon/imp0rt/ImportProcessor.java @@ -19,10 +19,11 @@ import one.edee.babylon.statistics.TranslationStatisticsOfImport; import java.io.File; -import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStreamWriter; import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Paths; import java.security.GeneralSecurityException; import java.util.List; import java.util.Map; @@ -39,7 +40,7 @@ public class ImportProcessor { private final SnapshotManager snapshotManager; - private final PropertyFileLoader propertyFileLoader; + private final List propertyFileLoaders; private final LightGSheetService lightGSheetService; private final TranslationConfiguration configuration; @@ -49,10 +50,10 @@ public class ImportProcessor { public ImportProcessor(LightGSheetService lightGSheetService, SnapshotManager snapshotManager, - PropertyFileLoader propertyFileLoader, + List propertyFileLoaders, TranslationConfiguration configuration) { this.snapshotManager = snapshotManager; - this.propertyFileLoader = propertyFileLoader; + this.propertyFileLoaders = propertyFileLoaders; this.lightGSheetService = lightGSheetService; this.configuration = configuration; this.gitAdd = new RuntimeExecGitAdd(); @@ -74,7 +75,7 @@ public void doImport(String googleSheetId) throws IOException, GeneralSecurityEx importSheetProcessor.processSheet(sheet, snapshot); } - Map dataPropFiles = snapshotManager.getOrCreateDataFile().getDataPropFiles(); + Map dataPropFiles = snapshotManager.getOrCreateDataFile().getProps(); saveTranslations(statistics, configuration.getMutations(), dataPropFiles); saveDataFile(snapshot, configuration.getDataFileName()); @@ -88,7 +89,7 @@ public void doImport(String googleSheetId) throws IOException, GeneralSecurityEx * @throws IOException some exception derived from {@link IOException} */ private void saveDataFile(Snapshot snapshot, String dbFileName) throws IOException { - if (!snapshot.getDataPropFiles().isEmpty()) { + if (!snapshot.getProps().isEmpty()) { File toFile = new File(dbFileName); SnapshotUtils.writeSnapshot(snapshot, toFile); } else { @@ -111,7 +112,7 @@ private void saveTranslations(TranslationStatisticsOfImport statistics, List i.canBeLoaded(mutationPropFilePath)) + .findFirst() + .orElseThrow(() -> new IllegalArgumentException(mutationPropFilePath + " cannot be loaded by any file loader!")); + final ImportFileStatistic fileStatistic = fs; // Load target properties file to get formatting and row numbers of all its properties. - PropertyFileActiveRecord originalMutationFileProps = Optional.ofNullable(propertyFileLoader.loadPropertiesFromFile(mutationPropFilePath)).orElse(new PropertyFileActiveRecord()); + FileActiveRecord originalMutationFileProps = Optional.ofNullable(propertyFileLoader.loadPropertiesFromFile(mutationPropFilePath)).orElse(propertyFileLoader.createFileActiveRecord()); // Load also properties of primary mutation file to get format from it. - PropertyFileActiveRecord updatedFileProps = propertyFileLoader.loadPropertiesFromFile(primaryPropFilePath); + FileActiveRecord updatedFileProps = propertyFileLoader.loadPropertiesFromFile(primaryPropFilePath); // Clears all keys values in loaded primaryFileProps to create template for making of mutation properties file. // In this point we have clear format, this means each key and value on correct row, // empty rows and comments from primary mutation file is also on correct rows. @@ -145,7 +153,7 @@ private void saveMutationPropertiesToFile(String primaryPropFilePath, String mut property.setValue(SheetConstants.EMPTY_VAL); } }); - PropertyFileActiveRecord propsOnlyInMutation = new PropertyFileActiveRecord(); + FileActiveRecord propsOnlyInMutation = propertyFileLoader.createFileActiveRecord(); // Sets values of all keys from mutation properties file into updatedFileProps. Properties which exists only // in secondary mutation file is added to another map and append at end of mutation property file. originalMutationFileProps.forEach((key, sourceProp) -> { @@ -153,7 +161,7 @@ private void saveMutationPropertiesToFile(String primaryPropFilePath, String mut if (!sourceProp.isPropValue() && !sourceProp.isPropValueMultiLine()) { return; } - Property targetProp = updatedFileProps.get(key); + AbstractProperty targetProp = updatedFileProps.get(key); // Set values only for keys existing in primary mutation file. if (targetProp != null) { targetProp.setValue(sourceProp.getValue()); @@ -166,7 +174,7 @@ private void saveMutationPropertiesToFile(String primaryPropFilePath, String mut }); // Sets all values for keys from properties map (data from google sheet filled up by translation agency). mutationProperties.forEach((key, value) -> { - Property property = updatedFileProps.get(key); + AbstractProperty property = updatedFileProps.get(key); if (property != null && !Objects.equals(value, property.getValue())) { property.setValue(value); updatedFileProps.put(key, property); @@ -178,25 +186,26 @@ private void saveMutationPropertiesToFile(String primaryPropFilePath, String mut if (!propsOnlyInMutation.isEmpty()) { fileStatistic.setNotFoundInPrimaryFile(propsOnlyInMutation.size()); statistics.incTotalNotFoundInPrimaryFile(propsOnlyInMutation.size()); - propsOnlyInMutation.forEach(updatedFileProps::put); + updatedFileProps.putAll(propsOnlyInMutation); log.info("Property keys only in mutation file \"" + String.join(",", propsOnlyInMutation.keySet()) + "\""); } + // Removes all properties, that does not occur in sheet and was not in mutation properties file before - e.g. loaded from original props.. List propsToRemove = updatedFileProps .entrySet() .stream() - .filter(k -> k.getValue().getValue().equals(SheetConstants.EMPTY_VAL) && !mutationProperties.containsKey(k.getKey())) + .filter(k -> k.getValue().getValue().equals(SheetConstants.EMPTY_VAL) && !messageFileContent.containsKey(k.getKey())) .map(Map.Entry::getKey) .collect(Collectors.toList()); propsToRemove.forEach(updatedFileProps::remove); // Save changes into target file on disk. - savePropertiesToFile(updatedFileProps, mutationPropFilePath); + savePropertiesToFile(updatedFileProps, mutationPropFilePath, primaryPropFilePath, mutation); } - private void savePropertiesToFile(PropertyFileActiveRecord propertyFileActiveRecord, String pathFileName) { - try (OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(pathFileName), StandardCharsets.UTF_8)) { - propertyFileActiveRecord.save(outputStreamWriter); + private void savePropertiesToFile(FileActiveRecord propertyFileActiveRecord, String pathFileName, String primaryPropFilePath, String mutation) { + try (OutputStreamWriter outputStreamWriter = new OutputStreamWriter(Files.newOutputStream(Paths.get(pathFileName)), StandardCharsets.UTF_8)) { + propertyFileActiveRecord.save(outputStreamWriter, primaryPropFilePath, mutation); } catch (Exception e) { throw new RuntimeException("Could not close the file " + pathFileName, e); } diff --git a/src/main/java/one/edee/babylon/maven/BabylonExpImpBaseMojo.java b/src/main/java/one/edee/babylon/maven/BabylonExpImpBaseMojo.java index 936c2ef..09ef8db 100644 --- a/src/main/java/one/edee/babylon/maven/BabylonExpImpBaseMojo.java +++ b/src/main/java/one/edee/babylon/maven/BabylonExpImpBaseMojo.java @@ -13,6 +13,7 @@ public abstract class BabylonExpImpBaseMojo extends AbstractMojo { public static final String CONFIG_FILE_PARAM = "config.file"; public static final String GOOGLE_SHEET_ID_PARAM = "google.sheet.id"; + public static final String COMBINE_SHEET_PARAM = "combine.sheets"; /** * File name and relative path to the Json configuration file. @@ -26,16 +27,24 @@ public abstract class BabylonExpImpBaseMojo extends AbstractMojo { @Parameter(property = GOOGLE_SHEET_ID_PARAM, required = true) private String googleSheetId; + /** + * Combine sheets param. + */ + @Parameter(property = COMBINE_SHEET_PARAM) + private Boolean combineSheets; + @Override public void execute() { SpringBootConsoleApplication.main(getArguments()); } private String[] getArguments() { - String[] arg = new String[3]; + String[] arg = new String[5]; arg[0] = getAction().name(); arg[1] = this.configFileName; arg[2] = this.googleSheetId; + arg[3] = String.valueOf(this.combineSheets); + return arg; } diff --git a/src/main/java/one/edee/babylon/msgfile/TranslationFileUtils.java b/src/main/java/one/edee/babylon/msgfile/TranslationFileUtils.java index 6e7cdf3..b8db3db 100644 --- a/src/main/java/one/edee/babylon/msgfile/TranslationFileUtils.java +++ b/src/main/java/one/edee/babylon/msgfile/TranslationFileUtils.java @@ -3,11 +3,15 @@ import org.apache.commons.io.FilenameUtils; import org.springframework.util.StringUtils; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + /** * Utility methods that deal with i18n files in some way. * Methods here should be moved else eventually and this class deleted. */ public class TranslationFileUtils { + private static final Pattern pattern = Pattern.compile("\\.([a-z]{2})\\."); /** * Get file name like primaryPropFilePath + ("_" + mutation if is not null or empty) + possible original extension of primaryPropFilePath. @@ -20,10 +24,26 @@ public static String getFileNameForTranslation(String primaryPropFilePath, Strin return primaryPropFilePath; } String fileExtension = FilenameUtils.getExtension(primaryPropFilePath); - if (!StringUtils.isEmpty(fileExtension)) { + + if (!StringUtils.isEmpty(fileExtension)){ fileExtension = "." + fileExtension; + if (fileExtension.equalsIgnoreCase(".ts")){ + + String mutationFileName = FilenameUtils.removeExtension(primaryPropFilePath); + // Define a callback function to perform the replacement + Matcher matcher = pattern.matcher(mutationFileName); + StringBuffer updatedString = new StringBuffer(); + while (matcher.find()) { + matcher.appendReplacement(updatedString, "." + mutation + "."); + } + matcher.appendTail(updatedString); + updatedString.append(fileExtension); + + return updatedString.toString(); + } } String fileMutation = "_" + mutation; + String mutationFileName = FilenameUtils.removeExtension(primaryPropFilePath); mutationFileName += fileMutation + fileExtension; return mutationFileName; diff --git a/src/main/java/one/edee/babylon/properties/AbstractProperty.java b/src/main/java/one/edee/babylon/properties/AbstractProperty.java new file mode 100644 index 0000000..c0b370d --- /dev/null +++ b/src/main/java/one/edee/babylon/properties/AbstractProperty.java @@ -0,0 +1,52 @@ +package one.edee.babylon.properties; + +import lombok.Data; +import one.edee.babylon.enums.PropertyType; + +/** + * Common class for property values of all types by {@link PropertyType} + * + * @author Tomas Langer (langer@fg.cz), FG Forrest a.s. (c) 2019 + */ +@Data +public abstract class AbstractProperty { + + private PropertyType type; + + protected AbstractProperty(PropertyType type) { + this.type = type; + } + + public abstract String getValue(); + + public String getQuotedValue(){ + return getValue(); + } + + public abstract void setValue(String value); + + public boolean isPropValue() { + return type == PropertyType.VALUE; + } + + public boolean isPropValueMultiLine() { + return type == PropertyType.MULTILINE; + } + + public boolean isPropEmptyLine() { + return type == PropertyType.EMPTY; + } + + public boolean isPropComment() { + return type == PropertyType.COMMENT; + } + + @Override + public String toString() { + return "Property{" + + "type=" + getType() + + ", value='" + getValue() + '\'' + + '}'; + } + +} diff --git a/src/main/java/one/edee/babylon/properties/FileActiveRecord.java b/src/main/java/one/edee/babylon/properties/FileActiveRecord.java new file mode 100644 index 0000000..09dc23d --- /dev/null +++ b/src/main/java/one/edee/babylon/properties/FileActiveRecord.java @@ -0,0 +1,33 @@ +package one.edee.babylon.properties; + +import java.io.IOException; +import java.io.Reader; +import java.io.Writer; +import java.util.LinkedHashMap; + +/** + * My own implementation for reading/writing of properties files. Implementation take care about precise format of file. + * Keeps information about row number for each row which represents values: key and value, empty lines or comments + * + * @author Tomas Langer (langer@fg.cz), FG Forrest a.s. (c) 2019 + */ +public abstract class FileActiveRecord extends LinkedHashMap { + + /** + * Loads properties from file by specified reader. + * + * @param reader Some {@link Reader} implementation. + * @throws IOException some exception derived from {@link IOException} + */ + public abstract void load(Reader reader) throws IOException; + + /** + * Saves properties into file by specified writer. + * + * @param writer Some {@link Writer} implementation. + * @param mutation + * @throws IOException some exception derived from {@link IOException} + */ + public abstract void save(Writer writer, String primaryPropFilePath, String mutation) throws IOException; + +} diff --git a/src/main/java/one/edee/babylon/properties/FileLoader.java b/src/main/java/one/edee/babylon/properties/FileLoader.java new file mode 100644 index 0000000..b388252 --- /dev/null +++ b/src/main/java/one/edee/babylon/properties/FileLoader.java @@ -0,0 +1,58 @@ +package one.edee.babylon.properties; + +import lombok.extern.log4j.Log4j2; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Loads {@link FileLoader} from a file. + */ +@Log4j2 +public abstract class FileLoader { + + /** + * Loads properties from file. + * + * @param fileNamePath path to existing properties file + * @return Returns properties {@link FileActiveRecord} or null if file not exists. + */ + public FileActiveRecord loadPropertiesFromFile(String fileNamePath) { + if (!new File(fileNamePath).exists()) { + return createFileActiveRecord(); + } + log.info("Loading file: " + fileNamePath); + try (InputStream propertyFile = Files.newInputStream(Paths.get(fileNamePath))) { + return loadProperties(propertyFile); + } catch (Exception e) { + throw new IllegalArgumentException("Could not close file " + fileNamePath, e); + } + } + + /** + * Loads properties from input stream. + * + * @param propertyFile input stream with properties content + * @return Returns loaded file {@link FileActiveRecord} + * @throws IOException error when reading the stream + */ + public FileActiveRecord loadProperties(InputStream propertyFile) throws IOException { + FileActiveRecord propertyFileActiveRecord = createFileActiveRecord(); + try (InputStreamReader inputStreamReader = new InputStreamReader(propertyFile, StandardCharsets.UTF_8)) { + propertyFileActiveRecord.load(inputStreamReader); + } + return propertyFileActiveRecord; + } + + /** + * Indicates whether file could be loaded by implementation. + */ + public abstract boolean canBeLoaded(String filePath); + + public abstract FileActiveRecord createFileActiveRecord(); +} diff --git a/src/main/java/one/edee/babylon/properties/Property.java b/src/main/java/one/edee/babylon/properties/Property.java index c0ae2f9..ca878b7 100644 --- a/src/main/java/one/edee/babylon/properties/Property.java +++ b/src/main/java/one/edee/babylon/properties/Property.java @@ -10,19 +10,18 @@ * Common class for property values of all types by {@link PropertyType} * @author Tomas Langer (langer@fg.cz), FG Forrest a.s. (c) 2019 */ -public class Property { +public class Property extends AbstractProperty { static final String MULTILINE_SEPARATOR = "\\"; - private PropertyType type; private String value; /* Only for PropertyType#MULTILINE */ private final List lines = new LinkedList<>(); public Property(PropertyType type, String value) { - this.value = value; - this.type = type; + super(type); + this.value = clearValue(value); } void addLine(String line) { @@ -33,10 +32,6 @@ public Integer getRowCount() { return lines.size(); } - public PropertyType getType() { - return type; - } - public String getValue() { if (isPropValueMultiLine()) { return getMultilineValue(); @@ -48,6 +43,7 @@ public String getValue() { } public void setValue(String value) { + value = clearValue(value); if (isPropValueMultiLine()) { setMultilineValue(value); return; @@ -55,22 +51,6 @@ public void setValue(String value) { this.value = value; } - public boolean isPropValue() { - return type == PropertyType.VALUE; - } - - public boolean isPropValueMultiLine() { - return type == PropertyType.MULTILINE; - } - - public boolean isPropEmptyLine() { - return type == PropertyType.EMPTY; - } - - public boolean isPropComment() { - return type == PropertyType.COMMENT; - } - private void setMultilineValue(String value) { if (StringUtils.isEmpty(value)) { lines.clear(); @@ -99,11 +79,7 @@ private String getMultilineValue() { return sb.toString(); } - @Override - public String toString() { - return "Property{" + - "type=" + type + - ", value='" + value + '\'' + - '}'; + public static String clearValue(String value){ + return value.replace("\n","\\n"); } } diff --git a/src/main/java/one/edee/babylon/properties/PropertyFileActiveRecord.java b/src/main/java/one/edee/babylon/properties/PropertyFileActiveRecord.java index 11e5591..37b7876 100644 --- a/src/main/java/one/edee/babylon/properties/PropertyFileActiveRecord.java +++ b/src/main/java/one/edee/babylon/properties/PropertyFileActiveRecord.java @@ -1,14 +1,13 @@ package one.edee.babylon.properties; -import one.edee.babylon.enums.PropertyType; import com.google.common.io.LineReader; +import one.edee.babylon.enums.PropertyType; import java.io.BufferedWriter; import java.io.IOException; import java.io.Reader; import java.io.Writer; import java.util.Iterator; -import java.util.LinkedHashMap; import java.util.Map; /** @@ -16,23 +15,27 @@ * Keeps information about row number for each row which represents values: key and value, empty lines or comments * @author Tomas Langer (langer@fg.cz), FG Forrest a.s. (c) 2019 */ -public class PropertyFileActiveRecord extends LinkedHashMap { +public class PropertyFileActiveRecord extends FileActiveRecord { /** * Loads properties from file by specified reader. * @param reader Some {@link Reader} implementation. * @throws IOException some exception derived from {@link IOException} */ + @Override public void load(Reader reader) throws IOException { loadByLineReader(new LineReader(reader)); } /** * Saves properties into file by specified writer. - * @param writer Some {@link Writer} implementation. + * + * @param writer Some {@link Writer} implementation. + * @param mutation * @throws IOException some exception derived from {@link IOException} - */ - public void save(Writer writer) throws IOException { + */ + @Override + public void save(Writer writer, String baseFileName, String mutation) throws IOException { saveByBufferedWriter((writer instanceof BufferedWriter) ? (BufferedWriter)writer : new BufferedWriter(writer)); } @@ -58,10 +61,10 @@ private void loadByLineReader(LineReader lr) throws IOException { private void saveByBufferedWriter(BufferedWriter bw) throws IOException { synchronized (this) { - for (Iterator> iterator = entrySet().iterator(); iterator.hasNext(); ) { - Map.Entry e = iterator.next(); + for (Iterator> iterator = entrySet().iterator(); iterator.hasNext(); ) { + Map.Entry e = iterator.next(); String key = e.getKey(); - Property value = e.getValue(); + AbstractProperty value = e.getValue(); if (value.isPropValue() || value.isPropValueMultiLine()) { bw.write(key + "=" + e.getValue().getValue()); // Break line on all rows except last one. @@ -85,13 +88,14 @@ private void saveByBufferedWriter(BufferedWriter bw) throws IOException { } /** - * Parsing one property into correct map entry with correct subclass of {@link Property} class for one line in properties file. + * Parsing one property into correct map entry with correct subclass of {@link AbstractProperty} class for one line in properties file. * @param line current line from file, from given row number * @param row actual row, in case of PropValueMultiLine can be increment by its row count * @param lr line reader is used for reading multi-line properties values escaped by '\' * @return map entry with key and value. */ private Map.Entry parseProperty(String line, int row, LineReader lr) throws IOException { + line = line.trim(); if (line.contains("=")) { // key=value @@ -110,7 +114,7 @@ private Map.Entry parseProperty(String line, int row, LineRead } /** - * Creates property entry with key and value. Can produce map of {@link Property} instances with type {@link PropertyType#VALUE} + * Creates property entry with key and value. Can produce map of {@link AbstractProperty} instances with type {@link PropertyType#VALUE} * or {@link PropertyType#MULTILINE}. * @param keyAndVal {@link String} array where 0th element is key and 1th element is value. * @param lr line reader is used for reading multi-line properties values escaped by '\' diff --git a/src/main/java/one/edee/babylon/properties/PropertyFileLoader.java b/src/main/java/one/edee/babylon/properties/PropertyFileLoader.java index 95e5ac2..605a5c2 100644 --- a/src/main/java/one/edee/babylon/properties/PropertyFileLoader.java +++ b/src/main/java/one/edee/babylon/properties/PropertyFileLoader.java @@ -1,44 +1,19 @@ package one.edee.babylon.properties; -import java.io.*; -import java.nio.charset.StandardCharsets; +import one.edee.babylon.export.ApronMessageLoader; /** * Loads {@link PropertyFileLoader} from a file. */ -public class PropertyFileLoader { +public class PropertyFileLoader extends FileLoader { - /** - * Loads properties from file. - * - * @param fileNamePath path to existing properties file - * @return Returns properties {@link PropertyFileActiveRecord} or null if file not exists. - * @throws IOException error when reading the file - */ - public PropertyFileActiveRecord loadPropertiesFromFile(String fileNamePath) { - if (!new File(fileNamePath).exists()) { - return null; - } - try (InputStream propertyFile = new FileInputStream(fileNamePath)) { - return loadProperties(propertyFile); - } catch (Exception e) { - throw new RuntimeException("Could not close file " + fileNamePath, e); - } + @Override + public boolean canBeLoaded(String filePath) { + return filePath.endsWith(ApronMessageLoader.PROPERTIES_FILE_EXTENSION); } - /** - * Loads properties from input stream. - * - * @param propertyFile input stream with properties content - * @return Returns loaded file {@link PropertyFileActiveRecord} - * @throws IOException error when reading the stream - */ - public PropertyFileActiveRecord loadProperties(InputStream propertyFile) throws IOException { - PropertyFileActiveRecord propertyFileActiveRecord = new PropertyFileActiveRecord(); - try (InputStreamReader inputStreamReader = new InputStreamReader(propertyFile, StandardCharsets.UTF_8)) { - propertyFileActiveRecord.load(inputStreamReader); - } - return propertyFileActiveRecord; + @Override + public FileActiveRecord createFileActiveRecord() { + return new PropertyFileActiveRecord(); } - } diff --git a/src/main/java/one/edee/babylon/properties/TsAttribute.java b/src/main/java/one/edee/babylon/properties/TsAttribute.java new file mode 100644 index 0000000..7be8f8a --- /dev/null +++ b/src/main/java/one/edee/babylon/properties/TsAttribute.java @@ -0,0 +1,43 @@ +package one.edee.babylon.properties; + +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; +import one.edee.babylon.enums.PropertyType; + +/** + * TypeScript class for property values of all types by {@link PropertyType} + * + * @author Tomas Langer (langer@fg.cz), FG Forrest a.s. (c) 2019 + */ +@Getter +@EqualsAndHashCode(callSuper = false) +public class TsAttribute extends AbstractProperty { + public static final String MULTI_LINE_DELIMITER = "`"; + public static final String SINGLE_LINE_DELIMITER = "'"; + + @Setter + private String value; + + public TsAttribute(PropertyType type, String value) { + super(type); + this.value = value; + } + + @Override + public String getQuotedValue() { + String delimiter = isPropValueMultiLine() ? MULTI_LINE_DELIMITER : SINGLE_LINE_DELIMITER; + + if (isPropEmptyLine()) { + return ""; + } + return delimiter + value + delimiter; + } + + @Override + public boolean isPropValueMultiLine() { + return getType() == PropertyType.MULTILINE + || getValue().contains("\n") + || getValue().contains("\r"); + } +} diff --git a/src/main/java/one/edee/babylon/properties/TsFileActiveRecord.java b/src/main/java/one/edee/babylon/properties/TsFileActiveRecord.java new file mode 100644 index 0000000..ea3b612 --- /dev/null +++ b/src/main/java/one/edee/babylon/properties/TsFileActiveRecord.java @@ -0,0 +1,109 @@ +package one.edee.babylon.properties; + +import one.edee.babylon.enums.PropertyType; +import one.edee.babylon.export.TsMessageLoader; +import one.edee.babylon.export.ts.TypeScriptBabylonParserListener; +import one.edee.babylon.util.FileUtils; +import org.apache.commons.io.FilenameUtils; +import org.springframework.util.Assert; + +import java.io.BufferedWriter; +import java.io.IOException; +import java.io.Reader; +import java.io.Writer; +import java.util.List; +import java.util.Map; + +/** + * My own implementation for reading/writing of properties files. Implementation take care about precise format of file. + * Keeps information about row number for each row which represents values: key and value, empty lines or comments + * @author Tomas Langer (langer@fg.cz), FG Forrest a.s. (c) 2019 + */ +public class TsFileActiveRecord extends FileActiveRecord { + + private static final String DEFAULT_LANG_DEF_IMPORT = "import type { LangDef } from '@edeeone/juan-core/i18n/LangDef';"; + + /** + * Loads properties from file by specified reader. + * @param reader Some {@link Reader} implementation. + * @throws IOException some exception derived from {@link IOException} + */ + @Override + public void load(Reader reader) throws IOException { + Map result = TsMessageLoader.dumpTsFile(reader); + + for (Map.Entry entry : result.entrySet()) { + String input = entry.getValue(); + AbstractProperty property = new TsAttribute( + input.contains("\n") || input.contains("\r") + ? PropertyType.MULTILINE + : PropertyType.VALUE, input); + put(entry.getKey(), property); + } + } + + /** + * Saves properties into file by specified writer. + * + * @param writer Some {@link Writer} implementation. + * @param mutation + * @throws IOException some exception derived from {@link IOException} + */ + @Override + public void save(Writer writer, String primaryPropFilePath, String mutation) throws IOException { + + + TypeScriptBabylonParserListener loadedFile = TsMessageLoader.loadFile(primaryPropFilePath); + Assert.notNull(loadedFile,"Cannot load primary file on path:" + primaryPropFilePath); + List imports = loadedFile.getImports(); + + imports.add(DEFAULT_LANG_DEF_IMPORT); + + String baseName = FilenameUtils.getBaseName(primaryPropFilePath); + baseName = baseName.contains(".") ? baseName.substring(0, baseName.indexOf(".")) : baseName; + Assert.isTrue(loadedFile.getPropertyListDefName().size() <= 1, "There has to be only one property list declaration name in file:" + primaryPropFilePath); + String propertyListDefName = loadedFile.getPropertyListDefName().stream().findFirst().orElse(baseName); + imports.add("import type " + propertyListDefName + " from './" + FilenameUtils.removeExtension(FileUtils.fileFromPathOrCreate(primaryPropFilePath).getName()) + "';"); + + + BufferedWriter bufferedWriter = (writer instanceof BufferedWriter) ? (BufferedWriter) writer : new BufferedWriter(writer); + + + for (String tsImport : imports) { + bufferedWriter.write(tsImport); + bufferedWriter.newLine(); + } + + bufferedWriter.newLine(); + String finalLocalizationName = propertyListDefName + firstLetterToUppercase(mutation); + bufferedWriter.write("const " + finalLocalizationName + ": LangDef = {"); + bufferedWriter.newLine(); + + synchronized (this) { + for (Map.Entry entry : entrySet()) { + String key = entry.getKey(); + AbstractProperty value = entry.getValue(); + String keyDelimiter = key.matches("\\[.*]") ? "" : "'"; + + bufferedWriter.write(" " + keyDelimiter + key + keyDelimiter +": "+ value.getQuotedValue() + ","); + bufferedWriter.newLine(); + } + } + + bufferedWriter.write("};"); + bufferedWriter.newLine(); + bufferedWriter.write("export default "+finalLocalizationName+";"); + + bufferedWriter.flush(); + } + + public static String firstLetterToUppercase(String input) { + if (input == null || input.isEmpty()) { + return input; // Handle edge cases + } + char firstChar = Character.toUpperCase(input.charAt(0)); + String restOfString = input.substring(1); + return firstChar + restOfString; + } + +} diff --git a/src/main/java/one/edee/babylon/properties/TsFileLoader.java b/src/main/java/one/edee/babylon/properties/TsFileLoader.java new file mode 100644 index 0000000..47e6161 --- /dev/null +++ b/src/main/java/one/edee/babylon/properties/TsFileLoader.java @@ -0,0 +1,18 @@ +package one.edee.babylon.properties; + +import one.edee.babylon.export.TsMessageLoader; + +/** + * Loads {@link TsFileLoader} from a file. + */ +public class TsFileLoader extends FileLoader { + + @Override + public boolean canBeLoaded(String filePath) { + return filePath.endsWith(TsMessageLoader.TS_FILE_EXTENSION); + } + @Override + public FileActiveRecord createFileActiveRecord() { + return new TsFileActiveRecord(); + } +} diff --git a/src/main/java/one/edee/babylon/sheets/gsheets/GSheetApiRequestFactory.java b/src/main/java/one/edee/babylon/sheets/gsheets/GSheetApiRequestFactory.java index adb5ddb..b1d7f5b 100644 --- a/src/main/java/one/edee/babylon/sheets/gsheets/GSheetApiRequestFactory.java +++ b/src/main/java/one/edee/babylon/sheets/gsheets/GSheetApiRequestFactory.java @@ -2,7 +2,11 @@ import com.google.api.services.sheets.v4.model.*; +import java.util.LinkedList; import java.util.List; +import java.util.Map; + +import static java.util.Collections.singletonList; /** * Helps create requests for the Google Sheets API client library. @@ -152,4 +156,51 @@ private DeleteSheetRequest deleteSheetRequest(Integer sheetId) { .setSheetId(sheetId); } + public List changeCellColor(Integer sheetId, String sheetTitle, Map> changed) { + List changes = changed.get(sheetTitle); + List reqs = new LinkedList<>(); + if (changes != null && !changes.isEmpty()) { + for (String change : changes) { + String[] s = change.split("_"); + int row = Integer.parseInt(s[0]); + int column = Integer.parseInt(s[1]); + + reqs.add( + new Request() + .setUpdateCells( + new UpdateCellsRequest() + .setRange( + new GridRange() + .setSheetId(sheetId) + .setStartColumnIndex(column) + .setEndColumnIndex(column + 1) + .setStartRowIndex(row) + .setEndRowIndex(row + 1) + ) + .setRows( + singletonList( + new RowData() + .setValues( + singletonList( + new CellData() + .setUserEnteredFormat( + new CellFormat() + .setBackgroundColor( + new Color() + .setRed(1f) + .setGreen(0.8f) + .setBlue(0.61f) + ) + ) + ) + ) + ) + ) + .setFields("userEnteredFormat.backgroundColor") + ) + ); + } + } + return reqs; + } } diff --git a/src/main/java/one/edee/babylon/sheets/gsheets/LightGSheetService.java b/src/main/java/one/edee/babylon/sheets/gsheets/LightGSheetService.java index abbef29..c0b6bf8 100644 --- a/src/main/java/one/edee/babylon/sheets/gsheets/LightGSheetService.java +++ b/src/main/java/one/edee/babylon/sheets/gsheets/LightGSheetService.java @@ -8,10 +8,7 @@ import java.io.IOException; import java.security.GeneralSecurityException; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.List; +import java.util.*; import java.util.stream.Collectors; /** @@ -136,19 +133,25 @@ private List> convertNullsToEmptyString(List lockedCellEditors) throws GeneralSecurityException, IOException { - Request setWrappingStrategy = gSheetsRequestFactory.setWrapWrappingStrategyForAllCells(sheetId); - Request resizeColumns = gSheetsRequestFactory.resizeAllColumns(sheetId, COLUMN_WIDTH); - Request protectColumns = gSheetsRequestFactory.protectCellsInFirstTwoColumns(sheetId, lockedCellEditors); - Request hideColumn = gSheetsRequestFactory.hideFirstColumn(sheetId); + public void updateSheetStyle(String spreadsheetId, String sheetTitle, Integer sheetId, List lockedCellEditors, Map> changed) throws GeneralSecurityException, IOException { + List requests = new LinkedList<>(); + requests.add(gSheetsRequestFactory.setWrapWrappingStrategyForAllCells(sheetId)); + requests.add(gSheetsRequestFactory.resizeAllColumns(sheetId, COLUMN_WIDTH)); + if (!lockedCellEditors.isEmpty()) + requests.add(gSheetsRequestFactory.protectCellsInFirstTwoColumns(sheetId, lockedCellEditors)); + requests.add(gSheetsRequestFactory.hideFirstColumn(sheetId)); + requests.addAll(gSheetsRequestFactory.changeCellColor(sheetId, sheetTitle, changed)); + + executeRequests(spreadsheetId, requests.toArray(new Request[0])); - executeRequests(spreadsheetId, setWrappingStrategy, resizeColumns, protectColumns, hideColumn); } public void deleteSheets(String spreadsheetId, Collection sheetIds) throws GeneralSecurityException, IOException { diff --git a/src/main/java/one/edee/babylon/sheets/gsheets/LightGSheetServiceExporterContractAdaptor.java b/src/main/java/one/edee/babylon/sheets/gsheets/LightGSheetServiceExporterContractAdaptor.java index a1fb731..319660b 100644 --- a/src/main/java/one/edee/babylon/sheets/gsheets/LightGSheetServiceExporterContractAdaptor.java +++ b/src/main/java/one/edee/babylon/sheets/gsheets/LightGSheetServiceExporterContractAdaptor.java @@ -10,6 +10,7 @@ import java.security.GeneralSecurityException; import java.util.Collection; import java.util.List; +import java.util.Map; import java.util.stream.Collectors; /** @@ -45,7 +46,7 @@ public void deleteSheets(String spreadsheetId, Collection sheetIds) thr } @Override - public void createSheet(String spreadsheetId, String sheetTitle, List> sheetRows, List lockedCellEditors) throws SheetsException { + public void createSheet(String spreadsheetId, String sheetTitle, List> sheetRows, List lockedCellEditors, Map> changed) throws SheetsException { try { Sheet existingSheet = lightGSheetService.loadSheet(spreadsheetId, sheetTitle); if (existingSheet != null) { @@ -54,7 +55,7 @@ public void createSheet(String spreadsheetId, String sheetTitle, List { private static final int HTTP_TOO_MANY_REQUESTS = 429; + private static final int HTTP_BAD_REQUEST = 400; static final int MAX_BACKOFF_TIME_SEC = 64; static final int MAX_RETRIES = 50; @@ -62,6 +63,9 @@ public U executeRequest() throws GeneralSecurityException, IOException { backoffTime *= 2; backoffTime = Math.min(backoffTime, MAX_BACKOFF_TIME_SEC); retries++; + }else { + log.warn(gjre.getDetails()); + retries = MAX_RETRIES; } } } diff --git a/src/main/java/one/edee/babylon/sheets/gsheets/legacy/AuthorizedGSheetsClient.java b/src/main/java/one/edee/babylon/sheets/gsheets/legacy/AuthorizedGSheetsClient.java index 36b6984..571e66d 100644 --- a/src/main/java/one/edee/babylon/sheets/gsheets/legacy/AuthorizedGSheetsClient.java +++ b/src/main/java/one/edee/babylon/sheets/gsheets/legacy/AuthorizedGSheetsClient.java @@ -6,6 +6,7 @@ import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow; import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets; import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport; +import com.google.api.client.http.HttpRequestInitializer; import com.google.api.client.http.javanet.NetHttpTransport; import com.google.api.client.json.JsonFactory; import com.google.api.client.json.jackson2.JacksonFactory; @@ -16,9 +17,13 @@ import one.edee.babylon.sheets.gsheets.GSheetsClient; import org.springframework.lang.NonNull; -import java.io.*; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.file.Files; import java.security.GeneralSecurityException; -import java.util.*; +import java.util.List; import static java.util.Collections.singletonList; @@ -34,6 +39,7 @@ public class AuthorizedGSheetsClient implements GSheetsClient { private static final List SCOPES = singletonList(SheetsScopes.SPREADSHEETS); private static final String TOKENS_DIRECTORY_PATH = "tokens"; private static final String GOOGLE_CREDENTIALS_JSON = "credentials.json"; + private static final int TIMEOUT_MS = 60000; /** Use only by cached and null safe access by {@link #getCredentials(NetHttpTransport)} method. */ private Credential credential; @@ -50,13 +56,25 @@ public class AuthorizedGSheetsClient implements GSheetsClient { public Sheets getSheetService() throws GeneralSecurityException, IOException { if (sheetService == null) { final NetHttpTransport HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport(); - sheetService = new Sheets.Builder(HTTP_TRANSPORT, JSON_FACTORY, getCredentials(HTTP_TRANSPORT)) + + sheetService = new Sheets.Builder(HTTP_TRANSPORT, JSON_FACTORY, createHttpRequestInitializer(getCredentials(HTTP_TRANSPORT))) .setApplicationName(APPLICATION_NAME) .build(); } return sheetService; } + /** + * Add custom timeouts. + */ + private HttpRequestInitializer createHttpRequestInitializer(final HttpRequestInitializer requestInitializer) { + return httpRequest -> { + requestInitializer.initialize(httpRequest); + httpRequest.setConnectTimeout(3 * 60000); // 3 minutes connect timeout + httpRequest.setReadTimeout(3 * 60000); // 3 minutes read timeout + }; + } + /** * Gets cached credentials object to access Google sheet or creates new one if not exists. * @param httpTransport The network HTTP Transport. @@ -72,7 +90,7 @@ private Credential getCredentials(final NetHttpTransport httpTransport) throws I InputStreamReader credentialsReader = null; try { if (credentialsFile.exists()) { - credentialsStream = new FileInputStream(credentialsFile); + credentialsStream = Files.newInputStream(credentialsFile.toPath()); } else { // If not exists then fallback into default credentials.json for FG Forest company in resources. credentialsStream = getClass().getClassLoader().getResourceAsStream(GOOGLE_CREDENTIALS_JSON); diff --git a/src/main/java/one/edee/babylon/snapshot/Snapshot.java b/src/main/java/one/edee/babylon/snapshot/Snapshot.java index 2782982..59afa84 100644 --- a/src/main/java/one/edee/babylon/snapshot/Snapshot.java +++ b/src/main/java/one/edee/babylon/snapshot/Snapshot.java @@ -1,20 +1,26 @@ package one.edee.babylon.snapshot; import com.fasterxml.jackson.annotation.JsonIgnore; -import one.edee.babylon.entity.MessageFileContent; +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.AccessLevel; +import lombok.Getter; +import lombok.Setter; import one.edee.babylon.config.TranslationConfiguration; -import lombok.Data; +import one.edee.babylon.entity.MessageFileContent; +import java.io.File; import java.io.Serializable; import java.util.*; +import java.util.stream.Collectors; /** * Class representing translation data file (snapshot) in json file. This data file keeps information about processing * of language properties files by given {@link TranslationConfiguration}. * @author Tomas Langer (langer@fg.cz), FG Forrest a.s. (c) 2019 */ -@Data public class Snapshot implements Serializable { + public static final String LINUX_DELIMITER = "/"; + public static final String ORIGINAL_DELIMITER = "\\"; private static final long serialVersionUID = 4891061639828627492L; @@ -23,7 +29,10 @@ public class Snapshot implements Serializable { * key - relative path to message file of the primary language
, eg lib_eshop_edee\\src\\main\\resources\\META-INF\\lib_eshop_edee\\i18n\\common.properties * value - contains {@link MessageFileContent} */ - Map dataPropFiles = new LinkedHashMap<>(); + @Getter(AccessLevel.PRIVATE) + @Setter(AccessLevel.PRIVATE) + @JsonProperty("dataPropFiles") + private Map dataPropFiles = new LinkedHashMap<>(); /** * Properties files data like {@link Map<String, DataPropFile>} by unique id
@@ -31,10 +40,10 @@ public class Snapshot implements Serializable { * value - contains {@link MessageFileContent} */ @JsonIgnore - Map dataPropFilesById = new LinkedHashMap<>(); + private Map dataPropFilesById = new LinkedHashMap<>(); public MessageFileContent putPropFile(String fileName, MessageFileContent messageFileContent) { - MessageFileContent propFile = dataPropFiles.put(fileName, messageFileContent); + MessageFileContent propFile = dataPropFiles.put(clearPath(fileName), messageFileContent); // Create unique id of filename and store same dataPropFile instance under this hash code as key into map. // Id is also stored into DataPropFile#id field. Integer fileNameId = getNextUniqueId(); @@ -53,6 +62,7 @@ public MessageFileContent putDataPropFileById(Integer fileNameId, MessageFileCon * @return existing {@link MessageFileContent} for specified fileName or create, add and return new {@link MessageFileContent} object for fileName. */ public MessageFileContent getOrPutNewPropFileByFileName(String fileName) { + fileName = clearPath(fileName); MessageFileContent messageFileContent = dataPropFiles.get(fileName); if (messageFileContent == null) { messageFileContent = new MessageFileContent(); @@ -62,7 +72,7 @@ public MessageFileContent getOrPutNewPropFileByFileName(String fileName) { } public MessageFileContent getPropFileByFileName(String fileName) { - return dataPropFiles.get(fileName); + return dataPropFiles.get(clearPath(fileName)); } /** @@ -74,6 +84,20 @@ public MessageFileContent getPropFileById(Integer id) { return dataPropFilesById.get(id); } + public void removePaths(Collection msgFilePaths) { + msgFilePaths.forEach(path -> dataPropFiles.remove(clearPath(path))); + } + + @JsonIgnore + public Collection getPaths() { + return dataPropFiles.keySet().stream().map(Snapshot::normalizePath).collect(Collectors.toList()); + } + + @JsonIgnore + public Map getProps() { + return dataPropFiles.entrySet().stream().collect(Collectors.toMap(i -> normalizePath(i.getKey()), Map.Entry::getValue)); + } + /** * Gets next unique ID for identification of one properties bundle in translation. * @return Get unique ID @@ -87,4 +111,17 @@ private Integer getNextUniqueId() { return maxId.get() + 1; } + private static String clearPath(String fileName) { + if (File.separator.equals(LINUX_DELIMITER)) + fileName = fileName.replace(LINUX_DELIMITER, ORIGINAL_DELIMITER); + + return fileName; + } + + private static String normalizePath(String fileName) { + if (File.separator.equals(LINUX_DELIMITER)) + fileName = fileName.replace(ORIGINAL_DELIMITER, LINUX_DELIMITER); + + return fileName; + } } diff --git a/src/main/java/one/edee/babylon/snapshot/SnapshotAdapter.java b/src/main/java/one/edee/babylon/snapshot/SnapshotAdapter.java index 72e31bd..ea5bac0 100644 --- a/src/main/java/one/edee/babylon/snapshot/SnapshotAdapter.java +++ b/src/main/java/one/edee/babylon/snapshot/SnapshotAdapter.java @@ -2,6 +2,8 @@ import one.edee.babylon.entity.MessageFileContent; import one.edee.babylon.entity.PropertiesMap; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import java.util.Collection; import java.util.NoSuchElementException; @@ -29,7 +31,7 @@ public boolean includesMsgFile(String msgFile) { @Override public Collection listMsgFiles() { - return snapshot.dataPropFiles.keySet(); + return snapshot.getPaths(); } @Override @@ -40,37 +42,40 @@ public Integer registerMsgFile(String msgFilePath) { @Override public void removeMsgFilePaths(Collection msgFilePaths) { - snapshot.dataPropFiles.keySet().removeAll(msgFilePaths); + snapshot.removePaths(msgFilePaths); } @Override public boolean containsMessage(String msgKey, String msgFile) { if (!includesMsgFile(msgFile)) return false; - return containsMessageInProps(msgKey, getTranslationProperties(msgFile)); + + if (!includesMsgFile(msgFile)) { + // caller should have asked before + throw new NoSuchElementException("Translation snapshot doesn't contain message file '$msgFile'."); + } + MessageFileContent propFileByFileName = snapshot.getPropFileByFileName(msgFile); + return containsMessageInProps(msgKey, propFileByFileName); } - private boolean containsMessageInProps(String msgKey, PropertiesMap msgProps) { + private boolean containsMessageInProps(String msgKey, MessageFileContent propFileByFileName) { // PropertiesMap replaces null values with empty strings internally - return msgProps.containsKey(msgKey) && msgProps.get(msgKey) != null && !msgProps.get(msgKey).isEmpty(); + return propFileByFileName.containsKey(msgKey) && propFileByFileName.getPropertyValue(msgKey) != null && !propFileByFileName.getPropertyValue(msgKey).isEmpty(); } - private PropertiesMap getTranslationProperties(String msgFile) { + @Override + public boolean hasSameMessage(@NotNull String msgKey, @NotNull String msgFile, @Nullable String currentMsg) { + if (!includesMsgFile(msgFile)) { // caller should have asked before throw new NoSuchElementException("Translation snapshot doesn't contain message file '$msgFile'."); } - return snapshot.getPropFileByFileName(msgFile).getProperties(); - } - - @Override - public String getLastMessageValue(String msgKey, String msgFile) { - PropertiesMap msgProps = getTranslationProperties(msgFile); - if (!containsMessageInProps(msgKey, msgProps)) { + MessageFileContent propFileByFileName = snapshot.getPropFileByFileName(msgFile); + if (!containsMessageInProps(msgKey, propFileByFileName)) { // caller should have asked before String errMsg = "No message for key '" + msgKey + "' in '" + msgFile +"' message file snapshot."; throw new NoSuchElementException(errMsg); } - return msgProps.get(msgKey); + return propFileByFileName.hasSameValue(msgKey, currentMsg); } } diff --git a/src/main/java/one/edee/babylon/snapshot/TranslationSnapshotReadContract.java b/src/main/java/one/edee/babylon/snapshot/TranslationSnapshotReadContract.java index 43f1bc6..0d0feb1 100644 --- a/src/main/java/one/edee/babylon/snapshot/TranslationSnapshotReadContract.java +++ b/src/main/java/one/edee/babylon/snapshot/TranslationSnapshotReadContract.java @@ -1,5 +1,8 @@ package one.edee.babylon.snapshot; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + import java.util.Collection; import java.util.NoSuchElementException; @@ -32,14 +35,5 @@ public interface TranslationSnapshotReadContract { */ boolean containsMessage(String msgKey, String msgFile); - /** - * Return the message value of the message key {@code msgKey} as captured in the snapshot. - * - * @param msgKey key of the message to retrieve from message file {@msgFile} - * @param msgFile message file path that will be examined for given {@msgKey} - * @throws NoSuchElementException if snapshot of file {@code msgFile} does not contain message with key {@code msgKey} - * of if the snapshot doesn't include {@code msgFile} at all - */ - String getLastMessageValue(String msgKey, String msgFile); - + boolean hasSameMessage(@NotNull String msgKey, @NotNull String msgFile, @Nullable String currentMsg); } diff --git a/src/main/java/one/edee/babylon/spring/CommonConfiguration.java b/src/main/java/one/edee/babylon/spring/CommonConfiguration.java index 6c613e2..065e6c7 100644 --- a/src/main/java/one/edee/babylon/spring/CommonConfiguration.java +++ b/src/main/java/one/edee/babylon/spring/CommonConfiguration.java @@ -1,5 +1,6 @@ package one.edee.babylon.spring; +import one.edee.babylon.SpringBootConsoleApplication; import one.edee.babylon.config.TranslationConfiguration; import one.edee.babylon.config.TranslationConfigurationReader; import one.edee.babylon.db.SnapshotManager; @@ -9,11 +10,13 @@ import one.edee.babylon.sheets.gsheets.legacy.AuthorizedGSheetsClient; import one.edee.babylon.util.AntPathResourceLoader; import one.edee.babylon.util.spring.SpringResourceLoader; +import org.springframework.boot.ApplicationArguments; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.core.env.Environment; import java.io.IOException; +import java.util.Optional; import static one.edee.babylon.maven.BabylonExpImpBaseMojo.CONFIG_FILE_PARAM; @@ -46,8 +49,16 @@ public GSheetsClient gSheetsClient() { } @Bean - public TranslationConfiguration translationConfiguration(Environment environment) throws IOException { - String configFileName = environment.getProperty(CONFIG_FILE_PARAM); + public TranslationConfiguration translationConfiguration(Environment environment, Optional applicationArguments) throws IOException { + String configFileName; + if (applicationArguments.isPresent()){ + String[] array = applicationArguments.get().getNonOptionArgs().toArray(new String[0]); + SpringBootConsoleApplication.Arguments arguments = SpringBootConsoleApplication.parseArguments(array); + + configFileName = arguments.getConfigFileName(); + }else { + configFileName = environment.getProperty(CONFIG_FILE_PARAM); + } TranslationConfigurationReader configReader = new TranslationConfigurationReader(); return configReader.readAndCheckConfiguration(configFileName); } diff --git a/src/main/java/one/edee/babylon/spring/ExporterConfiguration.java b/src/main/java/one/edee/babylon/spring/ExporterConfiguration.java index a0ec158..b941338 100644 --- a/src/main/java/one/edee/babylon/spring/ExporterConfiguration.java +++ b/src/main/java/one/edee/babylon/spring/ExporterConfiguration.java @@ -8,34 +8,43 @@ import one.edee.babylon.snapshot.TranslationSnapshotReadContract; import one.edee.babylon.snapshot.TranslationSnapshotWriteContract; import one.edee.babylon.util.AntPathResourceLoader; +import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import java.io.IOException; +import java.util.List; @Configuration +@ComponentScan(basePackages = "one.edee.babylon.export.translator") public class ExporterConfiguration { @Bean - public Exporter exporter(TranslationCollector translationCollector, + public Exporter exporter(ApplicationContext applicationContext, + TranslationCollector translationCollector, TranslationSnapshotWriteContract snapshot, Exporter.SheetContract sheetContract, AntPathResourceLoader resourceLoader) { - return new Exporter(translationCollector, snapshot, sheetContract, resourceLoader); + return new Exporter(applicationContext, translationCollector, snapshot, sheetContract, resourceLoader); } @Bean - public TranslationCollector translationCollector(MessageLoader messageLoader, - MessageFileProcessor messageFileProcessor, - TranslationSnapshotReadContract snapshotReadContract, - TranslationSnapshotWriteContract snapshotWriteContract) { - return new TranslationCollector(messageLoader, messageFileProcessor, snapshotReadContract, snapshotWriteContract); + public TranslationCollector translationCollector(List messageLoaders, + MessageFileProcessor messageFileProcessor, + TranslationSnapshotReadContract snapshotReadContract, + TranslationSnapshotWriteContract snapshotWriteContract) { + return new TranslationCollector(messageLoaders, messageFileProcessor, snapshotReadContract, snapshotWriteContract); } @Bean - public MessageLoader messageLoader() { + public MessageLoader apronMessageLoader() { return new ApronMessageLoader(); } + @Bean + public MessageLoader tsMessageLoader() { + return new TsMessageLoader(); + } @Bean public MessageFileProcessor messageFileProcessor(TranslationSnapshotReadContract snapshotReadContract) { diff --git a/src/main/java/one/edee/babylon/spring/ImporterConfiguration.java b/src/main/java/one/edee/babylon/spring/ImporterConfiguration.java index 351dda7..9b6b582 100644 --- a/src/main/java/one/edee/babylon/spring/ImporterConfiguration.java +++ b/src/main/java/one/edee/babylon/spring/ImporterConfiguration.java @@ -3,25 +3,33 @@ import one.edee.babylon.db.SnapshotManager; import one.edee.babylon.config.TranslationConfiguration; import one.edee.babylon.imp0rt.ImportProcessor; +import one.edee.babylon.properties.FileLoader; import one.edee.babylon.properties.PropertyFileLoader; +import one.edee.babylon.properties.TsFileLoader; import one.edee.babylon.sheets.gsheets.LightGSheetService; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; +import java.util.List; + @Configuration public class ImporterConfiguration { @Bean public ImportProcessor importProcessor(LightGSheetService lightGSheetService, SnapshotManager snapshotManager, - PropertyFileLoader propertyFileLoader, + List propertyFileLoaders, TranslationConfiguration configuration) { - return new ImportProcessor(lightGSheetService, snapshotManager, propertyFileLoader, configuration); + return new ImportProcessor(lightGSheetService, snapshotManager, propertyFileLoaders, configuration); } @Bean - public PropertyFileLoader propertyFileLoader() { + public FileLoader propertyFileLoader() { return new PropertyFileLoader(); } + @Bean + public FileLoader tsFileLoader() { + return new TsFileLoader(); + } } diff --git a/src/main/kotlin/one/edee/babylon/export/MessageFileProcessor.kt b/src/main/kotlin/one/edee/babylon/export/MessageFileProcessor.kt index cfd4094..fdc5d79 100644 --- a/src/main/kotlin/one/edee/babylon/export/MessageFileProcessor.kt +++ b/src/main/kotlin/one/edee/babylon/export/MessageFileProcessor.kt @@ -86,7 +86,7 @@ class MessageFileProcessor(private val snapshotReadContract: TranslationSnapshot if (!snapshotReadContract.containsMessage(msgKey, msgFile)) false else - snapshotReadContract.getLastMessageValue(msgKey, msgFile) != currentMsg + !snapshotReadContract.hasSameMessage(msgKey, msgFile, currentMsg) }.keys } diff --git a/src/test/java/one/edee/babylon/export/TSParseTest.java b/src/test/java/one/edee/babylon/export/TSParseTest.java new file mode 100644 index 0000000..bf5bca5 --- /dev/null +++ b/src/test/java/one/edee/babylon/export/TSParseTest.java @@ -0,0 +1,94 @@ +package one.edee.babylon.export; + +import lombok.extern.log4j.Log4j2; +import one.edee.babylon.export.ts.TypeScriptBabylonParserListener; +import one.edee.babylon.export.ts.gen.TypeScriptLexer; +import one.edee.babylon.export.ts.gen.TypeScriptParser; +import one.edee.babylon.msgfile.TranslationFileUtils; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.CharStreams; +import org.antlr.v4.runtime.CommonTokenStream; +import org.antlr.v4.runtime.tree.ParseTree; +import org.antlr.v4.runtime.tree.ParseTreeWalker; +import org.junit.Assert; +import org.junit.Test; + +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +@Log4j2 +public class TSParseTest { + + + @Test + public void testParseByLex() throws IOException { + CharStream input = CharStreams.fromFileName("src/test/resources/META-INF/09_mail_form/messages.ts"); + TypeScriptLexer lexer = new TypeScriptLexer(input); + CommonTokenStream tokens = new CommonTokenStream(lexer); + TypeScriptParser parser = new TypeScriptParser(tokens); + ParseTree tree = parser.program(); + + + TypeScriptBabylonParserListener listener = new TypeScriptBabylonParserListener(); + ParseTreeWalker walker = new ParseTreeWalker(); + walker.walk(listener, tree); + + + System.out.println(listener.getImports()); + System.out.println("/////////////////////////////////////"); + System.out.println(listener.getPropertyDefinitions()); + + } + + @Test + public void testRename(){ + String filePath = "some.cs.i18n.ts"; + log.info(filePath); + String translation = TranslationFileUtils.getFileNameForTranslation(filePath, "en"); + log.info(translation); + Assert.assertEquals("some.en.i18n.ts", translation); + } + + + @Test + public void testParse() { + // Define the path to your TypeScript file + String filePath = "src/test/resources/one/edee/babylon/export/test.ts"; + + // Create a Map to store the internationalization key-value pairs + Map i18nMap = new HashMap<>(); + + try (BufferedReader br = new BufferedReader(new FileReader(filePath))) { + String line; +// Pattern pattern = Pattern.compile("'([^']+)'\\s*:\\s*'([^']+)'"); + Pattern pattern = Pattern.compile("'([^']+)':\\\\s*`(?:[^`]*`[^`]*`|[^`]+)`"); + + while ((line = br.readLine()) != null) { + Matcher matcher = pattern.matcher(line); + while (matcher.find()) { + String key = matcher.group(1); + String value = matcher.group(2); + i18nMap.put(key, value); + } + } + } catch (IOException e) { + e.printStackTrace(); + } + + System.out.println(i18nMap); + +// // Now you can access the localized strings or CSS classes using the keys +// String alwaysAvailableClass = i18nMap.get("availability.color.ALWAYS_AVAILABLE"); +// String contactHoursText = i18nMap.get("contact_hours"); +// +// // Example usage +// System.out.println("CSS class for always available: " + alwaysAvailableClass); +// System.out.println("Contact hours text: " + contactHoursText); + } + +} diff --git a/src/test/java/one/edee/babylon/export/snapshot/ExporterSnapshotTest.java b/src/test/java/one/edee/babylon/export/snapshot/ExporterSnapshotTest.java index 4514ff3..c3e0058 100644 --- a/src/test/java/one/edee/babylon/export/snapshot/ExporterSnapshotTest.java +++ b/src/test/java/one/edee/babylon/export/snapshot/ExporterSnapshotTest.java @@ -16,6 +16,7 @@ import org.junit.*; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.ApplicationArguments; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @@ -29,9 +30,7 @@ import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; -import java.util.Arrays; -import java.util.List; -import java.util.Map; +import java.util.*; import static org.hamcrest.Matchers.*; import static org.junit.Assert.assertThat; @@ -90,22 +89,24 @@ public void deleteTempDir() { public void when_snapshot_does_not_exist_yet__then_new_snapshot_contains_empty_content_of_message_files__01() throws IOException { Path newSnapshot = Files.createTempFile(testDir, "empty-snapshot", ".json"); File msgFile = ResourceUtils.loadRelativeResourceAsFile("01-single.properties", testDir, this.getClass()); - List paths = Arrays.asList(msgFile.toString()); - List langs = Arrays.asList("sk", "en"); - exporter.walkPathsAndWriteSheets(paths, langs, "N/A", newSnapshot); + TranslationConfiguration configuration = new TranslationConfiguration(); + configuration.setMutations(Arrays.asList("sk", "en")); + configuration.setPath(Collections.singletonList(msgFile.toString())); + configuration.setDataFileName(newSnapshot.toAbsolutePath().toString()); + exporter.walkPathsAndWriteSheets(configuration, "N/A", false); assertThat("When a single message file was processed, then there should be one sheet created", fakeSheets.getSheets().size(), equalTo(1)); // manually load resulting snapshot file to examine it Snapshot resultingSnapshot = SnapshotUtils.readSnapshot(newSnapshot); - Map msgFiles = resultingSnapshot.getDataPropFiles(); + Map msgFiles = resultingSnapshot.getProps(); String msgFilePath = msgFile.getAbsolutePath(); assertThat("When single message file is exported and the snapshot is empty, then the snapshot must contain exactly one record", msgFiles, is(aMapWithSize(1))); assertThat("...then the snapshot must contain the message file", msgFiles, hasKey(msgFilePath)); assertThat("...then the message file must must be stored under id=0", msgFiles.get(msgFilePath).getId(), equalTo(0)); - assertThat("...then the content of the message file in snapshot must be empty (until it is imported back)", msgFiles.get(msgFilePath).getProperties(), is(anEmptyMap())); + assertThat("...then the content of the message file in snapshot must be empty (until it is imported back)", msgFiles.get(msgFilePath).getPropertiesSize(), equalTo(0)); } private Path getSnapshotAndReplacePlaceholder(String snapshotPath, String placeholder, String replaceWith) throws IOException { @@ -126,24 +127,28 @@ public void when_snapshot_exists_and_additional_messages_in_message_file__then_s Path existingSnapshotFile = getSnapshotAndReplacePlaceholder("02-nonempty-snapshot.json", "XXX", msgFile.getAbsolutePath()); SnapshotManagerTestUtils.setSnapshotFile(existingSnapshotFile, snapshotManager); - assumeThat("When a snapshot is loaded from existing snapshot file containing translations, then it is not empty", snapshotManager.getOrCreateDataFile().getDataPropFiles(), not(anEmptyMap())); + assumeThat("When a snapshot is loaded from existing snapshot file containing translations, then it is not empty", snapshotManager.getOrCreateDataFile().getProps(), not(anEmptyMap())); String existingMsgFilePath = msgFile.getAbsolutePath(); - assumeThat("...it already contains some messages", snapshotManager.getOrCreateDataFile().getDataPropFiles(), hasKey(existingMsgFilePath)); + assumeThat("...it already contains some messages", snapshotManager.getOrCreateDataFile().getProps(), hasKey(existingMsgFilePath)); - exporter.walkPathsAndWriteSheets(paths, langs, "N/A", snapshotOutput); + TranslationConfiguration configuration = new TranslationConfiguration(); + configuration.setMutations(langs); + configuration.setPath(paths); + configuration.setDataFileName(snapshotOutput.toAbsolutePath().toString()); + exporter.walkPathsAndWriteSheets(configuration, "N/A", false); assertThat("When existing snapshot contained the same message file as the message file processed, then there should be exactly one sheet created", fakeSheets.getSheets().size(), equalTo(1)); // manually load resulting snapshot file to examine it Snapshot resultingSnapshot = SnapshotUtils.readSnapshot(snapshotOutput); - Map msgFiles = resultingSnapshot.getDataPropFiles(); + Map msgFiles = resultingSnapshot.getProps(); String msgFilePath = msgFile.getAbsolutePath(); assertThat("When a message file is exported and snapshot already contains it, then the snapshot must contain exactly one record", msgFiles, is(aMapWithSize(1))); assertThat("...then the snapshot must contain the message file", msgFiles, hasKey(msgFilePath)); assertThat("...then the id of the stored message file must not change", msgFiles.get(msgFilePath).getId(), equalTo(0)); // this is the "exported" snapshot - assertThat("...then the content of the message remains empty)", msgFiles.get(msgFilePath).getProperties(), is(anEmptyMap())); + assertThat("...then the content of the message remains empty)", msgFiles.get(msgFilePath).getPropertiesSize(), equalTo(0)); } @Configuration @@ -158,7 +163,7 @@ public SnapshotManager snapshotManager(TranslationConfiguration configuration) t @Bean @Override - public TranslationConfiguration translationConfiguration(Environment environment) { + public TranslationConfiguration translationConfiguration(Environment environment, Optional applicationArguments) { // empty configuration is OK for tests, path to snapshot is explicitly return new TranslationConfiguration(); } diff --git a/src/test/java/one/edee/babylon/properties/PropertyFileActiveRecordTest.java b/src/test/java/one/edee/babylon/properties/PropertyFileActiveRecordTest.java index f8afc64..4926e63 100644 --- a/src/test/java/one/edee/babylon/properties/PropertyFileActiveRecordTest.java +++ b/src/test/java/one/edee/babylon/properties/PropertyFileActiveRecordTest.java @@ -1,12 +1,15 @@ package one.edee.babylon.properties; +import one.edee.babylon.export.TsMessageLoader; import one.edee.babylon.util.TestUtils; import lombok.extern.apachecommons.CommonsLog; import org.apache.commons.io.FileUtils; +import org.junit.Assert; import org.junit.Test; import java.io.*; import java.nio.charset.StandardCharsets; +import java.nio.file.Files; import java.util.Objects; import static org.junit.Assert.assertTrue; @@ -24,18 +27,52 @@ public class PropertyFileActiveRecordTest { public void checkLoadAndSavePropertiesFile() throws IOException { long stTime = System.currentTimeMillis(); PropertyFileActiveRecord propertyFileActiveRecord = new PropertyFileActiveRecord(); - File sourceFile = new File(Objects.requireNonNull(getClass().getClassLoader().getResource("META-INF/09_mail_form/messages.properties")).getFile()); - InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(sourceFile), StandardCharsets.UTF_8); + String primary = "META-INF/09_mail_form/messages.properties"; + File sourceFile = new File(Objects.requireNonNull(getClass().getClassLoader().getResource(primary)).getFile()); + InputStreamReader inputStreamReader = new InputStreamReader(Files.newInputStream(sourceFile.toPath()), StandardCharsets.UTF_8); propertyFileActiveRecord.load(inputStreamReader); propertyFileActiveRecord.entrySet().forEach(log::info); log.info("Load time: " + (System.currentTimeMillis() - stTime) + " ms"); stTime = System.currentTimeMillis(); String path = TestUtils.getTempDir() + "messages-out.properties"; File targetFile = new File(path); - OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(targetFile), StandardCharsets.UTF_8); - propertyFileActiveRecord.save(outputStreamWriter); + OutputStreamWriter outputStreamWriter = new OutputStreamWriter(Files.newOutputStream(targetFile.toPath()), StandardCharsets.UTF_8); + propertyFileActiveRecord.save(outputStreamWriter, primary, "en"); log.info("Save time: " + (System.currentTimeMillis() - stTime) + " ms"); assertTrue("Source and target file is different", FileUtils.contentEquals(sourceFile, targetFile)); } -} \ No newline at end of file + @Test + public void checkLoadAndSaveTsFile() throws IOException { + testTs("META-INF/09_mail_form/messages.ts", "messages-out.ts"); + } + + @Test + public void checkLoadAndSaveTsFileWithArgs() throws IOException { + testTs("META-INF/addresses/addresses.ts", "addresses-out.ts"); + } + @Test + public void checkLoadAndSaveTsFileWithDefault() throws IOException { + testTs("META-INF/goPayGate/Listing.cs.i18n.ts", "Listing-out.cs.i18n.ts"); + } + + + private void testTs(String primary, String output) throws IOException { + long stTime = System.currentTimeMillis(); + FileActiveRecord propertyFileActiveRecord = new TsFileActiveRecord(); + File sourceFile = new File(Objects.requireNonNull(getClass().getClassLoader().getResource(primary)).getFile()); + InputStreamReader inputStreamReader = new InputStreamReader(Files.newInputStream(sourceFile.toPath()), StandardCharsets.UTF_8); + propertyFileActiveRecord.load(inputStreamReader); + propertyFileActiveRecord.entrySet().forEach(log::info); + log.info("Load time: " + (System.currentTimeMillis() - stTime) + " ms"); + stTime = System.currentTimeMillis(); + String path = TestUtils.getTempDir() + output; + File targetFile = new File(path); + OutputStreamWriter outputStreamWriter = new OutputStreamWriter(Files.newOutputStream(targetFile.toPath()), StandardCharsets.UTF_8); + String absolutePath = sourceFile.getAbsolutePath(); + propertyFileActiveRecord.save(outputStreamWriter, absolutePath, "en"); + log.info("Save time: " + (System.currentTimeMillis() - stTime) + " ms"); + + Assert.assertEquals(Objects.requireNonNull(TsMessageLoader.loadFile(absolutePath)).getPropertyDefinitions(), Objects.requireNonNull(TsMessageLoader.loadFile(path)).getPropertyDefinitions()); + } +} diff --git a/src/test/java/one/edee/babylon/util/TestUtils.java b/src/test/java/one/edee/babylon/util/TestUtils.java index fa04efc..0a62d76 100644 --- a/src/test/java/one/edee/babylon/util/TestUtils.java +++ b/src/test/java/one/edee/babylon/util/TestUtils.java @@ -42,7 +42,7 @@ public static Snapshot createTestDataFile() { } public static TranslationConfiguration createTestConfiguration() { - TranslationConfiguration configuration = new TranslationConfiguration("translation-db.json"); + TranslationConfiguration configuration = new TranslationConfiguration("translation-db.json", "cz"); configuration.addFileToPath("src\\test\\resources\\META-INF\\lib_eshop_edee\\country.properties"); configuration.addFileToPath("src\\test\\resources\\META-INF\\09_mail_form\\messages.properties"); configuration.addFileToPath("src\\test\\resources\\META-INF\\goPayGate\\*.properties"); diff --git a/src/test/kotlin/one/edee/babylon/export/FakeExporterSheetContractImpl.kt b/src/test/kotlin/one/edee/babylon/export/FakeExporterSheetContractImpl.kt index 0bd7128..7613239 100644 --- a/src/test/kotlin/one/edee/babylon/export/FakeExporterSheetContractImpl.kt +++ b/src/test/kotlin/one/edee/babylon/export/FakeExporterSheetContractImpl.kt @@ -17,7 +17,13 @@ class FakeExporterSheetContractImpl : Exporter.SheetContract { sheets[spreadsheetId!!] = sheets[spreadsheetId]!!.filter { !sheetIds!!.contains(it.id) } } - override fun createSheet(spreadsheetId: String?, sheetTitle: String?, sheetRows: MutableList>?, lockedCellEditors: MutableList?) { + override fun createSheet( + spreadsheetId: String?, + sheetTitle: String?, + sheetRows: MutableList>?, + lockedCellEditors: MutableList?, + changed: MutableMap> + ) { sheets[spreadsheetId!!] = sheets[spreadsheetId] ?: emptyList() + listOf(FakeSheet(getAndIncId())) } @@ -33,4 +39,4 @@ class FakeSheet(private val sheetId: Int) : ASheet { override fun getId(): Int = sheetId -} \ No newline at end of file +} diff --git a/src/test/kotlin/one/edee/babylon/export/FakeTranslationSnapshot.kt b/src/test/kotlin/one/edee/babylon/export/FakeTranslationSnapshot.kt index 14967a0..518b319 100644 --- a/src/test/kotlin/one/edee/babylon/export/FakeTranslationSnapshot.kt +++ b/src/test/kotlin/one/edee/babylon/export/FakeTranslationSnapshot.kt @@ -17,7 +17,11 @@ class FakeTranslationSnapshot(val content: Map) : Transla else content[msgFile]!!.containsKey(msgKey) - override fun getLastMessageValue(msgKey: MessageKey, msgFile: MsgFilePath): Message = + override fun hasSameMessage(msgKey: String, msgFile: String, currentMsg: String?): Boolean { + return getLastMessageValue(msgKey, msgFile) != currentMsg; + } + + private fun getLastMessageValue(msgKey: MessageKey, msgFile: MsgFilePath): Message = if (!containsMessage(msgKey, msgFile)) throw NoSuchElementException("Message with key '$msgKey' is not included in the snapshot.") else diff --git a/src/test/kotlin/one/edee/babylon/properties/MultilinePropertyTest.kt b/src/test/kotlin/one/edee/babylon/properties/MultilinePropertyTest.kt index dd64084..b8e4806 100644 --- a/src/test/kotlin/one/edee/babylon/properties/MultilinePropertyTest.kt +++ b/src/test/kotlin/one/edee/babylon/properties/MultilinePropertyTest.kt @@ -20,4 +20,4 @@ class MultilinePropertyTest { private fun getClassPathResourceStream(resourceRelativePath: String): InputStream = this.javaClass.getResourceAsStream(resourceRelativePath) -} \ No newline at end of file +} diff --git a/src/test/resources/META-INF/09_mail_form/messages.ts b/src/test/resources/META-INF/09_mail_form/messages.ts new file mode 100644 index 0000000..92e59c6 --- /dev/null +++ b/src/test/resources/META-INF/09_mail_form/messages.ts @@ -0,0 +1,65 @@ +const messagesI18n = { + 'availability.color.ALWAYS_AVAILABLE': 'availability--available', + 'availability.color.NOT_AVAILABLE': 'availability--unavailable', + 'availability.color.DEPEND_ON_STOCK': `{count, plural, + =0 {availability--unavailable} + other {availability--available} + }`, + 'availability.color.ALL_DEPEND_ON_STOCK': `{count, plural, + =0 {availability--unavailable} + other {availability--available} + }`, + 'availability.text.ALWAYS_AVAILABLE': 'Skladem', + 'availability.text.NOT_AVAILABLE': 'Momentálně nedostupné', + 'availability.text.DEPEND_ON_STOCK': `{count, plural, + =0 {Nedostupné} + =1 {Poslední kus} + =2 {Poslední kusy} + =3 {Poslední kusy} + =4 {Poslední kusy} + other {Skladem} + }`, + 'availability.text.ALL_DEPEND_ON_STOCK': `{count, plural, + =0 {Nedostupné} + =1 {Poslední kus} + =2 {Poslední kusy} + =3 {Poslední kusy} + =4 {Poslední kusy} + other {Skladem} + }`, + 'productDetail.availability.text.ALWAYS_AVAILABLE': 'Skladem', + 'productDetail.availability.text.NOT_AVAILABLE': 'Momentálně nedostupné', + 'productDetail.availability.text.DEPEND_ON_STOCK': `{count, plural, + =0 {Momentálně nedostupné} + =1 {Skladem poslední kus} + =2 {Skladem poslední kusy} + =3 {Skladem poslední kusy} + =4 {Skladem poslední kusy} + other {Skladem} + }`, + 'productDetail.availability.text.ALL_DEPEND_ON_STOCK': `{count, plural, + =0 {Momentálně nedostupné} + =1 {Skladem poslední kus} + =2 {Skladem poslední kusy} + =3 {Skladem poslední kusy} + =4 {Skladem poslední kusy} + other {Skladem} + }`, + contact_hours: '(Po - Ne: 8 - 16)', + contact_name: 'Zákaznická linka', + contact_email: 'test@juan.com', + contact_phone: '+420 773 777 888', + contact_linkedin: 'https://linkedin.com', + contact_facebook: 'https://facebook.com', + contact_youtube: 'https://youtube.com', + contact_instagram: 'https://instagram.com', + UspList_item1: '13 prodejen po celé ČR', + UspList_item2: 'Doprava od 1000 Kč zdarma', + UspList_item3: 'Rychlé doručení', + UspList_item4: 'Bezpečná platba', + UspList_item1_ico: 'marker', + UspList_item2_ico: 'truck', + UspList_item3_ico: 'clock', + UspList_item4_ico: 'lock', +}; +export default messagesI18n; diff --git a/src/test/resources/META-INF/addresses/addresses.ts b/src/test/resources/META-INF/addresses/addresses.ts new file mode 100644 index 0000000..9f88a4e --- /dev/null +++ b/src/test/resources/META-INF/addresses/addresses.ts @@ -0,0 +1,20 @@ +// @ts-ignore +import { AddressType } from '../graphql/types.codegen'; +const addressesI18n = { + 'Addresses.loading': 'Načítání', + 'Addresses.error': 'Chyba při načítání adres', + 'Addresses.title': 'Moje adresy', + 'Addresses.pageTitle': 'Moje adresy', + 'Addresses.emptyHeading': 'Zatím jste si nepřidali žádnou adresu', + 'Addresses.emptyText': + 'Urychlete si nakupování a přidejte si sem své adresy. Při vašem dalším nákupu je budete mít automaticky předvyplněné.', + [`Addresses.${AddressType.BILLING}Addresses`]: 'Fakturační adresy', + [`Addresses.new${AddressType.BILLING}Address`]: 'Nová fakturační adresa', + [`Addresses.${AddressType.BILLING}Empty`]: + 'Zatím jste si nepřidali žádnou fakturační adresu.', + [`Addresses.${AddressType.DELIVERY}Addresses`]: 'Dodací adresy', + [`Addresses.new${AddressType.DELIVERY}Address`]: 'Nová dodací adresa', + [`Addresses.${AddressType.DELIVERY}Empty`]: + 'Zatím jste si nepřidali žádnou dodací adresu.', +}; +export default addressesI18n; diff --git a/src/test/resources/META-INF/goPayGate/Listing.cs.i18n.ts b/src/test/resources/META-INF/goPayGate/Listing.cs.i18n.ts new file mode 100644 index 0000000..3a06df4 --- /dev/null +++ b/src/test/resources/META-INF/goPayGate/Listing.cs.i18n.ts @@ -0,0 +1,14 @@ +export default { + recordCount: `{totalRecordCount, plural, + zero {Nic nenalezeno} + one {Nalezen # produkt} + few {Nalezeny # produkty} + other {Nalezeno # produktů} + }`, + recordCountShort: `{totalRecordCount, plural, + one {# produkt} + few {# produkty} + other {# produktů} + }`, + free: 'Zdarma', +};