| 1 | {"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/antlr4ts/Decorators.js","webpack:///./node_modules/antlr4ts/Token.js","webpack:///./node_modules/antlr4ts/misc/MurmurHash.js","webpack:///./node_modules/antlr4ts/misc/Interval.js","webpack:///./node_modules/antlr4ts/atn/PredictionContext.js","webpack:///external \"assert\"","webpack:///./node_modules/antlr4ts/misc/ObjectEqualityComparator.js","webpack:///./node_modules/antlr4ts/atn/ATN.js","webpack:///./node_modules/antlr4ts/misc/Utils.js","webpack:///./node_modules/antlr4ts/ParserRuleContext.js","webpack:///./node_modules/antlr4ts/misc/BitSet.js","webpack:///./node_modules/antlr4ts/atn/ATNState.js","webpack:///./node_modules/antlr4ts/misc/Stubs.js","webpack:///./node_modules/antlr4ts/misc/Array2DHashSet.js","webpack:///./node_modules/antlr4ts/atn/Transition.js","webpack:///./node_modules/antlr4ts/VocabularyImpl.js","webpack:///./node_modules/antlr4ts/atn/DecisionState.js","webpack:///./node_modules/antlr4ts/Lexer.js","webpack:///./node_modules/antlr4ts/misc/IntervalSet.js","webpack:///./node_modules/antlr4ts/RecognitionException.js","webpack:///./node_modules/antlr4ts/misc/Array2DHashMap.js","webpack:///./node_modules/antlr4ts/IntStream.js","webpack:///./node_modules/antlr4ts/Parser.js","webpack:///./node_modules/antlr4ts/atn/RuleStopState.js","webpack:///./node_modules/antlr4ts/Recognizer.js","webpack:///./node_modules/antlr4ts/atn/ATNConfigSet.js","webpack:///./node_modules/antlr4ts/atn/SemanticContext.js","webpack:///./node_modules/antlr4ts/atn/BlockStartState.js","webpack:///./node_modules/antlr4ts/NoViableAltException.js","webpack:///./node_modules/antlr4ts/dfa/DFAState.js","webpack:///./node_modules/antlr4ts/atn/ATNConfig.js","webpack:///./node_modules/antlr4ts/CommonToken.js","webpack:///./node_modules/antlr4ts/InputMismatchException.js","webpack:///./node_modules/antlr4ts/misc/ArrayEqualityComparator.js","webpack:///./node_modules/antlr4ts/FailedPredicateException.js","webpack:///./node_modules/antlr4ts/tree/TerminalNode.js","webpack:///./node_modules/antlr4ts/atn/ParserATNSimulator.js","webpack:///./node_modules/antlr4ts/atn/ATNDeserializer.js","webpack:///./node_modules/antlr4ts/LexerNoViableAltException.js","webpack:///./node_modules/antlr4ts/atn/RuleTransition.js","webpack:///./node_modules/antlr4ts/atn/SetTransition.js","webpack:///./node_modules/antlr4ts/atn/NotSetTransition.js","webpack:///./node_modules/antlr4ts/atn/StarLoopEntryState.js","webpack:///./node_modules/antlr4ts/ProxyErrorListener.js","webpack:///./node_modules/antlr4ts/atn/ATNSimulator.js","webpack:///./node_modules/antlr4ts/atn/PredictionContextCache.js","webpack:///./node_modules/antlr4ts/dfa/DFA.js","webpack:///./node_modules/antlr4ts/atn/LexerATNSimulator.js","webpack:///./node_modules/antlr4ts/CommonTokenFactory.js","webpack:///./node_modules/antlr4ts/misc/Arrays.js","webpack:///./node_modules/antlr4ts/misc/IntegerList.js","webpack:///./node_modules/antlr4ts/atn/AbstractPredicateTransition.js","webpack:///./node_modules/antlr4ts/DefaultErrorStrategy.js","webpack:///./node_modules/antlr4ts/InterpreterRuleContext.js","webpack:///./node_modules/antlr4ts/BufferedTokenStream.js","webpack:///./node_modules/antlr4ts/BaseErrorListener.js","webpack:///./node_modules/antlr4ts/ProxyParserErrorListener.js","webpack:///./node_modules/antlr4ts/tree/RuleNode.js","webpack:///./node_modules/antlr4ts/RuleContext.js","webpack:///./node_modules/antlr4ts/tree/ErrorNode.js","webpack:///./node_modules/antlr4ts/atn/LoopEndState.js","webpack:///./node_modules/antlr4ts/atn/AtomTransition.js","webpack:///./node_modules/antlr4ts/atn/ActionTransition.js","webpack:///./node_modules/antlr4ts/atn/ATNDeserializationOptions.js","webpack:///./node_modules/antlr4ts/atn/WildcardTransition.js","webpack:///./node_modules/antlr4ts/atn/BasicState.js","webpack:///./node_modules/antlr4ts/atn/InvalidState.js","webpack:///./node_modules/antlr4ts/ConsoleErrorListener.js","webpack:///./node_modules/antlr4ts/dfa/DFASerializer.js","webpack:///./node_modules/antlr4ts/dfa/AcceptStateInfo.js","webpack:///./node_modules/antlr4ts/misc/IntegerStack.js","webpack:///./node_modules/antlr4ts/misc/DefaultEqualityComparator.js","webpack:///./node_modules/antlr4ts/atn/PredicateTransition.js","webpack:///./src/defs.ts","webpack:///external \"util\"","webpack:///external \"fs\"","webpack:///./src/resolver.ts","webpack:///./src/grammar/ApiDefParser.ts","webpack:///./src/grammar/ApiDefLexer.ts","webpack:///./node_modules/antlr4ts/RuleVersion.js","webpack:///./node_modules/antlr4ts/RuleDependency.js","webpack:///./node_modules/antlr4ts/RuleContextWithAltNum.js","webpack:///./node_modules/antlr4ts/ParserInterpreter.js","webpack:///./node_modules/antlr4ts/ListTokenSource.js","webpack:///./node_modules/antlr4ts/LexerInterpreter.js","webpack:///./node_modules/antlr4ts/DiagnosticErrorListener.js","webpack:///./node_modules/antlr4ts/Dependents.js","webpack:///./node_modules/antlr4ts/CommonTokenStream.js","webpack:///./node_modules/antlr4ts/misc/ParseCancellationException.js","webpack:///./node_modules/antlr4ts/misc/UUID.js","webpack:///./node_modules/antlr4ts/atn/TokensStartState.js","webpack:///./node_modules/antlr4ts/atn/StarLoopbackState.js","webpack:///./node_modules/antlr4ts/atn/StarBlockStartState.js","webpack:///./node_modules/antlr4ts/atn/RuleStartState.js","webpack:///./node_modules/antlr4ts/atn/RangeTransition.js","webpack:///./node_modules/antlr4ts/atn/PrecedencePredicateTransition.js","webpack:///./node_modules/antlr4ts/atn/PlusLoopbackState.js","webpack:///./node_modules/antlr4ts/atn/PlusBlockStartState.js","webpack:///./node_modules/antlr4ts/atn/SimulatorState.js","webpack:///./node_modules/antlr4ts/atn/PredictionMode.js","webpack:///./node_modules/antlr4ts/tree/Trees.js","webpack:///./node_modules/antlr4ts/atn/ConflictInfo.js","webpack:///./node_modules/antlr4ts/atn/LexerTypeAction.js","webpack:///./node_modules/antlr4ts/atn/LexerSkipAction.js","webpack:///./node_modules/antlr4ts/atn/LexerPushModeAction.js","webpack:///./node_modules/antlr4ts/atn/LexerPopModeAction.js","webpack:///./node_modules/antlr4ts/atn/LexerMoreAction.js","webpack:///./node_modules/antlr4ts/atn/LexerModeAction.js","webpack:///./node_modules/antlr4ts/atn/LexerCustomAction.js","webpack:///./node_modules/antlr4ts/atn/LexerChannelAction.js","webpack:///./node_modules/antlr4ts/atn/EpsilonTransition.js","webpack:///./node_modules/antlr4ts/atn/BlockEndState.js","webpack:///./node_modules/antlr4ts/atn/BasicBlockStartState.js","webpack:///./node_modules/antlr4ts/atn/OrderedATNConfigSet.js","webpack:///./node_modules/antlr4ts/atn/LexerIndexedCustomAction.js","webpack:///./node_modules/antlr4ts/atn/LexerActionExecutor.js","webpack:///./node_modules/antlr4ts/atn/LL1Analyzer.js","webpack:///./node_modules/antlr4ts/dfa/LexerDFASerializer.js","webpack:///./node_modules/antlr4ts/BailErrorStrategy.js","webpack:///./node_modules/antlr4ts/ANTLRInputStream.js","webpack:///./node_modules/antlr4ts/index.js","webpack:///./src/parser.ts","webpack:///./node_modules/textbuilder/dist/textbuilder.js","webpack:///./src/generators/typescript.ts","webpack:///external \"path\"","webpack:///external \"child_process\"","webpack:///external \"events\"","webpack:///./node_modules/commander/index.js","webpack:///(webpack)/buildin/module.js","webpack:///./src/cli.ts"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","r","value","n","__esModule","default","object","property","prototype","hasOwnProperty","p","w","s","t","e","NotNull","target","propertyKey","propertyDescriptor","Nullable","Override","SuppressWarnings","options","descriptor","IntStream_1","Token","INVALID_TYPE","EPSILON","MIN_USER_TOKEN_TYPE","EOF","IntStream","DEFAULT_CHANNEL","HIDDEN_CHANNEL","MIN_USER_CHANNEL_VALUE","MurmurHash","DEFAULT_SEED","initialize","seed","update","hash","str","len","length","charCodeAt","hashCode","k","Math","imul","finish","numberOfWords","data","__decorate","this","decorators","key","desc","arguments","getOwnPropertyDescriptor","Reflect","decorate","Decorators_1","INTERVAL_POOL_MAX_VALUE","Interval","[object Object]","a","b","INVALID","_INVALID","cache","other","startsBeforeDisjoint","startsAfterDisjoint","of","min","max","diff","startsBeforeNonDisjoint","startsAfterNonDisjoint","Array","__param","paramIndex","decorator","Array2DHashMap_1","Array2DHashSet_1","Arrays_1","MurmurHash_1","PredictionContextCache_1","assert","INITIAL_HASH","PredictionContext","cachedHashCode","parent","returnState","parents","returnStates","atn","outerContext","fullContext","isEmpty","EMPTY_FULL","EMPTY_LOCAL","_parent","fromRuleContext","transition","states","invokingState","getChild","followState","stateNumber","context","addEmptyContext","removeEmptyContext","context0","context1","contextCache","PredictionContextCache","UNCACHED","isEmptyLocal","context0size","size","context1size","getReturnState","merged","join","getParent","count","parentsList","returnStatesList","leftIndex","rightIndex","canReturnLeft","canReturnRight","slice","SingletonPredictionContext","ArrayPredictionContext","visited","existing","put","updated","changed","getCachedContext","j","putIfAbsent","returnContext","appendContext","recognizer","currentState","stop","result","outer","perm","offset","last","localBuffer","index","bits","ruleNames","ruleIndex","EMPTY_FULL_STATE_KEY","push","EmptyPredictionContext","super","calculateEmptyHashCode","isFullContext","suffix","hasEmpty","calculateHashCode","Arrays","binarySearch","parents2","returnStates2","appendContextImpl","IdentityHashMap","parentCount","updatedParents","updatedReturnStates","equalsImpl","Array2DHashSet","selfWorkList","otherWorkList","currentSelf","pop","currentOther","operands","IdentityCommutativePredictionContextOperands","add","selfSize","x","y","selfParent","otherParent","equals","calculateSingleHashCode","EMPTY_LOCAL_STATE_KEY","Array2DHashMap","IdentityEqualityComparator","INSTANCE","obj","require","ObjectEqualityComparator","DFA_1","IntervalSet_1","InvalidState_1","LL1Analyzer_1","ObjectEqualityComparator_1","PredictionContext_1","Token_1","ATN","grammarType","maxTokenType","decisionToState","modeNameToStartState","Map","modeToStartState","decisionToDFA","modeToDFA","LL1Table","DFA","clear","contextCacheSize","ctx","LL1Analyzer","LOOK","nextTokenWithinRule","nextTokens","setReadonly","state","invalidState","InvalidState","set","defineDecisionState","decision","numberOfDecisions","RangeError","following","contains","expected","IntervalSet","addAll","remove","rt","INVALID_ALT_NUMBER","escapeWhitespace","escapeSpaces","replace","collection","separator","buf","first","current","toMap","keys","toCharArray","Uint16Array","ErrorNode_1","Interval_1","RuleContext_1","TerminalNode_1","ParserRuleContext","RuleContext","invokingStateNumber","EMPTY","_start","_stop","children","child","ErrorNode","listener","TerminalNode","badToken","addChild","TypeError","ctxType","tryGetChild","Error","ttype","tryGetToken","symbol","type","tokens","ruleContext","contexts","childCount","sourceInterval","tokenIndex","start","getRuleInvocationStack","reverse","util","EMPTY_DATA","getIndex","bitNumber","unIndex","findLSBSet","word","bit","findMSBSet","bitsFor","fromBit","toBit","POP_CNT","Uint8Array","stride","BitSet","arg","v","words","lastWord","fromIndex","toIndex","fill","smallerLength","bound","previousSetBit","ignore","mask","minWords","dest","longer","temp","forEach","_setBits","byteLength","nextSetBit","Symbol","iterator","BitSetIterator","inspect","custom","toString","done","ATNState","INVALID_STATE_NUMBER","epsilonOnlyTransitions","transitions","optimizedTransitions","nonStopStateNumber","getStateNumber","isNonGreedyExitState","String","numberOfTransitions","isEpsilon","splice","onlyHasEpsilonTransitions","isOptimized","numberOfOptimizedTransitions","serializationNames","asIterable","_iterator","hasNext","next","undefined","DefaultEqualityComparator_1","Stubs_1","INITAL_CAPACITY","INITAL_BUCKET_CAPACITY","LOAD_FACTOR","comparatorOrSet","initialCapacity","initialBucketCapacity","threshold","floor","comparator","buckets","DefaultEqualityComparator","createBuckets","expand","getOrAddImpl","getBucket","bucket","createBucket","oldLength","containsAll","old","newCapacity","newTable","newBucketLengths","Uint32Array","oldSize","newBucket","bucketLength","getOrAdd","containsFast","asElementType","SetIterator","toArray","removeFast","copyWithin","newsize","capacity","nextIndex","removed","Transition","label","VocabularyImpl","literalNames","symbolicNames","displayNames","_maxTokenType","tokenType","displayName","literalName","getLiteralName","getSymbolicName","EMPTY_VOCABULARY","ATNState_1","DecisionState","nonGreedy","sll","CommonTokenFactory_1","IntegerStack_1","LexerATNSimulator_1","LexerNoViableAltException_1","Recognizer_1","Lexer","Recognizer","input","_factory","CommonTokenFactory","DEFAULT","_tokenStartCharIndex","_tokenStartLine","_tokenStartCharPositionInLine","_hitEOF","_channel","_type","_modeStack","IntegerStack","_mode","DEFAULT_MODE","_input","_tokenFactorySourcePair","source","stream","DEFAULT_TOKEN_CHANNEL","HIDDEN","resetInput","seek","_token","_text","interpreter","reset","tokenStartMarker","mark","emitEOF","charPositionInLine","line","match","LexerNoViableAltException","notifyListeners","recover","SKIP","LA","MORE","emit","release","LexerATNSimulator","debug","console","log","mode","peek","tokenFactory","factory","inputStream","sourceName","token","create","charIndex","cpos","eof","text","getText","channel","nextToken","msg","getErrorDisplay","getErrorListenerDispatch","syntaxError","fromCharCode","re","consume","MIN_CHAR_VALUE","MAX_CHAR_VALUE","ArrayEqualityComparator_1","IntegerList_1","Lexer_1","intervals","readonly","_intervals","COMPLETE_CHAR_SET","_COMPLETE_CHAR_SET","EMPTY_SET","_EMPTY_SET","addRange","addition","adjacent","disjoint","bigger","union","sets","I","toList","minElement","maxElement","complement","vocabulary","isNil","vocabularyIS","subtract","left","right","resultI","rightI","beforeCurrent","afterCurrent","resultInterval","rightInterval","intersection","myIntervals","theirIntervals","mySize","theirSize","mine","theirs","properlyContains","el","ArrayEqualityComparator","elemAreChar","elementName","getDisplayName","numIntervals","firstInterval","values","IntegerList","Set","oldb","isReadonly","RecognitionException","message","_offendingState","_recognizer","offendingState","expectedTokens","getExpectedTokens","offendingToken","MapKeyEqualityComparator","keyComparator","keyComparer","backingStore","EntrySet","KeySet","element","entry","entrySet","getKey","getValue","ValueCollection","map","removedAny","delegate","UNKNOWN_SOURCE_NAME","Utils","ATNDeserializationOptions_1","ATNDeserializer_1","DefaultErrorStrategy_1","ProxyParserErrorListener_1","TraceListener","tokenStream","LT","node","Parser","_errHandler","DefaultErrorStrategy","_precedenceStack","_buildParseTrees","_parseListeners","_syntaxErrors","matchedEOF","_ctx","isTrace","currentToken","reportMatch","recoverInline","addErrorNode","buildParseTree","buildParseTrees","findIndex","enterEveryRule","enterRule","exitRule","exitEveryRule","numberOfSyntaxErrors","tokenSource","serializedAtn","serializedATN","bypassAltsAtnCache","deserializationOptions","ATNDeserializationOptions","isGenerateRuleBypassTransitions","ATNDeserializer","deserialize","pattern","patternRuleIndex","lexer","errorHandler","handler","hasListener","inErrorRecoveryMode","visitErrorNode","visitTerminal","localctx","addContextToParseTree","triggerEnterRuleEvent","factoredContext","removeLastChild","tryLT","triggerExitRuleEvent","altNum","altNumber","precedence","previous","_parentctx","retctx","ProxyParserErrorListener","getErrorListeners","isMatchedEOF","ruleName","getRuleIndexMap","stack","_interp","dfa","seenOne","process","stdout","write","parseInfo","profile","trace","_tracer","removeParseListener","addParseListener","WeakMap","RuleStopState","stateType","ConsoleErrorListener_1","ProxyErrorListener_1","_listeners","ConsoleErrorListener","_stateNumber","tokenTypeMapCache","intermediateResult","symbolicName","freeze","ruleIndexMapCache","tokenName","getTokenTypeMap","getOffendingToken","position","indexOf","ProxyErrorListener","_localctx","actionIndex","atnState","ATN_1","ATNConfig_1","BitSet_1","SemanticContext_1","KeyTypeEqualityComparer","alt","NewKeyedConfigMap","ATNConfigSet","_uniqueAlt","_hasSemanticContext","_dipsIntoOuterContext","outermostConfigSet","mergedConfigs","unmerged","isReadOnly","configs","_conflictInfo","conflictedAlts","clone","alts","config","isOutermostConfigSet","copy","ATNConfig","configKey","mergedConfig","canMerge","ATNConfigSetIterator","ensureWritable","addKey","reachesIntoOuterContext","outerContextDepth","isPrecedenceFilterSuppressed","joined","updatePropertiesForMergedConfig","unmergedConfig","updatePropertiesForAddedConfig","SemanticContext","NONE","semanticContext","leftKey","group","showContext","sortedConfigs","sort","o1","o2","localeCompare","isExact","uniqueAlt","hasSemanticContext","conflictInfo","conflictingAlts","isExactConflict","dipsIntoOuterContext","indexOrItem","_NONE","Predicate","parser","parserCallStack","AND","opnds","OR","filterPrecedencePredicates","PrecedencePredicate","predIndex","isCtxDependent","sempred","precpred","Operator","reduced","items","compareTo","opnd","eval","differs","evaluated","evalPrecedence","and","or","DecisionState_1","BlockStartState","Parser_1","RecognitionException_1","NoViableAltException","startToken","deadEndConfigs","_deadEndConfigs","_startToken","setOffendingToken","DFAState","arg0","arg1","edges","contextEdges","isContextSensitive","contextSymbols","acceptStateInfo","_acceptStateInfo","isAcceptState","prediction","lexerActionExecutor","has","delete","predicates","PredPrediction","pred","altOrConfig","_state","altAndOuterContextDepth","_context","ActionSemanticContextATNConfig","SemanticContextATNConfig","ActionATNConfig","hasPassedThroughNonGreedyDecision","transform","checkNonGreedy","arg2","transformImpl","passedThroughNonGreedy","checkNonGreedyDecision","appendedContext","appendSingleContext","subconfig","leftWorkList","rightWorkList","findReturnState","builder","workList","getOrAddContext","newNumber","recog","showAlt","toStrings","contextDesc","_semanticContext","passedThroughNonGreedyDecision","_lexerActionExecutor","CommonToken","EMPTY_SOURCE","_line","_charPositionInLine","oldToken","startIndex","stopIndex","channelStr","txt","typeString","InputMismatchException","PredicateTransition_1","FailedPredicateException","predicate","formatMessage","trans","PredicateTransition","_ruleIndex","_predicateIndex","_predicate","predicateIndex","_symbol","payload","visitor","AcceptStateInfo_1","ActionTransition_1","ATNConfigSet_1","ATNSimulator_1","AtomTransition_1","ConflictInfo_1","DFAState_1","NotSetTransition_1","NoViableAltException_1","ParserRuleContext_1","PredictionMode_1","RuleStopState_1","RuleTransition_1","SetTransition_1","SimulatorState_1","VocabularyImpl_1","ParserATNSimulator","ATNSimulator","predictionMode","PredictionMode","LL","force_global_context","always_try_local_context","enable_global_context_dfa","optimize_unique_closure","optimize_ll1","optimize_tail_calls","tail_call_preserves_sll","treat_sllk1_conflict_as_ambiguity","reportAmbiguities","userWantsCtxSensitive","_parser","useContext","isPrecedenceDfa","ll_1","SLL","emptyContext","getStartState","getLookaheadName","computeStartState","execDFA","getPrecedenceStartState","SimulatorState","s0","remainingContext","s0full","skipTailCalls","getContextTarget","dfa_debug","remainingOuterContext","isContextSymbol","initialState","execATN","getExistingTargetState","interval","ERROR","errorState","handleNoViableAlt","atnStartState","conflictIndex","evalSemanticContext","cardinality","conflictState","reportAttemptingFullContext","adaptivePredict","LL_EXACT_AMBIG_DETECTION","noViableAlt","reportAmbiguity","nextState","computeReachSet","setDFAEdge","D","predictedAlt","reportContextSensitivity","attemptFullContext","predPredictions","fullContextState","maxAlt","filteredConfigs","altToPred","getPredsForAmbigAlts","getPredicatePredictions","filteredAlts","remainingGlobalContext","computeTargetState","getTarget","contextElements","stepIntoGlobal","closureConfigs","reach","hasMoreContext","skippedStopStates","reachIntermediate","getTokenName","ti","getOptimizedTransition","getReachableTarget","collectPredicates","treatEofAsEpsilon","closure","removeAllConfigsNotInRuleStopState","hasConfigInRuleStopState","nextContextElement","addDFAEdge","allConfigsInRuleStopStates","globalContext","setContextSensitive","previousContext","initialContext","addDFAState","applyPrecedenceFilter","setPrecedenceStartState","setContextTarget","statesFromAlt1","configSet","updatedContext","matches","nalts","getConflictingAltsFromConfigSet","ambigAlts","nPredAlts","pairs","containsPredicate","complete","predictions","pair","evaluatedResult","evalSemanticContextImpl","sourceConfigs","currentConfigs","closureBusy","intermediate","closureImpl","hasMoreContexts","depth","getRuleName","nonEmptySize","newContext","precedenceRuleDecision","precedenceDecision","suppress","precedenceLoopbackStates","continueCollecting","ActionTransition","getEpsilonTarget","RuleTransition","newDepth","outermostPrecedenceReturn","optimizedTailCall","inContext","serializationType","ruleTransition","precedenceTransition","predTransition","actionTransition","pt","newSemCtx","configset","STATE_ALT_SORT_COMPARATOR","exact","minAlt","representedAlts","currentAlt","firstIndexCurrentState","lastIndexCurrentStateMinAlt","joinedCheckContext","config2","joinedCheckContext2","lastIndexCurrentStateCurrentAlt","check","ConflictInfo","nvae","AtomTransition","_label","SetTransition","NotSetTransition","fromState","contextTransitions","toConfigs","from","to","setContextSymbol","addDFAContextState","q","setTarget","contextConfigs","enableDfa","optimizeConfigs","proposed","createDFAState","isConflicted","newState","decisionState","getDecisionState","getUniqueAlt","AcceptStateInfo","predicateDFAState","added","addState","retry_debug","acceptState","tailCall","BasicBlockStartState_1","BasicState_1","BlockEndState_1","BlockStartState_1","EpsilonTransition_1","LexerChannelAction_1","LexerCustomAction_1","LexerModeAction_1","LexerMoreAction_1","LexerPopModeAction_1","LexerPushModeAction_1","LexerSkipAction_1","LexerTypeAction_1","LoopEndState_1","ParserATNSimulator_1","PlusBlockStartState_1","PlusLoopbackState_1","PrecedencePredicateTransition_1","RangeTransition_1","RuleStartState_1","StarBlockStartState_1","StarLoopbackState_1","StarLoopEntryState_1","TokensStartState_1","UUID_1","WildcardTransition_1","defaultOptions","SERIALIZED_VERSION","feature","actualUuid","featureIndex","SUPPORTED_UUIDS","version","toInt","reason","uuid","toUUID","SERIALIZED_UUID","supportsLexerActions","isFeatureSupported","ADDED_LEXER_ACTIONS","loopBackStateNumbers","endStateNumbers","nstates","stype","stateFactory","loopBackStateNumber","endStateNumber","loopBackState","endState","numNonGreedyStates","numSllDecisions","numPrecedenceStates","isPrecedenceRule","nrules","ruleToTokenType","Int32Array","ruleToStartState","startState","leftFactored","actionIndexIgnored","ruleToStopState","stopState","nmodes","nsets","nintervals","nedges","src","trg","arg3","edgeFactory","addTransition","returnTransitionsSet","returnTransitions","returningToLeftFactored","returnTransition","EpsilonTransition","PlusLoopbackState","loopbackState","PlusBlockStartState","StarLoopbackState","StarLoopEntryState","ndecisions","decState","lexerActions","actionType","data1","data2","lexerAction","lexerActionFactory","legacyLexerActions","LexerCustomAction","setTransition","markPrecedenceDecisions","isVerifyATN","verifyATN","bypassStart","BasicBlockStartState","excludeTransition","bypassStop","BlockEndState","maybeLoopEndState","LoopEndState","removeTransition","matchState","BasicState","isOptimize","optimizationCount","inlineSetRules","combineChainedEpsilons","preserveOrder","optimizeSets","identifyTailCalls","rulePrecedenceDecisions","getTransitions","checkCondition","starLoopEntryState","StarBlockStartState","RuleStartState","condition","inlinedCalls","ruleToInlineTransition","middleState","matchTransition","matchTarget","effective","intermediateState","setRuleIndex","RangeTransition","removeOptimizedTransition","addOptimizedTransition","removedEdges","nextTransition","removedPaths","decisions","setTransitions","epsTransition","newTransition","blockEndState","matchSet","matchInterval","setOptimizedState","testTailCall","optimizedPath","reachable","worklist","transitionCount","leastSigBits","toInt32","lessSigBits","moreSigBits","mostSigBits","UUID","PrecedencePredicateTransition","WildcardTransition","TokensStartState","LexerChannelAction","LexerModeAction","LexerMoreAction","LexerPopModeAction","LexerPushModeAction","LexerSkipAction","LexerTypeAction","BASE_SERIALIZED_UUID","fromString","_startIndex","Transition_1","ruleStart","minVocabSymbol","maxVocabSymbol","delegates","offendingSymbol","_ERROR","clearDFA","enableCache","childContexts","joinContexts","PredictionContextAndInt","getAsCached","_x","_y","DFASerializer_1","LexerDFASerializer_1","nextStateNumber","precedenceDfa","getEdgeMap","serializer","DFASerializer","LexerDFASerializer","LexerActionExecutor_1","OrderedATNConfigSet_1","prevAccept","SimState","simulator","match_calls","matchATN","old_mode","s0_closure","suppressEdge","predict","toLexerString","ds0","captureSimState","failOrAccept","OrderedATNConfigSet","getReachableConfigSet","dfaState","accept","charPos","skipAlt","currentAltReachedAcceptState","fixOffsetBeforeMatch","execute","speculative","returnStateNumber","evaluatePredicate","LexerActionExecutor","append","savedCharPositionInLine","savedLine","marker","settings","firstConfigWithRuleStopState","CommonToken_1","copyText","array","low","high","mid","midVal","INITIAL_SIZE","MAX_ARRAY_SIZE","_data","_size","ensureCapacity","list","isArray","subarray","xi","newLength","tmp","AbstractPredicateTransition","FailedPredicateException_1","InputMismatchException_1","errorRecoveryMode","lastErrorIndex","endErrorCondition","lastErrorStates","beginErrorCondition","reportNoViableAlternative","reportInputMismatch","reportFailedPredicate","error","notifyErrorListeners","followSet","getErrorRecoverySet","consumeUntil","la","singleTokenDeletion","reportUnwantedToken","whatFollowsLoopIterationOrRule","getTextFromRange","escapeWSAndQuote","expectedString","toStringVocabulary","getTokenErrorDisplay","matchedSymbol","singleTokenInsertion","getMissingSymbol","currentSymbolType","reportMissingToken","nextTokenType","tokenText","currentSymbol","expectedTokenType","lookback","constructToken","getSymbolText","getSymbolType","recoverSet","follow","InterpreterRuleContext","BufferedTokenStream","fetchedEOF","_tokenSource","lazyInit","adjustSeekIndex","skipEofCheck","sync","fetch","isWritableToken","subset","tryLB","setup","types","typesSet","filteredTokens","filter","nextOnChannel","nextTokenOnChannel","filterForChannel","prevOnChannel","previousTokenOnChannel","hidden","isToken","BaseErrorListener","getDelegates","isParserErrorListener","RuleNode","RuleNode_1","Trees_1","visitChildren","Trees","toStringTree","readOnly","generateRuleBypassTransitions","optimize","_defaultOptions","makeReadOnly","throwIfReadOnly","edgeKeys","getContextEdgeMap","contextEdgeKeys","contextSymbol","getStateString","getEdgeLabel","getContextLabel","output","stateStr","_prediction","removeAt","AbstractPredicateTransition_1","PRIMITIVE_TYPES","defs_1","resolve","api","recordedErrors","definedEndpoints","definedTypes","typeDef","typeDefs","entries","checkType","endpoint","endpoints","headers","kind","errors","possibleType","fieldName","fieldType","Decorators_2","__importStar","ApiDefParser","_ATN","VOCABULARY","grammarFileName","_serializedATN","_la","ApiContext","RULE_api","enterOuterAlt","LINEBREAK","T__0","T__3","T__11","typedef","exception","reportError","EndpointContext","RULE_endpoint","endpointname","T__1","method","route","typename","T__2","HeadersContext","RULE_headers","T__4","T__5","EndpointnameContext","RULE_endpointname","MethodContext","RULE_method","T__6","T__7","T__8","T__9","RouteContext","RULE_route","T__10","subpath","SubpathContext","RULE_subpath","_dynamic","TypedefContext","RULE_typedef","T__12","_p","_parentState","TypeContext","enterRecursionRule","RULE_type","_alt","struct","pushNewRecursionContext","T__13","unrollRecursionContexts","ArrayContext","RULE_array","T__14","StructContext","RULE_struct","T__15","NAME","structfield","T__16","StructfieldContext","RULE_structfield","fieldname","T__17","_optional","FieldnameContext","RULE_fieldname","TypenameContext","RULE_typename","SymbolContext","RULE_symbol","T__18","NameContext","RULE_name","SeparatorContext","RULE_separator","T__19","type_sempred","__ATN","WHITESPACE","BLOCK_COMMENT","LINE_COMMENT","_LITERAL_NAMES","_SYMBOLIC_NAMES","getToken","getTokens","getRuleContexts","getRuleContext","tryGetRuleContext","ApiDefLexer","modeNames","RuleVersion","RuleDependency","dependency","RuleContextWithAltNum","_altNumber","InterpreterRuleContext_1","ParserInterpreter","_parentContextStack","overrideDecision","overrideDecisionInputIndex","overrideDecisionAlt","overrideDecisionReached","_overrideDecisionRoot","_grammarFileName","_atn","pushRecursionContextStates","_ruleNames","_vocabulary","startRuleIndex","startRuleStartState","_rootContext","createInterpreterRuleContext","parentContext","visitRuleStopState","visitState","visitDecisionState","matchWildcard","ruleStartState","newctx","predicateTransition","action","forcedAlt","overrideDecisionRoot","tok","sourcePair","errToken","rootContext","ListTokenSource","_sourceName","eofToken","lastToken","lastNewLine","lastIndexOf","previousStop","charAt","LexerInterpreter","_modeNames","BaseErrorListener_1","DiagnosticErrorListener","exactOnly","getDecisionDescription","getConflictingAlts","reportedAlts","Dependents","SELF","PARENTS","CHILDREN","ANCESTORS","DESCENDANTS","SIBLINGS","PRECEEDING_SIBLINGS","FOLLOWING_SIBLINGS","PRECEEDING","FOLLOWING","BufferedTokenStream_1","CommonTokenStream","ParseCancellationException","cause","test","segments","split","parseInt","substr","loopEntryState","AltAndContextConfigEqualityComparator","getNodeText","kids","ancestors","unshift","u","findAllNodes","findTokens","nodes","_findAllNodes","recurse","startTokenIndex","stopTokenIndex","getRootOfSubtreeEnclosingRegion","stopToken","root","range","isAncestorOf","abbrev","_conflictedAlts","isPositionDependent","skip","pushMode","popMode","more","_actionIndex","_outermostPrecedenceReturn","LexerIndexedCustomAction","_offset","_action","LexerIndexedCustomAction_1","_lexerActions","updatedLexerActions","requiresSeek","look","lookBusy","seeThruPreds","_LOOK","HIT_PRED","calledRuleStack","addEOF","ParseCancellationException_1","BailErrorStrategy","ANTLRInputStream","__export","antlr4ts_1","ApiDefLexer_1","ApiDefParser_1","read_endpoint","read_subpath","read_typename","dynamic","read_typedef","read_type","reduce","acc","curr","concat","read_structfield","assign","parse","code","removeErrorListeners","addErrorListener","_parts","_indentLevel","incomingTextLength","_getLastCharacter","block","_addLinebreakIfNotBeginning","lastCharacter","linebreak","lastPart","__importDefault","textbuilder_1","generateTypeScript","endpointDefinitions","typeDefinitions","firstBlock","baseUrl","endsWith","appendClientEndpoint","appendServerEndpoint","appendType","build","endpointArguments","indented","path","toLowerCase","args","headersType","exported","typeName","EventEmitter","spawn","dirname","basename","fs","Option","flags","description","required","optional","bool","short","shift","long","Command","commands","_execs","_allowUnknownOption","_args","_name","pad","width","outputHelpIfNecessary","cmd","outputHelp","exit","humanReadableArgName","nameOutput","variadic","exists","file","statSync","isFile","inherits","attributeName","toUpperCase","is","command","opts","executables","isDefault","defaultExecutable","_noHelp","noHelp","parseExpectedArgs","addImplicitHelpCommand","self","argDetails","fn","unknown","parsed","parseOptions","unknownOption","missingArgument","variadicArgNotLast","apply","on","_alias","option","defaultValue","oname","RegExp","regex","val","def","exec","allowUnknownOption","argv","rawArgs","normalize","parseArgs","aliasCommand","alias","executeSubCommand","help","baseDir","f","bin","link","lstatSync","isSymbolicLink","readlinkSync","proc","localBin","isExplicitJS","platform","execArgv","stdio","customFds","execPath","signal","killed","exitCode","kill","bind","err","runningCommand","lastOpt","ret","optionFor","listeners","literal","unknownOptions","optionMissingArgument","_versionOptionName","_version","flag","versionOption","argsDescription","_description","_argsDescription","usage","_usage","prepareCommands","largestCommandLength","largestOptionLength","largestArgLength","padWidth","optionHelp","commandHelp","helpInformation","cmdName","cmds","cb","passthru","webpackPolyfill","deprecate","paths","commander_1","typescript_1","parser_1","resolver_1","cli","env","existsSync","readFileSync","generateOptions","client","server","generated","info","warn","out"],"mappings":"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","file":"cli.bundle.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// object to store loaded and loading wasm modules\n \tvar installedWasmModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// object with all compiled WebAssembly.Modules\n \t__webpack_require__.w = {};\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 129);\n","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nfunction NotNull(target, propertyKey, propertyDescriptor) {\r\n}\r\nexports.NotNull = NotNull;\r\nfunction Nullable(target, propertyKey, propertyDescriptor) {\r\n}\r\nexports.Nullable = Nullable;\r\nfunction Override(target, propertyKey, propertyDescriptor) {\r\n // do something with 'target' ...\r\n}\r\nexports.Override = Override;\r\nfunction SuppressWarnings(options) {\r\n return (target, propertyKey, descriptor) => {\r\n };\r\n}\r\nexports.SuppressWarnings = SuppressWarnings;\r\n//# sourceMappingURL=Decorators.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nconst IntStream_1 = require(\"./IntStream\");\r\nvar Token;\r\n(function (Token) {\r\n Token.INVALID_TYPE = 0;\r\n /** During lookahead operations, this \"token\" signifies we hit rule end ATN state\r\n * and did not follow it despite needing to.\r\n */\r\n Token.EPSILON = -2;\r\n Token.MIN_USER_TOKEN_TYPE = 1;\r\n Token.EOF = IntStream_1.IntStream.EOF;\r\n /** All tokens go to the parser (unless skip() is called in that rule)\r\n * on a particular \"channel\". The parser tunes to a particular channel\r\n * so that whitespace etc... can go to the parser on a \"hidden\" channel.\r\n */\r\n Token.DEFAULT_CHANNEL = 0;\r\n /** Anything on different channel than DEFAULT_CHANNEL is not parsed\r\n * by parser.\r\n */\r\n Token.HIDDEN_CHANNEL = 1;\r\n /**\r\n * This is the minimum constant value which can be assigned to a\r\n * user-defined token channel.\r\n *\r\n * <p>\r\n * The non-negative numbers less than {@link #MIN_USER_CHANNEL_VALUE} are\r\n * assigned to the predefined channels {@link #DEFAULT_CHANNEL} and\r\n * {@link #HIDDEN_CHANNEL}.</p>\r\n *\r\n * @see `Token.channel`\r\n */\r\n Token.MIN_USER_CHANNEL_VALUE = 2;\r\n})(Token = exports.Token || (exports.Token = {}));\r\n//# sourceMappingURL=Token.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nvar MurmurHash;\r\n(function (MurmurHash) {\r\n const DEFAULT_SEED = 0;\r\n /**\r\n * Initialize the hash using the specified {@code seed}.\r\n *\r\n * @param seed the seed (optional)\r\n * @return the intermediate hash value\r\n */\r\n function initialize(seed = DEFAULT_SEED) {\r\n return seed;\r\n }\r\n MurmurHash.initialize = initialize;\r\n /**\r\n * Update the intermediate hash value for the next input {@code value}.\r\n *\r\n * @param hash the intermediate hash value\r\n * @param value the value to add to the current hash\r\n * @return the updated intermediate hash value\r\n */\r\n function update(hash, value) {\r\n const c1 = 0xCC9E2D51;\r\n const c2 = 0x1B873593;\r\n const r1 = 15;\r\n const r2 = 13;\r\n const m = 5;\r\n const n = 0xE6546B64;\r\n if (value == null) {\r\n value = 0;\r\n }\r\n else if (typeof value === 'string') {\r\n value = hashString(value);\r\n }\r\n else if (typeof value === 'object') {\r\n value = value.hashCode();\r\n }\r\n let k = value;\r\n k = Math.imul(k, c1);\r\n k = (k << r1) | (k >>> (32 - r1));\r\n k = Math.imul(k, c2);\r\n hash = hash ^ k;\r\n hash = (hash << r2) | (hash >>> (32 - r2));\r\n hash = Math.imul(hash, m) + n;\r\n return hash & 0xFFFFFFFF;\r\n }\r\n MurmurHash.update = update;\r\n /**\r\n * Apply the final computation steps to the intermediate value {@code hash}\r\n * to form the final result of the MurmurHash 3 hash function.\r\n *\r\n * @param hash the intermediate hash value\r\n * @param numberOfWords the number of integer values added to the hash\r\n * @return the final hash result\r\n */\r\n function finish(hash, numberOfWords) {\r\n hash = hash ^ (numberOfWords * 4);\r\n hash = hash ^ (hash >>> 16);\r\n hash = Math.imul(hash, 0x85EBCA6B);\r\n hash = hash ^ (hash >>> 13);\r\n hash = Math.imul(hash, 0xC2B2AE35);\r\n hash = hash ^ (hash >>> 16);\r\n return hash;\r\n }\r\n MurmurHash.finish = finish;\r\n /**\r\n * Utility function to compute the hash code of an array using the\r\n * MurmurHash algorithm.\r\n *\r\n * @param <T> the array element type\r\n * @param data the array data\r\n * @param seed the seed for the MurmurHash algorithm\r\n * @return the hash code of the data\r\n */\r\n function hashCode(data, seed = DEFAULT_SEED) {\r\n let hash = initialize(seed);\r\n let length = 0;\r\n for (let value of data) {\r\n hash = update(hash, value);\r\n length++;\r\n }\r\n hash = finish(hash, length);\r\n return hash;\r\n }\r\n MurmurHash.hashCode = hashCode;\r\n /**\r\n * Function to hash a string. Based on the implementation found here:\r\n * http://stackoverflow.com/a/7616484\r\n */\r\n function hashString(str) {\r\n let len = str.length;\r\n if (len === 0) {\r\n return 0;\r\n }\r\n let hash = 0;\r\n for (let i = 0; i < len; i++) {\r\n let c = str.charCodeAt(i);\r\n hash = (((hash << 5) >>> 0) - hash) + c;\r\n hash |= 0;\r\n }\r\n return hash;\r\n }\r\n})(MurmurHash = exports.MurmurHash || (exports.MurmurHash = {}));\r\n//# sourceMappingURL=MurmurHash.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:40.7402214-07:00\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst INTERVAL_POOL_MAX_VALUE = 1000;\r\n/** An immutable inclusive interval a..b */\r\nclass Interval {\r\n /**\r\n * @param a The start of the interval\r\n * @param b The end of the interval (inclusive)\r\n */\r\n constructor(a, b) {\r\n this.a = a;\r\n this.b = b;\r\n }\r\n static get INVALID() {\r\n return Interval._INVALID;\r\n }\r\n /** Interval objects are used readonly so share all with the\r\n * same single value a==b up to some max size. Use an array as a perfect hash.\r\n * Return shared object for 0..INTERVAL_POOL_MAX_VALUE or a new\r\n * Interval object with a..a in it. On Java.g4, 218623 IntervalSets\r\n * have a..a (set with 1 element).\r\n */\r\n static of(a, b) {\r\n // cache just a..a\r\n if (a !== b || a < 0 || a > INTERVAL_POOL_MAX_VALUE) {\r\n return new Interval(a, b);\r\n }\r\n if (Interval.cache[a] == null) {\r\n Interval.cache[a] = new Interval(a, a);\r\n }\r\n return Interval.cache[a];\r\n }\r\n /** return number of elements between a and b inclusively. x..x is length 1.\r\n * if b < a, then length is 0. 9..10 has length 2.\r\n */\r\n get length() {\r\n if (this.b < this.a) {\r\n return 0;\r\n }\r\n return this.b - this.a + 1;\r\n }\r\n equals(o) {\r\n if (o === this) {\r\n return true;\r\n }\r\n else if (!(o instanceof Interval)) {\r\n return false;\r\n }\r\n let other = o;\r\n return this.a === other.a && this.b === other.b;\r\n }\r\n hashCode() {\r\n let hash = 23;\r\n hash = hash * 31 + this.a;\r\n hash = hash * 31 + this.b;\r\n return hash;\r\n }\r\n /** Does this start completely before other? Disjoint */\r\n startsBeforeDisjoint(other) {\r\n return this.a < other.a && this.b < other.a;\r\n }\r\n /** Does this start at or before other? Nondisjoint */\r\n startsBeforeNonDisjoint(other) {\r\n return this.a <= other.a && this.b >= other.a;\r\n }\r\n /** Does this.a start after other.b? May or may not be disjoint */\r\n startsAfter(other) {\r\n return this.a > other.a;\r\n }\r\n /** Does this start completely after other? Disjoint */\r\n startsAfterDisjoint(other) {\r\n return this.a > other.b;\r\n }\r\n /** Does this start after other? NonDisjoint */\r\n startsAfterNonDisjoint(other) {\r\n return this.a > other.a && this.a <= other.b; // this.b>=other.b implied\r\n }\r\n /** Are both ranges disjoint? I.e., no overlap? */\r\n disjoint(other) {\r\n return this.startsBeforeDisjoint(other) || this.startsAfterDisjoint(other);\r\n }\r\n /** Are two intervals adjacent such as 0..41 and 42..42? */\r\n adjacent(other) {\r\n return this.a === other.b + 1 || this.b === other.a - 1;\r\n }\r\n properlyContains(other) {\r\n return other.a >= this.a && other.b <= this.b;\r\n }\r\n /** Return the interval computed from combining this and other */\r\n union(other) {\r\n return Interval.of(Math.min(this.a, other.a), Math.max(this.b, other.b));\r\n }\r\n /** Return the interval in common between this and o */\r\n intersection(other) {\r\n return Interval.of(Math.max(this.a, other.a), Math.min(this.b, other.b));\r\n }\r\n /** Return the interval with elements from {@code this} not in {@code other};\r\n * {@code other} must not be totally enclosed (properly contained)\r\n * within {@code this}, which would result in two disjoint intervals\r\n * instead of the single one returned by this method.\r\n */\r\n differenceNotProperlyContained(other) {\r\n let diff;\r\n if (other.startsBeforeNonDisjoint(this)) {\r\n // other.a to left of this.a (or same)\r\n diff = Interval.of(Math.max(this.a, other.b + 1), this.b);\r\n }\r\n else if (other.startsAfterNonDisjoint(this)) {\r\n // other.a to right of this.a\r\n diff = Interval.of(this.a, other.a - 1);\r\n }\r\n return diff;\r\n }\r\n toString() {\r\n return this.a + \"..\" + this.b;\r\n }\r\n}\r\nInterval._INVALID = new Interval(-1, -2);\r\nInterval.cache = new Array(INTERVAL_POOL_MAX_VALUE + 1);\r\n__decorate([\r\n Decorators_1.Override\r\n], Interval.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Interval.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Interval.prototype, \"toString\", null);\r\nexports.Interval = Interval;\r\n//# sourceMappingURL=Interval.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:35.3812636-07:00\r\nconst Array2DHashMap_1 = require(\"../misc/Array2DHashMap\");\r\nconst Array2DHashSet_1 = require(\"../misc/Array2DHashSet\");\r\nconst Arrays_1 = require(\"../misc/Arrays\");\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst PredictionContextCache_1 = require(\"./PredictionContextCache\");\r\nconst assert = require(\"assert\");\r\nconst INITIAL_HASH = 1;\r\nclass PredictionContext {\r\n constructor(cachedHashCode) {\r\n this.cachedHashCode = cachedHashCode;\r\n }\r\n static calculateEmptyHashCode() {\r\n let hash = MurmurHash_1.MurmurHash.initialize(INITIAL_HASH);\r\n hash = MurmurHash_1.MurmurHash.finish(hash, 0);\r\n return hash;\r\n }\r\n static calculateSingleHashCode(parent, returnState) {\r\n let hash = MurmurHash_1.MurmurHash.initialize(INITIAL_HASH);\r\n hash = MurmurHash_1.MurmurHash.update(hash, parent);\r\n hash = MurmurHash_1.MurmurHash.update(hash, returnState);\r\n hash = MurmurHash_1.MurmurHash.finish(hash, 2);\r\n return hash;\r\n }\r\n static calculateHashCode(parents, returnStates) {\r\n let hash = MurmurHash_1.MurmurHash.initialize(INITIAL_HASH);\r\n for (let parent of parents) {\r\n hash = MurmurHash_1.MurmurHash.update(hash, parent);\r\n }\r\n for (let returnState of returnStates) {\r\n hash = MurmurHash_1.MurmurHash.update(hash, returnState);\r\n }\r\n hash = MurmurHash_1.MurmurHash.finish(hash, 2 * parents.length);\r\n return hash;\r\n }\r\n static fromRuleContext(atn, outerContext, fullContext = true) {\r\n if (outerContext.isEmpty) {\r\n return fullContext ? PredictionContext.EMPTY_FULL : PredictionContext.EMPTY_LOCAL;\r\n }\r\n let parent;\r\n if (outerContext._parent) {\r\n parent = PredictionContext.fromRuleContext(atn, outerContext._parent, fullContext);\r\n }\r\n else {\r\n parent = fullContext ? PredictionContext.EMPTY_FULL : PredictionContext.EMPTY_LOCAL;\r\n }\r\n let state = atn.states[outerContext.invokingState];\r\n let transition = state.transition(0);\r\n return parent.getChild(transition.followState.stateNumber);\r\n }\r\n static addEmptyContext(context) {\r\n return context.addEmptyContext();\r\n }\r\n static removeEmptyContext(context) {\r\n return context.removeEmptyContext();\r\n }\r\n static join(context0, context1, contextCache = PredictionContextCache_1.PredictionContextCache.UNCACHED) {\r\n if (context0 == context1) {\r\n return context0;\r\n }\r\n if (context0.isEmpty) {\r\n return PredictionContext.isEmptyLocal(context0) ? context0 : PredictionContext.addEmptyContext(context1);\r\n }\r\n else if (context1.isEmpty) {\r\n return PredictionContext.isEmptyLocal(context1) ? context1 : PredictionContext.addEmptyContext(context0);\r\n }\r\n let context0size = context0.size;\r\n let context1size = context1.size;\r\n if (context0size === 1 && context1size === 1 && context0.getReturnState(0) === context1.getReturnState(0)) {\r\n let merged = contextCache.join(context0.getParent(0), context1.getParent(0));\r\n if (merged === context0.getParent(0)) {\r\n return context0;\r\n }\r\n else if (merged === context1.getParent(0)) {\r\n return context1;\r\n }\r\n else {\r\n return merged.getChild(context0.getReturnState(0));\r\n }\r\n }\r\n let count = 0;\r\n let parentsList = new Array(context0size + context1size);\r\n let returnStatesList = new Array(parentsList.length);\r\n let leftIndex = 0;\r\n let rightIndex = 0;\r\n let canReturnLeft = true;\r\n let canReturnRight = true;\r\n while (leftIndex < context0size && rightIndex < context1size) {\r\n if (context0.getReturnState(leftIndex) === context1.getReturnState(rightIndex)) {\r\n parentsList[count] = contextCache.join(context0.getParent(leftIndex), context1.getParent(rightIndex));\r\n returnStatesList[count] = context0.getReturnState(leftIndex);\r\n canReturnLeft = canReturnLeft && parentsList[count] === context0.getParent(leftIndex);\r\n canReturnRight = canReturnRight && parentsList[count] === context1.getParent(rightIndex);\r\n leftIndex++;\r\n rightIndex++;\r\n }\r\n else if (context0.getReturnState(leftIndex) < context1.getReturnState(rightIndex)) {\r\n parentsList[count] = context0.getParent(leftIndex);\r\n returnStatesList[count] = context0.getReturnState(leftIndex);\r\n canReturnRight = false;\r\n leftIndex++;\r\n }\r\n else {\r\n assert(context1.getReturnState(rightIndex) < context0.getReturnState(leftIndex));\r\n parentsList[count] = context1.getParent(rightIndex);\r\n returnStatesList[count] = context1.getReturnState(rightIndex);\r\n canReturnLeft = false;\r\n rightIndex++;\r\n }\r\n count++;\r\n }\r\n while (leftIndex < context0size) {\r\n parentsList[count] = context0.getParent(leftIndex);\r\n returnStatesList[count] = context0.getReturnState(leftIndex);\r\n leftIndex++;\r\n canReturnRight = false;\r\n count++;\r\n }\r\n while (rightIndex < context1size) {\r\n parentsList[count] = context1.getParent(rightIndex);\r\n returnStatesList[count] = context1.getReturnState(rightIndex);\r\n rightIndex++;\r\n canReturnLeft = false;\r\n count++;\r\n }\r\n if (canReturnLeft) {\r\n return context0;\r\n }\r\n else if (canReturnRight) {\r\n return context1;\r\n }\r\n if (count < parentsList.length) {\r\n parentsList = parentsList.slice(0, count);\r\n returnStatesList = returnStatesList.slice(0, count);\r\n }\r\n if (parentsList.length === 0) {\r\n // if one of them was EMPTY_LOCAL, it would be empty and handled at the beginning of the method\r\n return PredictionContext.EMPTY_FULL;\r\n }\r\n else if (parentsList.length === 1) {\r\n return new SingletonPredictionContext(parentsList[0], returnStatesList[0]);\r\n }\r\n else {\r\n return new ArrayPredictionContext(parentsList, returnStatesList);\r\n }\r\n }\r\n static isEmptyLocal(context) {\r\n return context === PredictionContext.EMPTY_LOCAL;\r\n }\r\n static getCachedContext(context, contextCache, visited) {\r\n if (context.isEmpty) {\r\n return context;\r\n }\r\n let existing = visited.get(context);\r\n if (existing) {\r\n return existing;\r\n }\r\n existing = contextCache.get(context);\r\n if (existing) {\r\n visited.put(context, existing);\r\n return existing;\r\n }\r\n let changed = false;\r\n let parents = new Array(context.size);\r\n for (let i = 0; i < parents.length; i++) {\r\n let parent = PredictionContext.getCachedContext(context.getParent(i), contextCache, visited);\r\n if (changed || parent !== context.getParent(i)) {\r\n if (!changed) {\r\n parents = new Array(context.size);\r\n for (let j = 0; j < context.size; j++) {\r\n parents[j] = context.getParent(j);\r\n }\r\n changed = true;\r\n }\r\n parents[i] = parent;\r\n }\r\n }\r\n if (!changed) {\r\n existing = contextCache.putIfAbsent(context, context);\r\n visited.put(context, existing != null ? existing : context);\r\n return context;\r\n }\r\n // We know parents.length>0 because context.isEmpty is checked at the beginning of the method.\r\n let updated;\r\n if (parents.length === 1) {\r\n updated = new SingletonPredictionContext(parents[0], context.getReturnState(0));\r\n }\r\n else {\r\n let returnStates = new Array(context.size);\r\n for (let i = 0; i < context.size; i++) {\r\n returnStates[i] = context.getReturnState(i);\r\n }\r\n updated = new ArrayPredictionContext(parents, returnStates, context.hashCode());\r\n }\r\n existing = contextCache.putIfAbsent(updated, updated);\r\n visited.put(updated, existing || updated);\r\n visited.put(context, existing || updated);\r\n return updated;\r\n }\r\n appendSingleContext(returnContext, contextCache) {\r\n return this.appendContext(PredictionContext.EMPTY_FULL.getChild(returnContext), contextCache);\r\n }\r\n getChild(returnState) {\r\n return new SingletonPredictionContext(this, returnState);\r\n }\r\n hashCode() {\r\n return this.cachedHashCode;\r\n }\r\n toStrings(recognizer, currentState, stop = PredictionContext.EMPTY_FULL) {\r\n let result = [];\r\n outer: for (let perm = 0;; perm++) {\r\n let offset = 0;\r\n let last = true;\r\n let p = this;\r\n let stateNumber = currentState;\r\n let localBuffer = \"\";\r\n localBuffer += \"[\";\r\n while (!p.isEmpty && p !== stop) {\r\n let index = 0;\r\n if (p.size > 0) {\r\n let bits = 1;\r\n while (((1 << bits) >>> 0) < p.size) {\r\n bits++;\r\n }\r\n let mask = ((1 << bits) >>> 0) - 1;\r\n index = (perm >> offset) & mask;\r\n last = last && index >= p.size - 1;\r\n if (index >= p.size) {\r\n continue outer;\r\n }\r\n offset += bits;\r\n }\r\n if (recognizer) {\r\n if (localBuffer.length > 1) {\r\n // first char is '[', if more than that this isn't the first rule\r\n localBuffer += ' ';\r\n }\r\n let atn = recognizer.atn;\r\n let s = atn.states[stateNumber];\r\n let ruleName = recognizer.ruleNames[s.ruleIndex];\r\n localBuffer += ruleName;\r\n }\r\n else if (p.getReturnState(index) !== PredictionContext.EMPTY_FULL_STATE_KEY) {\r\n if (!p.isEmpty) {\r\n if (localBuffer.length > 1) {\r\n // first char is '[', if more than that this isn't the first rule\r\n localBuffer += ' ';\r\n }\r\n localBuffer += p.getReturnState(index);\r\n }\r\n }\r\n stateNumber = p.getReturnState(index);\r\n p = p.getParent(index);\r\n }\r\n localBuffer += \"]\";\r\n result.push(localBuffer);\r\n if (last) {\r\n break;\r\n }\r\n }\r\n return result;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], PredictionContext.prototype, \"hashCode\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)\r\n], PredictionContext, \"join\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(2, Decorators_1.NotNull)\r\n], PredictionContext, \"getCachedContext\", null);\r\nexports.PredictionContext = PredictionContext;\r\nclass EmptyPredictionContext extends PredictionContext {\r\n constructor(fullContext) {\r\n super(PredictionContext.calculateEmptyHashCode());\r\n this.fullContext = fullContext;\r\n }\r\n get isFullContext() {\r\n return this.fullContext;\r\n }\r\n addEmptyContext() {\r\n return this;\r\n }\r\n removeEmptyContext() {\r\n throw \"Cannot remove the empty context from itself.\";\r\n }\r\n getParent(index) {\r\n throw \"index out of bounds\";\r\n }\r\n getReturnState(index) {\r\n throw \"index out of bounds\";\r\n }\r\n findReturnState(returnState) {\r\n return -1;\r\n }\r\n get size() {\r\n return 0;\r\n }\r\n appendSingleContext(returnContext, contextCache) {\r\n return contextCache.getChild(this, returnContext);\r\n }\r\n appendContext(suffix, contextCache) {\r\n return suffix;\r\n }\r\n get isEmpty() {\r\n return true;\r\n }\r\n get hasEmpty() {\r\n return true;\r\n }\r\n equals(o) {\r\n return this === o;\r\n }\r\n toStrings(recognizer, currentState, stop) {\r\n return [\"[]\"];\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], EmptyPredictionContext.prototype, \"addEmptyContext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], EmptyPredictionContext.prototype, \"removeEmptyContext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], EmptyPredictionContext.prototype, \"getParent\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], EmptyPredictionContext.prototype, \"getReturnState\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], EmptyPredictionContext.prototype, \"findReturnState\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], EmptyPredictionContext.prototype, \"size\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], EmptyPredictionContext.prototype, \"appendSingleContext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], EmptyPredictionContext.prototype, \"appendContext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], EmptyPredictionContext.prototype, \"isEmpty\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], EmptyPredictionContext.prototype, \"hasEmpty\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], EmptyPredictionContext.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], EmptyPredictionContext.prototype, \"toStrings\", null);\r\nlet ArrayPredictionContext = class ArrayPredictionContext extends PredictionContext {\r\n constructor(parents, returnStates, hashCode) {\r\n super(hashCode || PredictionContext.calculateHashCode(parents, returnStates));\r\n assert(parents.length === returnStates.length);\r\n assert(returnStates.length > 1 || returnStates[0] !== PredictionContext.EMPTY_FULL_STATE_KEY, \"Should be using PredictionContext.EMPTY instead.\");\r\n this.parents = parents;\r\n this.returnStates = returnStates;\r\n }\r\n getParent(index) {\r\n return this.parents[index];\r\n }\r\n getReturnState(index) {\r\n return this.returnStates[index];\r\n }\r\n findReturnState(returnState) {\r\n return Arrays_1.Arrays.binarySearch(this.returnStates, returnState);\r\n }\r\n get size() {\r\n return this.returnStates.length;\r\n }\r\n get isEmpty() {\r\n return false;\r\n }\r\n get hasEmpty() {\r\n return this.returnStates[this.returnStates.length - 1] === PredictionContext.EMPTY_FULL_STATE_KEY;\r\n }\r\n addEmptyContext() {\r\n if (this.hasEmpty) {\r\n return this;\r\n }\r\n let parents2 = this.parents.slice(0);\r\n let returnStates2 = this.returnStates.slice(0);\r\n parents2.push(PredictionContext.EMPTY_FULL);\r\n returnStates2.push(PredictionContext.EMPTY_FULL_STATE_KEY);\r\n return new ArrayPredictionContext(parents2, returnStates2);\r\n }\r\n removeEmptyContext() {\r\n if (!this.hasEmpty) {\r\n return this;\r\n }\r\n if (this.returnStates.length === 2) {\r\n return new SingletonPredictionContext(this.parents[0], this.returnStates[0]);\r\n }\r\n else {\r\n let parents2 = this.parents.slice(0, this.parents.length - 1);\r\n let returnStates2 = this.returnStates.slice(0, this.returnStates.length - 1);\r\n return new ArrayPredictionContext(parents2, returnStates2);\r\n }\r\n }\r\n appendContext(suffix, contextCache) {\r\n return ArrayPredictionContext.appendContextImpl(this, suffix, new PredictionContext.IdentityHashMap());\r\n }\r\n static appendContextImpl(context, suffix, visited) {\r\n if (suffix.isEmpty) {\r\n if (PredictionContext.isEmptyLocal(suffix)) {\r\n if (context.hasEmpty) {\r\n return PredictionContext.EMPTY_LOCAL;\r\n }\r\n throw \"what to do here?\";\r\n }\r\n return context;\r\n }\r\n if (suffix.size !== 1) {\r\n throw \"Appending a tree suffix is not yet supported.\";\r\n }\r\n let result = visited.get(context);\r\n if (!result) {\r\n if (context.isEmpty) {\r\n result = suffix;\r\n }\r\n else {\r\n let parentCount = context.size;\r\n if (context.hasEmpty) {\r\n parentCount--;\r\n }\r\n let updatedParents = new Array(parentCount);\r\n let updatedReturnStates = new Array(parentCount);\r\n for (let i = 0; i < parentCount; i++) {\r\n updatedReturnStates[i] = context.getReturnState(i);\r\n }\r\n for (let i = 0; i < parentCount; i++) {\r\n updatedParents[i] = ArrayPredictionContext.appendContextImpl(context.getParent(i), suffix, visited);\r\n }\r\n if (updatedParents.length === 1) {\r\n result = new SingletonPredictionContext(updatedParents[0], updatedReturnStates[0]);\r\n }\r\n else {\r\n assert(updatedParents.length > 1);\r\n result = new ArrayPredictionContext(updatedParents, updatedReturnStates);\r\n }\r\n if (context.hasEmpty) {\r\n result = PredictionContext.join(result, suffix);\r\n }\r\n }\r\n visited.put(context, result);\r\n }\r\n return result;\r\n }\r\n equals(o) {\r\n if (this === o) {\r\n return true;\r\n }\r\n else if (!(o instanceof ArrayPredictionContext)) {\r\n return false;\r\n }\r\n if (this.hashCode() !== o.hashCode()) {\r\n // can't be same if hash is different\r\n return false;\r\n }\r\n let other = o;\r\n return this.equalsImpl(other, new Array2DHashSet_1.Array2DHashSet());\r\n }\r\n equalsImpl(other, visited) {\r\n let selfWorkList = [];\r\n let otherWorkList = [];\r\n selfWorkList.push(this);\r\n otherWorkList.push(other);\r\n while (true) {\r\n let currentSelf = selfWorkList.pop();\r\n let currentOther = otherWorkList.pop();\r\n if (!currentSelf || !currentOther) {\r\n break;\r\n }\r\n let operands = new PredictionContextCache_1.PredictionContextCache.IdentityCommutativePredictionContextOperands(currentSelf, currentOther);\r\n if (!visited.add(operands)) {\r\n continue;\r\n }\r\n let selfSize = operands.x.size;\r\n if (selfSize === 0) {\r\n if (!operands.x.equals(operands.y)) {\r\n return false;\r\n }\r\n continue;\r\n }\r\n let otherSize = operands.y.size;\r\n if (selfSize !== otherSize) {\r\n return false;\r\n }\r\n for (let i = 0; i < selfSize; i++) {\r\n if (operands.x.getReturnState(i) !== operands.y.getReturnState(i)) {\r\n return false;\r\n }\r\n let selfParent = operands.x.getParent(i);\r\n let otherParent = operands.y.getParent(i);\r\n if (selfParent.hashCode() !== otherParent.hashCode()) {\r\n return false;\r\n }\r\n if (selfParent !== otherParent) {\r\n selfWorkList.push(selfParent);\r\n otherWorkList.push(otherParent);\r\n }\r\n }\r\n }\r\n return true;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ArrayPredictionContext.prototype, \"parents\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ArrayPredictionContext.prototype, \"returnStates\", void 0);\r\n__decorate([\r\n Decorators_1.Override\r\n], ArrayPredictionContext.prototype, \"getParent\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ArrayPredictionContext.prototype, \"getReturnState\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ArrayPredictionContext.prototype, \"findReturnState\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ArrayPredictionContext.prototype, \"size\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ArrayPredictionContext.prototype, \"isEmpty\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ArrayPredictionContext.prototype, \"hasEmpty\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ArrayPredictionContext.prototype, \"addEmptyContext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ArrayPredictionContext.prototype, \"removeEmptyContext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ArrayPredictionContext.prototype, \"appendContext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ArrayPredictionContext.prototype, \"equals\", null);\r\nArrayPredictionContext = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ArrayPredictionContext);\r\nlet SingletonPredictionContext = class SingletonPredictionContext extends PredictionContext {\r\n constructor(parent, returnState) {\r\n super(PredictionContext.calculateSingleHashCode(parent, returnState));\r\n // assert(returnState != PredictionContext.EMPTY_FULL_STATE_KEY && returnState != PredictionContext.EMPTY_LOCAL_STATE_KEY);\r\n this.parent = parent;\r\n this.returnState = returnState;\r\n }\r\n getParent(index) {\r\n // assert(index == 0);\r\n return this.parent;\r\n }\r\n getReturnState(index) {\r\n // assert(index == 0);\r\n return this.returnState;\r\n }\r\n findReturnState(returnState) {\r\n return this.returnState === returnState ? 0 : -1;\r\n }\r\n get size() {\r\n return 1;\r\n }\r\n get isEmpty() {\r\n return false;\r\n }\r\n get hasEmpty() {\r\n return false;\r\n }\r\n appendContext(suffix, contextCache) {\r\n return contextCache.getChild(this.parent.appendContext(suffix, contextCache), this.returnState);\r\n }\r\n addEmptyContext() {\r\n let parents = [this.parent, PredictionContext.EMPTY_FULL];\r\n let returnStates = [this.returnState, PredictionContext.EMPTY_FULL_STATE_KEY];\r\n return new ArrayPredictionContext(parents, returnStates);\r\n }\r\n removeEmptyContext() {\r\n return this;\r\n }\r\n equals(o) {\r\n if (o === this) {\r\n return true;\r\n }\r\n else if (!(o instanceof SingletonPredictionContext)) {\r\n return false;\r\n }\r\n let other = o;\r\n if (this.hashCode() !== other.hashCode()) {\r\n return false;\r\n }\r\n return this.returnState === other.returnState\r\n && this.parent.equals(other.parent);\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], SingletonPredictionContext.prototype, \"parent\", void 0);\r\n__decorate([\r\n Decorators_1.Override\r\n], SingletonPredictionContext.prototype, \"getParent\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], SingletonPredictionContext.prototype, \"getReturnState\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], SingletonPredictionContext.prototype, \"findReturnState\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], SingletonPredictionContext.prototype, \"size\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], SingletonPredictionContext.prototype, \"isEmpty\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], SingletonPredictionContext.prototype, \"hasEmpty\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], SingletonPredictionContext.prototype, \"appendContext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], SingletonPredictionContext.prototype, \"addEmptyContext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], SingletonPredictionContext.prototype, \"removeEmptyContext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], SingletonPredictionContext.prototype, \"equals\", null);\r\nSingletonPredictionContext = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], SingletonPredictionContext);\r\nexports.SingletonPredictionContext = SingletonPredictionContext;\r\n(function (PredictionContext) {\r\n PredictionContext.EMPTY_LOCAL = new EmptyPredictionContext(false);\r\n PredictionContext.EMPTY_FULL = new EmptyPredictionContext(true);\r\n PredictionContext.EMPTY_LOCAL_STATE_KEY = -((1 << 31) >>> 0);\r\n PredictionContext.EMPTY_FULL_STATE_KEY = ((1 << 31) >>> 0) - 1;\r\n class IdentityHashMap extends Array2DHashMap_1.Array2DHashMap {\r\n constructor() {\r\n super(IdentityEqualityComparator.INSTANCE);\r\n }\r\n }\r\n PredictionContext.IdentityHashMap = IdentityHashMap;\r\n class IdentityEqualityComparator {\r\n IdentityEqualityComparator() {\r\n }\r\n hashCode(obj) {\r\n return obj.hashCode();\r\n }\r\n equals(a, b) {\r\n return a === b;\r\n }\r\n }\r\n IdentityEqualityComparator.INSTANCE = new IdentityEqualityComparator();\r\n __decorate([\r\n Decorators_1.Override\r\n ], IdentityEqualityComparator.prototype, \"hashCode\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], IdentityEqualityComparator.prototype, \"equals\", null);\r\n PredictionContext.IdentityEqualityComparator = IdentityEqualityComparator;\r\n})(PredictionContext = exports.PredictionContext || (exports.PredictionContext = {}));\r\n//# sourceMappingURL=PredictionContext.js.map","module.exports = require(\"assert\");","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n * This default implementation of {@link EqualityComparator} uses object equality\r\n * for comparisons by calling {@link Object#hashCode} and {@link Object#equals}.\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass ObjectEqualityComparator {\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This implementation returns\r\n * {@code obj.}{@link Object#hashCode hashCode()}.</p>\r\n */\r\n hashCode(obj) {\r\n if (obj == null) {\r\n return 0;\r\n }\r\n return obj.hashCode();\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This implementation relies on object equality. If both objects are\r\n * {@code null}, this method returns {@code true}. Otherwise if only\r\n * {@code a} is {@code null}, this method returns {@code false}. Otherwise,\r\n * this method returns the result of\r\n * {@code a.}{@link Object#equals equals}{@code (b)}.</p>\r\n */\r\n equals(a, b) {\r\n if (a == null) {\r\n return b == null;\r\n }\r\n return a.equals(b);\r\n }\r\n}\r\nObjectEqualityComparator.INSTANCE = new ObjectEqualityComparator();\r\n__decorate([\r\n Decorators_1.Override\r\n], ObjectEqualityComparator.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ObjectEqualityComparator.prototype, \"equals\", null);\r\nexports.ObjectEqualityComparator = ObjectEqualityComparator;\r\n//# sourceMappingURL=ObjectEqualityComparator.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:25.1063510-07:00\r\nconst Array2DHashMap_1 = require(\"../misc/Array2DHashMap\");\r\nconst DFA_1 = require(\"../dfa/DFA\");\r\nconst IntervalSet_1 = require(\"../misc/IntervalSet\");\r\nconst InvalidState_1 = require(\"./InvalidState\");\r\nconst LL1Analyzer_1 = require(\"./LL1Analyzer\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst ObjectEqualityComparator_1 = require(\"../misc/ObjectEqualityComparator\");\r\nconst PredictionContext_1 = require(\"./PredictionContext\");\r\nconst Token_1 = require(\"../Token\");\r\nconst assert = require(\"assert\");\r\n/** */\r\nlet ATN = class ATN {\r\n /** Used for runtime deserialization of ATNs from strings */\r\n constructor(grammarType, maxTokenType) {\r\n this.states = [];\r\n /** Each subrule/rule is a decision point and we must track them so we\r\n * can go back later and build DFA predictors for them. This includes\r\n * all the rules, subrules, optional blocks, ()+, ()* etc...\r\n */\r\n this.decisionToState = [];\r\n this.modeNameToStartState = new Map();\r\n this.modeToStartState = [];\r\n this.contextCache = new Array2DHashMap_1.Array2DHashMap(ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE);\r\n this.decisionToDFA = [];\r\n this.modeToDFA = [];\r\n this.LL1Table = new Map();\r\n this.grammarType = grammarType;\r\n this.maxTokenType = maxTokenType;\r\n }\r\n clearDFA() {\r\n this.decisionToDFA = new Array(this.decisionToState.length);\r\n for (let i = 0; i < this.decisionToDFA.length; i++) {\r\n this.decisionToDFA[i] = new DFA_1.DFA(this.decisionToState[i], i);\r\n }\r\n this.modeToDFA = new Array(this.modeToStartState.length);\r\n for (let i = 0; i < this.modeToDFA.length; i++) {\r\n this.modeToDFA[i] = new DFA_1.DFA(this.modeToStartState[i]);\r\n }\r\n this.contextCache.clear();\r\n this.LL1Table.clear();\r\n }\r\n get contextCacheSize() {\r\n return this.contextCache.size;\r\n }\r\n getCachedContext(context) {\r\n return PredictionContext_1.PredictionContext.getCachedContext(context, this.contextCache, new PredictionContext_1.PredictionContext.IdentityHashMap());\r\n }\r\n getDecisionToDFA() {\r\n assert(this.decisionToDFA != null && this.decisionToDFA.length === this.decisionToState.length);\r\n return this.decisionToDFA;\r\n }\r\n nextTokens(s, ctx) {\r\n if (ctx) {\r\n let anal = new LL1Analyzer_1.LL1Analyzer(this);\r\n let next = anal.LOOK(s, ctx);\r\n return next;\r\n }\r\n else {\r\n if (s.nextTokenWithinRule) {\r\n return s.nextTokenWithinRule;\r\n }\r\n s.nextTokenWithinRule = this.nextTokens(s, PredictionContext_1.PredictionContext.EMPTY_LOCAL);\r\n s.nextTokenWithinRule.setReadonly(true);\r\n return s.nextTokenWithinRule;\r\n }\r\n }\r\n addState(state) {\r\n state.atn = this;\r\n state.stateNumber = this.states.length;\r\n this.states.push(state);\r\n }\r\n removeState(state) {\r\n // just replace the state, don't shift states in list\r\n let invalidState = new InvalidState_1.InvalidState();\r\n invalidState.atn = this;\r\n invalidState.stateNumber = state.stateNumber;\r\n this.states[state.stateNumber] = invalidState;\r\n }\r\n defineMode(name, s) {\r\n this.modeNameToStartState.set(name, s);\r\n this.modeToStartState.push(s);\r\n this.modeToDFA.push(new DFA_1.DFA(s));\r\n this.defineDecisionState(s);\r\n }\r\n defineDecisionState(s) {\r\n this.decisionToState.push(s);\r\n s.decision = this.decisionToState.length - 1;\r\n this.decisionToDFA.push(new DFA_1.DFA(s, s.decision));\r\n return s.decision;\r\n }\r\n getDecisionState(decision) {\r\n if (this.decisionToState.length > 0) {\r\n return this.decisionToState[decision];\r\n }\r\n return undefined;\r\n }\r\n get numberOfDecisions() {\r\n return this.decisionToState.length;\r\n }\r\n /**\r\n * Computes the set of input symbols which could follow ATN state number\r\n * {@code stateNumber} in the specified full {@code context}. This method\r\n * considers the complete parser context, but does not evaluate semantic\r\n * predicates (i.e. all predicates encountered during the calculation are\r\n * assumed true). If a path in the ATN exists from the starting state to the\r\n * {@link RuleStopState} of the outermost context without matching any\r\n * symbols, {@link Token#EOF} is added to the returned set.\r\n *\r\n * <p>If {@code context} is {@code null}, it is treated as\r\n * {@link ParserRuleContext#EMPTY}.</p>\r\n *\r\n * <p>Note that this does NOT give you the set of all tokens that could\r\n * appear at a given token position in the input phrase. In other words, it\r\n * does not answer:</p>\r\n *\r\n * <quote>\"Given a specific partial input phrase, return the set of all\r\n * tokens that can follow the last token in the input phrase.\"</quote>\r\n *\r\n * <p>The big difference is that with just the input, the parser could land\r\n * right in the middle of a lookahead decision. Getting all\r\n * <em>possible</em> tokens given a partial input stream is a separate\r\n * computation. See https://github.com/antlr/antlr4/issues/1428</p>\r\n *\r\n * <p>For this function, we are specifying an ATN state and call stack to\r\n * compute what token(s) can come next and specifically: outside of a\r\n * lookahead decision. That is what you want for error reporting and\r\n * recovery upon parse error.</p>\r\n *\r\n * @param stateNumber the ATN state number\r\n * @param context the full parse context\r\n * @return The set of potentially valid input symbols which could follow the\r\n * specified state in the specified context.\r\n * @ if the ATN does not contain a state with\r\n * number {@code stateNumber}\r\n */\r\n getExpectedTokens(stateNumber, context) {\r\n if (stateNumber < 0 || stateNumber >= this.states.length) {\r\n throw new RangeError(\"Invalid state number.\");\r\n }\r\n let ctx = context;\r\n let s = this.states[stateNumber];\r\n let following = this.nextTokens(s);\r\n if (!following.contains(Token_1.Token.EPSILON)) {\r\n return following;\r\n }\r\n let expected = new IntervalSet_1.IntervalSet();\r\n expected.addAll(following);\r\n expected.remove(Token_1.Token.EPSILON);\r\n while (ctx != null && ctx.invokingState >= 0 && following.contains(Token_1.Token.EPSILON)) {\r\n let invokingState = this.states[ctx.invokingState];\r\n let rt = invokingState.transition(0);\r\n following = this.nextTokens(rt.followState);\r\n expected.addAll(following);\r\n expected.remove(Token_1.Token.EPSILON);\r\n ctx = ctx._parent;\r\n }\r\n if (following.contains(Token_1.Token.EPSILON)) {\r\n expected.add(Token_1.Token.EOF);\r\n }\r\n return expected;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATN.prototype, \"states\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATN.prototype, \"decisionToState\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATN.prototype, \"modeNameToStartState\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATN.prototype, \"modeToStartState\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATN.prototype, \"decisionToDFA\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATN.prototype, \"modeToDFA\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATN.prototype, \"nextTokens\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ATN.prototype, \"removeState\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n], ATN.prototype, \"defineMode\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ATN.prototype, \"defineDecisionState\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATN.prototype, \"getExpectedTokens\", null);\r\nATN = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ATN);\r\nexports.ATN = ATN;\r\n(function (ATN) {\r\n ATN.INVALID_ALT_NUMBER = 0;\r\n})(ATN = exports.ATN || (exports.ATN = {}));\r\nexports.ATN = ATN;\r\n//# sourceMappingURL=ATN.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nfunction escapeWhitespace(s, escapeSpaces) {\r\n return escapeSpaces ? s.replace(/ /, '\\u00B7') : s\r\n .replace(/\\t/, \"\\\\t\")\r\n .replace(/\\n/, \"\\\\n\")\r\n .replace(/\\r/, \"\\\\r\");\r\n}\r\nexports.escapeWhitespace = escapeWhitespace;\r\n// Seriously: why isn't this built in to java? ugh!\r\nfunction join(collection, separator) {\r\n let buf = \"\";\r\n let first = true;\r\n for (let current of collection) {\r\n if (first) {\r\n first = false;\r\n }\r\n else {\r\n buf += separator;\r\n }\r\n buf += current;\r\n }\r\n return buf;\r\n}\r\nexports.join = join;\r\nfunction equals(x, y) {\r\n if (x === y) {\r\n return true;\r\n }\r\n if (x == null || y == null) {\r\n return false;\r\n }\r\n return x.equals(y);\r\n}\r\nexports.equals = equals;\r\n// export function numNonnull(data: any[]): number {\r\n// \tlet n: number = 0;\r\n// \tif ( data == null ) return n;\r\n// \tfor (let o of data) {\r\n// \t\tif ( o!=null ) n++;\r\n// \t}\r\n// \treturn n;\r\n// }\r\n// export function removeAllElements<T>(data: Collection<T>, value: T): void {\r\n// \tif ( data==null ) return;\r\n// \twhile ( data.contains(value) ) data.remove(value);\r\n// }\r\n// export function writeFile(@NotNull fileName: string, @NotNull content: string): void {\r\n// \twriteFile(fileName, content, null);\r\n// }\r\n// export function writeFile(@NotNull fileName: string, @NotNull content: string, @Nullable encoding: string): void {\r\n// \tlet f: File = new File(fileName);\r\n// \tlet fos: FileOutputStream = new FileOutputStream(f);\r\n// \tlet osw: OutputStreamWriter;\r\n// \tif (encoding != null) {\r\n// \t\tosw = new OutputStreamWriter(fos, encoding);\r\n// \t}\r\n// \telse {\r\n// \t\tosw = new OutputStreamWriter(fos);\r\n// \t}\r\n// \ttry {\r\n// \t\tosw.write(content);\r\n// \t}\r\n// \tfinally {\r\n// \t\tosw.close();\r\n// \t}\r\n// }\r\n// @NotNull\r\n// export function readFile(@NotNull fileName: string): char[] {\r\n// \treturn readFile(fileName, null);\r\n// }\r\n// @NotNull\r\n// export function readFile(@NotNull fileName: string, @Nullable encoding: string): char[] {\r\n// \tlet f: File = new File(fileName);\r\n// \tlet size: number = (int)f.length();\r\n// \tlet isr: InputStreamReader;\r\n// \tlet fis: FileInputStream = new FileInputStream(fileName);\r\n// \tif ( encoding!=null ) {\r\n// \t\tisr = new InputStreamReader(fis, encoding);\r\n// \t}\r\n// \telse {\r\n// \t\tisr = new InputStreamReader(fis);\r\n// \t}\r\n// \tlet data: char[] = null;\r\n// \ttry {\r\n// \t\tdata = new char[size];\r\n// \t\tlet n: number = isr.read(data);\r\n// \t\tif (n < data.length) {\r\n// \t\t\tdata = Arrays.copyOf(data, n);\r\n// \t\t}\r\n// \t}\r\n// \tfinally {\r\n// \t\tisr.close();\r\n// \t}\r\n// \treturn data;\r\n// }\r\n// export function removeAll<T>(@NotNull predicate: List<T> list,@NotNull Predicate<? super T>): void {\r\n// \tlet j: number = 0;\r\n// \tfor (let i = 0; i < list.size; i++) {\r\n// \t\tlet item: T = list.get(i);\r\n// \t\tif (!predicate.eval(item)) {\r\n// \t\t\tif (j != i) {\r\n// \t\t\t\tlist.set(j, item);\r\n// \t\t\t}\r\n// \t\t\tj++;\r\n// \t\t}\r\n// \t}\r\n// \tif (j < list.size) {\r\n// \t\tlist.subList(j, list.size).clear();\r\n// \t}\r\n// }\r\n// export function removeAll<T>(@NotNull predicate: Iterable<T> iterable,@NotNull Predicate<? super T>): void {\r\n// \tif (iterable instanceof List<?>) {\r\n// \t\tremoveAll((List<T>)iterable, predicate);\r\n// \t\treturn;\r\n// \t}\r\n// \tfor (Iterator<T> iterator = iterable.iterator(); iterator.hasNext(); ) {\r\n// \t\tlet item: T = iterator.next();\r\n// \t\tif (predicate.eval(item)) {\r\n// \t\t\titerator.remove();\r\n// \t\t}\r\n// \t}\r\n// }\r\n/** Convert array of strings to string→index map. Useful for\r\n * converting rulenames to name→ruleindex map.\r\n */\r\nfunction toMap(keys) {\r\n let m = new Map();\r\n for (let i = 0; i < keys.length; i++) {\r\n m.set(keys[i], i);\r\n }\r\n return m;\r\n}\r\nexports.toMap = toMap;\r\nfunction toCharArray(str) {\r\n let result = new Uint16Array(str.length);\r\n for (let i = 0; i < str.length; i++) {\r\n result[i] = str.charCodeAt(i);\r\n }\r\n return result;\r\n}\r\nexports.toCharArray = toCharArray;\r\n// export function toCharArray(data: IntegerList): char[] {\r\n// \tif ( data==null ) return null;\r\n// \tlet cdata: char[] = new char[data.size];\r\n// \tfor (let i=0; i<data.size; i++) {\r\n// \t\tcdata[i] = (char)data.get(i);\r\n// \t}\r\n// \treturn cdata;\r\n// }\r\n// /**\r\n// \t* @since 4.5\r\n// \t*/\r\n// @NotNull\r\n// export function toSet(@NotNull bits: BitSet): IntervalSet {\r\n// \tlet s: IntervalSet = new IntervalSet();\r\n// \tlet i: number = bits.nextSetBit(0);\r\n// \twhile ( i >= 0 ) {\r\n// \t\ts.add(i);\r\n// \t\ti = bits.nextSetBit(i+1);\r\n// \t}\r\n// \treturn s;\r\n// }\r\n//# sourceMappingURL=Utils.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:56.6285494-07:00\r\nconst ErrorNode_1 = require(\"./tree/ErrorNode\");\r\nconst Interval_1 = require(\"./misc/Interval\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst RuleContext_1 = require(\"./RuleContext\");\r\nconst TerminalNode_1 = require(\"./tree/TerminalNode\");\r\n/** A rule invocation record for parsing.\r\n *\r\n * Contains all of the information about the current rule not stored in the\r\n * RuleContext. It handles parse tree children list, Any ATN state\r\n * tracing, and the default values available for rule invocations:\r\n * start, stop, rule index, current alt number.\r\n *\r\n * Subclasses made for each rule and grammar track the parameters,\r\n * return values, locals, and labels specific to that rule. These\r\n * are the objects that are returned from rules.\r\n *\r\n * Note text is not an actual field of a rule return value; it is computed\r\n * from start and stop using the input stream's toString() method. I\r\n * could add a ctor to this so that we can pass in and store the input\r\n * stream, but I'm not sure we want to do that. It would seem to be undefined\r\n * to get the .text property anyway if the rule matches tokens from multiple\r\n * input streams.\r\n *\r\n * I do not use getters for fields of objects that are used simply to\r\n * group values such as this aggregate. The getters/setters are there to\r\n * satisfy the superclass interface.\r\n */\r\nclass ParserRuleContext extends RuleContext_1.RuleContext {\r\n constructor(parent, invokingStateNumber) {\r\n if (invokingStateNumber == null) {\r\n super();\r\n }\r\n else {\r\n super(parent, invokingStateNumber);\r\n }\r\n }\r\n static emptyContext() {\r\n return ParserRuleContext.EMPTY;\r\n }\r\n /**\r\n * COPY a ctx (I'm deliberately not using copy constructor) to avoid\r\n * confusion with creating node with parent. Does not copy children.\r\n *\r\n * This is used in the generated parser code to flip a generic XContext\r\n * node for rule X to a YContext for alt label Y. In that sense, it is not\r\n * really a generic copy function.\r\n *\r\n * If we do an error sync() at start of a rule, we might add error nodes\r\n * to the generic XContext so this function must copy those nodes to the\r\n * YContext as well else they are lost!\r\n */\r\n copyFrom(ctx) {\r\n this._parent = ctx._parent;\r\n this.invokingState = ctx.invokingState;\r\n this._start = ctx._start;\r\n this._stop = ctx._stop;\r\n // copy any error nodes to alt label node\r\n if (ctx.children) {\r\n this.children = [];\r\n // reset parent pointer for any error nodes\r\n for (let child of ctx.children) {\r\n if (child instanceof ErrorNode_1.ErrorNode) {\r\n this.children.push(child);\r\n child._parent = this;\r\n }\r\n }\r\n }\r\n }\r\n // Double dispatch methods for listeners\r\n enterRule(listener) { }\r\n exitRule(listener) { }\r\n addChild(t) {\r\n let result;\r\n if (t instanceof TerminalNode_1.TerminalNode) {\r\n }\r\n else if (t instanceof RuleContext_1.RuleContext) {\r\n }\r\n else {\r\n t = new TerminalNode_1.TerminalNode(t);\r\n t._parent = this;\r\n result = t;\r\n }\r\n if (!this.children) {\r\n this.children = [t];\r\n }\r\n else {\r\n this.children.push(t);\r\n }\r\n return result;\r\n }\r\n /** Used by enterOuterAlt to toss out a RuleContext previously added as\r\n * we entered a rule. If we have # label, we will need to remove\r\n * generic ruleContext object.\r\n */\r\n removeLastChild() {\r\n if (this.children) {\r\n this.children.pop();\r\n }\r\n }\r\n //\tpublic void trace(int s) {\r\n //\t\tif ( states==null ) states = new ArrayList<Integer>();\r\n //\t\tstates.add(s);\r\n //\t}\r\n addErrorNode(badToken) {\r\n let t = new ErrorNode_1.ErrorNode(badToken);\r\n this.addChild(t);\r\n t._parent = this;\r\n return t;\r\n }\r\n get parent() {\r\n let parent = super.parent;\r\n if (parent === undefined || parent instanceof ParserRuleContext) {\r\n return parent;\r\n }\r\n throw new TypeError(\"Invalid parent type for ParserRuleContext\");\r\n }\r\n // Note: in TypeScript, order or arguments reversed\r\n getChild(i, ctxType) {\r\n if (!this.children || i < 0 || i >= this.children.length) {\r\n throw new RangeError(\"index parameter must be between >= 0 and <= number of children.\");\r\n }\r\n if (ctxType == null) {\r\n return this.children[i];\r\n }\r\n let result = this.tryGetChild(i, ctxType);\r\n if (result === undefined) {\r\n throw new Error(\"The specified node does not exist\");\r\n }\r\n return result;\r\n }\r\n tryGetChild(i, ctxType) {\r\n if (!this.children || i < 0 || i >= this.children.length) {\r\n return undefined;\r\n }\r\n let j = -1; // what node with ctxType have we found?\r\n for (let o of this.children) {\r\n if (o instanceof ctxType) {\r\n j++;\r\n if (j === i) {\r\n return o;\r\n }\r\n }\r\n }\r\n return undefined;\r\n }\r\n getToken(ttype, i) {\r\n let result = this.tryGetToken(ttype, i);\r\n if (result === undefined) {\r\n throw new Error(\"The specified token does not exist\");\r\n }\r\n return result;\r\n }\r\n tryGetToken(ttype, i) {\r\n if (!this.children || i < 0 || i >= this.children.length) {\r\n return undefined;\r\n }\r\n let j = -1; // what token with ttype have we found?\r\n for (let o of this.children) {\r\n if (o instanceof TerminalNode_1.TerminalNode) {\r\n let symbol = o.symbol;\r\n if (symbol.type === ttype) {\r\n j++;\r\n if (j === i) {\r\n return o;\r\n }\r\n }\r\n }\r\n }\r\n return undefined;\r\n }\r\n getTokens(ttype) {\r\n let tokens = [];\r\n if (!this.children) {\r\n return tokens;\r\n }\r\n for (let o of this.children) {\r\n if (o instanceof TerminalNode_1.TerminalNode) {\r\n let symbol = o.symbol;\r\n if (symbol.type === ttype) {\r\n tokens.push(o);\r\n }\r\n }\r\n }\r\n return tokens;\r\n }\r\n get ruleContext() {\r\n return this;\r\n }\r\n // NOTE: argument order change from Java version\r\n getRuleContext(i, ctxType) {\r\n return this.getChild(i, ctxType);\r\n }\r\n tryGetRuleContext(i, ctxType) {\r\n return this.tryGetChild(i, ctxType);\r\n }\r\n getRuleContexts(ctxType) {\r\n let contexts = [];\r\n if (!this.children) {\r\n return contexts;\r\n }\r\n for (let o of this.children) {\r\n if (o instanceof ctxType) {\r\n contexts.push(o);\r\n }\r\n }\r\n return contexts;\r\n }\r\n get childCount() {\r\n return this.children ? this.children.length : 0;\r\n }\r\n get sourceInterval() {\r\n if (!this._start) {\r\n return Interval_1.Interval.INVALID;\r\n }\r\n if (!this._stop || this._stop.tokenIndex < this._start.tokenIndex) {\r\n return Interval_1.Interval.of(this._start.tokenIndex, this._start.tokenIndex - 1); // empty\r\n }\r\n return Interval_1.Interval.of(this._start.tokenIndex, this._stop.tokenIndex);\r\n }\r\n /**\r\n * Get the initial token in this context.\r\n * Note that the range from start to stop is inclusive, so for rules that do not consume anything\r\n * (for example, zero length or error productions) this token may exceed stop.\r\n */\r\n get start() { return this._start; }\r\n /**\r\n * Get the final token in this context.\r\n * Note that the range from start to stop is inclusive, so for rules that do not consume anything\r\n * (for example, zero length or error productions) this token may precede start.\r\n */\r\n get stop() { return this._stop; }\r\n /** Used for rule context info debugging during parse-time, not so much for ATN debugging */\r\n toInfoString(recognizer) {\r\n let rules = recognizer.getRuleInvocationStack(this).reverse();\r\n return \"ParserRuleContext\" + rules + \"{\" +\r\n \"start=\" + this._start +\r\n \", stop=\" + this._stop +\r\n '}';\r\n }\r\n}\r\nParserRuleContext.EMPTY = new ParserRuleContext();\r\n__decorate([\r\n Decorators_1.Override\r\n], ParserRuleContext.prototype, \"parent\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ParserRuleContext.prototype, \"childCount\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ParserRuleContext.prototype, \"sourceInterval\", null);\r\nexports.ParserRuleContext = ParserRuleContext;\r\n//# sourceMappingURL=ParserRuleContext.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nconst util = require(\"util\");\r\nconst MurmurHash_1 = require(\"./MurmurHash\");\r\n/**\r\n * Private empty array used to construct empty BitSets\r\n */\r\nconst EMPTY_DATA = new Uint16Array(0);\r\n/**\r\n * Gets the word index of the `UInt16` element in `BitSet.data` containing the bit with the specified index.\r\n */\r\nfunction getIndex(bitNumber) {\r\n return bitNumber >>> 4;\r\n}\r\n/**\r\n * Convert a word index into the bit index of the LSB of that word\r\n */\r\nfunction unIndex(n) {\r\n return n * 16;\r\n}\r\n/**\r\n * Get's the bit number of the least signficant bit set LSB which is set in a word non-zero word;\r\n * Bit numbers run from LSB to MSB starting with 0.\r\n */\r\nfunction findLSBSet(word) {\r\n let bit = 1;\r\n for (let i = 0; i < 16; i++) {\r\n if ((word & bit) !== 0)\r\n return i;\r\n bit = (bit << 1) >>> 0;\r\n }\r\n throw new RangeError(\"No specified bit found\");\r\n}\r\nfunction findMSBSet(word) {\r\n let bit = (1 << 15) >>> 0;\r\n for (let i = 15; i >= 0; i--) {\r\n if ((word & bit) !== 0)\r\n return i;\r\n bit = bit >>> 1;\r\n }\r\n throw new RangeError(\"No specified bit found\");\r\n}\r\n/**\r\n * Gets a 16-bit mask with bit numbers fromBit to toBit (inclusive) set.\r\n * Bit numbers run from LSB to MSB starting with 0.\r\n */\r\nfunction bitsFor(fromBit, toBit) {\r\n fromBit &= 0xF;\r\n toBit &= 0xF;\r\n if (fromBit === toBit)\r\n return (1 << fromBit) >>> 0;\r\n return ((0xFFFF >>> (15 - toBit)) ^ (0xFFFF >>> (16 - fromBit)));\r\n}\r\n/**\r\n * A lookup table for number of set bits in a 16-bit integer. This is used to quickly count the cardinality (number of unique elements) of a BitSet.\r\n */\r\nconst POP_CNT = new Uint8Array(65536);\r\nfor (let i = 0; i < 16; i++) {\r\n const stride = (1 << i) >>> 0;\r\n let index = 0;\r\n while (index < POP_CNT.length) {\r\n // skip the numbers where the bit isn't set\r\n index += stride;\r\n // increment the ones where the bit is set\r\n for (let j = 0; j < stride; j++) {\r\n POP_CNT[index]++;\r\n index++;\r\n }\r\n }\r\n}\r\nclass BitSet {\r\n /*\r\n ** constructor implementation\r\n */\r\n constructor(arg) {\r\n if (!arg) {\r\n // covering the case of unspecified and nbits===0\r\n this.data = EMPTY_DATA;\r\n }\r\n else if (typeof arg === \"number\") {\r\n if (arg < 0) {\r\n throw new RangeError(\"nbits cannot be negative\");\r\n }\r\n else {\r\n this.data = new Uint16Array(getIndex(arg - 1) + 1);\r\n }\r\n }\r\n else {\r\n if (arg instanceof BitSet) {\r\n this.data = arg.data.slice(0); // Clone the data\r\n }\r\n else {\r\n let max = -1;\r\n for (let v of arg) {\r\n if (max < v)\r\n max = v;\r\n }\r\n this.data = new Uint16Array(getIndex(max - 1) + 1);\r\n for (let v of arg) {\r\n this.set(v);\r\n }\r\n }\r\n }\r\n }\r\n /**\r\n * Performs a logical **AND** of this target bit set with the argument bit set. This bit set is modified so that\r\n * each bit in it has the value `true` if and only if it both initially had the value `true` and the corresponding\r\n * bit in the bit set argument also had the value `true`.\r\n */\r\n and(set) {\r\n const data = this.data;\r\n const other = set.data;\r\n const words = Math.min(data.length, other.length);\r\n let lastWord = -1; // Keep track of index of last non-zero word\r\n for (let i = 0; i < words; i++) {\r\n if ((data[i] &= other[i]) !== 0) {\r\n lastWord = i;\r\n ;\r\n }\r\n }\r\n if (lastWord === -1) {\r\n this.data = EMPTY_DATA;\r\n }\r\n if (lastWord < data.length - 1) {\r\n this.data = data.slice(0, lastWord + 1);\r\n }\r\n }\r\n /**\r\n * Clears all of the bits in this `BitSet` whose corresponding bit is set in the specified `BitSet`.\r\n */\r\n andNot(set) {\r\n const data = this.data;\r\n const other = set.data;\r\n const words = Math.min(data.length, other.length);\r\n let lastWord = -1; // Keep track of index of last non-zero word\r\n for (let i = 0; i < words; i++) {\r\n if ((data[i] &= (other[i] ^ 0xFFFF)) !== 0) {\r\n lastWord = i;\r\n ;\r\n }\r\n }\r\n if (lastWord === -1) {\r\n this.data = EMPTY_DATA;\r\n }\r\n if (lastWord < data.length - 1) {\r\n this.data = data.slice(0, lastWord + 1);\r\n }\r\n }\r\n /**\r\n * Returns the number of bits set to `true` in this `BitSet`.\r\n */\r\n cardinality() {\r\n if (this.isEmpty) {\r\n return 0;\r\n }\r\n const data = this.data;\r\n const length = data.length;\r\n let result = 0;\r\n for (let i = 0; i < length; i++) {\r\n result += POP_CNT[data[i]];\r\n }\r\n return result;\r\n }\r\n clear(fromIndex, toIndex) {\r\n if (fromIndex == null) {\r\n this.data.fill(0);\r\n }\r\n else if (toIndex == null) {\r\n this.set(fromIndex, false);\r\n }\r\n else {\r\n this.set(fromIndex, toIndex, false);\r\n }\r\n }\r\n flip(fromIndex, toIndex) {\r\n if (toIndex == null) {\r\n toIndex = fromIndex;\r\n }\r\n if (fromIndex < 0 || toIndex < fromIndex)\r\n throw new RangeError();\r\n let word = getIndex(fromIndex);\r\n const lastWord = getIndex(toIndex);\r\n if (word === lastWord) {\r\n this.data[word] ^= bitsFor(fromIndex, toIndex);\r\n }\r\n else {\r\n this.data[word++] ^= bitsFor(fromIndex, 15);\r\n while (word < lastWord) {\r\n this.data[word++] ^= 0xFFFF;\r\n }\r\n this.data[word++] ^= bitsFor(0, toIndex);\r\n }\r\n }\r\n get(fromIndex, toIndex) {\r\n if (toIndex === undefined) {\r\n return !!(this.data[getIndex(fromIndex)] & bitsFor(fromIndex, fromIndex));\r\n }\r\n else {\r\n // return a BitSet\r\n let result = new BitSet(toIndex + 1);\r\n for (let i = fromIndex; i <= toIndex; i++) {\r\n result.set(i, this.get(i));\r\n }\r\n return result;\r\n }\r\n }\r\n /**\r\n * Returns true if the specified `BitSet` has any bits set to `true` that are also set to `true` in this `BitSet`.\r\n *\r\n * @param set `BitSet` to intersect with\r\n */\r\n intersects(set) {\r\n let smallerLength = Math.min(this.length(), set.length());\r\n if (smallerLength === 0) {\r\n return false;\r\n }\r\n let bound = getIndex(smallerLength - 1);\r\n for (let i = 0; i <= bound; i++) {\r\n if ((this.data[i] & set.data[i]) !== 0) {\r\n return true;\r\n }\r\n }\r\n return false;\r\n }\r\n /**\r\n * Returns true if this `BitSet` contains no bits that are set to `true`.\r\n */\r\n get isEmpty() {\r\n return this.length() === 0;\r\n }\r\n /**\r\n * Returns the \"logical size\" of this `BitSet`: the index of the highest set bit in the `BitSet` plus one. Returns\r\n * zero if the `BitSet` contains no set bits.\r\n */\r\n length() {\r\n if (!this.data.length)\r\n return 0;\r\n return this.previousSetBit(unIndex(this.data.length) - 1) + 1;\r\n }\r\n /**\r\n * Returns the index of the first bit that is set to `false` that occurs on or after the specified starting index,\r\n * If no such bit exists then `-1` is returned.\r\n *\r\n * @param fromIndex the index to start checking from (inclusive)\r\n *\r\n * @throws RangeError if the specified index is negative\r\n */\r\n nextClearBit(fromIndex) {\r\n if (fromIndex < 0) {\r\n throw new RangeError(\"fromIndex cannot be negative\");\r\n }\r\n const data = this.data;\r\n const length = data.length;\r\n let word = getIndex(fromIndex);\r\n if (word > length)\r\n return -1;\r\n let ignore = 0xFFFF ^ bitsFor(fromIndex, 15);\r\n if ((data[word] | ignore) === 0xFFFF) {\r\n word++;\r\n ignore = 0;\r\n for (; word < length; word++) {\r\n if (data[word] !== 0xFFFF)\r\n break;\r\n }\r\n if (word === length)\r\n return -1; // Hit the end\r\n }\r\n return unIndex(word) + findLSBSet((data[word] | ignore) ^ 0xFFFF);\r\n }\r\n /**\r\n * Returns the index of the first bit that is set to `true` that occurs on or after the specified starting index.\r\n * If no such bit exists then `-1` is returned.\r\n *\r\n * To iterate over the `true` bits in a `BitSet`, use the following loop:\r\n *\r\n * ```\r\n * for (let i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i + 1)) {\r\n * // operate on index i here\r\n * }\r\n * ```\r\n *\r\n * @param fromIndex the index to start checking from (inclusive)\r\n *\r\n * @throws RangeError if the specified index is negative\r\n */\r\n nextSetBit(fromIndex) {\r\n if (fromIndex < 0) {\r\n throw new RangeError(\"fromIndex cannot be negative\");\r\n }\r\n const data = this.data;\r\n const length = data.length;\r\n let word = getIndex(fromIndex);\r\n if (word > length)\r\n return -1;\r\n let mask = bitsFor(fromIndex, 15);\r\n if ((data[word] & mask) === 0) {\r\n word++;\r\n mask = 0xFFFF;\r\n for (; word < length; word++) {\r\n if (data[word] !== 0)\r\n break;\r\n }\r\n if (word >= length)\r\n return -1;\r\n }\r\n return unIndex(word) + findLSBSet(data[word] & mask);\r\n }\r\n /**\r\n * Performs a logical **OR** of this bit set with the bit set argument. This bit set is modified so that a bit in it\r\n * has the value `true` if and only if it either already had the value `true` or the corresponding bit in the bit\r\n * set argument has the value `true`.\r\n */\r\n or(set) {\r\n const data = this.data;\r\n const other = set.data;\r\n const minWords = Math.min(data.length, other.length);\r\n const words = Math.max(data.length, other.length);\r\n const dest = data.length === words ? data : new Uint16Array(words);\r\n let lastWord = -1;\r\n // Or those words both sets have in common\r\n for (let i = 0; i < minWords; i++) {\r\n if ((dest[i] = data[i] | other[i]) !== 0)\r\n lastWord = i;\r\n }\r\n // Copy words from larger set (if there is one)\r\n const longer = data.length > other.length ? data : other;\r\n for (let i = minWords; i < words; i++) {\r\n if ((dest[i] = longer[i]) !== 0)\r\n lastWord = i;\r\n }\r\n if (lastWord === -1) {\r\n this.data = EMPTY_DATA;\r\n }\r\n else if (dest.length === lastWord + 1) {\r\n this.data = dest;\r\n }\r\n else {\r\n this.data = dest.slice(0, lastWord);\r\n }\r\n }\r\n /**\r\n * Returns the index of the nearest bit that is set to `false` that occurs on or before the specified starting\r\n * index. If no such bit exists, or if `-1` is given as the starting index, then `-1` is returned.\r\n *\r\n * @param fromIndex the index to start checking from (inclusive)\r\n *\r\n * @throws RangeError if the specified index is less than `-1`\r\n */\r\n previousClearBit(fromIndex) {\r\n if (fromIndex < 0) {\r\n throw new RangeError(\"fromIndex cannot be negative\");\r\n }\r\n const data = this.data;\r\n const length = data.length;\r\n let word = getIndex(fromIndex);\r\n if (word >= length)\r\n word = length - 1;\r\n let ignore = 0xFFFF ^ bitsFor(0, fromIndex);\r\n if ((data[word] | ignore) === 0xFFFF) {\r\n ignore = 0;\r\n word--;\r\n for (; word >= 0; word--) {\r\n if (data[word] !== 0xFFFF)\r\n break;\r\n }\r\n if (word < 0)\r\n return -1; // Hit the end\r\n }\r\n return unIndex(word) + findMSBSet((data[word] | ignore) ^ 0xFFFF);\r\n }\r\n /**\r\n * Returns the index of the nearest bit that is set to `true` that occurs on or before the specified starting index.\r\n * If no such bit exists, or if `-1` is given as the starting index, then `-1` is returned.\r\n *\r\n * To iterate over the `true` bits in a `BitSet`, use the following loop:\r\n *\r\n * ```\r\n * for (let i = bs.length(); (i = bs.previousSetBit(i-1)) >= 0; ) {\r\n * // operate on index i here\r\n * }\r\n * ```\r\n *\r\n * @param fromIndex the index to start checking from (inclusive)\r\n *\r\n * @throws RangeError if the specified index is less than `-1`\r\n */\r\n previousSetBit(fromIndex) {\r\n if (fromIndex < 0) {\r\n throw new RangeError(\"fromIndex cannot be negative\");\r\n }\r\n const data = this.data;\r\n const length = data.length;\r\n let word = getIndex(fromIndex);\r\n if (word >= length)\r\n word = length - 1;\r\n let mask = bitsFor(0, fromIndex);\r\n if ((data[word] & mask) === 0) {\r\n word--;\r\n mask = 0xFFFF;\r\n for (; word >= 0; word--) {\r\n if (data[word] !== 0)\r\n break;\r\n }\r\n if (word < 0)\r\n return -1;\r\n }\r\n return unIndex(word) + findMSBSet(data[word] & mask);\r\n }\r\n set(fromIndex, toIndex, value) {\r\n if (toIndex === undefined) {\r\n toIndex = fromIndex;\r\n value = true;\r\n }\r\n else if (typeof toIndex === 'boolean') {\r\n value = toIndex;\r\n toIndex = fromIndex;\r\n }\r\n if (value === undefined) {\r\n value = true;\r\n }\r\n if (fromIndex < 0 || fromIndex > toIndex) {\r\n throw new RangeError();\r\n }\r\n let word = getIndex(fromIndex);\r\n let lastWord = getIndex(toIndex);\r\n if (value && lastWord >= this.data.length) {\r\n // Grow array \"just enough\" for bits we need to set\r\n var temp = new Uint16Array(lastWord + 1);\r\n this.data.forEach((value, index) => temp[index] = value);\r\n this.data = temp;\r\n }\r\n else if (!value) {\r\n // But there is no need to grow array to clear bits.\r\n if (word >= this.data.length)\r\n return; // Early exit\r\n if (lastWord >= this.data.length) {\r\n // Adjust work to fit array\r\n lastWord = this.data.length - 1;\r\n toIndex = this.data.length * 16 - 1;\r\n }\r\n }\r\n if (word === lastWord) {\r\n this._setBits(word, value, bitsFor(fromIndex, toIndex));\r\n }\r\n else {\r\n this._setBits(word++, value, bitsFor(fromIndex, 15));\r\n while (word < lastWord) {\r\n this.data[word++] = value ? 0xFFFF : 0;\r\n }\r\n this._setBits(word, value, bitsFor(0, toIndex));\r\n }\r\n }\r\n _setBits(word, value, mask) {\r\n if (value) {\r\n this.data[word] |= mask;\r\n }\r\n else {\r\n this.data[word] &= 0xFFFF ^ mask;\r\n }\r\n }\r\n /**\r\n * Returns the number of bits of space actually in use by this `BitSet` to represent bit values. The maximum element\r\n * in the set is the size - 1st element.\r\n */\r\n get size() {\r\n return this.data.byteLength * 8;\r\n }\r\n /**\r\n * Returns a new byte array containing all the bits in this bit set.\r\n *\r\n * More precisely, if\r\n * `let bytes = s.toByteArray();`\r\n * then `bytes.length === (s.length()+7)/8` and `s.get(n) === ((bytes[n/8] & (1<<(n%8))) != 0)` for all\r\n * `n < 8 * bytes.length`.\r\n */\r\n // toByteArray(): Int8Array {\r\n // \tthrow \"NOT IMPLEMENTED\";\r\n // }\r\n /**\r\n * Returns a new integer array containing all the bits in this bit set.\r\n *\r\n * More precisely, if\r\n * `let integers = s.toIntegerArray();`\r\n * then `integers.length === (s.length()+31)/32` and `s.get(n) === ((integers[n/32] & (1<<(n%32))) != 0)` for all\r\n * `n < 32 * integers.length`.\r\n */\r\n // toIntegerArray(): Int32Array {\r\n // \tthrow \"NOT IMPLEMENTED\";\r\n // }\r\n hashCode() {\r\n return MurmurHash_1.MurmurHash.hashCode(this.data, 22);\r\n }\r\n /**\r\n * Compares this object against the specified object. The result is `true` if and only if the argument is not `null`\r\n * and is a `Bitset` object that has exactly the same set of bits set to `true` as this bit set. That is, for every\r\n * nonnegative index `k`,\r\n *\r\n * ((BitSet)obj).get(k) == this.get(k)\r\n *\r\n * must be true. The current sizes of the two bit sets are not compared.\r\n */\r\n equals(obj) {\r\n if (obj === this) {\r\n return true;\r\n }\r\n else if (!(obj instanceof BitSet)) {\r\n return false;\r\n }\r\n const len = this.length();\r\n if (len !== obj.length()) {\r\n return false;\r\n }\r\n if (len === 0) {\r\n return true;\r\n }\r\n let bound = getIndex(len - 1);\r\n for (let i = 0; i <= bound; i++) {\r\n if (this.data[i] !== obj.data[i]) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }\r\n /**\r\n * Returns a string representation of this bit set. For every index for which this `BitSet` contains a bit in the\r\n * set state, the decimal representation of that index is included in the result. Such indices are listed in order\r\n * from lowest to highest, separated by \", \" (a comma and a space) and surrounded by braces, resulting in the usual\r\n * mathematical notation for a set of integers.\r\n *\r\n * Example:\r\n *\r\n * BitSet drPepper = new BitSet();\r\n *\r\n * Now `drPepper.toString()` returns `\"{}\"`.\r\n *\r\n * drPepper.set(2);\r\n *\r\n * Now `drPepper.toString()` returns `\"{2}\"`.\r\n *\r\n * drPepper.set(4);\r\n * drPepper.set(10);\r\n *\r\n * Now `drPepper.toString()` returns `\"{2, 4, 10}\"`.\r\n */\r\n toString() {\r\n let result = \"{\";\r\n let first = true;\r\n for (let i = this.nextSetBit(0); i >= 0; i = this.nextSetBit(i + 1)) {\r\n if (first) {\r\n first = false;\r\n }\r\n else {\r\n result += \", \";\r\n }\r\n result += i;\r\n }\r\n result += \"}\";\r\n return result;\r\n }\r\n // static valueOf(bytes: Int8Array): BitSet;\r\n // static valueOf(buffer: ArrayBuffer): BitSet;\r\n // static valueOf(integers: Int32Array): BitSet;\r\n // static valueOf(data: Int8Array | Int32Array | ArrayBuffer): BitSet {\r\n // \tthrow \"NOT IMPLEMENTED\";\r\n // }\r\n /**\r\n * Performs a logical **XOR** of this bit set with the bit set argument. This bit set is modified so that a bit in\r\n * it has the value `true` if and only if one of the following statements holds:\r\n *\r\n * * The bit initially has the value `true`, and the corresponding bit in the argument has the value `false`.\r\n * * The bit initially has the value `false`, and the corresponding bit in the argument has the value `true`.\r\n */\r\n xor(set) {\r\n const data = this.data;\r\n const other = set.data;\r\n const minWords = Math.min(data.length, other.length);\r\n const words = Math.max(data.length, other.length);\r\n const dest = data.length === words ? data : new Uint16Array(words);\r\n let lastWord = -1;\r\n // Xor those words both sets have in common\r\n for (let i = 0; i < minWords; i++) {\r\n if ((dest[i] = data[i] ^ other[i]) !== 0)\r\n lastWord = i;\r\n }\r\n // Copy words from larger set (if there is one)\r\n const longer = data.length > other.length ? data : other;\r\n for (let i = minWords; i < words; i++) {\r\n if ((dest[i] = longer[i]) !== 0)\r\n lastWord = i;\r\n }\r\n if (lastWord === -1) {\r\n this.data = EMPTY_DATA;\r\n }\r\n else if (dest.length === lastWord + 1) {\r\n this.data = dest;\r\n }\r\n else {\r\n this.data = dest.slice(0, lastWord + 1);\r\n }\r\n }\r\n clone() {\r\n return new BitSet(this);\r\n }\r\n [Symbol.iterator]() {\r\n return new BitSetIterator(this.data);\r\n }\r\n // Overrides formatting for nodejs assert etc.\r\n [util.inspect.custom]() {\r\n return \"BitSet \" + this.toString();\r\n }\r\n}\r\nexports.BitSet = BitSet;\r\nclass BitSetIterator {\r\n constructor(data) {\r\n this.data = data;\r\n this.index = 0;\r\n this.mask = 0xFFFF;\r\n }\r\n next() {\r\n while (this.index < this.data.length) {\r\n const bits = this.data[this.index] & this.mask;\r\n ;\r\n if (bits !== 0) {\r\n const bitNumber = unIndex(this.index) + findLSBSet(bits);\r\n this.mask = bitsFor(bitNumber + 1, 15);\r\n return { done: false, value: bitNumber };\r\n }\r\n this.index++;\r\n this.mask = 0xFFFF;\r\n }\r\n return { done: true, value: -1 };\r\n }\r\n [Symbol.iterator]() { return this; }\r\n}\r\n//# sourceMappingURL=BitSet.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst INITIAL_NUM_TRANSITIONS = 4;\r\n/**\r\n * The following images show the relation of states and\r\n * {@link ATNState#transitions} for various grammar constructs.\r\n *\r\n * <ul>\r\n *\r\n * <li>Solid edges marked with an ε indicate a required\r\n * {@link EpsilonTransition}.</li>\r\n *\r\n * <li>Dashed edges indicate locations where any transition derived from\r\n * {@link Transition} might appear.</li>\r\n *\r\n * <li>Dashed nodes are place holders for either a sequence of linked\r\n * {@link BasicState} states or the inclusion of a block representing a nested\r\n * construct in one of the forms below.</li>\r\n *\r\n * <li>Nodes showing multiple outgoing alternatives with a {@code ...} support\r\n * any number of alternatives (one or more). Nodes without the {@code ...} only\r\n * support the exact number of alternatives shown in the diagram.</li>\r\n *\r\n * </ul>\r\n *\r\n * <h2>Basic Blocks</h2>\r\n *\r\n * <h3>Rule</h3>\r\n *\r\n * <embed src=\"images/Rule.svg\" type=\"image/svg+xml\"/>\r\n *\r\n * <h3>Block of 1 or more alternatives</h3>\r\n *\r\n * <embed src=\"images/Block.svg\" type=\"image/svg+xml\"/>\r\n *\r\n * <h2>Greedy Loops</h2>\r\n *\r\n * <h3>Greedy Closure: {@code (...)*}</h3>\r\n *\r\n * <embed src=\"images/ClosureGreedy.svg\" type=\"image/svg+xml\"/>\r\n *\r\n * <h3>Greedy Positive Closure: {@code (...)+}</h3>\r\n *\r\n * <embed src=\"images/PositiveClosureGreedy.svg\" type=\"image/svg+xml\"/>\r\n *\r\n * <h3>Greedy Optional: {@code (...)?}</h3>\r\n *\r\n * <embed src=\"images/OptionalGreedy.svg\" type=\"image/svg+xml\"/>\r\n *\r\n * <h2>Non-Greedy Loops</h2>\r\n *\r\n * <h3>Non-Greedy Closure: {@code (...)*?}</h3>\r\n *\r\n * <embed src=\"images/ClosureNonGreedy.svg\" type=\"image/svg+xml\"/>\r\n *\r\n * <h3>Non-Greedy Positive Closure: {@code (...)+?}</h3>\r\n *\r\n * <embed src=\"images/PositiveClosureNonGreedy.svg\" type=\"image/svg+xml\"/>\r\n *\r\n * <h3>Non-Greedy Optional: {@code (...)??}</h3>\r\n *\r\n * <embed src=\"images/OptionalNonGreedy.svg\" type=\"image/svg+xml\"/>\r\n */\r\nclass ATNState {\r\n constructor() {\r\n this.stateNumber = ATNState.INVALID_STATE_NUMBER;\r\n this.ruleIndex = 0; // at runtime, we don't have Rule objects\r\n this.epsilonOnlyTransitions = false;\r\n /** Track the transitions emanating from this ATN state. */\r\n this.transitions = [];\r\n this.optimizedTransitions = this.transitions;\r\n }\r\n /**\r\n * Gets the state number.\r\n *\r\n * @return the state number\r\n */\r\n getStateNumber() {\r\n return this.stateNumber;\r\n }\r\n /**\r\n * For all states except {@link RuleStopState}, this returns the state\r\n * number. Returns -1 for stop states.\r\n *\r\n * @return -1 for {@link RuleStopState}, otherwise the state number\r\n */\r\n get nonStopStateNumber() {\r\n return this.getStateNumber();\r\n }\r\n hashCode() {\r\n return this.stateNumber;\r\n }\r\n equals(o) {\r\n // are these states same object?\r\n if (o instanceof ATNState) {\r\n return this.stateNumber === o.stateNumber;\r\n }\r\n return false;\r\n }\r\n get isNonGreedyExitState() {\r\n return false;\r\n }\r\n toString() {\r\n return String(this.stateNumber);\r\n }\r\n getTransitions() {\r\n return this.transitions.slice(0);\r\n }\r\n get numberOfTransitions() {\r\n return this.transitions.length;\r\n }\r\n addTransition(e, index) {\r\n if (this.transitions.length === 0) {\r\n this.epsilonOnlyTransitions = e.isEpsilon;\r\n }\r\n else if (this.epsilonOnlyTransitions !== e.isEpsilon) {\r\n this.epsilonOnlyTransitions = false;\r\n throw new Error(\"ATN state \" + this.stateNumber + \" has both epsilon and non-epsilon transitions.\");\r\n }\r\n this.transitions.splice(index !== undefined ? index : this.transitions.length, 0, e);\r\n }\r\n transition(i) {\r\n return this.transitions[i];\r\n }\r\n setTransition(i, e) {\r\n this.transitions[i] = e;\r\n }\r\n removeTransition(index) {\r\n return this.transitions.splice(index, 1)[0];\r\n }\r\n get onlyHasEpsilonTransitions() {\r\n return this.epsilonOnlyTransitions;\r\n }\r\n setRuleIndex(ruleIndex) {\r\n this.ruleIndex = ruleIndex;\r\n }\r\n get isOptimized() {\r\n return this.optimizedTransitions !== this.transitions;\r\n }\r\n get numberOfOptimizedTransitions() {\r\n return this.optimizedTransitions.length;\r\n }\r\n getOptimizedTransition(i) {\r\n return this.optimizedTransitions[i];\r\n }\r\n addOptimizedTransition(e) {\r\n if (!this.isOptimized) {\r\n this.optimizedTransitions = new Array();\r\n }\r\n this.optimizedTransitions.push(e);\r\n }\r\n setOptimizedTransition(i, e) {\r\n if (!this.isOptimized) {\r\n throw new Error(\"This ATNState is not optimized.\");\r\n }\r\n this.optimizedTransitions[i] = e;\r\n }\r\n removeOptimizedTransition(i) {\r\n if (!this.isOptimized) {\r\n throw new Error(\"This ATNState is not optimized.\");\r\n }\r\n this.optimizedTransitions.splice(i, 1);\r\n }\r\n}\r\nATNState.serializationNames = [\r\n \"INVALID\",\r\n \"BASIC\",\r\n \"RULE_START\",\r\n \"BLOCK_START\",\r\n \"PLUS_BLOCK_START\",\r\n \"STAR_BLOCK_START\",\r\n \"TOKEN_START\",\r\n \"RULE_STOP\",\r\n \"BLOCK_END\",\r\n \"STAR_LOOP_BACK\",\r\n \"STAR_LOOP_ENTRY\",\r\n \"PLUS_LOOP_BACK\",\r\n \"LOOP_END\"\r\n];\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNState.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNState.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNState.prototype, \"toString\", null);\r\nexports.ATNState = ATNState;\r\n(function (ATNState) {\r\n ATNState.INVALID_STATE_NUMBER = -1;\r\n})(ATNState = exports.ATNState || (exports.ATNState = {}));\r\n//# sourceMappingURL=ATNState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\n/**\r\n * This adapter function allows Collection<T> arguments to be used in JavaScript for...of loops\r\n */\r\nfunction asIterable(collection) {\r\n if (collection[Symbol.iterator])\r\n return collection;\r\n return new IterableAdapter(collection);\r\n}\r\nexports.asIterable = asIterable;\r\n// implementation detail of above...\r\nclass IterableAdapter {\r\n constructor(collection) {\r\n this.collection = collection;\r\n }\r\n [Symbol.iterator]() { this._iterator = this.collection.iterator(); return this; }\r\n next() {\r\n if (!this._iterator.hasNext()) {\r\n // A bit of a hack needed here, tracking under https://github.com/Microsoft/TypeScript/issues/11375\r\n return { done: true, value: undefined };\r\n }\r\n return { done: false, value: this._iterator.next() };\r\n }\r\n}\r\n//# sourceMappingURL=Stubs.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-03T02:09:41.7434086-07:00\r\nconst assert = require(\"assert\");\r\nconst DefaultEqualityComparator_1 = require(\"./DefaultEqualityComparator\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst Stubs_1 = require(\"./Stubs\");\r\nconst MurmurHash_1 = require(\"./MurmurHash\");\r\n/** {@link Set} implementation with closed hashing (open addressing). */\r\n// NOTE: JavaScript's Set interface has on significant different diffrence from Java's:\r\n// \t\t e.g. the return type of add() differs!\r\n// For this reason I've commented tweaked the implements clause\r\nconst INITAL_CAPACITY = 16; // must be power of 2\r\nconst INITAL_BUCKET_CAPACITY = 8;\r\nconst LOAD_FACTOR = 0.75;\r\nclass Array2DHashSet {\r\n constructor(comparatorOrSet, initialCapacity = INITAL_CAPACITY, initialBucketCapacity = INITAL_BUCKET_CAPACITY) {\r\n /** How many elements in set */\r\n this.n = 0;\r\n this.threshold = Math.floor(INITAL_CAPACITY * LOAD_FACTOR); // when to expand\r\n this.initialBucketCapacity = INITAL_BUCKET_CAPACITY;\r\n if (comparatorOrSet instanceof Array2DHashSet) {\r\n this.comparator = comparatorOrSet.comparator;\r\n this.buckets = comparatorOrSet.buckets.slice(0);\r\n for (let i = 0; i < this.buckets.length; i++) {\r\n if (this.buckets[i]) {\r\n this.buckets[i] = this.buckets[i].slice(0);\r\n }\r\n }\r\n this.n = comparatorOrSet.n;\r\n this.threshold = comparatorOrSet.threshold;\r\n this.initialBucketCapacity = comparatorOrSet.initialBucketCapacity;\r\n }\r\n else {\r\n this.comparator = comparatorOrSet || DefaultEqualityComparator_1.DefaultEqualityComparator.INSTANCE;\r\n this.buckets = this.createBuckets(initialCapacity);\r\n this.initialBucketCapacity = initialBucketCapacity;\r\n }\r\n }\r\n /**\r\n * Add {@code o} to set if not there; return existing value if already\r\n * there. This method performs the same operation as {@link #add} aside from\r\n * the return value.\r\n */\r\n getOrAdd(o) {\r\n if (this.n > this.threshold)\r\n this.expand();\r\n return this.getOrAddImpl(o);\r\n }\r\n getOrAddImpl(o) {\r\n let b = this.getBucket(o);\r\n let bucket = this.buckets[b];\r\n // NEW BUCKET\r\n if (!bucket) {\r\n bucket = this.createBucket(this.initialBucketCapacity);\r\n bucket[0] = o;\r\n this.buckets[b] = bucket;\r\n this.n++;\r\n return o;\r\n }\r\n // LOOK FOR IT IN BUCKET\r\n for (let i = 0; i < bucket.length; i++) {\r\n let existing = bucket[i];\r\n if (!existing) {\r\n // empty slot; not there, add.\r\n bucket[i] = o;\r\n this.n++;\r\n return o;\r\n }\r\n if (this.comparator.equals(existing, o))\r\n return existing; // found existing, quit\r\n }\r\n // FULL BUCKET, expand and add to end\r\n let oldLength = bucket.length;\r\n bucket.length *= 2;\r\n bucket[oldLength] = o; // add to end\r\n this.n++;\r\n return o;\r\n }\r\n get(o) {\r\n if (o == null)\r\n return o;\r\n let b = this.getBucket(o);\r\n let bucket = this.buckets[b];\r\n if (!bucket) {\r\n // no bucket\r\n return undefined;\r\n }\r\n for (let e of bucket) {\r\n if (!e) {\r\n // empty slot; not there\r\n return undefined;\r\n }\r\n if (this.comparator.equals(e, o))\r\n return e;\r\n }\r\n return undefined;\r\n }\r\n getBucket(o) {\r\n let hash = this.comparator.hashCode(o);\r\n let b = hash & (this.buckets.length - 1); // assumes len is power of 2\r\n return b;\r\n }\r\n hashCode() {\r\n let hash = MurmurHash_1.MurmurHash.initialize();\r\n for (let bucket of this.buckets) {\r\n if (bucket == null)\r\n continue;\r\n for (let o of bucket) {\r\n if (o == null)\r\n break;\r\n hash = MurmurHash_1.MurmurHash.update(hash, this.comparator.hashCode(o));\r\n }\r\n }\r\n hash = MurmurHash_1.MurmurHash.finish(hash, this.size);\r\n return hash;\r\n }\r\n equals(o) {\r\n if (o === this)\r\n return true;\r\n if (!(o instanceof Array2DHashSet))\r\n return false;\r\n if (o.size !== this.size)\r\n return false;\r\n let same = this.containsAll(o);\r\n return same;\r\n }\r\n expand() {\r\n let old = this.buckets;\r\n let newCapacity = this.buckets.length * 2;\r\n let newTable = this.createBuckets(newCapacity);\r\n let newBucketLengths = new Uint32Array(newTable.length);\r\n this.buckets = newTable;\r\n this.threshold = Math.floor(newCapacity * LOAD_FACTOR);\r\n //\t\tSystem.out.println(\"new size=\"+newCapacity+\", thres=\"+threshold);\r\n // rehash all existing entries\r\n let oldSize = this.size;\r\n for (let bucket of old) {\r\n if (bucket == null) {\r\n continue;\r\n }\r\n for (let o of bucket) {\r\n if (o == null) {\r\n break;\r\n }\r\n let b = this.getBucket(o);\r\n let bucketLength = newBucketLengths[b];\r\n let newBucket;\r\n if (bucketLength === 0) {\r\n // new bucket\r\n newBucket = this.createBucket(this.initialBucketCapacity);\r\n newTable[b] = newBucket;\r\n }\r\n else {\r\n newBucket = newTable[b];\r\n if (bucketLength === newBucket.length) {\r\n // expand\r\n newBucket.length *= 2;\r\n }\r\n }\r\n newBucket[bucketLength] = o;\r\n newBucketLengths[b]++;\r\n }\r\n }\r\n assert(this.n === oldSize);\r\n }\r\n add(t) {\r\n let existing = this.getOrAdd(t);\r\n return existing === t;\r\n }\r\n get size() {\r\n return this.n;\r\n }\r\n get isEmpty() {\r\n return this.n === 0;\r\n }\r\n contains(o) {\r\n return this.containsFast(this.asElementType(o));\r\n }\r\n containsFast(obj) {\r\n if (obj == null) {\r\n return false;\r\n }\r\n return this.get(obj) != null;\r\n }\r\n iterator() {\r\n return new SetIterator(this.toArray(), this);\r\n }\r\n toArray(a) {\r\n // Check if the array argument was provided\r\n if (!a || a.length < this.size) {\r\n a = new Array(this.size);\r\n }\r\n // Copy elements from the nested arrays into the destination array\r\n let i = 0; // Position within destination array\r\n for (let bucket of this.buckets) {\r\n if (bucket == null) {\r\n continue;\r\n }\r\n for (let o of bucket) {\r\n if (o == null) {\r\n break;\r\n }\r\n a[i++] = o;\r\n }\r\n }\r\n return a;\r\n }\r\n remove(o) {\r\n return this.removeFast(this.asElementType(o));\r\n }\r\n removeFast(obj) {\r\n if (obj == null) {\r\n return false;\r\n }\r\n let b = this.getBucket(obj);\r\n let bucket = this.buckets[b];\r\n if (!bucket) {\r\n // no bucket\r\n return false;\r\n }\r\n for (let i = 0; i < bucket.length; i++) {\r\n let e = bucket[i];\r\n if (!e) {\r\n // empty slot; not there\r\n return false;\r\n }\r\n if (this.comparator.equals(e, obj)) {\r\n // shift all elements to the right down one\r\n bucket.copyWithin(i, i + 1);\r\n bucket[bucket.length - 1] = undefined;\r\n this.n--;\r\n return true;\r\n }\r\n }\r\n return false;\r\n }\r\n containsAll(collection) {\r\n if (collection instanceof Array2DHashSet) {\r\n let s = collection;\r\n for (let bucket of s.buckets) {\r\n if (bucket == null)\r\n continue;\r\n for (let o of bucket) {\r\n if (o == null)\r\n break;\r\n if (!this.containsFast(this.asElementType(o)))\r\n return false;\r\n }\r\n }\r\n }\r\n else {\r\n for (let o of Stubs_1.asIterable(collection)) {\r\n if (!this.containsFast(this.asElementType(o)))\r\n return false;\r\n }\r\n }\r\n return true;\r\n }\r\n addAll(c) {\r\n let changed = false;\r\n for (let o of Stubs_1.asIterable(c)) {\r\n let existing = this.getOrAdd(o);\r\n if (existing !== o)\r\n changed = true;\r\n }\r\n return changed;\r\n }\r\n retainAll(c) {\r\n let newsize = 0;\r\n for (let bucket of this.buckets) {\r\n if (bucket == null) {\r\n continue;\r\n }\r\n let i;\r\n let j;\r\n for (i = 0, j = 0; i < bucket.length; i++) {\r\n if (bucket[i] == null) {\r\n break;\r\n }\r\n if (!c.contains(bucket[i])) {\r\n // removed\r\n continue;\r\n }\r\n // keep\r\n if (i !== j) {\r\n bucket[j] = bucket[i];\r\n }\r\n j++;\r\n newsize++;\r\n }\r\n newsize += j;\r\n while (j < i) {\r\n bucket[j] = undefined;\r\n j++;\r\n }\r\n }\r\n let changed = newsize != this.n;\r\n this.n = newsize;\r\n return changed;\r\n }\r\n removeAll(c) {\r\n let changed = false;\r\n for (let o of Stubs_1.asIterable(c)) {\r\n if (this.removeFast(this.asElementType(o)))\r\n changed = true;\r\n }\r\n return changed;\r\n }\r\n clear() {\r\n this.buckets = this.createBuckets(INITAL_CAPACITY);\r\n this.n = 0;\r\n this.threshold = Math.floor(INITAL_CAPACITY * LOAD_FACTOR);\r\n }\r\n toString() {\r\n if (this.size === 0)\r\n return \"{}\";\r\n let buf = '{';\r\n let first = true;\r\n for (let bucket of this.buckets) {\r\n if (bucket == null)\r\n continue;\r\n for (let o of bucket) {\r\n if (o == null)\r\n break;\r\n if (first)\r\n first = false;\r\n else\r\n buf += \", \";\r\n buf += o.toString();\r\n }\r\n }\r\n buf += '}';\r\n return buf;\r\n }\r\n toTableString() {\r\n let buf = \"\";\r\n for (let bucket of this.buckets) {\r\n if (bucket == null) {\r\n buf += \"null\\n\";\r\n continue;\r\n }\r\n buf += '[';\r\n let first = true;\r\n for (let o of bucket) {\r\n if (first)\r\n first = false;\r\n else\r\n buf += \" \";\r\n if (o == null)\r\n buf += \"_\";\r\n else\r\n buf += o.toString();\r\n }\r\n buf += \"]\\n\";\r\n }\r\n return buf;\r\n }\r\n /**\r\n * Return {@code o} as an instance of the element type {@code T}. If\r\n * {@code o} is non-null but known to not be an instance of {@code T}, this\r\n * method returns {@code null}. The base implementation does not perform any\r\n * type checks; override this method to provide strong type checks for the\r\n * {@link #contains} and {@link #remove} methods to ensure the arguments to\r\n * the {@link EqualityComparator} for the set always have the expected\r\n * types.\r\n *\r\n * @param o the object to try and cast to the element type of the set\r\n * @return {@code o} if it could be an instance of {@code T}, otherwise\r\n * {@code null}.\r\n */\r\n asElementType(o) {\r\n return o;\r\n }\r\n /**\r\n * Return an array of {@code T[]} with length {@code capacity}.\r\n *\r\n * @param capacity the length of the array to return\r\n * @return the newly constructed array\r\n */\r\n createBuckets(capacity) {\r\n return new Array(capacity);\r\n }\r\n /**\r\n * Return an array of {@code T} with length {@code capacity}.\r\n *\r\n * @param capacity the length of the array to return\r\n * @return the newly constructed array\r\n */\r\n createBucket(capacity) {\r\n return new Array(capacity);\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Array2DHashSet.prototype, \"comparator\", void 0);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"add\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"size\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"isEmpty\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"contains\", null);\r\n__decorate([\r\n __param(0, Decorators_1.Nullable)\r\n], Array2DHashSet.prototype, \"containsFast\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"iterator\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"toArray\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"remove\", null);\r\n__decorate([\r\n __param(0, Decorators_1.Nullable)\r\n], Array2DHashSet.prototype, \"removeFast\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"containsAll\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"addAll\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"retainAll\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"removeAll\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"clear\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Array2DHashSet.prototype, \"toString\", null);\r\n__decorate([\r\n Decorators_1.SuppressWarnings(\"unchecked\")\r\n], Array2DHashSet.prototype, \"asElementType\", null);\r\n__decorate([\r\n Decorators_1.SuppressWarnings(\"unchecked\")\r\n], Array2DHashSet.prototype, \"createBuckets\", null);\r\n__decorate([\r\n Decorators_1.SuppressWarnings(\"unchecked\")\r\n], Array2DHashSet.prototype, \"createBucket\", null);\r\nexports.Array2DHashSet = Array2DHashSet;\r\nclass SetIterator {\r\n constructor(data, set) {\r\n this.data = data;\r\n this.set = set;\r\n this.nextIndex = 0;\r\n this.removed = true;\r\n }\r\n hasNext() {\r\n return this.nextIndex < this.data.length;\r\n }\r\n next() {\r\n if (this.nextIndex >= this.data.length)\r\n throw new RangeError(\"Attempted to iterate past end.\");\r\n this.removed = false;\r\n return this.data[this.nextIndex++];\r\n }\r\n // Note: this is an untested extension to the JavaScript iterator interface\r\n remove() {\r\n if (this.removed) {\r\n throw new Error(\"This entry has already been removed\");\r\n }\r\n this.set.remove(this.data[this.nextIndex - 1]);\r\n this.removed = true;\r\n }\r\n}\r\n//# sourceMappingURL=Array2DHashSet.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/** An ATN transition between any two ATN states. Subclasses define\r\n * atom, set, epsilon, action, predicate, rule transitions.\r\n *\r\n * <p>This is a one way link. It emanates from a state (usually via a list of\r\n * transitions) and has a target state.</p>\r\n *\r\n * <p>Since we never have to change the ATN transitions once we construct it,\r\n * we can fix these transitions as specific classes. The DFA transitions\r\n * on the other hand need to update the labels as it adds transitions to\r\n * the states. We'll use the term Edge for the DFA to distinguish them from\r\n * ATN transitions.</p>\r\n */\r\nlet Transition = class Transition {\r\n constructor(target) {\r\n if (target == null) {\r\n throw \"target cannot be null.\";\r\n }\r\n this.target = target;\r\n }\r\n /**\r\n * Determines if the transition is an \"epsilon\" transition.\r\n *\r\n * <p>The default implementation returns {@code false}.</p>\r\n *\r\n * @return {@code true} if traversing this transition in the ATN does not\r\n * consume an input symbol; otherwise, {@code false} if traversing this\r\n * transition consumes (matches) an input symbol.\r\n */\r\n get isEpsilon() {\r\n return false;\r\n }\r\n get label() {\r\n return undefined;\r\n }\r\n};\r\nTransition.serializationNames = [\r\n \"INVALID\",\r\n \"EPSILON\",\r\n \"RANGE\",\r\n \"RULE\",\r\n \"PREDICATE\",\r\n \"ATOM\",\r\n \"ACTION\",\r\n \"SET\",\r\n \"NOT_SET\",\r\n \"WILDCARD\",\r\n \"PRECEDENCE\"\r\n];\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Transition.prototype, \"target\", void 0);\r\nTransition = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], Transition);\r\nexports.Transition = Transition;\r\n//# sourceMappingURL=Transition.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:59.5829654-07:00\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst Token_1 = require(\"./Token\");\r\n/**\r\n * This class provides a default implementation of the {@link Vocabulary}\r\n * interface.\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass VocabularyImpl {\r\n /**\r\n * Constructs a new instance of {@link VocabularyImpl} from the specified\r\n * literal, symbolic, and display token names.\r\n *\r\n * @param literalNames The literal names assigned to tokens, or an empty array\r\n * if no literal names are assigned.\r\n * @param symbolicNames The symbolic names assigned to tokens, or\r\n * an empty array if no symbolic names are assigned.\r\n * @param displayNames The display names assigned to tokens, or an empty array\r\n * to use the values in {@code literalNames} and {@code symbolicNames} as\r\n * the source of display names, as described in\r\n * {@link #getDisplayName(int)}.\r\n *\r\n * @see #getLiteralName(int)\r\n * @see #getSymbolicName(int)\r\n * @see #getDisplayName(int)\r\n */\r\n constructor(literalNames, symbolicNames, displayNames) {\r\n this.literalNames = literalNames;\r\n this.symbolicNames = symbolicNames;\r\n this.displayNames = displayNames;\r\n // See note here on -1 part: https://github.com/antlr/antlr4/pull/1146\r\n this._maxTokenType =\r\n Math.max(this.displayNames.length, Math.max(this.literalNames.length, this.symbolicNames.length)) - 1;\r\n }\r\n get maxTokenType() {\r\n return this._maxTokenType;\r\n }\r\n getLiteralName(tokenType) {\r\n if (tokenType >= 0 && tokenType < this.literalNames.length) {\r\n return this.literalNames[tokenType];\r\n }\r\n return undefined;\r\n }\r\n getSymbolicName(tokenType) {\r\n if (tokenType >= 0 && tokenType < this.symbolicNames.length) {\r\n return this.symbolicNames[tokenType];\r\n }\r\n if (tokenType === Token_1.Token.EOF) {\r\n return \"EOF\";\r\n }\r\n return undefined;\r\n }\r\n getDisplayName(tokenType) {\r\n if (tokenType >= 0 && tokenType < this.displayNames.length) {\r\n let displayName = this.displayNames[tokenType];\r\n if (displayName) {\r\n return displayName;\r\n }\r\n }\r\n let literalName = this.getLiteralName(tokenType);\r\n if (literalName) {\r\n return literalName;\r\n }\r\n let symbolicName = this.getSymbolicName(tokenType);\r\n if (symbolicName) {\r\n return symbolicName;\r\n }\r\n return String(tokenType);\r\n }\r\n}\r\n/**\r\n * Gets an empty {@link Vocabulary} instance.\r\n *\r\n * <p>\r\n * No literal or symbol names are assigned to token types, so\r\n * {@link #getDisplayName(int)} returns the numeric value for all tokens\r\n * except {@link Token#EOF}.</p>\r\n */\r\nVocabularyImpl.EMPTY_VOCABULARY = new VocabularyImpl([], [], []);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], VocabularyImpl.prototype, \"literalNames\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], VocabularyImpl.prototype, \"symbolicNames\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], VocabularyImpl.prototype, \"displayNames\", void 0);\r\n__decorate([\r\n Decorators_1.Override\r\n], VocabularyImpl.prototype, \"maxTokenType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], VocabularyImpl.prototype, \"getLiteralName\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], VocabularyImpl.prototype, \"getSymbolicName\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n Decorators_1.NotNull\r\n], VocabularyImpl.prototype, \"getDisplayName\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], VocabularyImpl, \"EMPTY_VOCABULARY\", void 0);\r\nexports.VocabularyImpl = VocabularyImpl;\r\n//# sourceMappingURL=VocabularyImpl.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\n// ConvertTo-TS run at 2016-10-04T11:26:28.4381103-07:00\r\nconst ATNState_1 = require(\"./ATNState\");\r\nclass DecisionState extends ATNState_1.ATNState {\r\n constructor() {\r\n super(...arguments);\r\n this.decision = -1;\r\n this.nonGreedy = false;\r\n this.sll = false;\r\n }\r\n}\r\nexports.DecisionState = DecisionState;\r\n//# sourceMappingURL=DecisionState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst CommonTokenFactory_1 = require(\"./CommonTokenFactory\");\r\nconst IntegerStack_1 = require(\"./misc/IntegerStack\");\r\nconst Interval_1 = require(\"./misc/Interval\");\r\nconst IntStream_1 = require(\"./IntStream\");\r\nconst LexerATNSimulator_1 = require(\"./atn/LexerATNSimulator\");\r\nconst LexerNoViableAltException_1 = require(\"./LexerNoViableAltException\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst Recognizer_1 = require(\"./Recognizer\");\r\nconst Token_1 = require(\"./Token\");\r\n/** A lexer is recognizer that draws input symbols from a character stream.\r\n * lexer grammars result in a subclass of this object. A Lexer object\r\n * uses simplified match() and error recovery mechanisms in the interest\r\n * of speed.\r\n */\r\nclass Lexer extends Recognizer_1.Recognizer {\r\n constructor(input) {\r\n super();\r\n /** How to create token objects */\r\n this._factory = CommonTokenFactory_1.CommonTokenFactory.DEFAULT;\r\n /** What character index in the stream did the current token start at?\r\n * Needed, for example, to get the text for current token. Set at\r\n * the start of nextToken.\r\n */\r\n this._tokenStartCharIndex = -1;\r\n /** The line on which the first character of the token resides */\r\n this._tokenStartLine = 0;\r\n /** The character position of first character within the line */\r\n this._tokenStartCharPositionInLine = 0;\r\n /** Once we see EOF on char stream, next token will be EOF.\r\n * If you have DONE : EOF ; then you see DONE EOF.\r\n */\r\n this._hitEOF = false;\r\n /** The channel number for the current token */\r\n this._channel = 0;\r\n /** The token type for the current token */\r\n this._type = 0;\r\n this._modeStack = new IntegerStack_1.IntegerStack();\r\n this._mode = Lexer.DEFAULT_MODE;\r\n this._input = input;\r\n this._tokenFactorySourcePair = { source: this, stream: input };\r\n }\r\n static get DEFAULT_TOKEN_CHANNEL() {\r\n return Token_1.Token.DEFAULT_CHANNEL;\r\n }\r\n static get HIDDEN() {\r\n return Token_1.Token.HIDDEN_CHANNEL;\r\n }\r\n reset(resetInput) {\r\n // wack Lexer state variables\r\n if (resetInput === undefined || resetInput === true) {\r\n this._input.seek(0); // rewind the input\r\n }\r\n this._token = undefined;\r\n this._type = Token_1.Token.INVALID_TYPE;\r\n this._channel = Token_1.Token.DEFAULT_CHANNEL;\r\n this._tokenStartCharIndex = -1;\r\n this._tokenStartCharPositionInLine = -1;\r\n this._tokenStartLine = -1;\r\n this._text = undefined;\r\n this._hitEOF = false;\r\n this._mode = Lexer.DEFAULT_MODE;\r\n this._modeStack.clear();\r\n this.interpreter.reset();\r\n }\r\n /** Return a token from this source; i.e., match a token on the char\r\n * stream.\r\n */\r\n nextToken() {\r\n if (this._input == null) {\r\n throw new Error(\"nextToken requires a non-null input stream.\");\r\n }\r\n // Mark start location in char stream so unbuffered streams are\r\n // guaranteed at least have text of current token\r\n let tokenStartMarker = this._input.mark();\r\n try {\r\n outer: while (true) {\r\n if (this._hitEOF) {\r\n return this.emitEOF();\r\n }\r\n this._token = undefined;\r\n this._channel = Token_1.Token.DEFAULT_CHANNEL;\r\n this._tokenStartCharIndex = this._input.index;\r\n this._tokenStartCharPositionInLine = this.interpreter.charPositionInLine;\r\n this._tokenStartLine = this.interpreter.line;\r\n this._text = undefined;\r\n do {\r\n this._type = Token_1.Token.INVALID_TYPE;\r\n //\t\t\t\tSystem.out.println(\"nextToken line \"+tokenStartLine+\" at \"+((char)input.LA(1))+\r\n //\t\t\t\t\t\t\t\t \" in mode \"+mode+\r\n //\t\t\t\t\t\t\t\t \" at index \"+input.index);\r\n let ttype;\r\n try {\r\n ttype = this.interpreter.match(this._input, this._mode);\r\n }\r\n catch (e) {\r\n if (e instanceof LexerNoViableAltException_1.LexerNoViableAltException) {\r\n this.notifyListeners(e); // report error\r\n this.recover(e);\r\n ttype = Lexer.SKIP;\r\n }\r\n else {\r\n throw e;\r\n }\r\n }\r\n if (this._input.LA(1) === IntStream_1.IntStream.EOF) {\r\n this._hitEOF = true;\r\n }\r\n if (this._type === Token_1.Token.INVALID_TYPE)\r\n this._type = ttype;\r\n if (this._type === Lexer.SKIP) {\r\n continue outer;\r\n }\r\n } while (this._type === Lexer.MORE);\r\n if (this._token == null)\r\n return this.emit();\r\n return this._token;\r\n }\r\n }\r\n finally {\r\n // make sure we release marker after match or\r\n // unbuffered char stream will keep buffering\r\n this._input.release(tokenStartMarker);\r\n }\r\n }\r\n /** Instruct the lexer to skip creating a token for current lexer rule\r\n * and look for another token. nextToken() knows to keep looking when\r\n * a lexer rule finishes with token set to SKIP_TOKEN. Recall that\r\n * if token==null at end of any token rule, it creates one for you\r\n * and emits it.\r\n */\r\n skip() {\r\n this._type = Lexer.SKIP;\r\n }\r\n more() {\r\n this._type = Lexer.MORE;\r\n }\r\n mode(m) {\r\n this._mode = m;\r\n }\r\n pushMode(m) {\r\n if (LexerATNSimulator_1.LexerATNSimulator.debug)\r\n console.log(\"pushMode \" + m);\r\n this._modeStack.push(this._mode);\r\n this.mode(m);\r\n }\r\n popMode() {\r\n if (this._modeStack.isEmpty)\r\n throw new Error(\"EmptyStackException\");\r\n if (LexerATNSimulator_1.LexerATNSimulator.debug)\r\n console.log(\"popMode back to \" + this._modeStack.peek());\r\n this.mode(this._modeStack.pop());\r\n return this._mode;\r\n }\r\n get tokenFactory() {\r\n return this._factory;\r\n }\r\n // @Override\r\n set tokenFactory(factory) {\r\n this._factory = factory;\r\n }\r\n /** Set the char stream and reset the lexer */\r\n set inputStream(input) {\r\n this.reset(false);\r\n this._input = input;\r\n this._tokenFactorySourcePair = { source: this, stream: this._input };\r\n }\r\n get sourceName() {\r\n return this._input.sourceName;\r\n }\r\n get inputStream() {\r\n return this._input;\r\n }\r\n emit(token) {\r\n if (!token)\r\n token = this._factory.create(this._tokenFactorySourcePair, this._type, this._text, this._channel, this._tokenStartCharIndex, this.charIndex - 1, this._tokenStartLine, this._tokenStartCharPositionInLine);\r\n this._token = token;\r\n return token;\r\n }\r\n emitEOF() {\r\n let cpos = this.charPositionInLine;\r\n let line = this.line;\r\n let eof = this._factory.create(this._tokenFactorySourcePair, Token_1.Token.EOF, undefined, Token_1.Token.DEFAULT_CHANNEL, this._input.index, this._input.index - 1, line, cpos);\r\n this.emit(eof);\r\n return eof;\r\n }\r\n get line() {\r\n return this.interpreter.line;\r\n }\r\n get charPositionInLine() {\r\n return this.interpreter.charPositionInLine;\r\n }\r\n set line(line) {\r\n this.interpreter.line = line;\r\n }\r\n set charPositionInLine(charPositionInLine) {\r\n this.interpreter.charPositionInLine = charPositionInLine;\r\n }\r\n /** What is the index of the current character of lookahead? */\r\n get charIndex() {\r\n return this._input.index;\r\n }\r\n /** Return the text matched so far for the current token or any\r\n * text override.\r\n */\r\n get text() {\r\n if (this._text != null) {\r\n return this._text;\r\n }\r\n return this.interpreter.getText(this._input);\r\n }\r\n /** Set the complete text of this token; it wipes any previous\r\n * changes to the text.\r\n */\r\n set text(text) {\r\n this._text = text;\r\n }\r\n /** Override if emitting multiple tokens. */\r\n get token() { return this._token; }\r\n set token(_token) {\r\n this._token = _token;\r\n }\r\n set type(ttype) {\r\n this._type = ttype;\r\n }\r\n get type() {\r\n return this._type;\r\n }\r\n set channel(channel) {\r\n this._channel = channel;\r\n }\r\n get channel() {\r\n return this._channel;\r\n }\r\n /** Return a list of all Token objects in input char stream.\r\n * Forces load of all tokens. Does not include EOF token.\r\n */\r\n getAllTokens() {\r\n let tokens = [];\r\n let t = this.nextToken();\r\n while (t.type != Token_1.Token.EOF) {\r\n tokens.push(t);\r\n t = this.nextToken();\r\n }\r\n return tokens;\r\n }\r\n notifyListeners(e) {\r\n let text = this._input.getText(Interval_1.Interval.of(this._tokenStartCharIndex, this._input.index));\r\n let msg = \"token recognition error at: '\" +\r\n this.getErrorDisplay(text) + \"'\";\r\n let listener = this.getErrorListenerDispatch();\r\n listener.syntaxError(this, undefined, this._tokenStartLine, this._tokenStartCharPositionInLine, msg, e);\r\n }\r\n getErrorDisplay(s) {\r\n if (typeof s === \"number\") {\r\n switch (s) {\r\n case Token_1.Token.EOF:\r\n return \"<EOF>\";\r\n case 0x0a:\r\n return \"\\\\n\";\r\n case 0x09:\r\n return \"\\\\t\";\r\n case 0x0d:\r\n return \"\\\\r\";\r\n }\r\n return String.fromCharCode(s);\r\n }\r\n return s.replace(/\\n/g, \"\\\\n\")\r\n .replace(/\\t/g, \"\\\\t\")\r\n .replace(/\\r/g, \"\\\\r\");\r\n }\r\n getCharErrorDisplay(c) {\r\n let s = this.getErrorDisplay(c);\r\n return \"'\" + s + \"'\";\r\n }\r\n recover(re) {\r\n if (re instanceof LexerNoViableAltException_1.LexerNoViableAltException) {\r\n if (this._input.LA(1) != IntStream_1.IntStream.EOF) {\r\n // skip a char and try again\r\n this.interpreter.consume(this._input);\r\n }\r\n }\r\n else {\r\n //System.out.println(\"consuming char \"+(char)input.LA(1)+\" during recovery\");\r\n //re.printStackTrace();\r\n // TODO: Do we lose character or line position information?\r\n this._input.consume();\r\n }\r\n }\r\n}\r\nLexer.DEFAULT_MODE = 0;\r\nLexer.MORE = -2;\r\nLexer.SKIP = -3;\r\nLexer.MIN_CHAR_VALUE = 0x0000;\r\nLexer.MAX_CHAR_VALUE = 0xFFFF;\r\n__decorate([\r\n Decorators_1.Override\r\n], Lexer.prototype, \"nextToken\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Lexer.prototype, \"tokenFactory\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Lexer.prototype, \"sourceName\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Lexer.prototype, \"line\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Lexer.prototype, \"charPositionInLine\", null);\r\nexports.Lexer = Lexer;\r\n//# sourceMappingURL=Lexer.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:40.8683480-07:00\r\nconst ArrayEqualityComparator_1 = require(\"./ArrayEqualityComparator\");\r\nconst IntegerList_1 = require(\"./IntegerList\");\r\nconst Interval_1 = require(\"./Interval\");\r\nconst Lexer_1 = require(\"../Lexer\");\r\nconst MurmurHash_1 = require(\"./MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst Token_1 = require(\"../Token\");\r\n/**\r\n * This class implements the {@link IntSet} backed by a sorted array of\r\n * non-overlapping intervals. It is particularly efficient for representing\r\n * large collections of numbers, where the majority of elements appear as part\r\n * of a sequential range of numbers that are all part of the set. For example,\r\n * the set { 1, 2, 3, 4, 7, 8 } may be represented as { [1, 4], [7, 8] }.\r\n *\r\n * <p>\r\n * This class is able to represent sets containing any combination of values in\r\n * the range {@link Integer#MIN_VALUE} to {@link Integer#MAX_VALUE}\r\n * (inclusive).</p>\r\n */\r\nclass IntervalSet {\r\n constructor(intervals) {\r\n this.readonly = false;\r\n if (intervals != null) {\r\n this._intervals = intervals.slice(0);\r\n }\r\n else {\r\n this._intervals = [];\r\n }\r\n }\r\n static get COMPLETE_CHAR_SET() {\r\n if (IntervalSet._COMPLETE_CHAR_SET === undefined) {\r\n IntervalSet._COMPLETE_CHAR_SET = IntervalSet.of(Lexer_1.Lexer.MIN_CHAR_VALUE, Lexer_1.Lexer.MAX_CHAR_VALUE);\r\n IntervalSet._COMPLETE_CHAR_SET.setReadonly(true);\r\n }\r\n return IntervalSet._COMPLETE_CHAR_SET;\r\n }\r\n static get EMPTY_SET() {\r\n if (IntervalSet._EMPTY_SET == null) {\r\n IntervalSet._EMPTY_SET = new IntervalSet();\r\n IntervalSet._EMPTY_SET.setReadonly(true);\r\n }\r\n return IntervalSet._EMPTY_SET;\r\n }\r\n /**\r\n * Create a set with all ints within range [a..b] (inclusive). If b is omitted, the set contains the single element\r\n * a.\r\n */\r\n static of(a, b = a) {\r\n let s = new IntervalSet();\r\n s.add(a, b);\r\n return s;\r\n }\r\n clear() {\r\n if (this.readonly) {\r\n throw \"can't alter readonly IntervalSet\";\r\n }\r\n this._intervals.length = 0;\r\n }\r\n /** Add interval; i.e., add all integers from a to b to set.\r\n * If b<a, do nothing.\r\n * Keep list in sorted order (by left range value).\r\n * If overlap, combine ranges. For example,\r\n * If this is {1..5, 10..20}, adding 6..7 yields\r\n * {1..5, 6..7, 10..20}. Adding 4..8 yields {1..8, 10..20}.\r\n */\r\n add(a, b = a) {\r\n this.addRange(Interval_1.Interval.of(a, b));\r\n }\r\n // copy on write so we can cache a..a intervals and sets of that\r\n addRange(addition) {\r\n if (this.readonly) {\r\n throw \"can't alter readonly IntervalSet\";\r\n }\r\n //System.out.println(\"add \"+addition+\" to \"+intervals.toString());\r\n if (addition.b < addition.a) {\r\n return;\r\n }\r\n // find position in list\r\n // Use iterators as we modify list in place\r\n for (let i = 0; i < this._intervals.length; i++) {\r\n let r = this._intervals[i];\r\n if (addition.equals(r)) {\r\n return;\r\n }\r\n if (addition.adjacent(r) || !addition.disjoint(r)) {\r\n // next to each other, make a single larger interval\r\n let bigger = addition.union(r);\r\n this._intervals[i] = bigger;\r\n // make sure we didn't just create an interval that\r\n // should be merged with next interval in list\r\n while (i < this._intervals.length - 1) {\r\n i++;\r\n let next = this._intervals[i];\r\n if (!bigger.adjacent(next) && bigger.disjoint(next)) {\r\n break;\r\n }\r\n // if we bump up against or overlap next, merge\r\n // remove this one\r\n this._intervals.splice(i, 1);\r\n i--;\r\n // move backwards to what we just set\r\n this._intervals[i] = bigger.union(next);\r\n }\r\n // first call to next after previous duplicates the result\r\n return;\r\n }\r\n if (addition.startsBeforeDisjoint(r)) {\r\n // insert before r\r\n this._intervals.splice(i, 0, addition);\r\n return;\r\n }\r\n }\r\n // ok, must be after last interval (and disjoint from last interval)\r\n // just add it\r\n this._intervals.push(addition);\r\n }\r\n /** combine all sets in the array returned the or'd value */\r\n static or(sets) {\r\n let r = new IntervalSet();\r\n for (let s of sets) {\r\n r.addAll(s);\r\n }\r\n return r;\r\n }\r\n addAll(set) {\r\n if (set == null) {\r\n return this;\r\n }\r\n if (set instanceof IntervalSet) {\r\n let other = set;\r\n // walk set and add each interval\r\n let n = other._intervals.length;\r\n for (let i = 0; i < n; i++) {\r\n let I = other._intervals[i];\r\n this.add(I.a, I.b);\r\n }\r\n }\r\n else {\r\n for (let value of set.toList()) {\r\n this.add(value);\r\n }\r\n }\r\n return this;\r\n }\r\n complementRange(minElement, maxElement) {\r\n return this.complement(IntervalSet.of(minElement, maxElement));\r\n }\r\n /** {@inheritDoc} */\r\n complement(vocabulary) {\r\n if (vocabulary.isNil) {\r\n // nothing in common with null set\r\n return IntervalSet.EMPTY_SET;\r\n }\r\n let vocabularyIS;\r\n if (vocabulary instanceof IntervalSet) {\r\n vocabularyIS = vocabulary;\r\n }\r\n else {\r\n vocabularyIS = new IntervalSet();\r\n vocabularyIS.addAll(vocabulary);\r\n }\r\n return vocabularyIS.subtract(this);\r\n }\r\n subtract(a) {\r\n if (a == null || a.isNil) {\r\n return new IntervalSet(this._intervals);\r\n }\r\n if (a instanceof IntervalSet) {\r\n return IntervalSet.subtract(this, a);\r\n }\r\n let other = new IntervalSet();\r\n other.addAll(a);\r\n return IntervalSet.subtract(this, other);\r\n }\r\n /**\r\n * Compute the set difference between two interval sets. The specific\r\n * operation is {@code left - right}.\r\n */\r\n static subtract(left, right) {\r\n if (left.isNil) {\r\n return new IntervalSet();\r\n }\r\n let result = new IntervalSet(left._intervals);\r\n if (right.isNil) {\r\n // right set has no elements; just return the copy of the current set\r\n return result;\r\n }\r\n let resultI = 0;\r\n let rightI = 0;\r\n while (resultI < result._intervals.length && rightI < right._intervals.length) {\r\n let resultInterval = result._intervals[resultI];\r\n let rightInterval = right._intervals[rightI];\r\n // operation: (resultInterval - rightInterval) and update indexes\r\n if (rightInterval.b < resultInterval.a) {\r\n rightI++;\r\n continue;\r\n }\r\n if (rightInterval.a > resultInterval.b) {\r\n resultI++;\r\n continue;\r\n }\r\n let beforeCurrent;\r\n let afterCurrent;\r\n if (rightInterval.a > resultInterval.a) {\r\n beforeCurrent = new Interval_1.Interval(resultInterval.a, rightInterval.a - 1);\r\n }\r\n if (rightInterval.b < resultInterval.b) {\r\n afterCurrent = new Interval_1.Interval(rightInterval.b + 1, resultInterval.b);\r\n }\r\n if (beforeCurrent) {\r\n if (afterCurrent) {\r\n // split the current interval into two\r\n result._intervals[resultI] = beforeCurrent;\r\n result._intervals.splice(resultI + 1, 0, afterCurrent);\r\n resultI++;\r\n rightI++;\r\n continue;\r\n }\r\n else {\r\n // replace the current interval\r\n result._intervals[resultI] = beforeCurrent;\r\n resultI++;\r\n continue;\r\n }\r\n }\r\n else {\r\n if (afterCurrent) {\r\n // replace the current interval\r\n result._intervals[resultI] = afterCurrent;\r\n rightI++;\r\n continue;\r\n }\r\n else {\r\n // remove the current interval (thus no need to increment resultI)\r\n result._intervals.splice(resultI, 1);\r\n continue;\r\n }\r\n }\r\n }\r\n // If rightI reached right.intervals.size, no more intervals to subtract from result.\r\n // If resultI reached result.intervals.size, we would be subtracting from an empty set.\r\n // Either way, we are done.\r\n return result;\r\n }\r\n or(a) {\r\n let o = new IntervalSet();\r\n o.addAll(this);\r\n o.addAll(a);\r\n return o;\r\n }\r\n /** {@inheritDoc} */\r\n and(other) {\r\n if (other.isNil) {\r\n // nothing in common with null set\r\n return new IntervalSet();\r\n }\r\n let myIntervals = this._intervals;\r\n let theirIntervals = other._intervals;\r\n let intersection;\r\n let mySize = myIntervals.length;\r\n let theirSize = theirIntervals.length;\r\n let i = 0;\r\n let j = 0;\r\n // iterate down both interval lists looking for nondisjoint intervals\r\n while (i < mySize && j < theirSize) {\r\n let mine = myIntervals[i];\r\n let theirs = theirIntervals[j];\r\n //System.out.println(\"mine=\"+mine+\" and theirs=\"+theirs);\r\n if (mine.startsBeforeDisjoint(theirs)) {\r\n // move this iterator looking for interval that might overlap\r\n i++;\r\n }\r\n else if (theirs.startsBeforeDisjoint(mine)) {\r\n // move other iterator looking for interval that might overlap\r\n j++;\r\n }\r\n else if (mine.properlyContains(theirs)) {\r\n // overlap, add intersection, get next theirs\r\n if (!intersection) {\r\n intersection = new IntervalSet();\r\n }\r\n intersection.addRange(mine.intersection(theirs));\r\n j++;\r\n }\r\n else if (theirs.properlyContains(mine)) {\r\n // overlap, add intersection, get next mine\r\n if (!intersection) {\r\n intersection = new IntervalSet();\r\n }\r\n intersection.addRange(mine.intersection(theirs));\r\n i++;\r\n }\r\n else if (!mine.disjoint(theirs)) {\r\n // overlap, add intersection\r\n if (!intersection) {\r\n intersection = new IntervalSet();\r\n }\r\n intersection.addRange(mine.intersection(theirs));\r\n // Move the iterator of lower range [a..b], but not\r\n // the upper range as it may contain elements that will collide\r\n // with the next iterator. So, if mine=[0..115] and\r\n // theirs=[115..200], then intersection is 115 and move mine\r\n // but not theirs as theirs may collide with the next range\r\n // in thisIter.\r\n // move both iterators to next ranges\r\n if (mine.startsAfterNonDisjoint(theirs)) {\r\n j++;\r\n }\r\n else if (theirs.startsAfterNonDisjoint(mine)) {\r\n i++;\r\n }\r\n }\r\n }\r\n if (!intersection) {\r\n return new IntervalSet();\r\n }\r\n return intersection;\r\n }\r\n /** {@inheritDoc} */\r\n contains(el) {\r\n let n = this._intervals.length;\r\n for (let i = 0; i < n; i++) {\r\n let I = this._intervals[i];\r\n let a = I.a;\r\n let b = I.b;\r\n if (el < a) {\r\n // list is sorted and el is before this interval; not here\r\n break;\r\n }\r\n if (el >= a && el <= b) {\r\n // found in this interval\r\n return true;\r\n }\r\n }\r\n return false;\r\n /*\r\n for (ListIterator iter = intervals.listIterator(); iter.hasNext();) {\r\n let I: Interval = (Interval) iter.next();\r\n if ( el<I.a ) {\r\n break; // list is sorted and el is before this interval; not here\r\n }\r\n if ( el>=I.a && el<=I.b ) {\r\n return true; // found in this interval\r\n }\r\n }\r\n return false;\r\n */\r\n }\r\n /** {@inheritDoc} */\r\n get isNil() {\r\n return this._intervals == null || this._intervals.length === 0;\r\n }\r\n /** {@inheritDoc} */\r\n getSingleElement() {\r\n if (this._intervals != null && this._intervals.length === 1) {\r\n let I = this._intervals[0];\r\n if (I.a === I.b) {\r\n return I.a;\r\n }\r\n }\r\n return Token_1.Token.INVALID_TYPE;\r\n }\r\n /**\r\n * Returns the maximum value contained in the set.\r\n *\r\n * @return the maximum value contained in the set. If the set is empty, this\r\n * method returns {@link Token#INVALID_TYPE}.\r\n */\r\n get maxElement() {\r\n if (this.isNil) {\r\n return Token_1.Token.INVALID_TYPE;\r\n }\r\n let last = this._intervals[this._intervals.length - 1];\r\n return last.b;\r\n }\r\n /**\r\n * Returns the minimum value contained in the set.\r\n *\r\n * @return the minimum value contained in the set. If the set is empty, this\r\n * method returns {@link Token#INVALID_TYPE}.\r\n */\r\n get minElement() {\r\n if (this.isNil) {\r\n return Token_1.Token.INVALID_TYPE;\r\n }\r\n return this._intervals[0].a;\r\n }\r\n /** Return a list of Interval objects. */\r\n get intervals() {\r\n return this._intervals;\r\n }\r\n hashCode() {\r\n let hash = MurmurHash_1.MurmurHash.initialize();\r\n for (let I of this._intervals) {\r\n hash = MurmurHash_1.MurmurHash.update(hash, I.a);\r\n hash = MurmurHash_1.MurmurHash.update(hash, I.b);\r\n }\r\n hash = MurmurHash_1.MurmurHash.finish(hash, this._intervals.length * 2);\r\n return hash;\r\n }\r\n /** Are two IntervalSets equal? Because all intervals are sorted\r\n * and disjoint, equals is a simple linear walk over both lists\r\n * to make sure they are the same. Interval.equals() is used\r\n * by the List.equals() method to check the ranges.\r\n */\r\n equals(o) {\r\n if (o == null || !(o instanceof IntervalSet)) {\r\n return false;\r\n }\r\n return ArrayEqualityComparator_1.ArrayEqualityComparator.INSTANCE.equals(this._intervals, o._intervals);\r\n }\r\n toString(elemAreChar = false) {\r\n let buf = \"\";\r\n if (this._intervals == null || this._intervals.length === 0) {\r\n return \"{}\";\r\n }\r\n if (this.size > 1) {\r\n buf += \"{\";\r\n }\r\n let first = true;\r\n for (let I of this._intervals) {\r\n if (first) {\r\n first = false;\r\n }\r\n else {\r\n buf += \", \";\r\n }\r\n let a = I.a;\r\n let b = I.b;\r\n if (a === b) {\r\n if (a == Token_1.Token.EOF) {\r\n buf += \"<EOF>\";\r\n }\r\n else if (elemAreChar) {\r\n buf += \"'\" + String.fromCharCode(a) + \"'\";\r\n }\r\n else {\r\n buf += a;\r\n }\r\n }\r\n else {\r\n if (elemAreChar) {\r\n buf += \"'\" + String.fromCharCode(a) + \"'..'\" + String.fromCharCode(b) + \"'\";\r\n }\r\n else {\r\n buf += a + \"..\" + b;\r\n }\r\n }\r\n }\r\n if (this.size > 1) {\r\n buf += \"}\";\r\n }\r\n return buf;\r\n }\r\n toStringVocabulary(vocabulary) {\r\n if (this._intervals == null || this._intervals.length === 0) {\r\n return \"{}\";\r\n }\r\n let buf = \"\";\r\n if (this.size > 1) {\r\n buf += \"{\";\r\n }\r\n let first = true;\r\n for (let I of this._intervals) {\r\n if (first) {\r\n first = false;\r\n }\r\n else {\r\n buf += \", \";\r\n }\r\n let a = I.a;\r\n let b = I.b;\r\n if (a === b) {\r\n buf += this.elementName(vocabulary, a);\r\n }\r\n else {\r\n for (let i = a; i <= b; i++) {\r\n if (i > a) {\r\n buf += \", \";\r\n }\r\n buf += this.elementName(vocabulary, i);\r\n }\r\n }\r\n }\r\n if (this.size > 1) {\r\n buf += \"}\";\r\n }\r\n return buf;\r\n }\r\n elementName(vocabulary, a) {\r\n if (a === Token_1.Token.EOF) {\r\n return \"<EOF>\";\r\n }\r\n else if (a === Token_1.Token.EPSILON) {\r\n return \"<EPSILON>\";\r\n }\r\n else {\r\n return vocabulary.getDisplayName(a);\r\n }\r\n }\r\n get size() {\r\n let n = 0;\r\n let numIntervals = this._intervals.length;\r\n if (numIntervals == 1) {\r\n let firstInterval = this._intervals[0];\r\n return firstInterval.b - firstInterval.a + 1;\r\n }\r\n for (let i = 0; i < numIntervals; i++) {\r\n let I = this._intervals[i];\r\n n += (I.b - I.a + 1);\r\n }\r\n return n;\r\n }\r\n toIntegerList() {\r\n let values = new IntegerList_1.IntegerList(this.size);\r\n let n = this._intervals.length;\r\n for (let i = 0; i < n; i++) {\r\n let I = this._intervals[i];\r\n let a = I.a;\r\n let b = I.b;\r\n for (let v = a; v <= b; v++) {\r\n values.add(v);\r\n }\r\n }\r\n return values;\r\n }\r\n toList() {\r\n let values = new Array();\r\n let n = this._intervals.length;\r\n for (let i = 0; i < n; i++) {\r\n let I = this._intervals[i];\r\n let a = I.a;\r\n let b = I.b;\r\n for (let v = a; v <= b; v++) {\r\n values.push(v);\r\n }\r\n }\r\n return values;\r\n }\r\n toSet() {\r\n let s = new Set();\r\n for (let I of this._intervals) {\r\n let a = I.a;\r\n let b = I.b;\r\n for (let v = a; v <= b; v++) {\r\n s.add(v);\r\n }\r\n }\r\n return s;\r\n }\r\n toArray() {\r\n return this.toList();\r\n }\r\n remove(el) {\r\n if (this.readonly) {\r\n throw \"can't alter readonly IntervalSet\";\r\n }\r\n let n = this._intervals.length;\r\n for (let i = 0; i < n; i++) {\r\n let I = this._intervals[i];\r\n let a = I.a;\r\n let b = I.b;\r\n if (el < a) {\r\n break; // list is sorted and el is before this interval; not here\r\n }\r\n // if whole interval x..x, rm\r\n if (el === a && el === b) {\r\n this._intervals.splice(i, 1);\r\n break;\r\n }\r\n // if on left edge x..b, adjust left\r\n if (el === a) {\r\n this._intervals[i] = Interval_1.Interval.of(I.a + 1, I.b);\r\n break;\r\n }\r\n // if on right edge a..x, adjust right\r\n if (el === b) {\r\n this._intervals[i] = Interval_1.Interval.of(I.a, I.b - 1);\r\n break;\r\n }\r\n // if in middle a..x..b, split interval\r\n if (el > a && el < b) {\r\n let oldb = I.b;\r\n this._intervals[i] = Interval_1.Interval.of(I.a, el - 1); // [a..x-1]\r\n this.add(el + 1, oldb); // add [x+1..b]\r\n }\r\n }\r\n }\r\n get isReadonly() {\r\n return this.readonly;\r\n }\r\n setReadonly(readonly) {\r\n if (this.readonly && !readonly) {\r\n throw \"can't alter readonly IntervalSet\";\r\n }\r\n this.readonly = readonly;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], IntervalSet.prototype, \"addAll\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntervalSet.prototype, \"complement\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntervalSet.prototype, \"subtract\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntervalSet.prototype, \"or\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntervalSet.prototype, \"and\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntervalSet.prototype, \"contains\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntervalSet.prototype, \"isNil\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntervalSet.prototype, \"getSingleElement\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntervalSet.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntervalSet.prototype, \"equals\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], IntervalSet.prototype, \"toStringVocabulary\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], IntervalSet.prototype, \"elementName\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntervalSet.prototype, \"size\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntervalSet.prototype, \"toList\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntervalSet.prototype, \"remove\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], IntervalSet, \"of\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], IntervalSet, \"subtract\", null);\r\nexports.IntervalSet = IntervalSet;\r\n//# sourceMappingURL=IntervalSet.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\n/** The root of the ANTLR exception hierarchy. In general, ANTLR tracks just\r\n * 3 kinds of errors: prediction errors, failed predicate errors, and\r\n * mismatched input errors. In each case, the parser knows where it is\r\n * in the input, where it is in the ATN, the rule invocation stack,\r\n * and what kind of problem occurred.\r\n */\r\nclass RecognitionException extends Error {\r\n constructor(recognizer, input, ctx, message) {\r\n super(message);\r\n this._offendingState = -1;\r\n this._recognizer = recognizer;\r\n this.input = input;\r\n this.ctx = ctx;\r\n if (recognizer)\r\n this._offendingState = recognizer.state;\r\n }\r\n /**\r\n * Get the ATN state number the parser was in at the time the error\r\n * occurred. For {@link NoViableAltException} and\r\n * {@link LexerNoViableAltException} exceptions, this is the\r\n * {@link DecisionState} number. For others, it is the state whose outgoing\r\n * edge we couldn't match.\r\n *\r\n * <p>If the state number is not known, this method returns -1.</p>\r\n */\r\n get offendingState() {\r\n return this._offendingState;\r\n }\r\n setOffendingState(offendingState) {\r\n this._offendingState = offendingState;\r\n }\r\n /**\r\n * Gets the set of input symbols which could potentially follow the\r\n * previously matched symbol at the time this exception was thrown.\r\n *\r\n * <p>If the set of expected tokens is not known and could not be computed,\r\n * this method returns {@code null}.</p>\r\n *\r\n * @return The set of token types that could potentially follow the current\r\n * state in the ATN, or {@code null} if the information is not available.\r\n */\r\n get expectedTokens() {\r\n if (this._recognizer) {\r\n return this._recognizer.atn.getExpectedTokens(this._offendingState, this.ctx);\r\n }\r\n return undefined;\r\n }\r\n /**\r\n * Gets the {@link RuleContext} at the time this exception was thrown.\r\n *\r\n * <p>If the context is not available, this method returns {@code null}.</p>\r\n *\r\n * @return The {@link RuleContext} at the time this exception was thrown.\r\n * If the context is not available, this method returns {@code null}.\r\n */\r\n get context() {\r\n return this.ctx;\r\n }\r\n /**\r\n * Gets the input stream which is the symbol source for the recognizer where\r\n * this exception was thrown.\r\n *\r\n * <p>If the input stream is not available, this method returns {@code null}.</p>\r\n *\r\n * @return The input stream which is the symbol source for the recognizer\r\n * where this exception was thrown, or {@code null} if the stream is not\r\n * available.\r\n */\r\n get inputStream() {\r\n return this.input;\r\n }\r\n getOffendingToken(recognizer) {\r\n if (recognizer && recognizer !== this._recognizer)\r\n return undefined;\r\n return this.offendingToken;\r\n }\r\n setOffendingToken(recognizer, offendingToken) {\r\n if (recognizer === this._recognizer) {\r\n this.offendingToken = offendingToken;\r\n }\r\n }\r\n /**\r\n * Gets the {@link Recognizer} where this exception occurred.\r\n *\r\n * <p>If the recognizer is not available, this method returns {@code null}.</p>\r\n *\r\n * @return The recognizer where this exception occurred, or {@code null} if\r\n * the recognizer is not available.\r\n */\r\n get recognizer() {\r\n return this._recognizer;\r\n }\r\n}\r\nexports.RecognitionException = RecognitionException;\r\n//# sourceMappingURL=RecognitionException.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nconst Array2DHashSet_1 = require(\"./Array2DHashSet\");\r\nconst Stubs_1 = require(\"./Stubs\");\r\nconst DefaultEqualityComparator_1 = require(\"./DefaultEqualityComparator\");\r\nclass MapKeyEqualityComparator {\r\n constructor(keyComparator) {\r\n this.keyComparator = keyComparator;\r\n }\r\n hashCode(obj) {\r\n return this.keyComparator.hashCode(obj.key);\r\n }\r\n equals(a, b) {\r\n return this.keyComparator.equals(a.key, b.key);\r\n }\r\n}\r\nclass Array2DHashMap {\r\n constructor(keyComparer) {\r\n if (keyComparer instanceof Array2DHashMap) {\r\n this.backingStore = new Array2DHashSet_1.Array2DHashSet(keyComparer.backingStore);\r\n }\r\n else {\r\n this.backingStore = new Array2DHashSet_1.Array2DHashSet(new MapKeyEqualityComparator(keyComparer));\r\n }\r\n }\r\n clear() {\r\n this.backingStore.clear();\r\n }\r\n containsKey(key) {\r\n return this.backingStore.contains({ key });\r\n }\r\n containsValue(value) {\r\n return this.values().contains(value);\r\n }\r\n entrySet() {\r\n return new EntrySet(this, this.backingStore);\r\n }\r\n get(key) {\r\n let bucket = this.backingStore.get({ key });\r\n if (!bucket) {\r\n return undefined;\r\n }\r\n return bucket.value;\r\n }\r\n get isEmpty() {\r\n return this.backingStore.isEmpty;\r\n }\r\n keySet() {\r\n return new KeySet(this, this.backingStore);\r\n }\r\n put(key, value) {\r\n let element = this.backingStore.get({ key, value });\r\n let result;\r\n if (!element) {\r\n this.backingStore.add({ key, value });\r\n }\r\n else {\r\n result = element.value;\r\n element.value = value;\r\n }\r\n return result;\r\n }\r\n putIfAbsent(key, value) {\r\n let element = this.backingStore.get({ key, value });\r\n let result;\r\n if (!element) {\r\n this.backingStore.add({ key, value });\r\n }\r\n else {\r\n result = element.value;\r\n }\r\n return result;\r\n }\r\n putAll(m) {\r\n for (let entry of Stubs_1.asIterable(m.entrySet())) {\r\n this.put(entry.getKey(), entry.getValue());\r\n }\r\n }\r\n remove(key) {\r\n let value = this.get(key);\r\n this.backingStore.remove({ key });\r\n return value;\r\n }\r\n get size() {\r\n return this.backingStore.size;\r\n }\r\n values() {\r\n return new ValueCollection(this, this.backingStore);\r\n }\r\n hashCode() {\r\n return this.backingStore.hashCode();\r\n }\r\n equals(o) {\r\n if (!(o instanceof Array2DHashMap)) {\r\n return false;\r\n }\r\n return this.backingStore.equals(o.backingStore);\r\n }\r\n}\r\nexports.Array2DHashMap = Array2DHashMap;\r\nclass EntrySet {\r\n constructor(map, backingStore) {\r\n this.map = map;\r\n this.backingStore = backingStore;\r\n }\r\n add(e) {\r\n throw new Error(\"Not implemented\");\r\n }\r\n addAll(collection) {\r\n throw new Error(\"Not implemented\");\r\n }\r\n clear() {\r\n this.map.clear();\r\n }\r\n contains(o) {\r\n throw new Error(\"Not implemented\");\r\n }\r\n containsAll(collection) {\r\n for (let key of Stubs_1.asIterable(collection)) {\r\n if (!this.contains(key)) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }\r\n equals(o) {\r\n if (o === this) {\r\n return true;\r\n }\r\n else if (!(o instanceof EntrySet)) {\r\n return false;\r\n }\r\n return this.backingStore.equals(o.backingStore);\r\n }\r\n hashCode() {\r\n return this.backingStore.hashCode();\r\n }\r\n get isEmpty() {\r\n return this.backingStore.isEmpty;\r\n }\r\n iterator() {\r\n throw new Error(\"Not implemented\");\r\n }\r\n remove(o) {\r\n throw new Error(\"Not implemented\");\r\n }\r\n removeAll(collection) {\r\n let removedAny = false;\r\n for (let key of Stubs_1.asIterable(collection)) {\r\n removedAny = this.remove(key) || removedAny;\r\n }\r\n return removedAny;\r\n }\r\n retainAll(collection) {\r\n throw new Error(\"Not implemented\");\r\n }\r\n get size() {\r\n return this.backingStore.size;\r\n }\r\n toArray(a) {\r\n throw new Error(\"Not implemented\");\r\n }\r\n}\r\nclass KeySet {\r\n constructor(map, backingStore) {\r\n this.map = map;\r\n this.backingStore = backingStore;\r\n }\r\n add(e) {\r\n throw new Error(\"Not supported\");\r\n }\r\n addAll(collection) {\r\n throw new Error(\"Not supported\");\r\n }\r\n clear() {\r\n this.map.clear();\r\n }\r\n contains(o) {\r\n return this.backingStore.contains({ key: o });\r\n }\r\n containsAll(collection) {\r\n for (let key of Stubs_1.asIterable(collection)) {\r\n if (!this.contains(key)) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }\r\n equals(o) {\r\n if (o === this) {\r\n return true;\r\n }\r\n else if (!(o instanceof KeySet)) {\r\n return false;\r\n }\r\n return this.backingStore.equals(o.backingStore);\r\n }\r\n hashCode() {\r\n return this.backingStore.hashCode();\r\n }\r\n get isEmpty() {\r\n return this.backingStore.isEmpty;\r\n }\r\n iterator() {\r\n throw new Error(\"Not implemented\");\r\n }\r\n remove(o) {\r\n return this.backingStore.remove({ key: o });\r\n }\r\n removeAll(collection) {\r\n let removedAny = false;\r\n for (let key of Stubs_1.asIterable(collection)) {\r\n removedAny = this.remove(key) || removedAny;\r\n }\r\n return removedAny;\r\n }\r\n retainAll(collection) {\r\n throw new Error(\"Not implemented\");\r\n }\r\n get size() {\r\n return this.backingStore.size;\r\n }\r\n toArray(a) {\r\n throw new Error(\"Not implemented\");\r\n }\r\n}\r\nclass ValueCollection {\r\n constructor(map, backingStore) {\r\n this.map = map;\r\n this.backingStore = backingStore;\r\n }\r\n add(e) {\r\n throw new Error(\"Not supported\");\r\n }\r\n addAll(collection) {\r\n throw new Error(\"Not supported\");\r\n }\r\n clear() {\r\n this.map.clear();\r\n }\r\n contains(o) {\r\n for (let bucket of Stubs_1.asIterable(this.backingStore)) {\r\n if (DefaultEqualityComparator_1.DefaultEqualityComparator.INSTANCE.equals(o, bucket.value)) {\r\n return true;\r\n }\r\n }\r\n return false;\r\n }\r\n containsAll(collection) {\r\n for (let key of Stubs_1.asIterable(collection)) {\r\n if (!this.contains(key)) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }\r\n equals(o) {\r\n if (o === this) {\r\n return true;\r\n }\r\n else if (!(o instanceof ValueCollection)) {\r\n return false;\r\n }\r\n return this.backingStore.equals(o.backingStore);\r\n }\r\n hashCode() {\r\n return this.backingStore.hashCode();\r\n }\r\n get isEmpty() {\r\n return this.backingStore.isEmpty;\r\n }\r\n iterator() {\r\n let delegate = this.backingStore.iterator();\r\n return {\r\n hasNext() {\r\n return delegate.hasNext();\r\n },\r\n next() {\r\n return delegate.next().value;\r\n },\r\n remove() {\r\n throw new Error(\"Not supported\");\r\n }\r\n };\r\n }\r\n remove(o) {\r\n throw new Error(\"Not implemented\");\r\n }\r\n removeAll(collection) {\r\n let removedAny = false;\r\n for (let key of Stubs_1.asIterable(collection)) {\r\n removedAny = this.remove(key) || removedAny;\r\n }\r\n return removedAny;\r\n }\r\n retainAll(collection) {\r\n throw new Error(\"Not implemented\");\r\n }\r\n get size() {\r\n return this.backingStore.size;\r\n }\r\n toArray(a) {\r\n if (a === undefined || a.length < this.backingStore.size) {\r\n a = new Array(this.backingStore.size);\r\n }\r\n let i = 0;\r\n for (let bucket of Stubs_1.asIterable(this.backingStore)) {\r\n a[i++] = bucket.value;\r\n }\r\n return a;\r\n }\r\n}\r\n//# sourceMappingURL=Array2DHashMap.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\n// ConvertTo-TS run at 2016-10-04T11:26:51.6934376-07:00\r\nvar IntStream;\r\n(function (IntStream) {\r\n /**\r\n * The value returned by {@link #LA LA()} when the end of the stream is\r\n * reached.\r\n */\r\n IntStream.EOF = -1;\r\n /**\r\n * The value returned by {@link #getSourceName} when the actual name of the\r\n * underlying source is not known.\r\n */\r\n IntStream.UNKNOWN_SOURCE_NAME = \"<unknown>\";\r\n})(IntStream = exports.IntStream || (exports.IntStream = {}));\r\n//# sourceMappingURL=IntStream.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst Utils = require(\"./misc/Utils\");\r\nconst ATNDeserializationOptions_1 = require(\"./atn/ATNDeserializationOptions\");\r\nconst ATNDeserializer_1 = require(\"./atn/ATNDeserializer\");\r\nconst DefaultErrorStrategy_1 = require(\"./DefaultErrorStrategy\");\r\nconst IntegerStack_1 = require(\"./misc/IntegerStack\");\r\nconst Lexer_1 = require(\"./Lexer\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\n// import { ParseTreePatternMatcher } from './tree/pattern/ParseTreePatternMatcher';\r\n// import { ProfilingATNSimulator } from './atn/ProfilingATNSimulator';\r\nconst ProxyParserErrorListener_1 = require(\"./ProxyParserErrorListener\");\r\nconst Recognizer_1 = require(\"./Recognizer\");\r\nconst Token_1 = require(\"./Token\");\r\nclass TraceListener {\r\n constructor(ruleNames, tokenStream) {\r\n this.ruleNames = ruleNames;\r\n this.tokenStream = tokenStream;\r\n }\r\n enterEveryRule(ctx) {\r\n console.log(\"enter \" + this.ruleNames[ctx.ruleIndex] +\r\n \", LT(1)=\" + this.tokenStream.LT(1).text);\r\n }\r\n exitEveryRule(ctx) {\r\n console.log(\"exit \" + this.ruleNames[ctx.ruleIndex] +\r\n \", LT(1)=\" + this.tokenStream.LT(1).text);\r\n }\r\n visitErrorNode(node) {\r\n }\r\n visitTerminal(node) {\r\n let parent = node.parent.ruleContext;\r\n let token = node.symbol;\r\n console.log(\"consume \" + token + \" rule \" + this.ruleNames[parent.ruleIndex]);\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], TraceListener.prototype, \"enterEveryRule\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], TraceListener.prototype, \"exitEveryRule\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], TraceListener.prototype, \"visitErrorNode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], TraceListener.prototype, \"visitTerminal\", null);\r\n/** This is all the parsing support code essentially; most of it is error recovery stuff. */\r\nclass Parser extends Recognizer_1.Recognizer {\r\n constructor(input) {\r\n super();\r\n /**\r\n * The error handling strategy for the parser. The default value is a new\r\n * instance of {@link DefaultErrorStrategy}.\r\n *\r\n * @see #getErrorHandler\r\n * @see #setErrorHandler\r\n */\r\n this._errHandler = new DefaultErrorStrategy_1.DefaultErrorStrategy();\r\n this._precedenceStack = new IntegerStack_1.IntegerStack();\r\n /**\r\n * Specifies whether or not the parser should construct a parse tree during\r\n * the parsing process. The default value is `true`.\r\n *\r\n * @see `buildParseTree`\r\n */\r\n this._buildParseTrees = true;\r\n /**\r\n * The list of {@link ParseTreeListener} listeners registered to receive\r\n * events during the parse.\r\n *\r\n * @see #addParseListener\r\n */\r\n this._parseListeners = [];\r\n /**\r\n * The number of syntax errors reported during parsing. This value is\r\n * incremented each time {@link #notifyErrorListeners} is called.\r\n */\r\n this._syntaxErrors = 0;\r\n /** Indicates parser has match()ed EOF token. See {@link #exitRule()}. */\r\n this.matchedEOF = false;\r\n this._precedenceStack.push(0);\r\n this.inputStream = input;\r\n }\r\n reset(resetInput) {\r\n // Note: this method executes when not parsing, so _ctx can be undefined\r\n if (resetInput === undefined || resetInput === true) {\r\n this.inputStream.seek(0);\r\n }\r\n this._errHandler.reset(this);\r\n this._ctx = undefined;\r\n this._syntaxErrors = 0;\r\n this.matchedEOF = false;\r\n this.isTrace = false;\r\n this._precedenceStack.clear();\r\n this._precedenceStack.push(0);\r\n let interpreter = this.interpreter;\r\n if (interpreter != null) {\r\n interpreter.reset();\r\n }\r\n }\r\n /**\r\n * Match current input symbol against {@code ttype}. If the symbol type\r\n * matches, {@link ANTLRErrorStrategy#reportMatch} and {@link #consume} are\r\n * called to complete the match process.\r\n *\r\n * <p>If the symbol type does not match,\r\n * {@link ANTLRErrorStrategy#recoverInline} is called on the current error\r\n * strategy to attempt recovery. If {@link #getBuildParseTree} is\r\n * {@code true} and the token index of the symbol returned by\r\n * {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to\r\n * the parse tree by calling {@link ParserRuleContext#addErrorNode}.</p>\r\n *\r\n * @param ttype the token type to match\r\n * @return the matched symbol\r\n * @ if the current input symbol did not match\r\n * {@code ttype} and the error strategy could not recover from the\r\n * mismatched symbol\r\n */\r\n match(ttype) {\r\n let t = this.currentToken;\r\n if (t.type === ttype) {\r\n if (ttype === Token_1.Token.EOF) {\r\n this.matchedEOF = true;\r\n }\r\n this._errHandler.reportMatch(this);\r\n this.consume();\r\n }\r\n else {\r\n t = this._errHandler.recoverInline(this);\r\n if (this._buildParseTrees && t.tokenIndex === -1) {\r\n // we must have conjured up a new token during single token insertion\r\n // if it's not the current symbol\r\n this._ctx.addErrorNode(t);\r\n }\r\n }\r\n return t;\r\n }\r\n /**\r\n * Match current input symbol as a wildcard. If the symbol type matches\r\n * (i.e. has a value greater than 0), {@link ANTLRErrorStrategy#reportMatch}\r\n * and {@link #consume} are called to complete the match process.\r\n *\r\n * <p>If the symbol type does not match,\r\n * {@link ANTLRErrorStrategy#recoverInline} is called on the current error\r\n * strategy to attempt recovery. If {@link #getBuildParseTree} is\r\n * {@code true} and the token index of the symbol returned by\r\n * {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to\r\n * the parse tree by calling {@link ParserRuleContext#addErrorNode}.</p>\r\n *\r\n * @return the matched symbol\r\n * @ if the current input symbol did not match\r\n * a wildcard and the error strategy could not recover from the mismatched\r\n * symbol\r\n */\r\n matchWildcard() {\r\n let t = this.currentToken;\r\n if (t.type > 0) {\r\n this._errHandler.reportMatch(this);\r\n this.consume();\r\n }\r\n else {\r\n t = this._errHandler.recoverInline(this);\r\n if (this._buildParseTrees && t.tokenIndex == -1) {\r\n // we must have conjured up a new token during single token insertion\r\n // if it's not the current symbol\r\n this._ctx.addErrorNode(t);\r\n }\r\n }\r\n return t;\r\n }\r\n /**\r\n * Track the {@link ParserRuleContext} objects during the parse and hook\r\n * them up using the {@link ParserRuleContext#children} list so that it\r\n * forms a parse tree. The {@link ParserRuleContext} returned from the start\r\n * rule represents the root of the parse tree.\r\n *\r\n * <p>Note that if we are not building parse trees, rule contexts only point\r\n * upwards. When a rule exits, it returns the context but that gets garbage\r\n * collected if nobody holds a reference. It points upwards but nobody\r\n * points at it.</p>\r\n *\r\n * <p>When we build parse trees, we are adding all of these contexts to\r\n * {@link ParserRuleContext#children} list. Contexts are then not candidates\r\n * for garbage collection.</p>\r\n */\r\n set buildParseTree(buildParseTrees) {\r\n this._buildParseTrees = buildParseTrees;\r\n }\r\n /**\r\n * Gets whether or not a complete parse tree will be constructed while\r\n * parsing. This property is {@code true} for a newly constructed parser.\r\n *\r\n * @return {@code true} if a complete parse tree will be constructed while\r\n * parsing, otherwise {@code false}\r\n */\r\n get buildParseTree() {\r\n return this._buildParseTrees;\r\n }\r\n getParseListeners() {\r\n return this._parseListeners;\r\n }\r\n /**\r\n * Registers {@code listener} to receive events during the parsing process.\r\n *\r\n * <p>To support output-preserving grammar transformations (including but not\r\n * limited to left-recursion removal, automated left-factoring, and\r\n * optimized code generation), calls to listener methods during the parse\r\n * may differ substantially from calls made by\r\n * {@link ParseTreeWalker#DEFAULT} used after the parse is complete. In\r\n * particular, rule entry and exit events may occur in a different order\r\n * during the parse than after the parser. In addition, calls to certain\r\n * rule entry methods may be omitted.</p>\r\n *\r\n * <p>With the following specific exceptions, calls to listener events are\r\n * <em>deterministic</em>, i.e. for identical input the calls to listener\r\n * methods will be the same.</p>\r\n *\r\n * <ul>\r\n * <li>Alterations to the grammar used to generate code may change the\r\n * behavior of the listener calls.</li>\r\n * <li>Alterations to the command line options passed to ANTLR 4 when\r\n * generating the parser may change the behavior of the listener calls.</li>\r\n * <li>Changing the version of the ANTLR Tool used to generate the parser\r\n * may change the behavior of the listener calls.</li>\r\n * </ul>\r\n *\r\n * @param listener the listener to add\r\n *\r\n * @ if {@code} listener is {@code null}\r\n */\r\n addParseListener(listener) {\r\n if (listener == null) {\r\n throw new TypeError(\"listener cannot be null\");\r\n }\r\n this._parseListeners.push(listener);\r\n }\r\n /**\r\n * Remove {@code listener} from the list of parse listeners.\r\n *\r\n * <p>If {@code listener} is {@code null} or has not been added as a parse\r\n * listener, this method does nothing.</p>\r\n *\r\n * @see #addParseListener\r\n *\r\n * @param listener the listener to remove\r\n */\r\n removeParseListener(listener) {\r\n let index = this._parseListeners.findIndex(l => l === listener);\r\n if (index != -1) {\r\n this._parseListeners.splice(index, 1);\r\n }\r\n }\r\n /**\r\n * Remove all parse listeners.\r\n *\r\n * @see #addParseListener\r\n */\r\n removeParseListeners() {\r\n this._parseListeners.length = 0;\r\n }\r\n /**\r\n * Notify any parse listeners of an enter rule event.\r\n *\r\n * @see #addParseListener\r\n */\r\n triggerEnterRuleEvent() {\r\n for (let listener of this._parseListeners) {\r\n if (listener.enterEveryRule) {\r\n listener.enterEveryRule(this._ctx);\r\n }\r\n this._ctx.enterRule(listener);\r\n }\r\n }\r\n /**\r\n * Notify any parse listeners of an exit rule event.\r\n *\r\n * @see #addParseListener\r\n */\r\n triggerExitRuleEvent() {\r\n // reverse order walk of listeners\r\n for (let i = this._parseListeners.length - 1; i >= 0; i--) {\r\n let listener = this._parseListeners[i];\r\n this._ctx.exitRule(listener);\r\n if (listener.exitEveryRule) {\r\n listener.exitEveryRule(this._ctx);\r\n }\r\n }\r\n }\r\n /**\r\n * Gets the number of syntax errors reported during parsing. This value is\r\n * incremented each time {@link #notifyErrorListeners} is called.\r\n *\r\n * @see #notifyErrorListeners\r\n */\r\n get numberOfSyntaxErrors() {\r\n return this._syntaxErrors;\r\n }\r\n get tokenFactory() {\r\n return this._input.tokenSource.tokenFactory;\r\n }\r\n /**\r\n * The ATN with bypass alternatives is expensive to create so we create it\r\n * lazily.\r\n *\r\n * @ if the current parser does not\r\n * implement the `serializedATN` property.\r\n */\r\n getATNWithBypassAlts() {\r\n let serializedAtn = this.serializedATN;\r\n if (serializedAtn == null) {\r\n throw new Error(\"The current parser does not support an ATN with bypass alternatives.\");\r\n }\r\n let result = Parser.bypassAltsAtnCache.get(serializedAtn);\r\n if (result == null) {\r\n let deserializationOptions = new ATNDeserializationOptions_1.ATNDeserializationOptions();\r\n deserializationOptions.isGenerateRuleBypassTransitions = true;\r\n result = new ATNDeserializer_1.ATNDeserializer(deserializationOptions).deserialize(Utils.toCharArray(serializedAtn));\r\n Parser.bypassAltsAtnCache.set(serializedAtn, result);\r\n }\r\n return result;\r\n }\r\n compileParseTreePattern(pattern, patternRuleIndex, lexer) {\r\n if (!lexer) {\r\n if (this.inputStream) {\r\n let tokenSource = this.inputStream.tokenSource;\r\n if (tokenSource instanceof Lexer_1.Lexer) {\r\n lexer = tokenSource;\r\n }\r\n }\r\n if (!lexer) {\r\n throw new Error(\"Parser can't discover a lexer to use\");\r\n }\r\n }\r\n throw new Error(\"Not implemented\");\r\n // let m: ParseTreePatternMatcher = new ParseTreePatternMatcher(lexer, this);\r\n // return m.compile(pattern, patternRuleIndex);\r\n }\r\n get errorHandler() {\r\n return this._errHandler;\r\n }\r\n set errorHandler(handler) {\r\n this._errHandler = handler;\r\n }\r\n get inputStream() {\r\n return this._input;\r\n }\r\n /** Set the token stream and reset the parser. */\r\n set inputStream(input) {\r\n this.reset(false);\r\n this._input = input;\r\n }\r\n /** Match needs to return the current input symbol, which gets put\r\n * into the label for the associated token ref; e.g., x=ID.\r\n */\r\n get currentToken() {\r\n return this._input.LT(1);\r\n }\r\n notifyErrorListeners(msg, offendingToken, e) {\r\n if (offendingToken === undefined) {\r\n offendingToken = this.currentToken;\r\n }\r\n else if (offendingToken === null) {\r\n offendingToken = undefined;\r\n }\r\n this._syntaxErrors++;\r\n let line = -1;\r\n let charPositionInLine = -1;\r\n if (offendingToken != null) {\r\n line = offendingToken.line;\r\n charPositionInLine = offendingToken.charPositionInLine;\r\n }\r\n let listener = this.getErrorListenerDispatch();\r\n listener.syntaxError(this, offendingToken, line, charPositionInLine, msg, e);\r\n }\r\n /**\r\n * Consume and return the [current symbol](`currentToken`).\r\n *\r\n * <p>E.g., given the following input with {@code A} being the current\r\n * lookahead symbol, this function moves the cursor to {@code B} and returns\r\n * {@code A}.</p>\r\n *\r\n * <pre>\r\n * A B\r\n * ^\r\n * </pre>\r\n *\r\n * If the parser is not in error recovery mode, the consumed symbol is added\r\n * to the parse tree using {@link ParserRuleContext#addChild(Token)}, and\r\n * {@link ParseTreeListener#visitTerminal} is called on any parse listeners.\r\n * If the parser <em>is</em> in error recovery mode, the consumed symbol is\r\n * added to the parse tree using\r\n * {@link ParserRuleContext#addErrorNode(Token)}, and\r\n * {@link ParseTreeListener#visitErrorNode} is called on any parse\r\n * listeners.\r\n */\r\n consume() {\r\n let o = this.currentToken;\r\n if (o.type != Parser.EOF) {\r\n this.inputStream.consume();\r\n }\r\n let hasListener = this._parseListeners.length !== 0;\r\n if (this._buildParseTrees || hasListener) {\r\n if (this._errHandler.inErrorRecoveryMode(this)) {\r\n let node = this._ctx.addErrorNode(o);\r\n if (hasListener) {\r\n for (let listener of this._parseListeners) {\r\n if (listener.visitErrorNode) {\r\n listener.visitErrorNode(node);\r\n }\r\n }\r\n }\r\n }\r\n else {\r\n let node = this._ctx.addChild(o);\r\n if (hasListener) {\r\n for (let listener of this._parseListeners) {\r\n if (listener.visitTerminal) {\r\n listener.visitTerminal(node);\r\n }\r\n }\r\n }\r\n }\r\n }\r\n return o;\r\n }\r\n addContextToParseTree() {\r\n let parent = this._ctx._parent;\r\n // add current context to parent if we have a parent\r\n if (parent != null) {\r\n parent.addChild(this._ctx);\r\n }\r\n }\r\n /**\r\n * Always called by generated parsers upon entry to a rule. Access field\r\n * {@link #_ctx} get the current context.\r\n */\r\n enterRule(localctx, state, ruleIndex) {\r\n this.state = state;\r\n this._ctx = localctx;\r\n this._ctx._start = this._input.LT(1);\r\n if (this._buildParseTrees)\r\n this.addContextToParseTree();\r\n this.triggerEnterRuleEvent();\r\n }\r\n enterLeftFactoredRule(localctx, state, ruleIndex) {\r\n this.state = state;\r\n if (this._buildParseTrees) {\r\n let factoredContext = this._ctx.getChild(this._ctx.childCount - 1);\r\n this._ctx.removeLastChild();\r\n factoredContext._parent = localctx;\r\n localctx.addChild(factoredContext);\r\n }\r\n this._ctx = localctx;\r\n this._ctx._start = this._input.LT(1);\r\n if (this._buildParseTrees) {\r\n this.addContextToParseTree();\r\n }\r\n this.triggerEnterRuleEvent();\r\n }\r\n exitRule() {\r\n if (this.matchedEOF) {\r\n // if we have matched EOF, it cannot consume past EOF so we use LT(1) here\r\n this._ctx._stop = this._input.LT(1); // LT(1) will be end of file\r\n }\r\n else {\r\n this._ctx._stop = this._input.tryLT(-1); // stop node is what we just matched\r\n }\r\n // trigger event on _ctx, before it reverts to parent\r\n this.triggerExitRuleEvent();\r\n this.state = this._ctx.invokingState;\r\n this._ctx = this._ctx._parent;\r\n }\r\n enterOuterAlt(localctx, altNum) {\r\n localctx.altNumber = altNum;\r\n // if we have new localctx, make sure we replace existing ctx\r\n // that is previous child of parse tree\r\n if (this._buildParseTrees && this._ctx !== localctx) {\r\n let parent = this._ctx._parent;\r\n if (parent != null) {\r\n parent.removeLastChild();\r\n parent.addChild(localctx);\r\n }\r\n }\r\n this._ctx = localctx;\r\n }\r\n /**\r\n * Get the precedence level for the top-most precedence rule.\r\n *\r\n * @return The precedence level for the top-most precedence rule, or -1 if\r\n * the parser context is not nested within a precedence rule.\r\n */\r\n get precedence() {\r\n if (this._precedenceStack.isEmpty) {\r\n return -1;\r\n }\r\n return this._precedenceStack.peek();\r\n }\r\n enterRecursionRule(localctx, state, ruleIndex, precedence) {\r\n this.state = state;\r\n this._precedenceStack.push(precedence);\r\n this._ctx = localctx;\r\n this._ctx._start = this._input.LT(1);\r\n this.triggerEnterRuleEvent(); // simulates rule entry for left-recursive rules\r\n }\r\n /** Like {@link #enterRule} but for recursive rules.\r\n * Make the current context the child of the incoming localctx.\r\n */\r\n pushNewRecursionContext(localctx, state, ruleIndex) {\r\n let previous = this._ctx;\r\n previous._parent = localctx;\r\n previous.invokingState = state;\r\n previous._stop = this._input.tryLT(-1);\r\n this._ctx = localctx;\r\n this._ctx._start = previous._start;\r\n if (this._buildParseTrees) {\r\n this._ctx.addChild(previous);\r\n }\r\n this.triggerEnterRuleEvent(); // simulates rule entry for left-recursive rules\r\n }\r\n unrollRecursionContexts(_parentctx) {\r\n this._precedenceStack.pop();\r\n this._ctx._stop = this._input.tryLT(-1);\r\n let retctx = this._ctx; // save current ctx (return value)\r\n // unroll so _ctx is as it was before call to recursive method\r\n if (this._parseListeners.length > 0) {\r\n while (this._ctx !== _parentctx) {\r\n this.triggerExitRuleEvent();\r\n this._ctx = this._ctx._parent;\r\n }\r\n }\r\n else {\r\n this._ctx = _parentctx;\r\n }\r\n // hook into tree\r\n retctx._parent = _parentctx;\r\n if (this._buildParseTrees && _parentctx != null) {\r\n // add return ctx into invoking rule's tree\r\n _parentctx.addChild(retctx);\r\n }\r\n }\r\n getInvokingContext(ruleIndex) {\r\n let p = this._ctx;\r\n while (p && p.ruleIndex !== ruleIndex) {\r\n p = p._parent;\r\n }\r\n return p;\r\n }\r\n get context() {\r\n return this._ctx;\r\n }\r\n set context(ctx) {\r\n this._ctx = ctx;\r\n }\r\n precpred(localctx, precedence) {\r\n return precedence >= this._precedenceStack.peek();\r\n }\r\n getErrorListenerDispatch() {\r\n return new ProxyParserErrorListener_1.ProxyParserErrorListener(this.getErrorListeners());\r\n }\r\n inContext(context) {\r\n // TODO: useful in parser?\r\n return false;\r\n }\r\n /**\r\n * Checks whether or not {@code symbol} can follow the current state in the\r\n * ATN. The behavior of this method is equivalent to the following, but is\r\n * implemented such that the complete context-sensitive follow set does not\r\n * need to be explicitly constructed.\r\n *\r\n * <pre>\r\n * return getExpectedTokens().contains(symbol);\r\n * </pre>\r\n *\r\n * @param symbol the symbol type to check\r\n * @return {@code true} if {@code symbol} can follow the current state in\r\n * the ATN, otherwise {@code false}.\r\n */\r\n isExpectedToken(symbol) {\r\n // \t\treturn interpreter.atn.nextTokens(_ctx);\r\n let atn = this.interpreter.atn;\r\n let ctx = this._ctx;\r\n let s = atn.states[this.state];\r\n let following = atn.nextTokens(s);\r\n if (following.contains(symbol)) {\r\n return true;\r\n }\r\n // System.out.println(\"following \"+s+\"=\"+following);\r\n if (!following.contains(Token_1.Token.EPSILON))\r\n return false;\r\n while (ctx != null && ctx.invokingState >= 0 && following.contains(Token_1.Token.EPSILON)) {\r\n let invokingState = atn.states[ctx.invokingState];\r\n let rt = invokingState.transition(0);\r\n following = atn.nextTokens(rt.followState);\r\n if (following.contains(symbol)) {\r\n return true;\r\n }\r\n ctx = ctx._parent;\r\n }\r\n if (following.contains(Token_1.Token.EPSILON) && symbol == Token_1.Token.EOF) {\r\n return true;\r\n }\r\n return false;\r\n }\r\n get isMatchedEOF() {\r\n return this.matchedEOF;\r\n }\r\n /**\r\n * Computes the set of input symbols which could follow the current parser\r\n * state and context, as given by {@link #getState} and {@link #getContext},\r\n * respectively.\r\n *\r\n * @see ATN#getExpectedTokens(int, RuleContext)\r\n */\r\n getExpectedTokens() {\r\n return this.atn.getExpectedTokens(this.state, this.context);\r\n }\r\n getExpectedTokensWithinCurrentRule() {\r\n let atn = this.interpreter.atn;\r\n let s = atn.states[this.state];\r\n return atn.nextTokens(s);\r\n }\r\n /** Get a rule's index (i.e., {@code RULE_ruleName} field) or -1 if not found. */\r\n getRuleIndex(ruleName) {\r\n let ruleIndex = this.getRuleIndexMap().get(ruleName);\r\n if (ruleIndex != null)\r\n return ruleIndex;\r\n return -1;\r\n }\r\n get ruleContext() { return this._ctx; }\r\n /** Return List<String> of the rule names in your parser instance\r\n * leading up to a call to the current rule. You could override if\r\n * you want more details such as the file/line info of where\r\n * in the ATN a rule is invoked.\r\n *\r\n * This is very useful for error messages.\r\n */\r\n getRuleInvocationStack(p = this._ctx) {\r\n let ruleNames = this.ruleNames;\r\n let stack = [];\r\n while (p != null) {\r\n // compute what follows who invoked us\r\n let ruleIndex = p.ruleIndex;\r\n if (ruleIndex < 0)\r\n stack.push(\"n/a\");\r\n else\r\n stack.push(ruleNames[ruleIndex]);\r\n p = p._parent;\r\n }\r\n return stack;\r\n }\r\n /** For debugging and other purposes. */\r\n getDFAStrings() {\r\n let s = [];\r\n for (let d = 0; d < this._interp.atn.decisionToDFA.length; d++) {\r\n let dfa = this._interp.atn.decisionToDFA[d];\r\n s.push(dfa.toString(this.vocabulary, this.ruleNames));\r\n }\r\n return s;\r\n }\r\n /** For debugging and other purposes. */\r\n dumpDFA() {\r\n let seenOne = false;\r\n for (let d = 0; d < this._interp.atn.decisionToDFA.length; d++) {\r\n let dfa = this._interp.atn.decisionToDFA[d];\r\n if (!dfa.isEmpty) {\r\n if (seenOne)\r\n console.log();\r\n console.log(\"Decision \" + dfa.decision + \":\");\r\n process.stdout.write(dfa.toString(this.vocabulary, this.ruleNames));\r\n seenOne = true;\r\n }\r\n }\r\n }\r\n get sourceName() {\r\n return this._input.sourceName;\r\n }\r\n get parseInfo() {\r\n throw new Error(\"Not implemented\");\r\n // let interp: ParserATNSimulator = this.interpreter;\r\n // if (interp instanceof ProfilingATNSimulator) {\r\n // \treturn new ParseInfo(interp);\r\n // }\r\n // return undefined;\r\n }\r\n /**\r\n * @since 4.3\r\n */\r\n setProfile(profile) {\r\n throw new Error(\"Not implemented\");\r\n // let interp: ParserATNSimulator = this.interpreter;\r\n // if ( profile ) {\r\n // \tif (!(interp instanceof ProfilingATNSimulator)) {\r\n // \t\tthis.interpreter = new ProfilingATNSimulator(this);\r\n // \t}\r\n // }\r\n // else if (interp instanceof ProfilingATNSimulator) {\r\n // \tthis.interpreter = new ParserATNSimulator(this.atn, this);\r\n // }\r\n // this.interpreter.setPredictionMode(interp.getPredictionMode());\r\n }\r\n /** During a parse is sometimes useful to listen in on the rule entry and exit\r\n * events as well as token matches. This is for quick and dirty debugging.\r\n */\r\n set isTrace(trace) {\r\n if (!trace) {\r\n if (this._tracer) {\r\n this.removeParseListener(this._tracer);\r\n this._tracer = undefined;\r\n }\r\n }\r\n else {\r\n if (this._tracer) {\r\n this.removeParseListener(this._tracer);\r\n }\r\n else {\r\n this._tracer = new TraceListener(this.ruleNames, this._input);\r\n }\r\n this.addParseListener(this._tracer);\r\n }\r\n }\r\n /**\r\n * Gets whether a {@link TraceListener} is registered as a parse listener\r\n * for the parser.\r\n */\r\n get isTrace() {\r\n return this._tracer != null;\r\n }\r\n}\r\n/**\r\n * This field maps from the serialized ATN string to the deserialized {@link ATN} with\r\n * bypass alternatives.\r\n *\r\n * @see ATNDeserializationOptions.isGenerateRuleBypassTransitions\r\n */\r\nParser.bypassAltsAtnCache = new WeakMap();\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Parser.prototype, \"_errHandler\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Parser.prototype, \"match\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Parser.prototype, \"matchWildcard\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Parser.prototype, \"getParseListeners\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], Parser.prototype, \"addParseListener\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Parser.prototype, \"getATNWithBypassAlts\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], Parser.prototype, \"errorHandler\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Parser.prototype, \"inputStream\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Parser.prototype, \"currentToken\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], Parser.prototype, \"enterRule\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.Nullable)\r\n], Parser.prototype, \"precpred\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Parser.prototype, \"getErrorListenerDispatch\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Parser.prototype, \"getExpectedTokens\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Parser.prototype, \"getExpectedTokensWithinCurrentRule\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], Parser.prototype, \"parseInfo\", null);\r\nexports.Parser = Parser;\r\n//# sourceMappingURL=Parser.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:36.7513856-07:00\r\nconst ATNState_1 = require(\"./ATNState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/** The last node in the ATN for a rule, unless that rule is the start symbol.\r\n * In that case, there is one transition to EOF. Later, we might encode\r\n * references to all calls to this rule to compute FOLLOW sets for\r\n * error handling.\r\n */\r\nclass RuleStopState extends ATNState_1.ATNState {\r\n get nonStopStateNumber() {\r\n return -1;\r\n }\r\n get stateType() {\r\n return 7 /* RULE_STOP */;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleStopState.prototype, \"nonStopStateNumber\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleStopState.prototype, \"stateType\", null);\r\nexports.RuleStopState = RuleStopState;\r\n//# sourceMappingURL=RuleStopState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst ConsoleErrorListener_1 = require(\"./ConsoleErrorListener\");\r\nconst ProxyErrorListener_1 = require(\"./ProxyErrorListener\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst Token_1 = require(\"./Token\");\r\nconst Utils = require(\"./misc/Utils\");\r\nclass Recognizer {\r\n constructor() {\r\n this._listeners = [ConsoleErrorListener_1.ConsoleErrorListener.INSTANCE];\r\n this._stateNumber = -1;\r\n }\r\n /**\r\n * Get a map from token names to token types.\r\n *\r\n * <p>Used for XPath and tree pattern compilation.</p>\r\n */\r\n getTokenTypeMap() {\r\n let vocabulary = this.vocabulary;\r\n let result = Recognizer.tokenTypeMapCache.get(vocabulary);\r\n if (result == null) {\r\n let intermediateResult = new Map();\r\n for (let i = 0; i <= this.atn.maxTokenType; i++) {\r\n let literalName = vocabulary.getLiteralName(i);\r\n if (literalName != null) {\r\n intermediateResult.set(literalName, i);\r\n }\r\n let symbolicName = vocabulary.getSymbolicName(i);\r\n if (symbolicName != null) {\r\n intermediateResult.set(symbolicName, i);\r\n }\r\n }\r\n intermediateResult.set(\"EOF\", Token_1.Token.EOF);\r\n result = Object.freeze(intermediateResult);\r\n Recognizer.tokenTypeMapCache.set(vocabulary, result);\r\n }\r\n return result;\r\n }\r\n /**\r\n * Get a map from rule names to rule indexes.\r\n *\r\n * <p>Used for XPath and tree pattern compilation.</p>\r\n */\r\n getRuleIndexMap() {\r\n let ruleNames = this.ruleNames;\r\n if (ruleNames == null) {\r\n throw new Error(\"The current recognizer does not provide a list of rule names.\");\r\n }\r\n let result = Recognizer.ruleIndexMapCache.get(ruleNames);\r\n if (result == null) {\r\n result = Object.freeze(Utils.toMap(ruleNames));\r\n Recognizer.ruleIndexMapCache.set(ruleNames, result);\r\n }\r\n return result;\r\n }\r\n getTokenType(tokenName) {\r\n let ttype = this.getTokenTypeMap().get(tokenName);\r\n if (ttype != null)\r\n return ttype;\r\n return Token_1.Token.INVALID_TYPE;\r\n }\r\n /**\r\n * If this recognizer was generated, it will have a serialized ATN\r\n * representation of the grammar.\r\n *\r\n * <p>For interpreters, we don't know their serialized ATN despite having\r\n * created the interpreter from it.</p>\r\n */\r\n get serializedATN() {\r\n throw new Error(\"there is no serialized ATN\");\r\n }\r\n /**\r\n * Get the {@link ATN} used by the recognizer for prediction.\r\n *\r\n * @return The {@link ATN} used by the recognizer for prediction.\r\n */\r\n get atn() {\r\n return this._interp.atn;\r\n }\r\n /**\r\n * Get the ATN interpreter used by the recognizer for prediction.\r\n *\r\n * @return The ATN interpreter used by the recognizer for prediction.\r\n */\r\n get interpreter() {\r\n return this._interp;\r\n }\r\n /** If profiling during the parse/lex, this will return DecisionInfo records\r\n * for each decision in recognizer in a ParseInfo object.\r\n *\r\n * @since 4.3\r\n */\r\n get parseInfo() {\r\n return undefined;\r\n }\r\n /**\r\n * Set the ATN interpreter used by the recognizer for prediction.\r\n *\r\n * @param interpreter The ATN interpreter used by the recognizer for\r\n * prediction.\r\n */\r\n set interpreter(interpreter) {\r\n this._interp = interpreter;\r\n }\r\n /** What is the error header, normally line/character position information? */\r\n getErrorHeader(e) {\r\n let token = e.getOffendingToken();\r\n if (!token)\r\n return \"\";\r\n let line = token.line;\r\n let charPositionInLine = token.charPositionInLine;\r\n return \"line \" + line + \":\" + charPositionInLine;\r\n }\r\n /**\r\n * @exception NullPointerException if {@code listener} is {@code null}.\r\n */\r\n addErrorListener(listener) {\r\n if (!listener)\r\n throw new TypeError(\"listener must not be null\");\r\n this._listeners.push(listener);\r\n }\r\n removeErrorListener(listener) {\r\n let position = this._listeners.indexOf(listener);\r\n if (position !== -1) {\r\n this._listeners.splice(position, 1);\r\n }\r\n }\r\n removeErrorListeners() {\r\n this._listeners.length = 0;\r\n }\r\n getErrorListeners() {\r\n return this._listeners.slice(0);\r\n }\r\n getErrorListenerDispatch() {\r\n return new ProxyErrorListener_1.ProxyErrorListener(this.getErrorListeners());\r\n }\r\n // subclass needs to override these if there are sempreds or actions\r\n // that the ATN interp needs to execute\r\n sempred(_localctx, ruleIndex, actionIndex) {\r\n return true;\r\n }\r\n precpred(localctx, precedence) {\r\n return true;\r\n }\r\n action(_localctx, ruleIndex, actionIndex) {\r\n }\r\n get state() {\r\n return this._stateNumber;\r\n }\r\n /** Indicate that the recognizer has changed internal state that is\r\n * consistent with the ATN state passed in. This way we always know\r\n * where we are in the ATN as the parser goes along. The rule\r\n * context objects form a stack that lets us see the stack of\r\n * invoking rules. Combine this and we have complete ATN\r\n * configuration information.\r\n */\r\n set state(atnState) {\r\n //\t\tSystem.err.println(\"setState \"+atnState);\r\n this._stateNumber = atnState;\r\n //\t\tif ( traceATNStates ) _ctx.trace(atnState);\r\n }\r\n}\r\nRecognizer.EOF = -1;\r\nRecognizer.tokenTypeMapCache = new WeakMap();\r\nRecognizer.ruleIndexMapCache = new WeakMap();\r\n__decorate([\r\n Decorators_1.SuppressWarnings(\"serial\"),\r\n Decorators_1.NotNull\r\n], Recognizer.prototype, \"_listeners\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Recognizer.prototype, \"getTokenTypeMap\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Recognizer.prototype, \"getRuleIndexMap\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Recognizer.prototype, \"serializedATN\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Recognizer.prototype, \"atn\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], Recognizer.prototype, \"interpreter\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], Recognizer.prototype, \"getErrorHeader\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], Recognizer.prototype, \"addErrorListener\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], Recognizer.prototype, \"removeErrorListener\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], Recognizer.prototype, \"getErrorListeners\", null);\r\nexports.Recognizer = Recognizer;\r\n//# sourceMappingURL=Recognizer.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:25.5488013-07:00\r\nconst Array2DHashMap_1 = require(\"../misc/Array2DHashMap\");\r\nconst Array2DHashSet_1 = require(\"../misc/Array2DHashSet\");\r\nconst ArrayEqualityComparator_1 = require(\"../misc/ArrayEqualityComparator\");\r\nconst ATN_1 = require(\"./ATN\");\r\nconst ATNConfig_1 = require(\"./ATNConfig\");\r\nconst BitSet_1 = require(\"../misc/BitSet\");\r\nconst Stubs_1 = require(\"../misc/Stubs\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst ObjectEqualityComparator_1 = require(\"../misc/ObjectEqualityComparator\");\r\nconst PredictionContext_1 = require(\"./PredictionContext\");\r\nconst PredictionContextCache_1 = require(\"./PredictionContextCache\");\r\nconst SemanticContext_1 = require(\"./SemanticContext\");\r\nconst assert = require(\"assert\");\r\nconst Utils = require(\"../misc/Utils\");\r\nclass KeyTypeEqualityComparer {\r\n hashCode(key) {\r\n return key.state ^ key.alt;\r\n }\r\n equals(a, b) {\r\n return a.state === b.state && a.alt === b.alt;\r\n }\r\n}\r\nKeyTypeEqualityComparer.INSTANCE = new KeyTypeEqualityComparer();\r\nfunction NewKeyedConfigMap(map) {\r\n if (map) {\r\n return new Array2DHashMap_1.Array2DHashMap(map);\r\n }\r\n else {\r\n return new Array2DHashMap_1.Array2DHashMap(KeyTypeEqualityComparer.INSTANCE);\r\n }\r\n}\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass ATNConfigSet {\r\n constructor(set, readonly) {\r\n this._uniqueAlt = 0;\r\n // Used in parser and lexer. In lexer, it indicates we hit a pred\r\n // while computing a closure operation. Don't make a DFA state from this.\r\n this._hasSemanticContext = false;\r\n this._dipsIntoOuterContext = false;\r\n /**\r\n * When {@code true}, this config set represents configurations where the entire\r\n * outer context has been consumed by the ATN interpreter. This prevents the\r\n * {@link ParserATNSimulator#closure} from pursuing the global FOLLOW when a\r\n * rule stop state is reached with an empty prediction context.\r\n * <p>\r\n * Note: {@code outermostConfigSet} and {@link #dipsIntoOuterContext} should never\r\n * be true at the same time.\r\n */\r\n this.outermostConfigSet = false;\r\n this.cachedHashCode = -1;\r\n if (!set) {\r\n this.mergedConfigs = NewKeyedConfigMap();\r\n this.unmerged = [];\r\n this.configs = [];\r\n this._uniqueAlt = ATN_1.ATN.INVALID_ALT_NUMBER;\r\n }\r\n else {\r\n if (readonly) {\r\n this.mergedConfigs = undefined;\r\n this.unmerged = undefined;\r\n }\r\n else if (!set.isReadOnly) {\r\n this.mergedConfigs = NewKeyedConfigMap(set.mergedConfigs);\r\n this.unmerged = set.unmerged.slice(0);\r\n }\r\n else {\r\n this.mergedConfigs = NewKeyedConfigMap();\r\n this.unmerged = [];\r\n }\r\n this.configs = set.configs.slice(0);\r\n this._dipsIntoOuterContext = set._dipsIntoOuterContext;\r\n this._hasSemanticContext = set._hasSemanticContext;\r\n this.outermostConfigSet = set.outermostConfigSet;\r\n if (readonly || !set.isReadOnly) {\r\n this._uniqueAlt = set._uniqueAlt;\r\n this._conflictInfo = set._conflictInfo;\r\n }\r\n }\r\n }\r\n /**\r\n * Get the set of all alternatives represented by configurations in this\r\n * set.\r\n */\r\n getRepresentedAlternatives() {\r\n if (this._conflictInfo != null) {\r\n return this._conflictInfo.conflictedAlts.clone();\r\n }\r\n let alts = new BitSet_1.BitSet();\r\n for (let config of Stubs_1.asIterable(this)) {\r\n alts.set(config.alt);\r\n }\r\n return alts;\r\n }\r\n get isReadOnly() {\r\n return this.mergedConfigs == null;\r\n }\r\n get isOutermostConfigSet() {\r\n return this.outermostConfigSet;\r\n }\r\n set isOutermostConfigSet(outermostConfigSet) {\r\n if (this.outermostConfigSet && !outermostConfigSet) {\r\n throw new Error(\"IllegalStateException\");\r\n }\r\n assert(!outermostConfigSet || !this._dipsIntoOuterContext);\r\n this.outermostConfigSet = outermostConfigSet;\r\n }\r\n getStates() {\r\n let states = new Array2DHashSet_1.Array2DHashSet(ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE);\r\n for (let c of this.configs) {\r\n states.add(c.state);\r\n }\r\n return states;\r\n }\r\n optimizeConfigs(interpreter) {\r\n if (this.configs.length === 0) {\r\n return;\r\n }\r\n for (let i = 0; i < this.configs.length; i++) {\r\n let config = this.configs[i];\r\n config.context = interpreter.atn.getCachedContext(config.context);\r\n }\r\n }\r\n clone(readonly) {\r\n let copy = new ATNConfigSet(this, readonly);\r\n if (!readonly && this.isReadOnly) {\r\n copy.addAll(this.configs);\r\n }\r\n return copy;\r\n }\r\n get size() {\r\n return this.configs.length;\r\n }\r\n get isEmpty() {\r\n return this.configs.length === 0;\r\n }\r\n contains(o) {\r\n if (!(o instanceof ATNConfig_1.ATNConfig)) {\r\n return false;\r\n }\r\n if (this.mergedConfigs && this.unmerged) {\r\n let config = o;\r\n let configKey = this.getKey(config);\r\n let mergedConfig = this.mergedConfigs.get(configKey);\r\n if (mergedConfig != null && this.canMerge(config, configKey, mergedConfig)) {\r\n return mergedConfig.contains(config);\r\n }\r\n for (let c of this.unmerged) {\r\n if (c.contains(o)) {\r\n return true;\r\n }\r\n }\r\n }\r\n else {\r\n for (let c of this.configs) {\r\n if (c.contains(o)) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }\r\n iterator() {\r\n return new ATNConfigSetIterator(this, this.configs);\r\n }\r\n toArray(a) {\r\n if (!a || a.length < this.configs.length) {\r\n return this.configs;\r\n }\r\n for (let i = 0; i < this.configs.length; i++) {\r\n a[i] = this.configs[i];\r\n }\r\n return a;\r\n }\r\n add(e, contextCache) {\r\n this.ensureWritable();\r\n if (!this.mergedConfigs || !this.unmerged) {\r\n throw new Error(\"Covered by ensureWritable but duplicated here for strict null check limitation\");\r\n }\r\n assert(!this.outermostConfigSet || !e.reachesIntoOuterContext);\r\n if (contextCache == null) {\r\n contextCache = PredictionContextCache_1.PredictionContextCache.UNCACHED;\r\n }\r\n let addKey;\r\n let key = this.getKey(e);\r\n let mergedConfig = this.mergedConfigs.get(key);\r\n addKey = (mergedConfig == null);\r\n if (mergedConfig != null && this.canMerge(e, key, mergedConfig)) {\r\n mergedConfig.outerContextDepth = Math.max(mergedConfig.outerContextDepth, e.outerContextDepth);\r\n if (e.isPrecedenceFilterSuppressed) {\r\n mergedConfig.isPrecedenceFilterSuppressed = true;\r\n }\r\n let joined = PredictionContext_1.PredictionContext.join(mergedConfig.context, e.context, contextCache);\r\n this.updatePropertiesForMergedConfig(e);\r\n if (mergedConfig.context == joined) {\r\n return false;\r\n }\r\n mergedConfig.context = joined;\r\n return true;\r\n }\r\n for (let i = 0; i < this.unmerged.length; i++) {\r\n let unmergedConfig = this.unmerged[i];\r\n if (this.canMerge(e, key, unmergedConfig)) {\r\n unmergedConfig.outerContextDepth = Math.max(unmergedConfig.outerContextDepth, e.outerContextDepth);\r\n if (e.isPrecedenceFilterSuppressed) {\r\n unmergedConfig.isPrecedenceFilterSuppressed = true;\r\n }\r\n let joined = PredictionContext_1.PredictionContext.join(unmergedConfig.context, e.context, contextCache);\r\n this.updatePropertiesForMergedConfig(e);\r\n if (unmergedConfig.context == joined) {\r\n return false;\r\n }\r\n unmergedConfig.context = joined;\r\n if (addKey) {\r\n this.mergedConfigs.put(key, unmergedConfig);\r\n this.unmerged.splice(i, 1);\r\n }\r\n return true;\r\n }\r\n }\r\n this.configs.push(e);\r\n if (addKey) {\r\n this.mergedConfigs.put(key, e);\r\n }\r\n else {\r\n this.unmerged.push(e);\r\n }\r\n this.updatePropertiesForAddedConfig(e);\r\n return true;\r\n }\r\n updatePropertiesForMergedConfig(config) {\r\n // merged configs can't change the alt or semantic context\r\n this._dipsIntoOuterContext = this._dipsIntoOuterContext || config.reachesIntoOuterContext;\r\n assert(!this.outermostConfigSet || !this._dipsIntoOuterContext);\r\n }\r\n updatePropertiesForAddedConfig(config) {\r\n if (this.configs.length === 1) {\r\n this._uniqueAlt = config.alt;\r\n }\r\n else if (this._uniqueAlt !== config.alt) {\r\n this._uniqueAlt = ATN_1.ATN.INVALID_ALT_NUMBER;\r\n }\r\n this._hasSemanticContext = this._hasSemanticContext || !SemanticContext_1.SemanticContext.NONE.equals(config.semanticContext);\r\n this._dipsIntoOuterContext = this._dipsIntoOuterContext || config.reachesIntoOuterContext;\r\n assert(!this.outermostConfigSet || !this._dipsIntoOuterContext);\r\n }\r\n canMerge(left, leftKey, right) {\r\n if (left.state.stateNumber != right.state.stateNumber) {\r\n return false;\r\n }\r\n if (leftKey.alt !== right.alt) {\r\n return false;\r\n }\r\n return left.semanticContext.equals(right.semanticContext);\r\n }\r\n getKey(e) {\r\n return { state: e.state.stateNumber, alt: e.alt };\r\n }\r\n containsAll(c) {\r\n for (let o of Stubs_1.asIterable(c)) {\r\n if (!(o instanceof ATNConfig_1.ATNConfig)) {\r\n return false;\r\n }\r\n if (!this.contains(o)) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }\r\n addAll(c, contextCache) {\r\n this.ensureWritable();\r\n let changed = false;\r\n for (let group of Stubs_1.asIterable(c)) {\r\n if (this.add(group, contextCache)) {\r\n changed = true;\r\n }\r\n }\r\n return changed;\r\n }\r\n retainAll(c) {\r\n this.ensureWritable();\r\n throw new Error(\"Not supported yet.\");\r\n }\r\n removeAll(c) {\r\n this.ensureWritable();\r\n throw new Error(\"Not supported yet.\");\r\n }\r\n clear() {\r\n this.ensureWritable();\r\n if (!this.mergedConfigs || !this.unmerged) {\r\n throw new Error(\"Covered by ensureWritable but duplicated here for strict null check limitation\");\r\n }\r\n this.mergedConfigs.clear();\r\n this.unmerged.length = 0;\r\n this.configs.length = 0;\r\n this._dipsIntoOuterContext = false;\r\n this._hasSemanticContext = false;\r\n this._uniqueAlt = ATN_1.ATN.INVALID_ALT_NUMBER;\r\n this._conflictInfo = undefined;\r\n }\r\n equals(obj) {\r\n if (this === obj) {\r\n return true;\r\n }\r\n if (!(obj instanceof ATNConfigSet)) {\r\n return false;\r\n }\r\n return this.outermostConfigSet == obj.outermostConfigSet\r\n && Utils.equals(this._conflictInfo, obj._conflictInfo)\r\n && ArrayEqualityComparator_1.ArrayEqualityComparator.INSTANCE.equals(this.configs, obj.configs);\r\n }\r\n hashCode() {\r\n if (this.isReadOnly && this.cachedHashCode != -1) {\r\n return this.cachedHashCode;\r\n }\r\n let hashCode = 1;\r\n hashCode = 5 * hashCode ^ (this.outermostConfigSet ? 1 : 0);\r\n hashCode = 5 * hashCode ^ ArrayEqualityComparator_1.ArrayEqualityComparator.INSTANCE.hashCode(this.configs);\r\n if (this.isReadOnly) {\r\n this.cachedHashCode = hashCode;\r\n }\r\n return hashCode;\r\n }\r\n toString(showContext) {\r\n if (showContext == null) {\r\n showContext = false;\r\n }\r\n let buf = \"\";\r\n let sortedConfigs = this.configs.slice(0);\r\n sortedConfigs.sort((o1, o2) => {\r\n if (o1.alt != o2.alt) {\r\n return o1.alt - o2.alt;\r\n }\r\n else if (o1.state.stateNumber != o2.state.stateNumber) {\r\n return o1.state.stateNumber - o2.state.stateNumber;\r\n }\r\n else {\r\n return o1.semanticContext.toString().localeCompare(o2.semanticContext.toString());\r\n }\r\n });\r\n buf += (\"[\");\r\n for (let i = 0; i < sortedConfigs.length; i++) {\r\n if (i > 0) {\r\n buf += (\", \");\r\n }\r\n buf += (sortedConfigs[i].toString(undefined, true, showContext));\r\n }\r\n buf += (\"]\");\r\n if (this._hasSemanticContext)\r\n buf += (\",hasSemanticContext=\") + (this._hasSemanticContext);\r\n if (this._uniqueAlt !== ATN_1.ATN.INVALID_ALT_NUMBER)\r\n buf += (\",uniqueAlt=\") + (this._uniqueAlt);\r\n if (this._conflictInfo != null) {\r\n buf += (\",conflictingAlts=\") + (this._conflictInfo.conflictedAlts);\r\n if (!this._conflictInfo.isExact) {\r\n buf += (\"*\");\r\n }\r\n }\r\n if (this._dipsIntoOuterContext)\r\n buf += (\",dipsIntoOuterContext\");\r\n return buf.toString();\r\n }\r\n get uniqueAlt() {\r\n return this._uniqueAlt;\r\n }\r\n get hasSemanticContext() {\r\n return this._hasSemanticContext;\r\n }\r\n set hasSemanticContext(value) {\r\n this.ensureWritable();\r\n this._hasSemanticContext = value;\r\n }\r\n get conflictInfo() {\r\n return this._conflictInfo;\r\n }\r\n set conflictInfo(conflictInfo) {\r\n this.ensureWritable();\r\n this._conflictInfo = conflictInfo;\r\n }\r\n get conflictingAlts() {\r\n if (this._conflictInfo == null) {\r\n return undefined;\r\n }\r\n return this._conflictInfo.conflictedAlts;\r\n }\r\n get isExactConflict() {\r\n if (this._conflictInfo == null) {\r\n return false;\r\n }\r\n return this._conflictInfo.isExact;\r\n }\r\n get dipsIntoOuterContext() {\r\n return this._dipsIntoOuterContext;\r\n }\r\n get(index) {\r\n return this.configs[index];\r\n }\r\n remove(indexOrItem) {\r\n this.ensureWritable();\r\n if (!this.mergedConfigs || !this.unmerged) {\r\n throw new Error(\"Covered by ensureWritable but duplicated here for strict null check limitation\");\r\n }\r\n if (typeof indexOrItem !== 'number') {\r\n throw new Error(\"Not supported yet\");\r\n }\r\n let index = indexOrItem;\r\n let config = this.configs[index];\r\n this.configs.splice(index, 1);\r\n let key = this.getKey(config);\r\n if (this.mergedConfigs.get(key) === config) {\r\n this.mergedConfigs.remove(key);\r\n }\r\n else {\r\n for (let i = 0; i < this.unmerged.length; i++) {\r\n if (this.unmerged[i] === config) {\r\n this.unmerged.splice(i, 1);\r\n return;\r\n }\r\n }\r\n }\r\n }\r\n ensureWritable() {\r\n if (this.isReadOnly) {\r\n throw new Error(\"This ATNConfigSet is read only.\");\r\n }\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATNConfigSet.prototype, \"getRepresentedAlternatives\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSet.prototype, \"size\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSet.prototype, \"isEmpty\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSet.prototype, \"contains\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSet.prototype, \"iterator\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSet.prototype, \"toArray\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSet.prototype, \"containsAll\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSet.prototype, \"retainAll\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSet.prototype, \"removeAll\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSet.prototype, \"clear\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSet.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSet.prototype, \"hashCode\", null);\r\nexports.ATNConfigSet = ATNConfigSet;\r\nclass ATNConfigSetIterator {\r\n constructor(set, configs) {\r\n this.index = -1;\r\n this.removed = false;\r\n this.configs = configs;\r\n }\r\n hasNext() {\r\n return this.index + 1 < this.configs.length;\r\n }\r\n next() {\r\n if (!this.hasNext()) {\r\n throw new Error(\"NoSuchElementException\");\r\n }\r\n this.index++;\r\n this.removed = false;\r\n return this.configs[this.index];\r\n }\r\n remove() {\r\n if (this.removed || this.index < 0 || this.index >= this.configs.length) {\r\n throw new Error(\"IllegalStateException\");\r\n }\r\n this.set.remove(this.index);\r\n this.removed = true;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSetIterator.prototype, \"hasNext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSetIterator.prototype, \"next\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfigSetIterator.prototype, \"remove\", null);\r\n//# sourceMappingURL=ATNConfigSet.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:36.9521478-07:00\r\nconst Array2DHashSet_1 = require(\"../misc/Array2DHashSet\");\r\nconst ArrayEqualityComparator_1 = require(\"../misc/ArrayEqualityComparator\");\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst ObjectEqualityComparator_1 = require(\"../misc/ObjectEqualityComparator\");\r\nconst Utils = require(\"../misc/Utils\");\r\nfunction max(items) {\r\n let result;\r\n for (let current of items) {\r\n if (result === undefined) {\r\n result = current;\r\n continue;\r\n }\r\n let comparison = result.compareTo(current);\r\n if (comparison < 0) {\r\n result = current;\r\n }\r\n }\r\n return result;\r\n}\r\nfunction min(items) {\r\n let result;\r\n for (let current of items) {\r\n if (result === undefined) {\r\n result = current;\r\n continue;\r\n }\r\n let comparison = result.compareTo(current);\r\n if (comparison > 0) {\r\n result = current;\r\n }\r\n }\r\n return result;\r\n}\r\n/** A tree structure used to record the semantic context in which\r\n * an ATN configuration is valid. It's either a single predicate,\r\n * a conjunction {@code p1&&p2}, or a sum of products {@code p1||p2}.\r\n *\r\n * <p>I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of\r\n * {@link SemanticContext} within the scope of this outer class.</p>\r\n */\r\nclass SemanticContext {\r\n /**\r\n * The default {@link SemanticContext}, which is semantically equivalent to\r\n * a predicate of the form {@code {true}?}.\r\n */\r\n static get NONE() {\r\n if (SemanticContext._NONE === undefined) {\r\n SemanticContext._NONE = new SemanticContext.Predicate();\r\n }\r\n return SemanticContext._NONE;\r\n }\r\n /**\r\n * Evaluate the precedence predicates for the context and reduce the result.\r\n *\r\n * @param parser The parser instance.\r\n * @param parserCallStack\r\n * @return The simplified semantic context after precedence predicates are\r\n * evaluated, which will be one of the following values.\r\n * <ul>\r\n * <li>{@link #NONE}: if the predicate simplifies to {@code true} after\r\n * precedence predicates are evaluated.</li>\r\n * <li>{@code null}: if the predicate simplifies to {@code false} after\r\n * precedence predicates are evaluated.</li>\r\n * <li>{@code this}: if the semantic context is not changed as a result of\r\n * precedence predicate evaluation.</li>\r\n * <li>A non-{@code null} {@link SemanticContext}: the new simplified\r\n * semantic context after precedence predicates are evaluated.</li>\r\n * </ul>\r\n */\r\n evalPrecedence(parser, parserCallStack) {\r\n return this;\r\n }\r\n static and(a, b) {\r\n if (!a || a === SemanticContext.NONE)\r\n return b;\r\n if (b === SemanticContext.NONE)\r\n return a;\r\n let result = new SemanticContext.AND(a, b);\r\n if (result.opnds.length === 1) {\r\n return result.opnds[0];\r\n }\r\n return result;\r\n }\r\n /**\r\n *\r\n * @see ParserATNSimulator#getPredsForAmbigAlts\r\n */\r\n static or(a, b) {\r\n if (!a) {\r\n return b;\r\n }\r\n if (a === SemanticContext.NONE || b === SemanticContext.NONE)\r\n return SemanticContext.NONE;\r\n let result = new SemanticContext.OR(a, b);\r\n if (result.opnds.length === 1) {\r\n return result.opnds[0];\r\n }\r\n return result;\r\n }\r\n}\r\nexports.SemanticContext = SemanticContext;\r\n(function (SemanticContext) {\r\n /**\r\n * This random 30-bit prime represents the value of `AND.class.hashCode()`.\r\n */\r\n const AND_HASHCODE = 40363613;\r\n /**\r\n * This random 30-bit prime represents the value of `OR.class.hashCode()`.\r\n */\r\n const OR_HASHCODE = 486279973;\r\n function filterPrecedencePredicates(collection) {\r\n let result = [];\r\n for (let i = 0; i < collection.length; i++) {\r\n let context = collection[i];\r\n if (context instanceof SemanticContext.PrecedencePredicate) {\r\n result.push(context);\r\n // Remove the item from 'collection' and move i back so we look at the same index again\r\n collection.splice(i, 1);\r\n i--;\r\n }\r\n }\r\n return result;\r\n }\r\n class Predicate extends SemanticContext {\r\n constructor(ruleIndex = -1, predIndex = -1, isCtxDependent = false) {\r\n super();\r\n this.ruleIndex = ruleIndex;\r\n this.predIndex = predIndex;\r\n this.isCtxDependent = isCtxDependent;\r\n }\r\n eval(parser, parserCallStack) {\r\n let localctx = this.isCtxDependent ? parserCallStack : undefined;\r\n return parser.sempred(localctx, this.ruleIndex, this.predIndex);\r\n }\r\n hashCode() {\r\n let hashCode = MurmurHash_1.MurmurHash.initialize();\r\n hashCode = MurmurHash_1.MurmurHash.update(hashCode, this.ruleIndex);\r\n hashCode = MurmurHash_1.MurmurHash.update(hashCode, this.predIndex);\r\n hashCode = MurmurHash_1.MurmurHash.update(hashCode, this.isCtxDependent ? 1 : 0);\r\n hashCode = MurmurHash_1.MurmurHash.finish(hashCode, 3);\r\n return hashCode;\r\n }\r\n equals(obj) {\r\n if (!(obj instanceof Predicate))\r\n return false;\r\n if (this === obj)\r\n return true;\r\n return this.ruleIndex === obj.ruleIndex &&\r\n this.predIndex === obj.predIndex &&\r\n this.isCtxDependent === obj.isCtxDependent;\r\n }\r\n toString() {\r\n return \"{\" + this.ruleIndex + \":\" + this.predIndex + \"}?\";\r\n }\r\n }\r\n __decorate([\r\n Decorators_1.Override\r\n ], Predicate.prototype, \"eval\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], Predicate.prototype, \"hashCode\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], Predicate.prototype, \"equals\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], Predicate.prototype, \"toString\", null);\r\n SemanticContext.Predicate = Predicate;\r\n class PrecedencePredicate extends SemanticContext {\r\n constructor(precedence) {\r\n super();\r\n this.precedence = precedence;\r\n }\r\n eval(parser, parserCallStack) {\r\n return parser.precpred(parserCallStack, this.precedence);\r\n }\r\n evalPrecedence(parser, parserCallStack) {\r\n if (parser.precpred(parserCallStack, this.precedence)) {\r\n return SemanticContext.NONE;\r\n }\r\n else {\r\n return undefined;\r\n }\r\n }\r\n compareTo(o) {\r\n return this.precedence - o.precedence;\r\n }\r\n hashCode() {\r\n let hashCode = 1;\r\n hashCode = 31 * hashCode + this.precedence;\r\n return hashCode;\r\n }\r\n equals(obj) {\r\n if (!(obj instanceof PrecedencePredicate)) {\r\n return false;\r\n }\r\n if (this === obj) {\r\n return true;\r\n }\r\n return this.precedence === obj.precedence;\r\n }\r\n // precedence >= _precedenceStack.peek()\r\n toString() {\r\n return \"{\" + this.precedence + \">=prec}?\";\r\n }\r\n }\r\n __decorate([\r\n Decorators_1.Override\r\n ], PrecedencePredicate.prototype, \"eval\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], PrecedencePredicate.prototype, \"evalPrecedence\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], PrecedencePredicate.prototype, \"compareTo\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], PrecedencePredicate.prototype, \"hashCode\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], PrecedencePredicate.prototype, \"equals\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], PrecedencePredicate.prototype, \"toString\", null);\r\n SemanticContext.PrecedencePredicate = PrecedencePredicate;\r\n /**\r\n * This is the base class for semantic context \"operators\", which operate on\r\n * a collection of semantic context \"operands\".\r\n *\r\n * @since 4.3\r\n */\r\n class Operator extends SemanticContext {\r\n }\r\n SemanticContext.Operator = Operator;\r\n /**\r\n * A semantic context which is true whenever none of the contained contexts\r\n * is false.\r\n */\r\n let AND = class AND extends Operator {\r\n constructor(a, b) {\r\n super();\r\n let operands = new Array2DHashSet_1.Array2DHashSet(ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE);\r\n if (a instanceof AND)\r\n operands.addAll(a.opnds);\r\n else\r\n operands.add(a);\r\n if (b instanceof AND)\r\n operands.addAll(b.opnds);\r\n else\r\n operands.add(b);\r\n this.opnds = operands.toArray();\r\n let precedencePredicates = filterPrecedencePredicates(this.opnds);\r\n // interested in the transition with the lowest precedence\r\n let reduced = min(precedencePredicates);\r\n if (reduced) {\r\n this.opnds.push(reduced);\r\n }\r\n }\r\n get operands() {\r\n return this.opnds;\r\n }\r\n equals(obj) {\r\n if (this === obj)\r\n return true;\r\n if (!(obj instanceof AND))\r\n return false;\r\n return ArrayEqualityComparator_1.ArrayEqualityComparator.INSTANCE.equals(this.opnds, obj.opnds);\r\n }\r\n hashCode() {\r\n return MurmurHash_1.MurmurHash.hashCode(this.opnds, AND_HASHCODE);\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>\r\n * The evaluation of predicates by this context is short-circuiting, but\r\n * unordered.</p>\r\n */\r\n eval(parser, parserCallStack) {\r\n for (let opnd of this.opnds) {\r\n if (!opnd.eval(parser, parserCallStack))\r\n return false;\r\n }\r\n return true;\r\n }\r\n evalPrecedence(parser, parserCallStack) {\r\n let differs = false;\r\n let operands = [];\r\n for (let context of this.opnds) {\r\n let evaluated = context.evalPrecedence(parser, parserCallStack);\r\n differs = differs || (evaluated !== context);\r\n if (evaluated == null) {\r\n // The AND context is false if any element is false\r\n return undefined;\r\n }\r\n else if (evaluated !== SemanticContext.NONE) {\r\n // Reduce the result by skipping true elements\r\n operands.push(evaluated);\r\n }\r\n }\r\n if (!differs) {\r\n return this;\r\n }\r\n if (operands.length === 0) {\r\n // all elements were true, so the AND context is true\r\n return SemanticContext.NONE;\r\n }\r\n let result = operands[0];\r\n for (let i = 1; i < operands.length; i++) {\r\n result = SemanticContext.and(result, operands[i]);\r\n }\r\n return result;\r\n }\r\n toString() {\r\n return Utils.join(this.opnds, \"&&\");\r\n }\r\n };\r\n __decorate([\r\n Decorators_1.Override\r\n ], AND.prototype, \"operands\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], AND.prototype, \"equals\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], AND.prototype, \"hashCode\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], AND.prototype, \"eval\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], AND.prototype, \"evalPrecedence\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], AND.prototype, \"toString\", null);\r\n AND = __decorate([\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n ], AND);\r\n SemanticContext.AND = AND;\r\n /**\r\n * A semantic context which is true whenever at least one of the contained\r\n * contexts is true.\r\n */\r\n let OR = class OR extends Operator {\r\n constructor(a, b) {\r\n super();\r\n let operands = new Array2DHashSet_1.Array2DHashSet(ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE);\r\n if (a instanceof OR)\r\n operands.addAll(a.opnds);\r\n else\r\n operands.add(a);\r\n if (b instanceof OR)\r\n operands.addAll(b.opnds);\r\n else\r\n operands.add(b);\r\n this.opnds = operands.toArray();\r\n let precedencePredicates = filterPrecedencePredicates(this.opnds);\r\n // interested in the transition with the highest precedence\r\n let reduced = max(precedencePredicates);\r\n if (reduced) {\r\n this.opnds.push(reduced);\r\n }\r\n }\r\n get operands() {\r\n return this.opnds;\r\n }\r\n equals(obj) {\r\n if (this === obj)\r\n return true;\r\n if (!(obj instanceof OR))\r\n return false;\r\n return ArrayEqualityComparator_1.ArrayEqualityComparator.INSTANCE.equals(this.opnds, obj.opnds);\r\n }\r\n hashCode() {\r\n return MurmurHash_1.MurmurHash.hashCode(this.opnds, OR_HASHCODE);\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>\r\n * The evaluation of predicates by this context is short-circuiting, but\r\n * unordered.</p>\r\n */\r\n eval(parser, parserCallStack) {\r\n for (let opnd of this.opnds) {\r\n if (opnd.eval(parser, parserCallStack))\r\n return true;\r\n }\r\n return false;\r\n }\r\n evalPrecedence(parser, parserCallStack) {\r\n let differs = false;\r\n let operands = [];\r\n for (let context of this.opnds) {\r\n let evaluated = context.evalPrecedence(parser, parserCallStack);\r\n differs = differs || (evaluated !== context);\r\n if (evaluated === SemanticContext.NONE) {\r\n // The OR context is true if any element is true\r\n return SemanticContext.NONE;\r\n }\r\n else if (evaluated) {\r\n // Reduce the result by skipping false elements\r\n operands.push(evaluated);\r\n }\r\n }\r\n if (!differs) {\r\n return this;\r\n }\r\n if (operands.length === 0) {\r\n // all elements were false, so the OR context is false\r\n return undefined;\r\n }\r\n let result = operands[0];\r\n for (let i = 1; i < operands.length; i++) {\r\n result = SemanticContext.or(result, operands[i]);\r\n }\r\n return result;\r\n }\r\n toString() {\r\n return Utils.join(this.opnds, \"||\");\r\n }\r\n };\r\n __decorate([\r\n Decorators_1.Override\r\n ], OR.prototype, \"operands\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], OR.prototype, \"equals\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], OR.prototype, \"hashCode\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], OR.prototype, \"eval\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], OR.prototype, \"evalPrecedence\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], OR.prototype, \"toString\", null);\r\n OR = __decorate([\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n ], OR);\r\n SemanticContext.OR = OR;\r\n})(SemanticContext = exports.SemanticContext || (exports.SemanticContext = {}));\r\n//# sourceMappingURL=SemanticContext.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nconst DecisionState_1 = require(\"./DecisionState\");\r\n/** The start of a regular {@code (...)} block. */\r\nclass BlockStartState extends DecisionState_1.DecisionState {\r\n}\r\nexports.BlockStartState = BlockStartState;\r\n//# sourceMappingURL=BlockStartState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst Parser_1 = require(\"./Parser\");\r\nconst RecognitionException_1 = require(\"./RecognitionException\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nclass NoViableAltException extends RecognitionException_1.RecognitionException {\r\n constructor(recognizer, input, startToken, offendingToken, deadEndConfigs, ctx) {\r\n if (recognizer instanceof Parser_1.Parser) {\r\n if (input === undefined) {\r\n input = recognizer.inputStream;\r\n }\r\n if (startToken === undefined) {\r\n startToken = recognizer.currentToken;\r\n }\r\n if (offendingToken === undefined) {\r\n offendingToken = recognizer.currentToken;\r\n }\r\n if (ctx === undefined) {\r\n ctx = recognizer.context;\r\n }\r\n }\r\n super(recognizer, input, ctx);\r\n this._deadEndConfigs = deadEndConfigs;\r\n this._startToken = startToken;\r\n this.setOffendingToken(recognizer, offendingToken);\r\n }\r\n get startToken() {\r\n return this._startToken;\r\n }\r\n get deadEndConfigs() {\r\n return this._deadEndConfigs;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.NotNull\r\n], NoViableAltException.prototype, \"_startToken\", void 0);\r\nexports.NoViableAltException = NoViableAltException;\r\n//# sourceMappingURL=NoViableAltException.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst ATN_1 = require(\"../atn/ATN\");\r\nconst BitSet_1 = require(\"../misc/BitSet\");\r\nconst DFA_1 = require(\"./DFA\");\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst PredictionContext_1 = require(\"../atn/PredictionContext\");\r\nconst assert = require(\"assert\");\r\n/** A DFA state represents a set of possible ATN configurations.\r\n * As Aho, Sethi, Ullman p. 117 says \"The DFA uses its state\r\n * to keep track of all possible states the ATN can be in after\r\n * reading each input symbol. That is to say, after reading\r\n * input a1a2..an, the DFA is in a state that represents the\r\n * subset T of the states of the ATN that are reachable from the\r\n * ATN's start state along some path labeled a1a2..an.\"\r\n * In conventional NFA→DFA conversion, therefore, the subset T\r\n * would be a bitset representing the set of states the\r\n * ATN could be in. We need to track the alt predicted by each\r\n * state as well, however. More importantly, we need to maintain\r\n * a stack of states, tracking the closure operations as they\r\n * jump from rule to rule, emulating rule invocations (method calls).\r\n * I have to add a stack to simulate the proper lookahead sequences for\r\n * the underlying LL grammar from which the ATN was derived.\r\n *\r\n * <p>I use a set of ATNConfig objects not simple states. An ATNConfig\r\n * is both a state (ala normal conversion) and a RuleContext describing\r\n * the chain of rules (if any) followed to arrive at that state.</p>\r\n *\r\n * <p>A DFA state may have multiple references to a particular state,\r\n * but with different ATN contexts (with same or different alts)\r\n * meaning that state was reached via a different set of rule invocations.</p>\r\n */\r\nclass DFAState {\r\n constructor(arg0, arg1) {\r\n this.stateNumber = -1;\r\n let configs;\r\n if (arg0 instanceof DFA_1.DFA) {\r\n configs = arg1;\r\n }\r\n else {\r\n configs = arg0;\r\n }\r\n this.configs = configs;\r\n this.edges = new Map();\r\n this.contextEdges = new Map();\r\n }\r\n get isContextSensitive() {\r\n return !!this.contextSymbols;\r\n }\r\n isContextSymbol(symbol) {\r\n if (!this.isContextSensitive) {\r\n return false;\r\n }\r\n return this.contextSymbols.get(symbol);\r\n }\r\n setContextSymbol(symbol) {\r\n assert(this.isContextSensitive);\r\n this.contextSymbols.set(symbol);\r\n }\r\n setContextSensitive(atn) {\r\n assert(!this.configs.isOutermostConfigSet);\r\n if (this.isContextSensitive) {\r\n return;\r\n }\r\n if (!this.contextSymbols) {\r\n this.contextSymbols = new BitSet_1.BitSet();\r\n }\r\n }\r\n get acceptStateInfo() {\r\n return this._acceptStateInfo;\r\n }\r\n set acceptStateInfo(acceptStateInfo) {\r\n this._acceptStateInfo = acceptStateInfo;\r\n }\r\n get isAcceptState() {\r\n return !!this._acceptStateInfo;\r\n }\r\n get prediction() {\r\n if (!this._acceptStateInfo) {\r\n return ATN_1.ATN.INVALID_ALT_NUMBER;\r\n }\r\n return this._acceptStateInfo.prediction;\r\n }\r\n get lexerActionExecutor() {\r\n if (!this._acceptStateInfo) {\r\n return undefined;\r\n }\r\n return this._acceptStateInfo.lexerActionExecutor;\r\n }\r\n getTarget(symbol) {\r\n return this.edges.get(symbol);\r\n }\r\n setTarget(symbol, target) {\r\n this.edges.set(symbol, target);\r\n }\r\n getEdgeMap() {\r\n return this.edges;\r\n }\r\n getContextTarget(invokingState) {\r\n if (invokingState === PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY) {\r\n invokingState = -1;\r\n }\r\n return this.contextEdges.get(invokingState);\r\n }\r\n setContextTarget(invokingState, target) {\r\n if (!this.isContextSensitive) {\r\n throw new Error(\"The state is not context sensitive.\");\r\n }\r\n if (invokingState === PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY) {\r\n invokingState = -1;\r\n }\r\n this.contextEdges.set(invokingState, target);\r\n }\r\n getContextEdgeMap() {\r\n let map = new Map(this.contextEdges);\r\n if (map.has(-1)) {\r\n if (map.size === 1) {\r\n let result = new Map();\r\n result.set(PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY, map.get(-1));\r\n return result;\r\n }\r\n else {\r\n let removed = map.get(-1);\r\n map.delete(-1);\r\n map.set(PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY, removed);\r\n }\r\n }\r\n return map;\r\n }\r\n hashCode() {\r\n let hash = MurmurHash_1.MurmurHash.initialize(7);\r\n hash = MurmurHash_1.MurmurHash.update(hash, this.configs.hashCode());\r\n hash = MurmurHash_1.MurmurHash.finish(hash, 1);\r\n return hash;\r\n }\r\n /**\r\n * Two {@link DFAState} instances are equal if their ATN configuration sets\r\n * are the same. This method is used to see if a state already exists.\r\n *\r\n * <p>Because the number of alternatives and number of ATN configurations are\r\n * finite, there is a finite number of DFA states that can be processed.\r\n * This is necessary to show that the algorithm terminates.</p>\r\n *\r\n * <p>Cannot test the DFA state numbers here because in\r\n * {@link ParserATNSimulator#addDFAState} we need to know if any other state\r\n * exists that has this exact set of ATN configurations. The\r\n * {@link #stateNumber} is irrelevant.</p>\r\n */\r\n equals(o) {\r\n // compare set of ATN configurations in this set with other\r\n if (this === o)\r\n return true;\r\n if (!(o instanceof DFAState)) {\r\n return false;\r\n }\r\n let other = o;\r\n let sameSet = this.configs.equals(other.configs);\r\n //\t\tSystem.out.println(\"DFAState.equals: \"+configs+(sameSet?\"==\":\"!=\")+other.configs);\r\n return sameSet;\r\n }\r\n toString() {\r\n let buf = \"\";\r\n buf += (this.stateNumber) + (\":\") + (this.configs);\r\n if (this.isAcceptState) {\r\n buf += (\"=>\");\r\n if (this.predicates) {\r\n buf += this.predicates;\r\n }\r\n else {\r\n buf += (this.prediction);\r\n }\r\n }\r\n return buf.toString();\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.NotNull\r\n], DFAState.prototype, \"configs\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], DFAState.prototype, \"edges\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], DFAState.prototype, \"contextEdges\", void 0);\r\n__decorate([\r\n Decorators_1.Override\r\n], DFAState.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], DFAState.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], DFAState.prototype, \"toString\", null);\r\nexports.DFAState = DFAState;\r\n(function (DFAState) {\r\n /** Map a predicate to a predicted alternative. */\r\n let PredPrediction = class PredPrediction {\r\n constructor(pred, alt) {\r\n this.alt = alt;\r\n this.pred = pred;\r\n }\r\n toString() {\r\n return \"(\" + this.pred + \", \" + this.alt + \")\";\r\n }\r\n };\r\n __decorate([\r\n Decorators_1.NotNull\r\n ], PredPrediction.prototype, \"pred\", void 0);\r\n __decorate([\r\n Decorators_1.Override\r\n ], PredPrediction.prototype, \"toString\", null);\r\n PredPrediction = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n ], PredPrediction);\r\n DFAState.PredPrediction = PredPrediction;\r\n})(DFAState = exports.DFAState || (exports.DFAState = {}));\r\n//# sourceMappingURL=DFAState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:25.2796692-07:00\r\nconst Array2DHashMap_1 = require(\"../misc/Array2DHashMap\");\r\nconst DecisionState_1 = require(\"./DecisionState\");\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst ObjectEqualityComparator_1 = require(\"../misc/ObjectEqualityComparator\");\r\nconst PredictionContext_1 = require(\"./PredictionContext\");\r\nconst SemanticContext_1 = require(\"./SemanticContext\");\r\nconst assert = require(\"assert\");\r\n/**\r\n * This field stores the bit mask for implementing the\r\n * {@link #isPrecedenceFilterSuppressed} property as a bit within the\r\n * existing {@link #altAndOuterContextDepth} field.\r\n */\r\nconst SUPPRESS_PRECEDENCE_FILTER = 0x80000000;\r\n/** A tuple: (ATN state, predicted alt, syntactic, semantic context).\r\n * The syntactic context is a graph-structured stack node whose\r\n * path(s) to the root is the rule invocation(s)\r\n * chain used to arrive at the state. The semantic context is\r\n * the tree of semantic predicates encountered before reaching\r\n * an ATN state.\r\n */\r\nlet ATNConfig = class ATNConfig {\r\n constructor(state, altOrConfig, context) {\r\n if (typeof altOrConfig === 'number') {\r\n assert((altOrConfig & 0xFFFFFF) == altOrConfig);\r\n this._state = state;\r\n this.altAndOuterContextDepth = altOrConfig;\r\n this._context = context;\r\n }\r\n else {\r\n this._state = state;\r\n this.altAndOuterContextDepth = altOrConfig.altAndOuterContextDepth;\r\n this._context = context;\r\n }\r\n }\r\n static create(state, alt, context, semanticContext = SemanticContext_1.SemanticContext.NONE, lexerActionExecutor) {\r\n if (semanticContext != SemanticContext_1.SemanticContext.NONE) {\r\n if (lexerActionExecutor != null) {\r\n return new ActionSemanticContextATNConfig(lexerActionExecutor, semanticContext, state, alt, context, false);\r\n }\r\n else {\r\n return new SemanticContextATNConfig(semanticContext, state, alt, context);\r\n }\r\n }\r\n else if (lexerActionExecutor != null) {\r\n return new ActionATNConfig(lexerActionExecutor, state, alt, context, false);\r\n }\r\n else {\r\n return new ATNConfig(state, alt, context);\r\n }\r\n }\r\n /** Gets the ATN state associated with this configuration */\r\n get state() {\r\n return this._state;\r\n }\r\n /** What alt (or lexer rule) is predicted by this configuration */\r\n get alt() {\r\n return this.altAndOuterContextDepth & 0x00FFFFFF;\r\n }\r\n get context() {\r\n return this._context;\r\n }\r\n set context(context) {\r\n this._context = context;\r\n }\r\n get reachesIntoOuterContext() {\r\n return this.outerContextDepth !== 0;\r\n }\r\n /**\r\n * We cannot execute predicates dependent upon local context unless\r\n * we know for sure we are in the correct context. Because there is\r\n * no way to do this efficiently, we simply cannot evaluate\r\n * dependent predicates unless we are in the rule that initially\r\n * invokes the ATN simulator.\r\n *\r\n * <p>\r\n * closure() tracks the depth of how far we dip into the outer context:\r\n * depth > 0. Note that it may not be totally accurate depth since I\r\n * don't ever decrement. TODO: make it a boolean then</p>\r\n */\r\n get outerContextDepth() {\r\n return (this.altAndOuterContextDepth >>> 24) & 0x7F;\r\n }\r\n set outerContextDepth(outerContextDepth) {\r\n assert(outerContextDepth >= 0);\r\n // saturate at 0x7F - everything but zero/positive is only used for debug information anyway\r\n outerContextDepth = Math.min(outerContextDepth, 0x7F);\r\n this.altAndOuterContextDepth = ((outerContextDepth << 24) | (this.altAndOuterContextDepth & ~0x7F000000) >>> 0);\r\n }\r\n get lexerActionExecutor() {\r\n return undefined;\r\n }\r\n get semanticContext() {\r\n return SemanticContext_1.SemanticContext.NONE;\r\n }\r\n get hasPassedThroughNonGreedyDecision() {\r\n return false;\r\n }\r\n clone() {\r\n return this.transform(this.state, false);\r\n }\r\n transform(/*@NotNull*/ state, checkNonGreedy, arg2) {\r\n if (arg2 == null) {\r\n return this.transformImpl(state, this._context, this.semanticContext, checkNonGreedy, this.lexerActionExecutor);\r\n }\r\n else if (arg2 instanceof PredictionContext_1.PredictionContext) {\r\n return this.transformImpl(state, arg2, this.semanticContext, checkNonGreedy, this.lexerActionExecutor);\r\n }\r\n else if (arg2 instanceof SemanticContext_1.SemanticContext) {\r\n return this.transformImpl(state, this._context, arg2, checkNonGreedy, this.lexerActionExecutor);\r\n }\r\n else {\r\n return this.transformImpl(state, this._context, this.semanticContext, checkNonGreedy, arg2);\r\n }\r\n }\r\n transformImpl(state, context, semanticContext, checkNonGreedy, lexerActionExecutor) {\r\n let passedThroughNonGreedy = checkNonGreedy && ATNConfig.checkNonGreedyDecision(this, state);\r\n if (semanticContext != SemanticContext_1.SemanticContext.NONE) {\r\n if (lexerActionExecutor != null || passedThroughNonGreedy) {\r\n return new ActionSemanticContextATNConfig(lexerActionExecutor, semanticContext, state, this, context, passedThroughNonGreedy);\r\n }\r\n else {\r\n return new SemanticContextATNConfig(semanticContext, state, this, context);\r\n }\r\n }\r\n else if (lexerActionExecutor != null || passedThroughNonGreedy) {\r\n return new ActionATNConfig(lexerActionExecutor, state, this, context, passedThroughNonGreedy);\r\n }\r\n else {\r\n return new ATNConfig(state, this, context);\r\n }\r\n }\r\n static checkNonGreedyDecision(source, target) {\r\n return source.hasPassedThroughNonGreedyDecision\r\n || target instanceof DecisionState_1.DecisionState && target.nonGreedy;\r\n }\r\n appendContext(context, contextCache) {\r\n if (typeof context === 'number') {\r\n let appendedContext = this.context.appendSingleContext(context, contextCache);\r\n let result = this.transform(this.state, false, appendedContext);\r\n return result;\r\n }\r\n else {\r\n let appendedContext = this.context.appendContext(context, contextCache);\r\n let result = this.transform(this.state, false, appendedContext);\r\n return result;\r\n }\r\n }\r\n contains(subconfig) {\r\n if (this.state.stateNumber !== subconfig.state.stateNumber\r\n || this.alt !== subconfig.alt\r\n || !this.semanticContext.equals(subconfig.semanticContext)) {\r\n return false;\r\n }\r\n let leftWorkList = [];\r\n let rightWorkList = [];\r\n leftWorkList.push(this.context);\r\n rightWorkList.push(subconfig.context);\r\n while (true) {\r\n let left = leftWorkList.pop();\r\n let right = rightWorkList.pop();\r\n if (!left || !right) {\r\n break;\r\n }\r\n if (left === right) {\r\n return true;\r\n }\r\n if (left.size < right.size) {\r\n return false;\r\n }\r\n if (right.isEmpty) {\r\n return left.hasEmpty;\r\n }\r\n else {\r\n for (let i = 0; i < right.size; i++) {\r\n let index = left.findReturnState(right.getReturnState(i));\r\n if (index < 0) {\r\n // assumes invokingStates has no duplicate entries\r\n return false;\r\n }\r\n leftWorkList.push(left.getParent(index));\r\n rightWorkList.push(right.getParent(i));\r\n }\r\n }\r\n }\r\n return false;\r\n }\r\n get isPrecedenceFilterSuppressed() {\r\n return (this.altAndOuterContextDepth & SUPPRESS_PRECEDENCE_FILTER) !== 0;\r\n }\r\n set isPrecedenceFilterSuppressed(value) {\r\n if (value) {\r\n this.altAndOuterContextDepth |= SUPPRESS_PRECEDENCE_FILTER;\r\n }\r\n else {\r\n this.altAndOuterContextDepth &= ~SUPPRESS_PRECEDENCE_FILTER;\r\n }\r\n }\r\n /** An ATN configuration is equal to another if both have\r\n * the same state, they predict the same alternative, and\r\n * syntactic/semantic contexts are the same.\r\n */\r\n equals(o) {\r\n if (this === o) {\r\n return true;\r\n }\r\n else if (!(o instanceof ATNConfig)) {\r\n return false;\r\n }\r\n return this.state.stateNumber == o.state.stateNumber\r\n && this.alt == o.alt\r\n && this.reachesIntoOuterContext == o.reachesIntoOuterContext\r\n && this.context.equals(o.context)\r\n && this.semanticContext.equals(o.semanticContext)\r\n && this.isPrecedenceFilterSuppressed == o.isPrecedenceFilterSuppressed\r\n && this.hasPassedThroughNonGreedyDecision == o.hasPassedThroughNonGreedyDecision\r\n && ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE.equals(this.lexerActionExecutor, o.lexerActionExecutor);\r\n }\r\n hashCode() {\r\n let hashCode = MurmurHash_1.MurmurHash.initialize(7);\r\n hashCode = MurmurHash_1.MurmurHash.update(hashCode, this.state.stateNumber);\r\n hashCode = MurmurHash_1.MurmurHash.update(hashCode, this.alt);\r\n hashCode = MurmurHash_1.MurmurHash.update(hashCode, this.reachesIntoOuterContext ? 1 : 0);\r\n hashCode = MurmurHash_1.MurmurHash.update(hashCode, this.context);\r\n hashCode = MurmurHash_1.MurmurHash.update(hashCode, this.semanticContext);\r\n hashCode = MurmurHash_1.MurmurHash.update(hashCode, this.hasPassedThroughNonGreedyDecision ? 1 : 0);\r\n hashCode = MurmurHash_1.MurmurHash.update(hashCode, this.lexerActionExecutor);\r\n hashCode = MurmurHash_1.MurmurHash.finish(hashCode, 7);\r\n return hashCode;\r\n }\r\n toDotString() {\r\n let builder = \"\";\r\n builder += (\"digraph G {\\n\");\r\n builder += (\"rankdir=LR;\\n\");\r\n let visited = new Array2DHashMap_1.Array2DHashMap(PredictionContext_1.PredictionContext.IdentityEqualityComparator.INSTANCE);\r\n let workList = [];\r\n function getOrAddContext(context) {\r\n let newNumber = visited.size;\r\n let result = visited.putIfAbsent(context, newNumber);\r\n if (result != null) {\r\n // Already saw this context\r\n return result;\r\n }\r\n workList.push(context);\r\n return newNumber;\r\n }\r\n workList.push(this.context);\r\n visited.put(this.context, 0);\r\n while (true) {\r\n let current = workList.pop();\r\n if (!current) {\r\n break;\r\n }\r\n for (let i = 0; i < current.size; i++) {\r\n builder += (\" s\") + (getOrAddContext(current));\r\n builder += (\"->\");\r\n builder += (\"s\") + (getOrAddContext(current.getParent(i)));\r\n builder += (\"[label=\\\"\") + (current.getReturnState(i)) + (\"\\\"];\\n\");\r\n }\r\n }\r\n builder += (\"}\\n\");\r\n return builder.toString();\r\n }\r\n toString(recog, showAlt, showContext) {\r\n // Must check showContext before showAlt to preserve original overload behavior\r\n if (showContext == null) {\r\n showContext = showAlt != null;\r\n }\r\n if (showAlt == null) {\r\n showAlt = true;\r\n }\r\n let buf = \"\";\r\n // if (this.state.ruleIndex >= 0) {\r\n // \tif (recog != null) {\r\n // \t\tbuf += (recog.ruleNames[this.state.ruleIndex] + \":\");\r\n // \t} else {\r\n // \t\tbuf += (this.state.ruleIndex + \":\");\r\n // \t}\r\n // }\r\n let contexts;\r\n if (showContext) {\r\n contexts = this.context.toStrings(recog, this.state.stateNumber);\r\n }\r\n else {\r\n contexts = [\"?\"];\r\n }\r\n let first = true;\r\n for (let contextDesc of contexts) {\r\n if (first) {\r\n first = false;\r\n }\r\n else {\r\n buf += (\", \");\r\n }\r\n buf += ('(');\r\n buf += (this.state);\r\n if (showAlt) {\r\n buf += (\",\");\r\n buf += (this.alt);\r\n }\r\n if (this.context) {\r\n buf += (\",\");\r\n buf += (contextDesc);\r\n }\r\n if (this.semanticContext !== SemanticContext_1.SemanticContext.NONE) {\r\n buf += (\",\");\r\n buf += (this.semanticContext);\r\n }\r\n if (this.reachesIntoOuterContext) {\r\n buf += (\",up=\") + (this.outerContextDepth);\r\n }\r\n buf += (')');\r\n }\r\n return buf.toString();\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATNConfig.prototype, \"_state\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATNConfig.prototype, \"_context\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATNConfig.prototype, \"state\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], ATNConfig.prototype, \"context\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATNConfig.prototype, \"semanticContext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfig.prototype, \"clone\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)\r\n], ATNConfig.prototype, \"transformImpl\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfig.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ATNConfig.prototype, \"hashCode\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull), __param(3, Decorators_1.NotNull)\r\n], ATNConfig, \"create\", null);\r\nATNConfig = __decorate([\r\n __param(0, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)\r\n], ATNConfig);\r\nexports.ATNConfig = ATNConfig;\r\nlet SemanticContextATNConfig = class SemanticContextATNConfig extends ATNConfig {\r\n constructor(semanticContext, state, altOrConfig, context) {\r\n if (typeof altOrConfig === 'number') {\r\n super(state, altOrConfig, context);\r\n }\r\n else {\r\n super(state, altOrConfig, context);\r\n }\r\n this._semanticContext = semanticContext;\r\n }\r\n get semanticContext() {\r\n return this._semanticContext;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], SemanticContextATNConfig.prototype, \"_semanticContext\", void 0);\r\n__decorate([\r\n Decorators_1.Override\r\n], SemanticContextATNConfig.prototype, \"semanticContext\", null);\r\nSemanticContextATNConfig = __decorate([\r\n __param(1, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)\r\n], SemanticContextATNConfig);\r\nlet ActionATNConfig = class ActionATNConfig extends ATNConfig {\r\n constructor(lexerActionExecutor, state, altOrConfig, context, passedThroughNonGreedyDecision) {\r\n if (typeof altOrConfig === 'number') {\r\n super(state, altOrConfig, context);\r\n }\r\n else {\r\n super(state, altOrConfig, context);\r\n if (altOrConfig.semanticContext !== SemanticContext_1.SemanticContext.NONE) {\r\n throw new Error(\"Not supported\");\r\n }\r\n }\r\n this._lexerActionExecutor = lexerActionExecutor;\r\n this.passedThroughNonGreedyDecision = passedThroughNonGreedyDecision;\r\n }\r\n get lexerActionExecutor() {\r\n return this._lexerActionExecutor;\r\n }\r\n get hasPassedThroughNonGreedyDecision() {\r\n return this.passedThroughNonGreedyDecision;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override\r\n], ActionATNConfig.prototype, \"lexerActionExecutor\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ActionATNConfig.prototype, \"hasPassedThroughNonGreedyDecision\", null);\r\nActionATNConfig = __decorate([\r\n __param(1, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)\r\n], ActionATNConfig);\r\nlet ActionSemanticContextATNConfig = class ActionSemanticContextATNConfig extends SemanticContextATNConfig {\r\n constructor(lexerActionExecutor, semanticContext, state, altOrConfig, context, passedThroughNonGreedyDecision) {\r\n if (typeof altOrConfig === 'number') {\r\n super(semanticContext, state, altOrConfig, context);\r\n }\r\n else {\r\n super(semanticContext, state, altOrConfig, context);\r\n }\r\n this._lexerActionExecutor = lexerActionExecutor;\r\n this.passedThroughNonGreedyDecision = passedThroughNonGreedyDecision;\r\n }\r\n get lexerActionExecutor() {\r\n return this._lexerActionExecutor;\r\n }\r\n get hasPassedThroughNonGreedyDecision() {\r\n return this.passedThroughNonGreedyDecision;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override\r\n], ActionSemanticContextATNConfig.prototype, \"lexerActionExecutor\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ActionSemanticContextATNConfig.prototype, \"hasPassedThroughNonGreedyDecision\", null);\r\nActionSemanticContextATNConfig = __decorate([\r\n __param(1, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)\r\n], ActionSemanticContextATNConfig);\r\n//# sourceMappingURL=ATNConfig.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst Interval_1 = require(\"./misc/Interval\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst Token_1 = require(\"./Token\");\r\nlet CommonToken = class CommonToken {\r\n constructor(type, text, source = CommonToken.EMPTY_SOURCE, channel = Token_1.Token.DEFAULT_CHANNEL, start = 0, stop = 0) {\r\n /**\r\n * This is the backing field for {@link #getLine} and {@link #setLine}.\r\n */\r\n this._line = 0;\r\n /**\r\n * This is the backing field for {@link #getCharPositionInLine} and\r\n * {@link #setCharPositionInLine}.\r\n */\r\n this._charPositionInLine = -1; // set to invalid position\r\n /**\r\n * This is the backing field for {@link #getChannel} and\r\n * {@link #setChannel}.\r\n */\r\n this._channel = Token_1.Token.DEFAULT_CHANNEL;\r\n /**\r\n * This is the backing field for `tokenIndex`.\r\n */\r\n this.index = -1;\r\n this._text = text;\r\n this._type = type;\r\n this.source = source;\r\n this._channel = channel;\r\n this.start = start;\r\n this.stop = stop;\r\n if (source.source != null) {\r\n this._line = source.source.line;\r\n this._charPositionInLine = source.source.charPositionInLine;\r\n }\r\n }\r\n /**\r\n * Constructs a new {@link CommonToken} as a copy of another {@link Token}.\r\n *\r\n * <p>\r\n * If {@code oldToken} is also a {@link CommonToken} instance, the newly\r\n * constructed token will share a reference to the {@link #text} field and\r\n * the {@link Tuple2} stored in {@link #source}. Otherwise, {@link #text} will\r\n * be assigned the result of calling {@link #getText}, and {@link #source}\r\n * will be constructed from the result of {@link Token#getTokenSource} and\r\n * {@link Token#getInputStream}.</p>\r\n *\r\n * @param oldToken The token to copy.\r\n */\r\n static fromToken(oldToken) {\r\n let result = new CommonToken(oldToken.type, undefined, CommonToken.EMPTY_SOURCE, oldToken.channel, oldToken.startIndex, oldToken.stopIndex);\r\n result._line = oldToken.line;\r\n result.index = oldToken.tokenIndex;\r\n result._charPositionInLine = oldToken.charPositionInLine;\r\n if (oldToken instanceof CommonToken) {\r\n result._text = oldToken.text;\r\n result.source = oldToken.source;\r\n }\r\n else {\r\n result._text = oldToken.text;\r\n result.source = { source: oldToken.tokenSource, stream: oldToken.inputStream };\r\n }\r\n return result;\r\n }\r\n get type() {\r\n return this._type;\r\n }\r\n // @Override\r\n set line(line) {\r\n this._line = line;\r\n }\r\n get text() {\r\n if (this._text != null) {\r\n return this._text;\r\n }\r\n let input = this.inputStream;\r\n if (input == null) {\r\n return undefined;\r\n }\r\n let n = input.size;\r\n if (this.start < n && this.stop < n) {\r\n return input.getText(Interval_1.Interval.of(this.start, this.stop));\r\n }\r\n else {\r\n return \"<EOF>\";\r\n }\r\n }\r\n /**\r\n * Explicitly set the text for this token. If {code text} is not\r\n * {@code null}, then {@link #getText} will return this value rather than\r\n * extracting the text from the input.\r\n *\r\n * @param text The explicit text of the token, or {@code null} if the text\r\n * should be obtained from the input along with the start and stop indexes\r\n * of the token.\r\n */\r\n // @Override\r\n set text(text) {\r\n this._text = text;\r\n }\r\n get line() {\r\n return this._line;\r\n }\r\n get charPositionInLine() {\r\n return this._charPositionInLine;\r\n }\r\n // @Override\r\n set charPositionInLine(charPositionInLine) {\r\n this._charPositionInLine = charPositionInLine;\r\n }\r\n get channel() {\r\n return this._channel;\r\n }\r\n // @Override\r\n set channel(channel) {\r\n this._channel = channel;\r\n }\r\n // @Override\r\n set type(type) {\r\n this._type = type;\r\n }\r\n get startIndex() {\r\n return this.start;\r\n }\r\n set startIndex(start) {\r\n this.start = start;\r\n }\r\n get stopIndex() {\r\n return this.stop;\r\n }\r\n set stopIndex(stop) {\r\n this.stop = stop;\r\n }\r\n get tokenIndex() {\r\n return this.index;\r\n }\r\n // @Override\r\n set tokenIndex(index) {\r\n this.index = index;\r\n }\r\n get tokenSource() {\r\n return this.source.source;\r\n }\r\n get inputStream() {\r\n return this.source.stream;\r\n }\r\n toString(recognizer) {\r\n let channelStr = \"\";\r\n if (this._channel > 0) {\r\n channelStr = \",channel=\" + this._channel;\r\n }\r\n let txt = this.text;\r\n if (txt != null) {\r\n txt = txt.replace(/\\n/g, \"\\\\n\");\r\n txt = txt.replace(/\\r/g, \"\\\\r\");\r\n txt = txt.replace(/\\t/g, \"\\\\t\");\r\n }\r\n else {\r\n txt = \"<no text>\";\r\n }\r\n let typeString = String(this._type);\r\n if (recognizer) {\r\n typeString = recognizer.vocabulary.getDisplayName(this._type);\r\n }\r\n return \"[@\" + this.tokenIndex + \",\" + this.start + \":\" + this.stop + \"='\" + txt + \"',<\" + typeString + \">\" + channelStr + \",\" + this._line + \":\" + this.charPositionInLine + \"]\";\r\n }\r\n};\r\n/**\r\n * An empty {@link Tuple2} which is used as the default value of\r\n * {@link #source} for tokens that do not have a source.\r\n */\r\nCommonToken.EMPTY_SOURCE = { source: undefined, stream: undefined };\r\n__decorate([\r\n Decorators_1.NotNull\r\n], CommonToken.prototype, \"source\", void 0);\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonToken.prototype, \"type\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonToken.prototype, \"text\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonToken.prototype, \"charPositionInLine\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonToken.prototype, \"channel\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonToken.prototype, \"startIndex\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonToken.prototype, \"stopIndex\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonToken.prototype, \"tokenIndex\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonToken.prototype, \"tokenSource\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonToken.prototype, \"inputStream\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonToken.prototype, \"toString\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], CommonToken, \"fromToken\", null);\r\nCommonToken = __decorate([\r\n __param(2, Decorators_1.NotNull)\r\n], CommonToken);\r\nexports.CommonToken = CommonToken;\r\n//# sourceMappingURL=CommonToken.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:51.5187682-07:00\r\n/** This signifies any kind of mismatched input exceptions such as\r\n * when the current input does not match the expected token.\r\n */\r\nconst RecognitionException_1 = require(\"./RecognitionException\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nlet InputMismatchException = class InputMismatchException extends RecognitionException_1.RecognitionException {\r\n //private static serialVersionUID: number = 1532568338707443067L;\r\n constructor(recognizer) {\r\n super(recognizer, recognizer.inputStream, recognizer.context);\r\n super.setOffendingToken(recognizer, recognizer.currentToken);\r\n }\r\n};\r\nInputMismatchException = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], InputMismatchException);\r\nexports.InputMismatchException = InputMismatchException;\r\n//# sourceMappingURL=InputMismatchException.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst MurmurHash_1 = require(\"./MurmurHash\");\r\nconst ObjectEqualityComparator_1 = require(\"./ObjectEqualityComparator\");\r\n/**\r\n * This default implementation of {@link EqualityComparator} uses object equality\r\n * for comparisons by calling {@link Object#hashCode} and {@link Object#equals}.\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass ArrayEqualityComparator {\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This implementation returns\r\n * {@code obj.}{@link Object#hashCode hashCode()}.</p>\r\n */\r\n hashCode(obj) {\r\n if (obj == null) {\r\n return 0;\r\n }\r\n return MurmurHash_1.MurmurHash.hashCode(obj, 0);\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This implementation relies on object equality. If both objects are\r\n * {@code null}, this method returns {@code true}. Otherwise if only\r\n * {@code a} is {@code null}, this method returns {@code false}. Otherwise,\r\n * this method returns the result of\r\n * {@code a.}{@link Object#equals equals}{@code (b)}.</p>\r\n */\r\n equals(a, b) {\r\n if (a == null) {\r\n return b == null;\r\n }\r\n else if (b == null) {\r\n return false;\r\n }\r\n if (a.length !== b.length) {\r\n return false;\r\n }\r\n for (let i = 0; i < a.length; i++) {\r\n if (!ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE.equals(a[i], b[i])) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }\r\n}\r\nArrayEqualityComparator.INSTANCE = new ArrayEqualityComparator();\r\n__decorate([\r\n Decorators_1.Override\r\n], ArrayEqualityComparator.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ArrayEqualityComparator.prototype, \"equals\", null);\r\nexports.ArrayEqualityComparator = ArrayEqualityComparator;\r\n//# sourceMappingURL=ArrayEqualityComparator.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst RecognitionException_1 = require(\"./RecognitionException\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst PredicateTransition_1 = require(\"./atn/PredicateTransition\");\r\nlet FailedPredicateException = class FailedPredicateException extends RecognitionException_1.RecognitionException {\r\n constructor(recognizer, predicate, message) {\r\n super(recognizer, recognizer.inputStream, recognizer.context, FailedPredicateException.formatMessage(predicate, message));\r\n let s = recognizer.interpreter.atn.states[recognizer.state];\r\n let trans = s.transition(0);\r\n if (trans instanceof PredicateTransition_1.PredicateTransition) {\r\n this._ruleIndex = trans.ruleIndex;\r\n this._predicateIndex = trans.predIndex;\r\n }\r\n else {\r\n this._ruleIndex = 0;\r\n this._predicateIndex = 0;\r\n }\r\n this._predicate = predicate;\r\n super.setOffendingToken(recognizer, recognizer.currentToken);\r\n }\r\n get ruleIndex() {\r\n return this._ruleIndex;\r\n }\r\n get predicateIndex() {\r\n return this._predicateIndex;\r\n }\r\n get predicate() {\r\n return this._predicate;\r\n }\r\n static formatMessage(predicate, message) {\r\n if (message) {\r\n return message;\r\n }\r\n return `failed predicate: {${predicate}}?`;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], FailedPredicateException, \"formatMessage\", null);\r\nFailedPredicateException = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], FailedPredicateException);\r\nexports.FailedPredicateException = FailedPredicateException;\r\n//# sourceMappingURL=FailedPredicateException.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:48.1433686-07:00\r\nconst Interval_1 = require(\"../misc/Interval\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst Token_1 = require(\"../Token\");\r\nclass TerminalNode {\r\n constructor(symbol) {\r\n this._symbol = symbol;\r\n }\r\n getChild(i) {\r\n throw new RangeError(\"Terminal Node has no children.\");\r\n }\r\n get symbol() {\r\n return this._symbol;\r\n }\r\n get parent() {\r\n return this._parent;\r\n }\r\n get payload() {\r\n return this._symbol;\r\n }\r\n get sourceInterval() {\r\n let tokenIndex = this._symbol.tokenIndex;\r\n return new Interval_1.Interval(tokenIndex, tokenIndex);\r\n }\r\n get childCount() {\r\n return 0;\r\n }\r\n accept(visitor) {\r\n return visitor.visitTerminal(this);\r\n }\r\n get text() {\r\n return this._symbol.text || \"\";\r\n }\r\n toStringTree(parser) {\r\n return this.toString();\r\n }\r\n toString() {\r\n if (this._symbol.type === Token_1.Token.EOF) {\r\n return \"<EOF>\";\r\n }\r\n return this._symbol.text || \"\";\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], TerminalNode.prototype, \"getChild\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], TerminalNode.prototype, \"parent\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], TerminalNode.prototype, \"payload\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], TerminalNode.prototype, \"sourceInterval\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], TerminalNode.prototype, \"childCount\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], TerminalNode.prototype, \"accept\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], TerminalNode.prototype, \"text\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], TerminalNode.prototype, \"toStringTree\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], TerminalNode.prototype, \"toString\", null);\r\nexports.TerminalNode = TerminalNode;\r\n//# sourceMappingURL=TerminalNode.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:31.1989835-07:00\r\nconst AcceptStateInfo_1 = require(\"../dfa/AcceptStateInfo\");\r\nconst ActionTransition_1 = require(\"./ActionTransition\");\r\nconst Array2DHashSet_1 = require(\"../misc/Array2DHashSet\");\r\nconst Arrays_1 = require(\"../misc/Arrays\");\r\nconst Stubs_1 = require(\"../misc/Stubs\");\r\nconst ATN_1 = require(\"./ATN\");\r\nconst ATNConfig_1 = require(\"./ATNConfig\");\r\nconst ATNConfigSet_1 = require(\"./ATNConfigSet\");\r\nconst ATNSimulator_1 = require(\"./ATNSimulator\");\r\nconst AtomTransition_1 = require(\"./AtomTransition\");\r\nconst BitSet_1 = require(\"../misc/BitSet\");\r\nconst ConflictInfo_1 = require(\"./ConflictInfo\");\r\nconst DecisionState_1 = require(\"./DecisionState\");\r\nconst DFAState_1 = require(\"../dfa/DFAState\");\r\nconst IntegerList_1 = require(\"../misc/IntegerList\");\r\nconst Interval_1 = require(\"../misc/Interval\");\r\nconst IntStream_1 = require(\"../IntStream\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst NotSetTransition_1 = require(\"./NotSetTransition\");\r\nconst NoViableAltException_1 = require(\"../NoViableAltException\");\r\nconst ObjectEqualityComparator_1 = require(\"../misc/ObjectEqualityComparator\");\r\nconst ParserRuleContext_1 = require(\"../ParserRuleContext\");\r\nconst PredictionContext_1 = require(\"./PredictionContext\");\r\nconst PredictionContextCache_1 = require(\"./PredictionContextCache\");\r\nconst PredictionMode_1 = require(\"./PredictionMode\");\r\nconst RuleStopState_1 = require(\"./RuleStopState\");\r\nconst RuleTransition_1 = require(\"./RuleTransition\");\r\nconst SemanticContext_1 = require(\"./SemanticContext\");\r\nconst SetTransition_1 = require(\"./SetTransition\");\r\nconst SimulatorState_1 = require(\"./SimulatorState\");\r\nconst Token_1 = require(\"../Token\");\r\nconst VocabularyImpl_1 = require(\"../VocabularyImpl\");\r\nconst assert = require(\"assert\");\r\nconst MAX_SHORT_VALUE = 0xFFFF;\r\nconst MIN_INTEGER_VALUE = -((1 << 31) >>> 0);\r\n/**\r\n * The embodiment of the adaptive LL(*), ALL(*), parsing strategy.\r\n *\r\n * <p>\r\n * The basic complexity of the adaptive strategy makes it harder to understand.\r\n * We begin with ATN simulation to build paths in a DFA. Subsequent prediction\r\n * requests go through the DFA first. If they reach a state without an edge for\r\n * the current symbol, the algorithm fails over to the ATN simulation to\r\n * complete the DFA path for the current input (until it finds a conflict state\r\n * or uniquely predicting state).</p>\r\n *\r\n * <p>\r\n * All of that is done without using the outer context because we want to create\r\n * a DFA that is not dependent upon the rule invocation stack when we do a\r\n * prediction. One DFA works in all contexts. We avoid using context not\r\n * necessarily because it's slower, although it can be, but because of the DFA\r\n * caching problem. The closure routine only considers the rule invocation stack\r\n * created during prediction beginning in the decision rule. For example, if\r\n * prediction occurs without invoking another rule's ATN, there are no context\r\n * stacks in the configurations. When lack of context leads to a conflict, we\r\n * don't know if it's an ambiguity or a weakness in the strong LL(*) parsing\r\n * strategy (versus full LL(*)).</p>\r\n *\r\n * <p>\r\n * When SLL yields a configuration set with conflict, we rewind the input and\r\n * retry the ATN simulation, this time using full outer context without adding\r\n * to the DFA. Configuration context stacks will be the full invocation stacks\r\n * from the start rule. If we get a conflict using full context, then we can\r\n * definitively say we have a true ambiguity for that input sequence. If we\r\n * don't get a conflict, it implies that the decision is sensitive to the outer\r\n * context. (It is not context-sensitive in the sense of context-sensitive\r\n * grammars.)</p>\r\n *\r\n * <p>\r\n * The next time we reach this DFA state with an SLL conflict, through DFA\r\n * simulation, we will again retry the ATN simulation using full context mode.\r\n * This is slow because we can't save the results and have to \"interpret\" the\r\n * ATN each time we get that input.</p>\r\n *\r\n * <p>\r\n * <strong>CACHING FULL CONTEXT PREDICTIONS</strong></p>\r\n *\r\n * <p>\r\n * We could cache results from full context to predicted alternative easily and\r\n * that saves a lot of time but doesn't work in presence of predicates. The set\r\n * of visible predicates from the ATN start state changes depending on the\r\n * context, because closure can fall off the end of a rule. I tried to cache\r\n * tuples (stack context, semantic context, predicted alt) but it was slower\r\n * than interpreting and much more complicated. Also required a huge amount of\r\n * memory. The goal is not to create the world's fastest parser anyway. I'd like\r\n * to keep this algorithm simple. By launching multiple threads, we can improve\r\n * the speed of parsing across a large number of files.</p>\r\n *\r\n * <p>\r\n * There is no strict ordering between the amount of input used by SLL vs LL,\r\n * which makes it really hard to build a cache for full context. Let's say that\r\n * we have input A B C that leads to an SLL conflict with full context X. That\r\n * implies that using X we might only use A B but we could also use A B C D to\r\n * resolve conflict. Input A B C D could predict alternative 1 in one position\r\n * in the input and A B C E could predict alternative 2 in another position in\r\n * input. The conflicting SLL configurations could still be non-unique in the\r\n * full context prediction, which would lead us to requiring more input than the\r\n * original A B C.\tTo make a\tprediction cache work, we have to track\tthe exact\r\n * input\tused during the previous prediction. That amounts to a cache that maps\r\n * X to a specific DFA for that context.</p>\r\n *\r\n * <p>\r\n * Something should be done for left-recursive expression predictions. They are\r\n * likely LL(1) + pred eval. Easier to do the whole SLL unless error and retry\r\n * with full LL thing Sam does.</p>\r\n *\r\n * <p>\r\n * <strong>AVOIDING FULL CONTEXT PREDICTION</strong></p>\r\n *\r\n * <p>\r\n * We avoid doing full context retry when the outer context is empty, we did not\r\n * dip into the outer context by falling off the end of the decision state rule,\r\n * or when we force SLL mode.</p>\r\n *\r\n * <p>\r\n * As an example of the not dip into outer context case, consider as super\r\n * constructor calls versus function calls. One grammar might look like\r\n * this:</p>\r\n *\r\n * <pre>\r\n * ctorBody\r\n * : '{' superCall? stat* '}'\r\n * ;\r\n * </pre>\r\n *\r\n * <p>\r\n * Or, you might see something like</p>\r\n *\r\n * <pre>\r\n * stat\r\n * : superCall ';'\r\n * | expression ';'\r\n * | ...\r\n * ;\r\n * </pre>\r\n *\r\n * <p>\r\n * In both cases I believe that no closure operations will dip into the outer\r\n * context. In the first case ctorBody in the worst case will stop at the '}'.\r\n * In the 2nd case it should stop at the ';'. Both cases should stay within the\r\n * entry rule and not dip into the outer context.</p>\r\n *\r\n * <p>\r\n * <strong>PREDICATES</strong></p>\r\n *\r\n * <p>\r\n * Predicates are always evaluated if present in either SLL or LL both. SLL and\r\n * LL simulation deals with predicates differently. SLL collects predicates as\r\n * it performs closure operations like ANTLR v3 did. It delays predicate\r\n * evaluation until it reaches and accept state. This allows us to cache the SLL\r\n * ATN simulation whereas, if we had evaluated predicates on-the-fly during\r\n * closure, the DFA state configuration sets would be different and we couldn't\r\n * build up a suitable DFA.</p>\r\n *\r\n * <p>\r\n * When building a DFA accept state during ATN simulation, we evaluate any\r\n * predicates and return the sole semantically valid alternative. If there is\r\n * more than 1 alternative, we report an ambiguity. If there are 0 alternatives,\r\n * we throw an exception. Alternatives without predicates act like they have\r\n * true predicates. The simple way to think about it is to strip away all\r\n * alternatives with false predicates and choose the minimum alternative that\r\n * remains.</p>\r\n *\r\n * <p>\r\n * When we start in the DFA and reach an accept state that's predicated, we test\r\n * those and return the minimum semantically viable alternative. If no\r\n * alternatives are viable, we throw an exception.</p>\r\n *\r\n * <p>\r\n * During full LL ATN simulation, closure always evaluates predicates and\r\n * on-the-fly. This is crucial to reducing the configuration set size during\r\n * closure. It hits a landmine when parsing with the Java grammar, for example,\r\n * without this on-the-fly evaluation.</p>\r\n *\r\n * <p>\r\n * <strong>SHARING DFA</strong></p>\r\n *\r\n * <p>\r\n * All instances of the same parser share the same decision DFAs through a\r\n * static field. Each instance gets its own ATN simulator but they share the\r\n * same {@link ATN#decisionToDFA} field. They also share a\r\n * {@link PredictionContextCache} object that makes sure that all\r\n * {@link PredictionContext} objects are shared among the DFA states. This makes\r\n * a big size difference.</p>\r\n *\r\n * <p>\r\n * <strong>THREAD SAFETY</strong></p>\r\n *\r\n * <p>\r\n * The {@link ParserATNSimulator} locks on the {@link ATN#decisionToDFA} field when\r\n * it adds a new DFA object to that array. {@link #addDFAEdge}\r\n * locks on the DFA for the current decision when setting the\r\n * {@link DFAState#edges} field. {@link #addDFAState} locks on\r\n * the DFA for the current decision when looking up a DFA state to see if it\r\n * already exists. We must make sure that all requests to add DFA states that\r\n * are equivalent result in the same shared DFA object. This is because lots of\r\n * threads will be trying to update the DFA at once. The\r\n * {@link #addDFAState} method also locks inside the DFA lock\r\n * but this time on the shared context cache when it rebuilds the\r\n * configurations' {@link PredictionContext} objects using cached\r\n * subgraphs/nodes. No other locking occurs, even during DFA simulation. This is\r\n * safe as long as we can guarantee that all threads referencing\r\n * {@code s.edge[t]} get the same physical target {@link DFAState}, or\r\n * {@code null}. Once into the DFA, the DFA simulation does not reference the\r\n * {@link DFA#states} map. It follows the {@link DFAState#edges} field to new\r\n * targets. The DFA simulator will either find {@link DFAState#edges} to be\r\n * {@code null}, to be non-{@code null} and {@code dfa.edges[t]} null, or\r\n * {@code dfa.edges[t]} to be non-null. The\r\n * {@link #addDFAEdge} method could be racing to set the field\r\n * but in either case the DFA simulator works; if {@code null}, and requests ATN\r\n * simulation. It could also race trying to get {@code dfa.edges[t]}, but either\r\n * way it will work because it's not doing a test and set operation.</p>\r\n *\r\n * <p>\r\n * <strong>Starting with SLL then failing to combined SLL/LL (Two-Stage\r\n * Parsing)</strong></p>\r\n *\r\n * <p>\r\n * Sam pointed out that if SLL does not give a syntax error, then there is no\r\n * point in doing full LL, which is slower. We only have to try LL if we get a\r\n * syntax error. For maximum speed, Sam starts the parser set to pure SLL\r\n * mode with the {@link BailErrorStrategy}:</p>\r\n *\r\n * <pre>\r\n * parser.interpreter.{@link #setPredictionMode setPredictionMode}{@code (}{@link PredictionMode#SLL}{@code )};\r\n * parser.{@link Parser#setErrorHandler setErrorHandler}(new {@link BailErrorStrategy}());\r\n * </pre>\r\n *\r\n * <p>\r\n * If it does not get a syntax error, then we're done. If it does get a syntax\r\n * error, we need to retry with the combined SLL/LL strategy.</p>\r\n *\r\n * <p>\r\n * The reason this works is as follows. If there are no SLL conflicts, then the\r\n * grammar is SLL (at least for that input set). If there is an SLL conflict,\r\n * the full LL analysis must yield a set of viable alternatives which is a\r\n * subset of the alternatives reported by SLL. If the LL set is a singleton,\r\n * then the grammar is LL but not SLL. If the LL set is the same size as the SLL\r\n * set, the decision is SLL. If the LL set has size > 1, then that decision\r\n * is truly ambiguous on the current input. If the LL set is smaller, then the\r\n * SLL conflict resolution might choose an alternative that the full LL would\r\n * rule out as a possibility based upon better context information. If that's\r\n * the case, then the SLL parse will definitely get an error because the full LL\r\n * analysis says it's not viable. If SLL conflict resolution chooses an\r\n * alternative within the LL set, them both SLL and LL would choose the same\r\n * alternative because they both choose the minimum of multiple conflicting\r\n * alternatives.</p>\r\n *\r\n * <p>\r\n * Let's say we have a set of SLL conflicting alternatives {@code {1, 2, 3}} and\r\n * a smaller LL set called <em>s</em>. If <em>s</em> is {@code {2, 3}}, then SLL\r\n * parsing will get an error because SLL will pursue alternative 1. If\r\n * <em>s</em> is {@code {1, 2}} or {@code {1, 3}} then both SLL and LL will\r\n * choose the same alternative because alternative one is the minimum of either\r\n * set. If <em>s</em> is {@code {2}} or {@code {3}} then SLL will get a syntax\r\n * error. If <em>s</em> is {@code {1}} then SLL will succeed.</p>\r\n *\r\n * <p>\r\n * Of course, if the input is invalid, then we will get an error for sure in\r\n * both SLL and LL parsing. Erroneous input will therefore require 2 passes over\r\n * the input.</p>\r\n */\r\nlet ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimulator {\r\n constructor(atn, parser) {\r\n super(atn);\r\n this.predictionMode = PredictionMode_1.PredictionMode.LL;\r\n this.force_global_context = false;\r\n this.always_try_local_context = true;\r\n /**\r\n * Determines whether the DFA is used for full-context predictions. When\r\n * {@code true}, the DFA stores transition information for both full-context\r\n * and SLL parsing; otherwise, the DFA only stores SLL transition\r\n * information.\r\n *\r\n * <p>\r\n * For some grammars, enabling the full-context DFA can result in a\r\n * substantial performance improvement. However, this improvement typically\r\n * comes at the expense of memory used for storing the cached DFA states,\r\n * configuration sets, and prediction contexts.</p>\r\n *\r\n * <p>\r\n * The default value is {@code false}.</p>\r\n */\r\n this.enable_global_context_dfa = false;\r\n this.optimize_unique_closure = true;\r\n this.optimize_ll1 = true;\r\n this.optimize_tail_calls = true;\r\n this.tail_call_preserves_sll = true;\r\n this.treat_sllk1_conflict_as_ambiguity = false;\r\n /**\r\n * When {@code true}, ambiguous alternatives are reported when they are\r\n * encountered within {@link #execATN}. When {@code false}, these messages\r\n * are suppressed. The default is {@code false}.\r\n * <p>\r\n * When messages about ambiguous alternatives are not required, setting this\r\n * to {@code false} enables additional internal optimizations which may lose\r\n * this information.\r\n */\r\n this.reportAmbiguities = false;\r\n /** By default we do full context-sensitive LL(*) parsing not\r\n * Strong LL(*) parsing. If we fail with Strong LL(*) we\r\n * try full LL(*). That means we rewind and use context information\r\n * when closure operations fall off the end of the rule that\r\n * holds the decision were evaluating.\r\n */\r\n this.userWantsCtxSensitive = true;\r\n this._parser = parser;\r\n }\r\n getPredictionMode() {\r\n return this.predictionMode;\r\n }\r\n setPredictionMode(predictionMode) {\r\n this.predictionMode = predictionMode;\r\n }\r\n reset() {\r\n }\r\n adaptivePredict(input, decision, outerContext, useContext) {\r\n if (useContext === undefined) {\r\n useContext = false;\r\n }\r\n let dfa = this.atn.decisionToDFA[decision];\r\n assert(dfa != null);\r\n if (this.optimize_ll1 && !dfa.isPrecedenceDfa && !dfa.isEmpty) {\r\n let ll_1 = input.LA(1);\r\n if (ll_1 >= 0 && ll_1 <= 0xFFFF) {\r\n let key = ((decision << 16) >>> 0) + ll_1;\r\n let alt = this.atn.LL1Table.get(key);\r\n if (alt != null) {\r\n return alt;\r\n }\r\n }\r\n }\r\n this.dfa = dfa;\r\n if (this.force_global_context) {\r\n useContext = true;\r\n }\r\n else if (!this.always_try_local_context) {\r\n useContext = useContext || dfa.isContextSensitive;\r\n }\r\n this.userWantsCtxSensitive = useContext || (this.predictionMode !== PredictionMode_1.PredictionMode.SLL && outerContext != null && !this.atn.decisionToState[decision].sll);\r\n if (outerContext == null) {\r\n outerContext = ParserRuleContext_1.ParserRuleContext.emptyContext();\r\n }\r\n let state;\r\n if (!dfa.isEmpty) {\r\n state = this.getStartState(dfa, input, outerContext, useContext);\r\n }\r\n if (state == null) {\r\n if (outerContext == null)\r\n outerContext = ParserRuleContext_1.ParserRuleContext.emptyContext();\r\n if (ParserATNSimulator.debug)\r\n console.log(\"ATN decision \" + dfa.decision +\r\n \" exec LA(1)==\" + this.getLookaheadName(input) +\r\n \", outerContext=\" + outerContext.toString(this._parser));\r\n state = this.computeStartState(dfa, outerContext, useContext);\r\n }\r\n let m = input.mark();\r\n let index = input.index;\r\n try {\r\n let alt = this.execDFA(dfa, input, index, state);\r\n if (ParserATNSimulator.debug)\r\n console.log(\"DFA after predictATN: \" + dfa.toString(this._parser.vocabulary, this._parser.ruleNames));\r\n return alt;\r\n }\r\n finally {\r\n this.dfa = undefined;\r\n input.seek(index);\r\n input.release(m);\r\n }\r\n }\r\n getStartState(dfa, input, outerContext, useContext) {\r\n if (!useContext) {\r\n if (dfa.isPrecedenceDfa) {\r\n // the start state for a precedence DFA depends on the current\r\n // parser precedence, and is provided by a DFA method.\r\n let state = dfa.getPrecedenceStartState(this._parser.precedence, false);\r\n if (state == null) {\r\n return undefined;\r\n }\r\n return new SimulatorState_1.SimulatorState(outerContext, state, false, outerContext);\r\n }\r\n else {\r\n if (dfa.s0 == null) {\r\n return undefined;\r\n }\r\n return new SimulatorState_1.SimulatorState(outerContext, dfa.s0, false, outerContext);\r\n }\r\n }\r\n if (!this.enable_global_context_dfa) {\r\n return undefined;\r\n }\r\n let remainingContext = outerContext;\r\n assert(outerContext != null);\r\n let s0;\r\n if (dfa.isPrecedenceDfa) {\r\n s0 = dfa.getPrecedenceStartState(this._parser.precedence, true);\r\n }\r\n else {\r\n s0 = dfa.s0full;\r\n }\r\n while (remainingContext != null && s0 != null && s0.isContextSensitive) {\r\n remainingContext = this.skipTailCalls(remainingContext);\r\n s0 = s0.getContextTarget(this.getReturnState(remainingContext));\r\n if (remainingContext.isEmpty) {\r\n assert(s0 == null || !s0.isContextSensitive);\r\n }\r\n else {\r\n remainingContext = remainingContext.parent;\r\n }\r\n }\r\n if (s0 == null) {\r\n return undefined;\r\n }\r\n return new SimulatorState_1.SimulatorState(outerContext, s0, useContext, remainingContext);\r\n }\r\n execDFA(dfa, input, startIndex, state) {\r\n let outerContext = state.outerContext;\r\n if (ParserATNSimulator.dfa_debug)\r\n console.log(\"DFA decision \" + dfa.decision +\r\n \" exec LA(1)==\" + this.getLookaheadName(input) +\r\n \", outerContext=\" + outerContext.toString(this._parser));\r\n if (ParserATNSimulator.dfa_debug)\r\n console.log(dfa.toString(this._parser.vocabulary, this._parser.ruleNames));\r\n let s = state.s0;\r\n let t = input.LA(1);\r\n let remainingOuterContext = state.remainingOuterContext;\r\n while (true) {\r\n if (ParserATNSimulator.dfa_debug)\r\n console.log(\"DFA state \" + s.stateNumber + \" LA(1)==\" + this.getLookaheadName(input));\r\n if (state.useContext) {\r\n while (s.isContextSymbol(t)) {\r\n let next;\r\n if (remainingOuterContext != null) {\r\n remainingOuterContext = this.skipTailCalls(remainingOuterContext);\r\n next = s.getContextTarget(this.getReturnState(remainingOuterContext));\r\n }\r\n if (next == null) {\r\n // fail over to ATN\r\n let initialState = new SimulatorState_1.SimulatorState(state.outerContext, s, state.useContext, remainingOuterContext);\r\n return this.execATN(dfa, input, startIndex, initialState);\r\n }\r\n assert(remainingOuterContext != null);\r\n remainingOuterContext = remainingOuterContext.parent;\r\n s = next;\r\n }\r\n }\r\n if (this.isAcceptState(s, state.useContext)) {\r\n if (s.predicates != null) {\r\n if (ParserATNSimulator.dfa_debug)\r\n console.log(\"accept \" + s);\r\n }\r\n else {\r\n if (ParserATNSimulator.dfa_debug)\r\n console.log(\"accept; predict \" + s.prediction + \" in state \" + s.stateNumber);\r\n }\r\n // keep going unless we're at EOF or state only has one alt number\r\n // mentioned in configs; check if something else could match\r\n // TODO: don't we always stop? only lexer would keep going\r\n // TODO: v3 dfa don't do this.\r\n break;\r\n }\r\n // t is not updated if one of these states is reached\r\n assert(!this.isAcceptState(s, state.useContext));\r\n // if no edge, pop over to ATN interpreter, update DFA and return\r\n let target = this.getExistingTargetState(s, t);\r\n if (target == null) {\r\n if (ParserATNSimulator.dfa_debug && t >= 0)\r\n console.log(\"no edge for \" + this._parser.vocabulary.getDisplayName(t));\r\n let alt;\r\n if (ParserATNSimulator.dfa_debug) {\r\n let interval = Interval_1.Interval.of(startIndex, this._parser.inputStream.index);\r\n console.log(\"ATN exec upon \" +\r\n this._parser.inputStream.getText(interval) +\r\n \" at DFA state \" + s.stateNumber);\r\n }\r\n let initialState = new SimulatorState_1.SimulatorState(outerContext, s, state.useContext, remainingOuterContext);\r\n alt = this.execATN(dfa, input, startIndex, initialState);\r\n if (ParserATNSimulator.dfa_debug) {\r\n console.log(\"back from DFA update, alt=\" + alt + \", dfa=\\n\" + dfa.toString(this._parser.vocabulary, this._parser.ruleNames));\r\n }\r\n // action already executed\r\n if (ParserATNSimulator.dfa_debug)\r\n console.log(\"DFA decision \" + dfa.decision +\r\n \" predicts \" + alt);\r\n return alt; // we've updated DFA, exec'd action, and have our deepest answer\r\n }\r\n else if (target === ATNSimulator_1.ATNSimulator.ERROR) {\r\n let errorState = new SimulatorState_1.SimulatorState(outerContext, s, state.useContext, remainingOuterContext);\r\n return this.handleNoViableAlt(input, startIndex, errorState);\r\n }\r\n s = target;\r\n if (!this.isAcceptState(s, state.useContext) && t !== IntStream_1.IntStream.EOF) {\r\n input.consume();\r\n t = input.LA(1);\r\n }\r\n }\r\n //\t\tif ( acceptState==null ) {\r\n //\t\t\tif ( debug ) System.out.println(\"!!! no viable alt in dfa\");\r\n //\t\t\treturn -1;\r\n //\t\t}\r\n if (!state.useContext && s.configs.conflictInfo != null) {\r\n if (dfa.atnStartState instanceof DecisionState_1.DecisionState) {\r\n if (!this.userWantsCtxSensitive ||\r\n (!s.configs.dipsIntoOuterContext && s.configs.isExactConflict) ||\r\n (this.treat_sllk1_conflict_as_ambiguity && input.index === startIndex)) {\r\n }\r\n else {\r\n assert(!state.useContext);\r\n // Before attempting full context prediction, check to see if there are\r\n // disambiguating or validating predicates to evaluate which allow an\r\n // immediate decision\r\n let conflictingAlts;\r\n let predicates = s.predicates;\r\n if (predicates != null) {\r\n let conflictIndex = input.index;\r\n if (conflictIndex !== startIndex) {\r\n input.seek(startIndex);\r\n }\r\n conflictingAlts = this.evalSemanticContext(predicates, outerContext, true);\r\n if (conflictingAlts.cardinality() === 1) {\r\n return conflictingAlts.nextSetBit(0);\r\n }\r\n if (conflictIndex !== startIndex) {\r\n // restore the index so reporting the fallback to full\r\n // context occurs with the index at the correct spot\r\n input.seek(conflictIndex);\r\n }\r\n }\r\n if (this.reportAmbiguities) {\r\n let conflictState = new SimulatorState_1.SimulatorState(outerContext, s, state.useContext, remainingOuterContext);\r\n this.reportAttemptingFullContext(dfa, conflictingAlts, conflictState, startIndex, input.index);\r\n }\r\n input.seek(startIndex);\r\n return this.adaptivePredict(input, dfa.decision, outerContext, true);\r\n }\r\n }\r\n }\r\n // Before jumping to prediction, check to see if there are\r\n // disambiguating or validating predicates to evaluate\r\n let predicates = s.predicates;\r\n if (predicates != null) {\r\n let stopIndex = input.index;\r\n if (startIndex !== stopIndex) {\r\n input.seek(startIndex);\r\n }\r\n let alts = this.evalSemanticContext(predicates, outerContext, this.reportAmbiguities && this.predictionMode === PredictionMode_1.PredictionMode.LL_EXACT_AMBIG_DETECTION);\r\n switch (alts.cardinality()) {\r\n case 0:\r\n throw this.noViableAlt(input, outerContext, s.configs, startIndex);\r\n case 1:\r\n return alts.nextSetBit(0);\r\n default:\r\n // report ambiguity after predicate evaluation to make sure the correct\r\n // set of ambig alts is reported.\r\n if (startIndex !== stopIndex) {\r\n input.seek(stopIndex);\r\n }\r\n this.reportAmbiguity(dfa, s, startIndex, stopIndex, s.configs.isExactConflict, alts, s.configs);\r\n return alts.nextSetBit(0);\r\n }\r\n }\r\n if (ParserATNSimulator.dfa_debug)\r\n console.log(\"DFA decision \" + dfa.decision +\r\n \" predicts \" + s.prediction);\r\n return s.prediction;\r\n }\r\n /**\r\n * Determines if a particular DFA state should be treated as an accept state\r\n * for the current prediction mode. In addition to the {@code useContext}\r\n * parameter, the {@link #getPredictionMode()} method provides the\r\n * prediction mode controlling the prediction algorithm as a whole.\r\n *\r\n * <p>\r\n * The default implementation simply returns the value of\r\n * `DFAState.isAcceptState` except for conflict states when\r\n * {@code useContext} is {@code true} and {@link #getPredictionMode()} is\r\n * {@link PredictionMode#LL_EXACT_AMBIG_DETECTION}. In that case, only\r\n * conflict states where {@link ATNConfigSet#isExactConflict} is\r\n * {@code true} are considered accept states.\r\n * </p>\r\n *\r\n * @param state The DFA state to check.\r\n * @param useContext {@code true} if the prediction algorithm is currently\r\n * considering the full parser context; otherwise, {@code false} if the\r\n * algorithm is currently performing a local context prediction.\r\n *\r\n * @return {@code true} if the specified {@code state} is an accept state;\r\n * otherwise, {@code false}.\r\n */\r\n isAcceptState(state, useContext) {\r\n if (!state.isAcceptState) {\r\n return false;\r\n }\r\n if (state.configs.conflictingAlts == null) {\r\n // unambiguous\r\n return true;\r\n }\r\n // More picky when we need exact conflicts\r\n if (useContext && this.predictionMode === PredictionMode_1.PredictionMode.LL_EXACT_AMBIG_DETECTION) {\r\n return state.configs.isExactConflict;\r\n }\r\n return true;\r\n }\r\n /** Performs ATN simulation to compute a predicted alternative based\r\n * upon the remaining input, but also updates the DFA cache to avoid\r\n * having to traverse the ATN again for the same input sequence.\r\n\r\n There are some key conditions we're looking for after computing a new\r\n set of ATN configs (proposed DFA state):\r\n * if the set is empty, there is no viable alternative for current symbol\r\n * does the state uniquely predict an alternative?\r\n * does the state have a conflict that would prevent us from\r\n putting it on the work list?\r\n * if in non-greedy decision is there a config at a rule stop state?\r\n\r\n We also have some key operations to do:\r\n * add an edge from previous DFA state to potentially new DFA state, D,\r\n upon current symbol but only if adding to work list, which means in all\r\n cases except no viable alternative (and possibly non-greedy decisions?)\r\n * collecting predicates and adding semantic context to DFA accept states\r\n * adding rule context to context-sensitive DFA accept states\r\n * consuming an input symbol\r\n * reporting a conflict\r\n * reporting an ambiguity\r\n * reporting a context sensitivity\r\n * reporting insufficient predicates\r\n\r\n We should isolate those operations, which are side-effecting, to the\r\n main work loop. We can isolate lots of code into other functions, but\r\n they should be side effect free. They can return package that\r\n indicates whether we should report something, whether we need to add a\r\n DFA edge, whether we need to augment accept state with semantic\r\n context or rule invocation context. Actually, it seems like we always\r\n add predicates if they exist, so that can simply be done in the main\r\n loop for any accept state creation or modification request.\r\n\r\n cover these cases:\r\n dead end\r\n single alt\r\n single alt + preds\r\n conflict\r\n conflict + preds\r\n\r\n TODO: greedy + those\r\n\r\n */\r\n execATN(dfa, input, startIndex, initialState) {\r\n if (ParserATNSimulator.debug)\r\n console.log(\"execATN decision \" + dfa.decision + \" exec LA(1)==\" + this.getLookaheadName(input));\r\n let outerContext = initialState.outerContext;\r\n let useContext = initialState.useContext;\r\n let t = input.LA(1);\r\n let previous = initialState;\r\n let contextCache = new PredictionContextCache_1.PredictionContextCache();\r\n while (true) {\r\n let nextState = this.computeReachSet(dfa, previous, t, contextCache);\r\n if (nextState == null) {\r\n this.setDFAEdge(previous.s0, input.LA(1), ATNSimulator_1.ATNSimulator.ERROR);\r\n return this.handleNoViableAlt(input, startIndex, previous);\r\n }\r\n let D = nextState.s0;\r\n // predicted alt => accept state\r\n assert(D.isAcceptState || D.prediction === ATN_1.ATN.INVALID_ALT_NUMBER);\r\n // conflicted => accept state\r\n assert(D.isAcceptState || D.configs.conflictInfo == null);\r\n if (this.isAcceptState(D, useContext)) {\r\n let conflictingAlts = D.configs.conflictingAlts;\r\n let predictedAlt = conflictingAlts == null ? D.prediction : ATN_1.ATN.INVALID_ALT_NUMBER;\r\n if (predictedAlt !== ATN_1.ATN.INVALID_ALT_NUMBER) {\r\n if (this.optimize_ll1\r\n && input.index === startIndex\r\n && !dfa.isPrecedenceDfa\r\n && nextState.outerContext === nextState.remainingOuterContext\r\n && dfa.decision >= 0\r\n && !D.configs.hasSemanticContext) {\r\n if (t >= 0 && t <= MAX_SHORT_VALUE) {\r\n let key = ((dfa.decision << 16) >>> 0) + t;\r\n this.atn.LL1Table.set(key, predictedAlt);\r\n }\r\n }\r\n if (useContext && this.always_try_local_context) {\r\n this.reportContextSensitivity(dfa, predictedAlt, nextState, startIndex, input.index);\r\n }\r\n }\r\n predictedAlt = D.prediction;\r\n //\t\t\t\tint k = input.index - startIndex + 1; // how much input we used\r\n //\t\t\t\tSystem.out.println(\"used k=\"+k);\r\n let attemptFullContext = conflictingAlts != null && this.userWantsCtxSensitive;\r\n if (attemptFullContext) {\r\n // Only exact conflicts are known to be ambiguous when local\r\n // prediction does not step out of the decision rule.\r\n attemptFullContext = !useContext\r\n && (D.configs.dipsIntoOuterContext || !D.configs.isExactConflict)\r\n && (!this.treat_sllk1_conflict_as_ambiguity || input.index !== startIndex);\r\n }\r\n if (D.configs.hasSemanticContext) {\r\n let predPredictions = D.predicates;\r\n if (predPredictions != null) {\r\n let conflictIndex = input.index;\r\n if (conflictIndex !== startIndex) {\r\n input.seek(startIndex);\r\n }\r\n // use complete evaluation here if we'll want to retry with full context if still ambiguous\r\n conflictingAlts = this.evalSemanticContext(predPredictions, outerContext, attemptFullContext || this.reportAmbiguities);\r\n switch (conflictingAlts.cardinality()) {\r\n case 0:\r\n throw this.noViableAlt(input, outerContext, D.configs, startIndex);\r\n case 1:\r\n return conflictingAlts.nextSetBit(0);\r\n default:\r\n break;\r\n }\r\n if (conflictIndex !== startIndex) {\r\n // restore the index so reporting the fallback to full\r\n // context occurs with the index at the correct spot\r\n input.seek(conflictIndex);\r\n }\r\n }\r\n }\r\n if (!attemptFullContext) {\r\n if (conflictingAlts != null) {\r\n if (this.reportAmbiguities && conflictingAlts.cardinality() > 1) {\r\n this.reportAmbiguity(dfa, D, startIndex, input.index, D.configs.isExactConflict, conflictingAlts, D.configs);\r\n }\r\n predictedAlt = conflictingAlts.nextSetBit(0);\r\n }\r\n return predictedAlt;\r\n }\r\n else {\r\n assert(!useContext);\r\n assert(this.isAcceptState(D, false));\r\n if (ParserATNSimulator.debug)\r\n console.log(\"RETRY with outerContext=\" + outerContext);\r\n let fullContextState = this.computeStartState(dfa, outerContext, true);\r\n if (this.reportAmbiguities) {\r\n this.reportAttemptingFullContext(dfa, conflictingAlts, nextState, startIndex, input.index);\r\n }\r\n input.seek(startIndex);\r\n return this.execATN(dfa, input, startIndex, fullContextState);\r\n }\r\n }\r\n previous = nextState;\r\n if (t !== IntStream_1.IntStream.EOF) {\r\n input.consume();\r\n t = input.LA(1);\r\n }\r\n }\r\n }\r\n /**\r\n * This method is used to improve the localization of error messages by\r\n * choosing an alternative rather than throwing a\r\n * {@link NoViableAltException} in particular prediction scenarios where the\r\n * {@link #ERROR} state was reached during ATN simulation.\r\n *\r\n * <p>\r\n * The default implementation of this method uses the following\r\n * algorithm to identify an ATN configuration which successfully parsed the\r\n * decision entry rule. Choosing such an alternative ensures that the\r\n * {@link ParserRuleContext} returned by the calling rule will be complete\r\n * and valid, and the syntax error will be reported later at a more\r\n * localized location.</p>\r\n *\r\n * <ul>\r\n * <li>If no configuration in {@code configs} reached the end of the\r\n * decision rule, return {@link ATN#INVALID_ALT_NUMBER}.</li>\r\n * <li>If all configurations in {@code configs} which reached the end of the\r\n * decision rule predict the same alternative, return that alternative.</li>\r\n * <li>If the configurations in {@code configs} which reached the end of the\r\n * decision rule predict multiple alternatives (call this <em>S</em>),\r\n * choose an alternative in the following order.\r\n * <ol>\r\n * <li>Filter the configurations in {@code configs} to only those\r\n * configurations which remain viable after evaluating semantic predicates.\r\n * If the set of these filtered configurations which also reached the end of\r\n * the decision rule is not empty, return the minimum alternative\r\n * represented in this set.</li>\r\n * <li>Otherwise, choose the minimum alternative in <em>S</em>.</li>\r\n * </ol>\r\n * </li>\r\n * </ul>\r\n *\r\n * <p>\r\n * In some scenarios, the algorithm described above could predict an\r\n * alternative which will result in a {@link FailedPredicateException} in\r\n * parser. Specifically, this could occur if the <em>only</em> configuration\r\n * capable of successfully parsing to the end of the decision rule is\r\n * blocked by a semantic predicate. By choosing this alternative within\r\n * {@link #adaptivePredict} instead of throwing a\r\n * {@link NoViableAltException}, the resulting\r\n * {@link FailedPredicateException} in the parser will identify the specific\r\n * predicate which is preventing the parser from successfully parsing the\r\n * decision rule, which helps developers identify and correct logic errors\r\n * in semantic predicates.\r\n * </p>\r\n *\r\n * @param input The input {@link TokenStream}\r\n * @param startIndex The start index for the current prediction, which is\r\n * the input index where any semantic context in {@code configs} should be\r\n * evaluated\r\n * @param previous The ATN simulation state immediately before the\r\n * {@link #ERROR} state was reached\r\n *\r\n * @return The value to return from {@link #adaptivePredict}, or\r\n * {@link ATN#INVALID_ALT_NUMBER} if a suitable alternative was not\r\n * identified and {@link #adaptivePredict} should report an error instead.\r\n */\r\n handleNoViableAlt(input, startIndex, previous) {\r\n if (previous.s0 != null) {\r\n let alts = new BitSet_1.BitSet();\r\n let maxAlt = 0;\r\n for (let config of Stubs_1.asIterable(previous.s0.configs)) {\r\n if (config.reachesIntoOuterContext || config.state instanceof RuleStopState_1.RuleStopState) {\r\n alts.set(config.alt);\r\n maxAlt = Math.max(maxAlt, config.alt);\r\n }\r\n }\r\n switch (alts.cardinality()) {\r\n case 0:\r\n break;\r\n case 1:\r\n return alts.nextSetBit(0);\r\n default:\r\n if (!previous.s0.configs.hasSemanticContext) {\r\n // configs doesn't contain any predicates, so the predicate\r\n // filtering code below would be pointless\r\n return alts.nextSetBit(0);\r\n }\r\n /*\r\n * Try to find a configuration set that not only dipped into the outer\r\n * context, but also isn't eliminated by a predicate.\r\n */\r\n let filteredConfigs = new ATNConfigSet_1.ATNConfigSet();\r\n for (let config of Stubs_1.asIterable(previous.s0.configs)) {\r\n if (config.reachesIntoOuterContext || config.state instanceof RuleStopState_1.RuleStopState) {\r\n filteredConfigs.add(config);\r\n }\r\n }\r\n /* The following code blocks are adapted from predicateDFAState with\r\n * the following key changes.\r\n *\r\n * 1. The code operates on an ATNConfigSet rather than a DFAState.\r\n * 2. Predicates are collected for all alternatives represented in\r\n * filteredConfigs, rather than restricting the evaluation to\r\n * conflicting and/or unique configurations.\r\n */\r\n let altToPred = this.getPredsForAmbigAlts(alts, filteredConfigs, maxAlt);\r\n if (altToPred != null) {\r\n let predicates = this.getPredicatePredictions(alts, altToPred);\r\n if (predicates != null) {\r\n let stopIndex = input.index;\r\n try {\r\n input.seek(startIndex);\r\n let filteredAlts = this.evalSemanticContext(predicates, previous.outerContext, false);\r\n if (!filteredAlts.isEmpty) {\r\n return filteredAlts.nextSetBit(0);\r\n }\r\n }\r\n finally {\r\n input.seek(stopIndex);\r\n }\r\n }\r\n }\r\n return alts.nextSetBit(0);\r\n }\r\n }\r\n throw this.noViableAlt(input, previous.outerContext, previous.s0.configs, startIndex);\r\n }\r\n computeReachSet(dfa, previous, t, contextCache) {\r\n let useContext = previous.useContext;\r\n let remainingGlobalContext = previous.remainingOuterContext;\r\n let s = previous.s0;\r\n if (useContext) {\r\n while (s.isContextSymbol(t)) {\r\n let next;\r\n if (remainingGlobalContext != null) {\r\n remainingGlobalContext = this.skipTailCalls(remainingGlobalContext);\r\n next = s.getContextTarget(this.getReturnState(remainingGlobalContext));\r\n }\r\n if (next == null) {\r\n break;\r\n }\r\n assert(remainingGlobalContext != null);\r\n remainingGlobalContext = remainingGlobalContext.parent;\r\n s = next;\r\n }\r\n }\r\n assert(!this.isAcceptState(s, useContext));\r\n if (this.isAcceptState(s, useContext)) {\r\n return new SimulatorState_1.SimulatorState(previous.outerContext, s, useContext, remainingGlobalContext);\r\n }\r\n let s0 = s;\r\n let target = this.getExistingTargetState(s0, t);\r\n if (target == null) {\r\n let result = this.computeTargetState(dfa, s0, remainingGlobalContext, t, useContext, contextCache);\r\n target = result[0];\r\n remainingGlobalContext = result[1];\r\n }\r\n if (target === ATNSimulator_1.ATNSimulator.ERROR) {\r\n return undefined;\r\n }\r\n assert(!useContext || !target.configs.dipsIntoOuterContext);\r\n return new SimulatorState_1.SimulatorState(previous.outerContext, target, useContext, remainingGlobalContext);\r\n }\r\n /**\r\n * Get an existing target state for an edge in the DFA. If the target state\r\n * for the edge has not yet been computed or is otherwise not available,\r\n * this method returns {@code null}.\r\n *\r\n * @param s The current DFA state\r\n * @param t The next input symbol\r\n * @return The existing target DFA state for the given input symbol\r\n * {@code t}, or {@code null} if the target state for this edge is not\r\n * already cached\r\n */\r\n getExistingTargetState(s, t) {\r\n return s.getTarget(t);\r\n }\r\n /**\r\n * Compute a target state for an edge in the DFA, and attempt to add the\r\n * computed state and corresponding edge to the DFA.\r\n *\r\n * @param dfa\r\n * @param s The current DFA state\r\n * @param remainingGlobalContext\r\n * @param t The next input symbol\r\n * @param useContext\r\n * @param contextCache\r\n *\r\n * @return The computed target DFA state for the given input symbol\r\n * {@code t}. If {@code t} does not lead to a valid DFA state, this method\r\n * returns {@link #ERROR}.\r\n */\r\n computeTargetState(dfa, s, remainingGlobalContext, t, useContext, contextCache) {\r\n let closureConfigs = s.configs.toArray();\r\n let contextElements;\r\n let reach = new ATNConfigSet_1.ATNConfigSet();\r\n let stepIntoGlobal;\r\n do {\r\n let hasMoreContext = !useContext || remainingGlobalContext != null;\r\n if (!hasMoreContext) {\r\n reach.isOutermostConfigSet = true;\r\n }\r\n let reachIntermediate = new ATNConfigSet_1.ATNConfigSet();\r\n /* Configurations already in a rule stop state indicate reaching the end\r\n * of the decision rule (local context) or end of the start rule (full\r\n * context). Once reached, these configurations are never updated by a\r\n * closure operation, so they are handled separately for the performance\r\n * advantage of having a smaller intermediate set when calling closure.\r\n *\r\n * For full-context reach operations, separate handling is required to\r\n * ensure that the alternative matching the longest overall sequence is\r\n * chosen when multiple such configurations can match the input.\r\n */\r\n let skippedStopStates;\r\n for (let c of closureConfigs) {\r\n if (ParserATNSimulator.debug)\r\n console.log(\"testing \" + this.getTokenName(t) + \" at \" + c.toString());\r\n if (c.state instanceof RuleStopState_1.RuleStopState) {\r\n assert(c.context.isEmpty);\r\n if (useContext && !c.reachesIntoOuterContext || t === IntStream_1.IntStream.EOF) {\r\n if (skippedStopStates == null) {\r\n skippedStopStates = [];\r\n }\r\n skippedStopStates.push(c);\r\n }\r\n continue;\r\n }\r\n let n = c.state.numberOfOptimizedTransitions;\r\n for (let ti = 0; ti < n; ti++) {\r\n let trans = c.state.getOptimizedTransition(ti);\r\n let target = this.getReachableTarget(c, trans, t);\r\n if (target != null) {\r\n reachIntermediate.add(c.transform(target, false), contextCache);\r\n }\r\n }\r\n }\r\n /* This block optimizes the reach operation for intermediate sets which\r\n * trivially indicate a termination state for the overall\r\n * adaptivePredict operation.\r\n *\r\n * The conditions assume that intermediate\r\n * contains all configurations relevant to the reach set, but this\r\n * condition is not true when one or more configurations have been\r\n * withheld in skippedStopStates, or when the current symbol is EOF.\r\n */\r\n if (this.optimize_unique_closure && skippedStopStates == null && t !== Token_1.Token.EOF && reachIntermediate.uniqueAlt !== ATN_1.ATN.INVALID_ALT_NUMBER) {\r\n reachIntermediate.isOutermostConfigSet = reach.isOutermostConfigSet;\r\n reach = reachIntermediate;\r\n break;\r\n }\r\n /* If the reach set could not be trivially determined, perform a closure\r\n * operation on the intermediate set to compute its initial value.\r\n */\r\n let collectPredicates = false;\r\n let treatEofAsEpsilon = t === Token_1.Token.EOF;\r\n this.closure(reachIntermediate, reach, collectPredicates, hasMoreContext, contextCache, treatEofAsEpsilon);\r\n stepIntoGlobal = reach.dipsIntoOuterContext;\r\n if (t === IntStream_1.IntStream.EOF) {\r\n /* After consuming EOF no additional input is possible, so we are\r\n * only interested in configurations which reached the end of the\r\n * decision rule (local context) or end of the start rule (full\r\n * context). Update reach to contain only these configurations. This\r\n * handles both explicit EOF transitions in the grammar and implicit\r\n * EOF transitions following the end of the decision or start rule.\r\n *\r\n * This is handled before the configurations in skippedStopStates,\r\n * because any configurations potentially added from that list are\r\n * already guaranteed to meet this condition whether or not it's\r\n * required.\r\n */\r\n reach = this.removeAllConfigsNotInRuleStopState(reach, contextCache);\r\n }\r\n /* If skippedStopStates is not null, then it contains at least one\r\n * configuration. For full-context reach operations, these\r\n * configurations reached the end of the start rule, in which case we\r\n * only add them back to reach if no configuration during the current\r\n * closure operation reached such a state. This ensures adaptivePredict\r\n * chooses an alternative matching the longest overall sequence when\r\n * multiple alternatives are viable.\r\n */\r\n if (skippedStopStates != null && (!useContext || !PredictionMode_1.PredictionMode.hasConfigInRuleStopState(reach))) {\r\n assert(skippedStopStates.length > 0);\r\n for (let c of skippedStopStates) {\r\n reach.add(c, contextCache);\r\n }\r\n }\r\n if (useContext && stepIntoGlobal) {\r\n reach.clear();\r\n // We know remainingGlobalContext is not undefined at this point (why?)\r\n remainingGlobalContext = remainingGlobalContext;\r\n remainingGlobalContext = this.skipTailCalls(remainingGlobalContext);\r\n let nextContextElement = this.getReturnState(remainingGlobalContext);\r\n if (contextElements == null) {\r\n contextElements = new IntegerList_1.IntegerList();\r\n }\r\n if (remainingGlobalContext.isEmpty) {\r\n remainingGlobalContext = undefined;\r\n }\r\n else {\r\n remainingGlobalContext = remainingGlobalContext.parent;\r\n }\r\n contextElements.add(nextContextElement);\r\n if (nextContextElement !== PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY) {\r\n for (let i = 0; i < closureConfigs.length; i++) {\r\n closureConfigs[i] = closureConfigs[i].appendContext(nextContextElement, contextCache);\r\n }\r\n }\r\n }\r\n } while (useContext && stepIntoGlobal);\r\n if (reach.isEmpty) {\r\n this.setDFAEdge(s, t, ATNSimulator_1.ATNSimulator.ERROR);\r\n return [ATNSimulator_1.ATNSimulator.ERROR, remainingGlobalContext];\r\n }\r\n let result = this.addDFAEdge(dfa, s, t, contextElements, reach, contextCache);\r\n return [result, remainingGlobalContext];\r\n }\r\n /**\r\n * Return a configuration set containing only the configurations from\r\n * {@code configs} which are in a {@link RuleStopState}. If all\r\n * configurations in {@code configs} are already in a rule stop state, this\r\n * method simply returns {@code configs}.\r\n *\r\n * @param configs the configuration set to update\r\n * @param contextCache the {@link PredictionContext} cache\r\n *\r\n * @return {@code configs} if all configurations in {@code configs} are in a\r\n * rule stop state, otherwise return a new configuration set containing only\r\n * the configurations from {@code configs} which are in a rule stop state\r\n */\r\n removeAllConfigsNotInRuleStopState(configs, contextCache) {\r\n if (PredictionMode_1.PredictionMode.allConfigsInRuleStopStates(configs)) {\r\n return configs;\r\n }\r\n let result = new ATNConfigSet_1.ATNConfigSet();\r\n for (let config of Stubs_1.asIterable(configs)) {\r\n if (!(config.state instanceof RuleStopState_1.RuleStopState)) {\r\n continue;\r\n }\r\n result.add(config, contextCache);\r\n }\r\n return result;\r\n }\r\n computeStartState(dfa, globalContext, useContext) {\r\n let s0 = dfa.isPrecedenceDfa ? dfa.getPrecedenceStartState(this._parser.precedence, useContext) :\r\n useContext ? dfa.s0full :\r\n dfa.s0;\r\n if (s0 != null) {\r\n if (!useContext) {\r\n return new SimulatorState_1.SimulatorState(globalContext, s0, useContext, globalContext);\r\n }\r\n s0.setContextSensitive(this.atn);\r\n }\r\n let decision = dfa.decision;\r\n // @NotNull\r\n let p = dfa.atnStartState;\r\n let previousContext = 0;\r\n let remainingGlobalContext = globalContext;\r\n let initialContext = useContext ? PredictionContext_1.PredictionContext.EMPTY_FULL : PredictionContext_1.PredictionContext.EMPTY_LOCAL; // always at least the implicit call to start rule\r\n let contextCache = new PredictionContextCache_1.PredictionContextCache();\r\n if (useContext) {\r\n if (!this.enable_global_context_dfa) {\r\n while (remainingGlobalContext != null) {\r\n if (remainingGlobalContext.isEmpty) {\r\n previousContext = PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY;\r\n remainingGlobalContext = undefined;\r\n }\r\n else {\r\n previousContext = this.getReturnState(remainingGlobalContext);\r\n initialContext = initialContext.appendSingleContext(previousContext, contextCache);\r\n remainingGlobalContext = remainingGlobalContext.parent;\r\n }\r\n }\r\n }\r\n while (s0 != null && s0.isContextSensitive && remainingGlobalContext != null) {\r\n let next;\r\n remainingGlobalContext = this.skipTailCalls(remainingGlobalContext);\r\n if (remainingGlobalContext.isEmpty) {\r\n next = s0.getContextTarget(PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY);\r\n previousContext = PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY;\r\n remainingGlobalContext = undefined;\r\n }\r\n else {\r\n previousContext = this.getReturnState(remainingGlobalContext);\r\n next = s0.getContextTarget(previousContext);\r\n initialContext = initialContext.appendSingleContext(previousContext, contextCache);\r\n remainingGlobalContext = remainingGlobalContext.parent;\r\n }\r\n if (next == null) {\r\n break;\r\n }\r\n s0 = next;\r\n }\r\n }\r\n if (s0 != null && !s0.isContextSensitive) {\r\n return new SimulatorState_1.SimulatorState(globalContext, s0, useContext, remainingGlobalContext);\r\n }\r\n let configs = new ATNConfigSet_1.ATNConfigSet();\r\n while (true) {\r\n let reachIntermediate = new ATNConfigSet_1.ATNConfigSet();\r\n let n = p.numberOfTransitions;\r\n for (let ti = 0; ti < n; ti++) {\r\n // for each transition\r\n let target = p.transition(ti).target;\r\n reachIntermediate.add(ATNConfig_1.ATNConfig.create(target, ti + 1, initialContext));\r\n }\r\n let hasMoreContext = remainingGlobalContext != null;\r\n if (!hasMoreContext) {\r\n configs.isOutermostConfigSet = true;\r\n }\r\n let collectPredicates = true;\r\n this.closure(reachIntermediate, configs, collectPredicates, hasMoreContext, contextCache, false);\r\n let stepIntoGlobal = configs.dipsIntoOuterContext;\r\n let next;\r\n if (useContext && !this.enable_global_context_dfa) {\r\n s0 = this.addDFAState(dfa, configs, contextCache);\r\n break;\r\n }\r\n else if (s0 == null) {\r\n if (!dfa.isPrecedenceDfa) {\r\n next = this.addDFAState(dfa, configs, contextCache);\r\n if (useContext) {\r\n if (!dfa.s0full) {\r\n dfa.s0full = next;\r\n }\r\n else {\r\n next = dfa.s0full;\r\n }\r\n }\r\n else {\r\n if (!dfa.s0) {\r\n dfa.s0 = next;\r\n }\r\n else {\r\n next = dfa.s0;\r\n }\r\n }\r\n }\r\n else {\r\n /* If this is a precedence DFA, we use applyPrecedenceFilter\r\n * to convert the computed start state to a precedence start\r\n * state. We then use DFA.setPrecedenceStartState to set the\r\n * appropriate start state for the precedence level rather\r\n * than simply setting DFA.s0.\r\n */\r\n configs = this.applyPrecedenceFilter(configs, globalContext, contextCache);\r\n next = this.addDFAState(dfa, configs, contextCache);\r\n dfa.setPrecedenceStartState(this._parser.precedence, useContext, next);\r\n }\r\n }\r\n else {\r\n if (dfa.isPrecedenceDfa) {\r\n configs = this.applyPrecedenceFilter(configs, globalContext, contextCache);\r\n }\r\n next = this.addDFAState(dfa, configs, contextCache);\r\n s0.setContextTarget(previousContext, next);\r\n }\r\n s0 = next;\r\n if (!useContext || !stepIntoGlobal) {\r\n break;\r\n }\r\n // TODO: make sure it distinguishes empty stack states\r\n next.setContextSensitive(this.atn);\r\n // We know remainingGlobalContext is not undefined at this point (why?)\r\n remainingGlobalContext = remainingGlobalContext;\r\n configs.clear();\r\n remainingGlobalContext = this.skipTailCalls(remainingGlobalContext);\r\n let nextContextElement = this.getReturnState(remainingGlobalContext);\r\n if (remainingGlobalContext.isEmpty) {\r\n remainingGlobalContext = undefined;\r\n }\r\n else {\r\n remainingGlobalContext = remainingGlobalContext.parent;\r\n }\r\n if (nextContextElement !== PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY) {\r\n initialContext = initialContext.appendSingleContext(nextContextElement, contextCache);\r\n }\r\n previousContext = nextContextElement;\r\n }\r\n return new SimulatorState_1.SimulatorState(globalContext, s0, useContext, remainingGlobalContext);\r\n }\r\n /**\r\n * This method transforms the start state computed by\r\n * {@link #computeStartState} to the special start state used by a\r\n * precedence DFA for a particular precedence value. The transformation\r\n * process applies the following changes to the start state's configuration\r\n * set.\r\n *\r\n * <ol>\r\n * <li>Evaluate the precedence predicates for each configuration using\r\n * {@link SemanticContext#evalPrecedence}.</li>\r\n * <li>When {@link ATNConfig#isPrecedenceFilterSuppressed} is {@code false},\r\n * remove all configurations which predict an alternative greater than 1,\r\n * for which another configuration that predicts alternative 1 is in the\r\n * same ATN state with the same prediction context. This transformation is\r\n * valid for the following reasons:\r\n * <ul>\r\n * <li>The closure block cannot contain any epsilon transitions which bypass\r\n * the body of the closure, so all states reachable via alternative 1 are\r\n * part of the precedence alternatives of the transformed left-recursive\r\n * rule.</li>\r\n * <li>The \"primary\" portion of a left recursive rule cannot contain an\r\n * epsilon transition, so the only way an alternative other than 1 can exist\r\n * in a state that is also reachable via alternative 1 is by nesting calls\r\n * to the left-recursive rule, with the outer calls not being at the\r\n * preferred precedence level. The\r\n * {@link ATNConfig#isPrecedenceFilterSuppressed} property marks ATN\r\n * configurations which do not meet this condition, and therefore are not\r\n * eligible for elimination during the filtering process.</li>\r\n * </ul>\r\n * </li>\r\n * </ol>\r\n *\r\n * <p>\r\n * The prediction context must be considered by this filter to address\r\n * situations like the following.\r\n * </p>\r\n * <code>\r\n * <pre>\r\n * grammar TA;\r\n * prog: statement* EOF;\r\n * statement: letterA | statement letterA 'b' ;\r\n * letterA: 'a';\r\n * </pre>\r\n * </code>\r\n * <p>\r\n * If the above grammar, the ATN state immediately before the token\r\n * reference {@code 'a'} in {@code letterA} is reachable from the left edge\r\n * of both the primary and closure blocks of the left-recursive rule\r\n * {@code statement}. The prediction context associated with each of these\r\n * configurations distinguishes between them, and prevents the alternative\r\n * which stepped out to {@code prog} (and then back in to {@code statement}\r\n * from being eliminated by the filter.\r\n * </p>\r\n *\r\n * @param configs The configuration set computed by\r\n * {@link #computeStartState} as the start state for the DFA.\r\n * @return The transformed configuration set representing the start state\r\n * for a precedence DFA at a particular precedence level (determined by\r\n * calling {@link Parser#getPrecedence}).\r\n */\r\n applyPrecedenceFilter(configs, globalContext, contextCache) {\r\n let statesFromAlt1 = new Map();\r\n let configSet = new ATNConfigSet_1.ATNConfigSet();\r\n for (let config of Stubs_1.asIterable(configs)) {\r\n // handle alt 1 first\r\n if (config.alt !== 1) {\r\n continue;\r\n }\r\n let updatedContext = config.semanticContext.evalPrecedence(this._parser, globalContext);\r\n if (updatedContext == null) {\r\n // the configuration was eliminated\r\n continue;\r\n }\r\n statesFromAlt1.set(config.state.stateNumber, config.context);\r\n if (updatedContext !== config.semanticContext) {\r\n configSet.add(config.transform(config.state, false, updatedContext), contextCache);\r\n }\r\n else {\r\n configSet.add(config, contextCache);\r\n }\r\n }\r\n for (let config of Stubs_1.asIterable(configs)) {\r\n if (config.alt === 1) {\r\n // already handled\r\n continue;\r\n }\r\n if (!config.isPrecedenceFilterSuppressed) {\r\n /* In the future, this elimination step could be updated to also\r\n * filter the prediction context for alternatives predicting alt>1\r\n * (basically a graph subtraction algorithm).\r\n */\r\n let context = statesFromAlt1.get(config.state.stateNumber);\r\n if (context != null && context.equals(config.context)) {\r\n // eliminated\r\n continue;\r\n }\r\n }\r\n configSet.add(config, contextCache);\r\n }\r\n return configSet;\r\n }\r\n getReachableTarget(source, trans, ttype) {\r\n if (trans.matches(ttype, 0, this.atn.maxTokenType)) {\r\n return trans.target;\r\n }\r\n return undefined;\r\n }\r\n /** collect and set D's semantic context */\r\n predicateDFAState(D, configs, nalts) {\r\n let conflictingAlts = this.getConflictingAltsFromConfigSet(configs);\r\n if (!conflictingAlts) {\r\n throw new Error(\"This unhandled scenario is intended to be unreachable, but I'm currently not sure of why we know that's the case.\");\r\n }\r\n if (ParserATNSimulator.debug)\r\n console.log(\"predicateDFAState \" + D);\r\n let altToPred = this.getPredsForAmbigAlts(conflictingAlts, configs, nalts);\r\n // altToPred[uniqueAlt] is now our validating predicate (if any)\r\n let predPredictions;\r\n if (altToPred != null) {\r\n // we have a validating predicate; test it\r\n // Update DFA so reach becomes accept state with predicate\r\n predPredictions = this.getPredicatePredictions(conflictingAlts, altToPred);\r\n D.predicates = predPredictions;\r\n }\r\n return predPredictions;\r\n }\r\n getPredsForAmbigAlts(ambigAlts, configs, nalts) {\r\n // REACH=[1|1|[]|0:0, 1|2|[]|0:1]\r\n /* altToPred starts as an array of all undefined contexts. The entry at index i\r\n * corresponds to alternative i. altToPred[i] may have one of three values:\r\n * 1. undefined: no ATNConfig c is found such that c.alt===i\r\n * 2. SemanticContext.NONE: At least one ATNConfig c exists such that\r\n * c.alt===i and c.semanticContext===SemanticContext.NONE. In other words,\r\n * alt i has at least one unpredicated config.\r\n * 3. Non-NONE Semantic Context: There exists at least one, and for all\r\n * ATNConfig c such that c.alt===i, c.semanticContext!==SemanticContext.NONE.\r\n *\r\n * From this, it is clear that NONE||anything==NONE.\r\n */\r\n let altToPred = new Array(nalts + 1);\r\n let n = altToPred.length;\r\n for (let c of Stubs_1.asIterable(configs)) {\r\n if (ambigAlts.get(c.alt)) {\r\n altToPred[c.alt] = SemanticContext_1.SemanticContext.or(altToPred[c.alt], c.semanticContext);\r\n }\r\n }\r\n let nPredAlts = 0;\r\n for (let i = 0; i < n; i++) {\r\n if (altToPred[i] == null) {\r\n altToPred[i] = SemanticContext_1.SemanticContext.NONE;\r\n }\r\n else if (altToPred[i] !== SemanticContext_1.SemanticContext.NONE) {\r\n nPredAlts++;\r\n }\r\n }\r\n // At this point we know `altToPred` doesn't contain any undefined entries\r\n let result = altToPred;\r\n // nonambig alts are undefined in result\r\n if (nPredAlts === 0)\r\n result = undefined;\r\n if (ParserATNSimulator.debug)\r\n console.log(\"getPredsForAmbigAlts result \" + (result ? Arrays_1.Arrays.toString(result) : \"undefined\"));\r\n return result;\r\n }\r\n getPredicatePredictions(ambigAlts, altToPred) {\r\n let pairs = [];\r\n let containsPredicate = false;\r\n for (let i = 1; i < altToPred.length; i++) {\r\n let pred = altToPred[i];\r\n // unpredicated is indicated by SemanticContext.NONE\r\n assert(pred != null);\r\n // find first unpredicated but ambig alternative, if any.\r\n // Only ambiguous alternatives will have SemanticContext.NONE.\r\n // Any unambig alts or ambig naked alts after first ambig naked are ignored\r\n // (null, i) means alt i is the default prediction\r\n // if no (null, i), then no default prediction.\r\n if (ambigAlts != null && ambigAlts.get(i) && pred === SemanticContext_1.SemanticContext.NONE) {\r\n pairs.push(new DFAState_1.DFAState.PredPrediction(pred, i));\r\n }\r\n else if (pred !== SemanticContext_1.SemanticContext.NONE) {\r\n containsPredicate = true;\r\n pairs.push(new DFAState_1.DFAState.PredPrediction(pred, i));\r\n }\r\n }\r\n if (!containsPredicate) {\r\n return undefined;\r\n }\r\n //\t\tSystem.out.println(Arrays.toString(altToPred)+\"->\"+pairs);\r\n return pairs;\r\n }\r\n /** Look through a list of predicate/alt pairs, returning alts for the\r\n * pairs that win. A {@code null} predicate indicates an alt containing an\r\n * unpredicated config which behaves as \"always true.\"\r\n */\r\n evalSemanticContext(predPredictions, outerContext, complete) {\r\n let predictions = new BitSet_1.BitSet();\r\n for (let pair of predPredictions) {\r\n if (pair.pred === SemanticContext_1.SemanticContext.NONE) {\r\n predictions.set(pair.alt);\r\n if (!complete) {\r\n break;\r\n }\r\n continue;\r\n }\r\n let evaluatedResult = this.evalSemanticContextImpl(pair.pred, outerContext, pair.alt);\r\n if (ParserATNSimulator.debug || ParserATNSimulator.dfa_debug) {\r\n console.log(\"eval pred \" + pair + \"=\" + evaluatedResult);\r\n }\r\n if (evaluatedResult) {\r\n if (ParserATNSimulator.debug || ParserATNSimulator.dfa_debug)\r\n console.log(\"PREDICT \" + pair.alt);\r\n predictions.set(pair.alt);\r\n if (!complete) {\r\n break;\r\n }\r\n }\r\n }\r\n return predictions;\r\n }\r\n /**\r\n * Evaluate a semantic context within a specific parser context.\r\n *\r\n * <p>\r\n * This method might not be called for every semantic context evaluated\r\n * during the prediction process. In particular, we currently do not\r\n * evaluate the following but it may change in the future:</p>\r\n *\r\n * <ul>\r\n * <li>Precedence predicates (represented by\r\n * {@link SemanticContext.PrecedencePredicate}) are not currently evaluated\r\n * through this method.</li>\r\n * <li>Operator predicates (represented by {@link SemanticContext.AND} and\r\n * {@link SemanticContext.OR}) are evaluated as a single semantic\r\n * context, rather than evaluating the operands individually.\r\n * Implementations which require evaluation results from individual\r\n * predicates should override this method to explicitly handle evaluation of\r\n * the operands within operator predicates.</li>\r\n * </ul>\r\n *\r\n * @param pred The semantic context to evaluate\r\n * @param parserCallStack The parser context in which to evaluate the\r\n * semantic context\r\n * @param alt The alternative which is guarded by {@code pred}\r\n *\r\n * @since 4.3\r\n */\r\n evalSemanticContextImpl(pred, parserCallStack, alt) {\r\n return pred.eval(this._parser, parserCallStack);\r\n }\r\n /* TODO: If we are doing predicates, there is no point in pursuing\r\n closure operations if we reach a DFA state that uniquely predicts\r\n alternative. We will not be caching that DFA state and it is a\r\n waste to pursue the closure. Might have to advance when we do\r\n ambig detection thought :(\r\n */\r\n closure(sourceConfigs, configs, collectPredicates, hasMoreContext, contextCache, treatEofAsEpsilon) {\r\n if (contextCache == null) {\r\n contextCache = PredictionContextCache_1.PredictionContextCache.UNCACHED;\r\n }\r\n let currentConfigs = sourceConfigs;\r\n let closureBusy = new Array2DHashSet_1.Array2DHashSet(ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE);\r\n while (currentConfigs.size > 0) {\r\n let intermediate = new ATNConfigSet_1.ATNConfigSet();\r\n for (let config of Stubs_1.asIterable(currentConfigs)) {\r\n this.closureImpl(config, configs, intermediate, closureBusy, collectPredicates, hasMoreContext, contextCache, 0, treatEofAsEpsilon);\r\n }\r\n currentConfigs = intermediate;\r\n }\r\n }\r\n closureImpl(config, configs, intermediate, closureBusy, collectPredicates, hasMoreContexts, contextCache, depth, treatEofAsEpsilon) {\r\n if (ParserATNSimulator.debug)\r\n console.log(\"closure(\" + config.toString(this._parser, true) + \")\");\r\n if (config.state instanceof RuleStopState_1.RuleStopState) {\r\n // We hit rule end. If we have context info, use it\r\n if (!config.context.isEmpty) {\r\n let hasEmpty = config.context.hasEmpty;\r\n let nonEmptySize = config.context.size - (hasEmpty ? 1 : 0);\r\n for (let i = 0; i < nonEmptySize; i++) {\r\n let newContext = config.context.getParent(i); // \"pop\" return state\r\n let returnState = this.atn.states[config.context.getReturnState(i)];\r\n let c = ATNConfig_1.ATNConfig.create(returnState, config.alt, newContext, config.semanticContext);\r\n // While we have context to pop back from, we may have\r\n // gotten that context AFTER having fallen off a rule.\r\n // Make sure we track that we are now out of context.\r\n c.outerContextDepth = config.outerContextDepth;\r\n c.isPrecedenceFilterSuppressed = config.isPrecedenceFilterSuppressed;\r\n assert(depth > MIN_INTEGER_VALUE);\r\n this.closureImpl(c, configs, intermediate, closureBusy, collectPredicates, hasMoreContexts, contextCache, depth - 1, treatEofAsEpsilon);\r\n }\r\n if (!hasEmpty || !hasMoreContexts) {\r\n return;\r\n }\r\n config = config.transform(config.state, false, PredictionContext_1.PredictionContext.EMPTY_LOCAL);\r\n }\r\n else if (!hasMoreContexts) {\r\n configs.add(config, contextCache);\r\n return;\r\n }\r\n else {\r\n // else if we have no context info, just chase follow links (if greedy)\r\n if (ParserATNSimulator.debug)\r\n console.log(\"FALLING off rule \" +\r\n this.getRuleName(config.state.ruleIndex));\r\n if (config.context === PredictionContext_1.PredictionContext.EMPTY_FULL) {\r\n // no need to keep full context overhead when we step out\r\n config = config.transform(config.state, false, PredictionContext_1.PredictionContext.EMPTY_LOCAL);\r\n }\r\n else if (!config.reachesIntoOuterContext && PredictionContext_1.PredictionContext.isEmptyLocal(config.context)) {\r\n // add stop state when leaving decision rule for the first time\r\n configs.add(config, contextCache);\r\n }\r\n }\r\n }\r\n let p = config.state;\r\n // optimization\r\n if (!p.onlyHasEpsilonTransitions) {\r\n configs.add(config, contextCache);\r\n // make sure to not return here, because EOF transitions can act as\r\n // both epsilon transitions and non-epsilon transitions.\r\n if (ParserATNSimulator.debug)\r\n console.log(\"added config \" + configs);\r\n }\r\n for (let i = 0; i < p.numberOfOptimizedTransitions; i++) {\r\n // This block implements first-edge elimination of ambiguous LR\r\n // alternatives as part of dynamic disambiguation during prediction.\r\n // See antlr/antlr4#1398.\r\n if (i === 0\r\n && p.stateType === 10 /* STAR_LOOP_ENTRY */\r\n && p.precedenceRuleDecision\r\n && !config.context.hasEmpty) {\r\n let precedenceDecision = p;\r\n // When suppress is true, it means the outgoing edge i==0 is\r\n // ambiguous with the outgoing edge i==1, and thus the closure\r\n // operation can dynamically disambiguate by suppressing this\r\n // edge during the closure operation.\r\n let suppress = true;\r\n for (let j = 0; j < config.context.size; j++) {\r\n if (!precedenceDecision.precedenceLoopbackStates.get(config.context.getReturnState(j))) {\r\n suppress = false;\r\n break;\r\n }\r\n }\r\n if (suppress) {\r\n continue;\r\n }\r\n }\r\n let t = p.getOptimizedTransition(i);\r\n let continueCollecting = !(t instanceof ActionTransition_1.ActionTransition) && collectPredicates;\r\n let c = this.getEpsilonTarget(config, t, continueCollecting, depth === 0, contextCache, treatEofAsEpsilon);\r\n if (c != null) {\r\n if (t instanceof RuleTransition_1.RuleTransition) {\r\n if (intermediate != null && !collectPredicates) {\r\n intermediate.add(c, contextCache);\r\n continue;\r\n }\r\n }\r\n if (!t.isEpsilon && !closureBusy.add(c)) {\r\n // avoid infinite recursion for EOF* and EOF+\r\n continue;\r\n }\r\n let newDepth = depth;\r\n if (config.state instanceof RuleStopState_1.RuleStopState) {\r\n // target fell off end of rule; mark resulting c as having dipped into outer context\r\n // We can't get here if incoming config was rule stop and we had context\r\n // track how far we dip into outer context. Might\r\n // come in handy and we avoid evaluating context dependent\r\n // preds if this is > 0.\r\n if (!closureBusy.add(c)) {\r\n // avoid infinite recursion for right-recursive rules\r\n continue;\r\n }\r\n if (this.dfa != null && this.dfa.isPrecedenceDfa) {\r\n let outermostPrecedenceReturn = t.outermostPrecedenceReturn;\r\n if (outermostPrecedenceReturn == this.dfa.atnStartState.ruleIndex) {\r\n c.isPrecedenceFilterSuppressed = true;\r\n }\r\n }\r\n c.outerContextDepth = c.outerContextDepth + 1;\r\n assert(newDepth > MIN_INTEGER_VALUE);\r\n newDepth--;\r\n if (ParserATNSimulator.debug)\r\n console.log(\"dips into outer ctx: \" + c);\r\n }\r\n else if (t instanceof RuleTransition_1.RuleTransition) {\r\n if (this.optimize_tail_calls && t.optimizedTailCall && (!this.tail_call_preserves_sll || !PredictionContext_1.PredictionContext.isEmptyLocal(config.context))) {\r\n assert(c.context === config.context);\r\n if (newDepth === 0) {\r\n // the pop/push of a tail call would keep the depth\r\n // constant, except we latch if it goes negative\r\n newDepth--;\r\n if (!this.tail_call_preserves_sll && PredictionContext_1.PredictionContext.isEmptyLocal(config.context)) {\r\n // make sure the SLL config \"dips into the outer context\" or prediction may not fall back to LL on conflict\r\n c.outerContextDepth = c.outerContextDepth + 1;\r\n }\r\n }\r\n }\r\n else {\r\n // latch when newDepth goes negative - once we step out of the entry context we can't return\r\n if (newDepth >= 0) {\r\n newDepth++;\r\n }\r\n }\r\n }\r\n this.closureImpl(c, configs, intermediate, closureBusy, continueCollecting, hasMoreContexts, contextCache, newDepth, treatEofAsEpsilon);\r\n }\r\n }\r\n }\r\n getRuleName(index) {\r\n if (this._parser != null && index >= 0)\r\n return this._parser.ruleNames[index];\r\n return \"<rule \" + index + \">\";\r\n }\r\n getEpsilonTarget(config, t, collectPredicates, inContext, contextCache, treatEofAsEpsilon) {\r\n switch (t.serializationType) {\r\n case 3 /* RULE */:\r\n return this.ruleTransition(config, t, contextCache);\r\n case 10 /* PRECEDENCE */:\r\n return this.precedenceTransition(config, t, collectPredicates, inContext);\r\n case 4 /* PREDICATE */:\r\n return this.predTransition(config, t, collectPredicates, inContext);\r\n case 6 /* ACTION */:\r\n return this.actionTransition(config, t);\r\n case 1 /* EPSILON */:\r\n return config.transform(t.target, false);\r\n case 5 /* ATOM */:\r\n case 2 /* RANGE */:\r\n case 7 /* SET */:\r\n // EOF transitions act like epsilon transitions after the first EOF\r\n // transition is traversed\r\n if (treatEofAsEpsilon) {\r\n if (t.matches(Token_1.Token.EOF, 0, 1)) {\r\n return config.transform(t.target, false);\r\n }\r\n }\r\n return undefined;\r\n default:\r\n return undefined;\r\n }\r\n }\r\n actionTransition(config, t) {\r\n if (ParserATNSimulator.debug)\r\n console.log(\"ACTION edge \" + t.ruleIndex + \":\" + t.actionIndex);\r\n return config.transform(t.target, false);\r\n }\r\n precedenceTransition(config, pt, collectPredicates, inContext) {\r\n if (ParserATNSimulator.debug) {\r\n console.log(\"PRED (collectPredicates=\" + collectPredicates + \") \" +\r\n pt.precedence + \">=_p\" +\r\n \", ctx dependent=true\");\r\n if (this._parser != null) {\r\n console.log(\"context surrounding pred is \" +\r\n this._parser.getRuleInvocationStack());\r\n }\r\n }\r\n let c;\r\n if (collectPredicates && inContext) {\r\n let newSemCtx = SemanticContext_1.SemanticContext.and(config.semanticContext, pt.predicate);\r\n c = config.transform(pt.target, false, newSemCtx);\r\n }\r\n else {\r\n c = config.transform(pt.target, false);\r\n }\r\n if (ParserATNSimulator.debug)\r\n console.log(\"config from pred transition=\" + c);\r\n return c;\r\n }\r\n predTransition(config, pt, collectPredicates, inContext) {\r\n if (ParserATNSimulator.debug) {\r\n console.log(\"PRED (collectPredicates=\" + collectPredicates + \") \" +\r\n pt.ruleIndex + \":\" + pt.predIndex +\r\n \", ctx dependent=\" + pt.isCtxDependent);\r\n if (this._parser != null) {\r\n console.log(\"context surrounding pred is \" +\r\n this._parser.getRuleInvocationStack());\r\n }\r\n }\r\n let c;\r\n if (collectPredicates &&\r\n (!pt.isCtxDependent || (pt.isCtxDependent && inContext))) {\r\n let newSemCtx = SemanticContext_1.SemanticContext.and(config.semanticContext, pt.predicate);\r\n c = config.transform(pt.target, false, newSemCtx);\r\n }\r\n else {\r\n c = config.transform(pt.target, false);\r\n }\r\n if (ParserATNSimulator.debug)\r\n console.log(\"config from pred transition=\" + c);\r\n return c;\r\n }\r\n ruleTransition(config, t, contextCache) {\r\n if (ParserATNSimulator.debug) {\r\n console.log(\"CALL rule \" + this.getRuleName(t.target.ruleIndex) +\r\n \", ctx=\" + config.context);\r\n }\r\n let returnState = t.followState;\r\n let newContext;\r\n if (this.optimize_tail_calls && t.optimizedTailCall && (!this.tail_call_preserves_sll || !PredictionContext_1.PredictionContext.isEmptyLocal(config.context))) {\r\n newContext = config.context;\r\n }\r\n else if (contextCache != null) {\r\n newContext = contextCache.getChild(config.context, returnState.stateNumber);\r\n }\r\n else {\r\n newContext = config.context.getChild(returnState.stateNumber);\r\n }\r\n return config.transform(t.target, false, newContext);\r\n }\r\n isConflicted(configset, contextCache) {\r\n if (configset.uniqueAlt !== ATN_1.ATN.INVALID_ALT_NUMBER || configset.size <= 1) {\r\n return undefined;\r\n }\r\n let configs = configset.toArray();\r\n configs.sort(ParserATNSimulator.STATE_ALT_SORT_COMPARATOR);\r\n let exact = !configset.dipsIntoOuterContext;\r\n let alts = new BitSet_1.BitSet();\r\n let minAlt = configs[0].alt;\r\n alts.set(minAlt);\r\n /* Quick checks come first (single pass, no context joining):\r\n * 1. Make sure first config in the sorted list predicts the minimum\r\n * represented alternative.\r\n * 2. Make sure every represented state has at least one configuration\r\n * which predicts the minimum represented alternative.\r\n * 3. (exact only) make sure every represented state has at least one\r\n * configuration which predicts each represented alternative.\r\n */\r\n // quick check 1 & 2 => if we assume #1 holds and check #2 against the\r\n // minAlt from the first state, #2 will fail if the assumption was\r\n // incorrect\r\n let currentState = configs[0].state.nonStopStateNumber;\r\n for (let config of configs) {\r\n let stateNumber = config.state.nonStopStateNumber;\r\n if (stateNumber !== currentState) {\r\n if (config.alt !== minAlt) {\r\n return undefined;\r\n }\r\n currentState = stateNumber;\r\n }\r\n }\r\n let representedAlts;\r\n if (exact) {\r\n currentState = configs[0].state.nonStopStateNumber;\r\n // get the represented alternatives of the first state\r\n representedAlts = new BitSet_1.BitSet();\r\n let maxAlt = minAlt;\r\n for (let config of configs) {\r\n if (config.state.nonStopStateNumber != currentState) {\r\n break;\r\n }\r\n let alt = config.alt;\r\n representedAlts.set(alt);\r\n maxAlt = alt;\r\n }\r\n // quick check #3:\r\n currentState = configs[0].state.nonStopStateNumber;\r\n let currentAlt = minAlt;\r\n for (let config of configs) {\r\n let stateNumber = config.state.nonStopStateNumber;\r\n let alt = config.alt;\r\n if (stateNumber !== currentState) {\r\n if (currentAlt !== maxAlt) {\r\n exact = false;\r\n break;\r\n }\r\n currentState = stateNumber;\r\n currentAlt = minAlt;\r\n }\r\n else if (alt !== currentAlt) {\r\n if (alt !== representedAlts.nextSetBit(currentAlt + 1)) {\r\n exact = false;\r\n break;\r\n }\r\n currentAlt = alt;\r\n }\r\n }\r\n }\r\n currentState = configs[0].state.nonStopStateNumber;\r\n let firstIndexCurrentState = 0;\r\n let lastIndexCurrentStateMinAlt = 0;\r\n let joinedCheckContext = configs[0].context;\r\n for (let i = 1; i < configs.length; i++) {\r\n let config = configs[i];\r\n if (config.alt !== minAlt) {\r\n break;\r\n }\r\n if (config.state.nonStopStateNumber !== currentState) {\r\n break;\r\n }\r\n lastIndexCurrentStateMinAlt = i;\r\n joinedCheckContext = contextCache.join(joinedCheckContext, configs[i].context);\r\n }\r\n for (let i = lastIndexCurrentStateMinAlt + 1; i < configs.length; i++) {\r\n let config = configs[i];\r\n let state = config.state;\r\n alts.set(config.alt);\r\n if (state.nonStopStateNumber !== currentState) {\r\n currentState = state.nonStopStateNumber;\r\n firstIndexCurrentState = i;\r\n lastIndexCurrentStateMinAlt = i;\r\n joinedCheckContext = config.context;\r\n for (let j = firstIndexCurrentState + 1; j < configs.length; j++) {\r\n let config2 = configs[j];\r\n if (config2.alt !== minAlt) {\r\n break;\r\n }\r\n if (config2.state.nonStopStateNumber !== currentState) {\r\n break;\r\n }\r\n lastIndexCurrentStateMinAlt = j;\r\n joinedCheckContext = contextCache.join(joinedCheckContext, config2.context);\r\n }\r\n i = lastIndexCurrentStateMinAlt;\r\n continue;\r\n }\r\n let joinedCheckContext2 = config.context;\r\n let currentAlt = config.alt;\r\n let lastIndexCurrentStateCurrentAlt = i;\r\n for (let j = lastIndexCurrentStateCurrentAlt + 1; j < configs.length; j++) {\r\n let config2 = configs[j];\r\n if (config2.alt !== currentAlt) {\r\n break;\r\n }\r\n if (config2.state.nonStopStateNumber !== currentState) {\r\n break;\r\n }\r\n lastIndexCurrentStateCurrentAlt = j;\r\n joinedCheckContext2 = contextCache.join(joinedCheckContext2, config2.context);\r\n }\r\n i = lastIndexCurrentStateCurrentAlt;\r\n let check = contextCache.join(joinedCheckContext, joinedCheckContext2);\r\n if (!joinedCheckContext.equals(check)) {\r\n return undefined;\r\n }\r\n // update exact if necessary\r\n exact = exact && joinedCheckContext.equals(joinedCheckContext2);\r\n }\r\n return new ConflictInfo_1.ConflictInfo(alts, exact);\r\n }\r\n getConflictingAltsFromConfigSet(configs) {\r\n let conflictingAlts = configs.conflictingAlts;\r\n if (conflictingAlts == null && configs.uniqueAlt !== ATN_1.ATN.INVALID_ALT_NUMBER) {\r\n conflictingAlts = new BitSet_1.BitSet();\r\n conflictingAlts.set(configs.uniqueAlt);\r\n }\r\n return conflictingAlts;\r\n }\r\n getTokenName(t) {\r\n if (t === Token_1.Token.EOF) {\r\n return \"EOF\";\r\n }\r\n let vocabulary = this._parser != null ? this._parser.vocabulary : VocabularyImpl_1.VocabularyImpl.EMPTY_VOCABULARY;\r\n let displayName = vocabulary.getDisplayName(t);\r\n if (displayName === String(t)) {\r\n return displayName;\r\n }\r\n return displayName + \"<\" + t + \">\";\r\n }\r\n getLookaheadName(input) {\r\n return this.getTokenName(input.LA(1));\r\n }\r\n dumpDeadEndConfigs(nvae) {\r\n console.log(\"dead end configs: \");\r\n let deadEndConfigs = nvae.deadEndConfigs;\r\n if (!deadEndConfigs) {\r\n return;\r\n }\r\n for (let c of Stubs_1.asIterable(deadEndConfigs)) {\r\n let trans = \"no edges\";\r\n if (c.state.numberOfOptimizedTransitions > 0) {\r\n let t = c.state.getOptimizedTransition(0);\r\n if (t instanceof AtomTransition_1.AtomTransition) {\r\n trans = \"Atom \" + this.getTokenName(t._label);\r\n }\r\n else if (t instanceof SetTransition_1.SetTransition) {\r\n let not = t instanceof NotSetTransition_1.NotSetTransition;\r\n trans = (not ? \"~\" : \"\") + \"Set \" + t.set.toString();\r\n }\r\n }\r\n console.log(c.toString(this._parser, true) + \":\" + trans);\r\n }\r\n }\r\n noViableAlt(input, outerContext, configs, startIndex) {\r\n return new NoViableAltException_1.NoViableAltException(this._parser, input, input.get(startIndex), input.LT(1), configs, outerContext);\r\n }\r\n getUniqueAlt(configs) {\r\n let alt = ATN_1.ATN.INVALID_ALT_NUMBER;\r\n for (let c of Stubs_1.asIterable(configs)) {\r\n if (alt === ATN_1.ATN.INVALID_ALT_NUMBER) {\r\n alt = c.alt; // found first alt\r\n }\r\n else if (c.alt !== alt) {\r\n return ATN_1.ATN.INVALID_ALT_NUMBER;\r\n }\r\n }\r\n return alt;\r\n }\r\n configWithAltAtStopState(configs, alt) {\r\n for (let c of Stubs_1.asIterable(configs)) {\r\n if (c.alt === alt) {\r\n if (c.state instanceof RuleStopState_1.RuleStopState) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }\r\n addDFAEdge(dfa, fromState, t, contextTransitions, toConfigs, contextCache) {\r\n assert(contextTransitions == null || contextTransitions.isEmpty || dfa.isContextSensitive);\r\n let from = fromState;\r\n let to = this.addDFAState(dfa, toConfigs, contextCache);\r\n if (contextTransitions != null) {\r\n for (let context of contextTransitions.toArray()) {\r\n if (context === PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY) {\r\n if (from.configs.isOutermostConfigSet) {\r\n continue;\r\n }\r\n }\r\n from.setContextSensitive(this.atn);\r\n from.setContextSymbol(t);\r\n let next = from.getContextTarget(context);\r\n if (next != null) {\r\n from = next;\r\n continue;\r\n }\r\n next = this.addDFAContextState(dfa, from.configs, context, contextCache);\r\n assert(context !== PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY || next.configs.isOutermostConfigSet);\r\n from.setContextTarget(context, next);\r\n from = next;\r\n }\r\n }\r\n if (ParserATNSimulator.debug)\r\n console.log(\"EDGE \" + from + \" -> \" + to + \" upon \" + this.getTokenName(t));\r\n this.setDFAEdge(from, t, to);\r\n if (ParserATNSimulator.debug)\r\n console.log(\"DFA=\\n\" + dfa.toString(this._parser != null ? this._parser.vocabulary : VocabularyImpl_1.VocabularyImpl.EMPTY_VOCABULARY, this._parser != null ? this._parser.ruleNames : undefined));\r\n return to;\r\n }\r\n setDFAEdge(p, t, q) {\r\n if (p != null) {\r\n p.setTarget(t, q);\r\n }\r\n }\r\n /** See comment on LexerInterpreter.addDFAState. */\r\n addDFAContextState(dfa, configs, returnContext, contextCache) {\r\n if (returnContext !== PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY) {\r\n let contextConfigs = new ATNConfigSet_1.ATNConfigSet();\r\n for (let config of Stubs_1.asIterable(configs)) {\r\n contextConfigs.add(config.appendContext(returnContext, contextCache));\r\n }\r\n return this.addDFAState(dfa, contextConfigs, contextCache);\r\n }\r\n else {\r\n assert(!configs.isOutermostConfigSet, \"Shouldn't be adding a duplicate edge.\");\r\n configs = configs.clone(true);\r\n configs.isOutermostConfigSet = true;\r\n return this.addDFAState(dfa, configs, contextCache);\r\n }\r\n }\r\n /** See comment on LexerInterpreter.addDFAState. */\r\n addDFAState(dfa, configs, contextCache) {\r\n let enableDfa = this.enable_global_context_dfa || !configs.isOutermostConfigSet;\r\n if (enableDfa) {\r\n if (!configs.isReadOnly) {\r\n configs.optimizeConfigs(this);\r\n }\r\n let proposed = this.createDFAState(dfa, configs);\r\n let existing = dfa.states.get(proposed);\r\n if (existing != null)\r\n return existing;\r\n }\r\n if (!configs.isReadOnly) {\r\n if (configs.conflictInfo == null) {\r\n configs.conflictInfo = this.isConflicted(configs, contextCache);\r\n }\r\n }\r\n let newState = this.createDFAState(dfa, configs.clone(true));\r\n // getDecisionState won't return undefined when we request a known valid decision\r\n let decisionState = this.atn.getDecisionState(dfa.decision);\r\n let predictedAlt = this.getUniqueAlt(configs);\r\n if (predictedAlt !== ATN_1.ATN.INVALID_ALT_NUMBER) {\r\n newState.acceptStateInfo = new AcceptStateInfo_1.AcceptStateInfo(predictedAlt);\r\n }\r\n else if (configs.conflictingAlts != null) {\r\n let conflictingAlts = configs.conflictingAlts;\r\n if (conflictingAlts) {\r\n newState.acceptStateInfo = new AcceptStateInfo_1.AcceptStateInfo(conflictingAlts.nextSetBit(0));\r\n }\r\n }\r\n if (newState.isAcceptState && configs.hasSemanticContext) {\r\n this.predicateDFAState(newState, configs, decisionState.numberOfTransitions);\r\n }\r\n if (!enableDfa) {\r\n return newState;\r\n }\r\n let added = dfa.addState(newState);\r\n if (ParserATNSimulator.debug && added === newState)\r\n console.log(\"adding new DFA state: \" + newState);\r\n return added;\r\n }\r\n createDFAState(dfa, configs) {\r\n return new DFAState_1.DFAState(dfa, configs);\r\n }\r\n reportAttemptingFullContext(dfa, conflictingAlts, conflictState, startIndex, stopIndex) {\r\n if (ParserATNSimulator.debug || ParserATNSimulator.retry_debug) {\r\n let interval = Interval_1.Interval.of(startIndex, stopIndex);\r\n console.log(\"reportAttemptingFullContext decision=\" + dfa.decision + \":\" + conflictState.s0.configs +\r\n \", input=\" + this._parser.inputStream.getText(interval));\r\n }\r\n if (this._parser != null)\r\n this._parser.getErrorListenerDispatch().reportAttemptingFullContext(this._parser, dfa, startIndex, stopIndex, conflictingAlts, conflictState);\r\n }\r\n reportContextSensitivity(dfa, prediction, acceptState, startIndex, stopIndex) {\r\n if (ParserATNSimulator.debug || ParserATNSimulator.retry_debug) {\r\n let interval = Interval_1.Interval.of(startIndex, stopIndex);\r\n console.log(\"reportContextSensitivity decision=\" + dfa.decision + \":\" + acceptState.s0.configs +\r\n \", input=\" + this._parser.inputStream.getText(interval));\r\n }\r\n if (this._parser != null)\r\n this._parser.getErrorListenerDispatch().reportContextSensitivity(this._parser, dfa, startIndex, stopIndex, prediction, acceptState);\r\n }\r\n /** If context sensitive parsing, we know it's ambiguity not conflict */\r\n reportAmbiguity(dfa, D, // the DFA state from execATN(): void that had SLL conflicts\r\n startIndex, stopIndex, exact, ambigAlts, configs) {\r\n if (ParserATNSimulator.debug || ParserATNSimulator.retry_debug) {\r\n let interval = Interval_1.Interval.of(startIndex, stopIndex);\r\n console.log(\"reportAmbiguity \" +\r\n ambigAlts + \":\" + configs +\r\n \", input=\" + this._parser.inputStream.getText(interval));\r\n }\r\n if (this._parser != null)\r\n this._parser.getErrorListenerDispatch().reportAmbiguity(this._parser, dfa, startIndex, stopIndex, exact, ambigAlts, configs);\r\n }\r\n getReturnState(context) {\r\n if (context.isEmpty) {\r\n return PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY;\r\n }\r\n let state = this.atn.states[context.invokingState];\r\n let transition = state.transition(0);\r\n return transition.followState.stateNumber;\r\n }\r\n skipTailCalls(context) {\r\n if (!this.optimize_tail_calls) {\r\n return context;\r\n }\r\n while (!context.isEmpty) {\r\n let state = this.atn.states[context.invokingState];\r\n assert(state.numberOfTransitions === 1 && state.transition(0).serializationType === 3 /* RULE */);\r\n let transition = state.transition(0);\r\n if (!transition.tailCall) {\r\n break;\r\n }\r\n // This method requires that the root ancestor of the ParserRuleContext be empty. If we make it to this\r\n // line, we know the current node is not empty, which means it does have a parent.\r\n context = context.parent;\r\n }\r\n return context;\r\n }\r\n /**\r\n * @since 4.3\r\n */\r\n get parser() {\r\n return this._parser;\r\n }\r\n};\r\nParserATNSimulator.debug = false;\r\nParserATNSimulator.dfa_debug = false;\r\nParserATNSimulator.retry_debug = false;\r\nParserATNSimulator.STATE_ALT_SORT_COMPARATOR = (o1, o2) => {\r\n let diff = o1.state.nonStopStateNumber - o2.state.nonStopStateNumber;\r\n if (diff !== 0) {\r\n return diff;\r\n }\r\n diff = o1.alt - o2.alt;\r\n if (diff !== 0) {\r\n return diff;\r\n }\r\n return 0;\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ParserATNSimulator.prototype, \"predictionMode\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ParserATNSimulator.prototype, \"getPredictionMode\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"setPredictionMode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ParserATNSimulator.prototype, \"reset\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"adaptivePredict\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(2, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"getStartState\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(3, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"execDFA\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(3, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"execATN\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"handleNoViableAlt\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"getExistingTargetState\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"computeTargetState\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"removeAllConfigsNotInRuleStopState\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ParserATNSimulator.prototype, \"computeStartState\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"applyPrecedenceFilter\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"getReachableTarget\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"getPredsForAmbigAlts\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"evalSemanticContext\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"evalSemanticContextImpl\", null);\r\n__decorate([\r\n __param(1, Decorators_1.NotNull),\r\n __param(4, Decorators_1.Nullable)\r\n], ParserATNSimulator.prototype, \"closure\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(2, Decorators_1.Nullable),\r\n __param(3, Decorators_1.NotNull),\r\n __param(6, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"closureImpl\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ParserATNSimulator.prototype, \"getRuleName\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"getEpsilonTarget\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"actionTransition\", null);\r\n__decorate([\r\n Decorators_1.Nullable,\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"precedenceTransition\", null);\r\n__decorate([\r\n Decorators_1.Nullable,\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"predTransition\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull), __param(2, Decorators_1.Nullable)\r\n], ParserATNSimulator.prototype, \"ruleTransition\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"isConflicted\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ParserATNSimulator.prototype, \"getTokenName\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"dumpDeadEndConfigs\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(2, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"noViableAlt\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"getUniqueAlt\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"configWithAltAtStopState\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(4, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"addDFAEdge\", null);\r\n__decorate([\r\n __param(0, Decorators_1.Nullable), __param(2, Decorators_1.Nullable)\r\n], ParserATNSimulator.prototype, \"setDFAEdge\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"addDFAContextState\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"addDFAState\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"createDFAState\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"reportAttemptingFullContext\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"reportContextSensitivity\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(5, Decorators_1.NotNull),\r\n __param(6, Decorators_1.NotNull)\r\n], ParserATNSimulator.prototype, \"reportAmbiguity\", null);\r\nParserATNSimulator = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ParserATNSimulator);\r\nexports.ParserATNSimulator = ParserATNSimulator;\r\n//# sourceMappingURL=ParserATNSimulator.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:25.9683447-07:00\r\nconst ActionTransition_1 = require(\"./ActionTransition\");\r\nconst Array2DHashSet_1 = require(\"../misc/Array2DHashSet\");\r\nconst ATN_1 = require(\"./ATN\");\r\nconst ATNDeserializationOptions_1 = require(\"./ATNDeserializationOptions\");\r\nconst AtomTransition_1 = require(\"./AtomTransition\");\r\nconst BasicBlockStartState_1 = require(\"./BasicBlockStartState\");\r\nconst BasicState_1 = require(\"./BasicState\");\r\nconst BitSet_1 = require(\"../misc/BitSet\");\r\nconst BlockEndState_1 = require(\"./BlockEndState\");\r\nconst BlockStartState_1 = require(\"./BlockStartState\");\r\nconst DecisionState_1 = require(\"./DecisionState\");\r\nconst DFA_1 = require(\"../dfa/DFA\");\r\nconst EpsilonTransition_1 = require(\"./EpsilonTransition\");\r\nconst IntervalSet_1 = require(\"../misc/IntervalSet\");\r\nconst InvalidState_1 = require(\"./InvalidState\");\r\nconst LexerChannelAction_1 = require(\"./LexerChannelAction\");\r\nconst LexerCustomAction_1 = require(\"./LexerCustomAction\");\r\nconst LexerModeAction_1 = require(\"./LexerModeAction\");\r\nconst LexerMoreAction_1 = require(\"./LexerMoreAction\");\r\nconst LexerPopModeAction_1 = require(\"./LexerPopModeAction\");\r\nconst LexerPushModeAction_1 = require(\"./LexerPushModeAction\");\r\nconst LexerSkipAction_1 = require(\"./LexerSkipAction\");\r\nconst LexerTypeAction_1 = require(\"./LexerTypeAction\");\r\nconst LoopEndState_1 = require(\"./LoopEndState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst NotSetTransition_1 = require(\"./NotSetTransition\");\r\nconst ParserATNSimulator_1 = require(\"./ParserATNSimulator\");\r\nconst PlusBlockStartState_1 = require(\"./PlusBlockStartState\");\r\nconst PlusLoopbackState_1 = require(\"./PlusLoopbackState\");\r\nconst PrecedencePredicateTransition_1 = require(\"./PrecedencePredicateTransition\");\r\nconst PredicateTransition_1 = require(\"./PredicateTransition\");\r\nconst RangeTransition_1 = require(\"./RangeTransition\");\r\nconst RuleStartState_1 = require(\"./RuleStartState\");\r\nconst RuleStopState_1 = require(\"./RuleStopState\");\r\nconst RuleTransition_1 = require(\"./RuleTransition\");\r\nconst SetTransition_1 = require(\"./SetTransition\");\r\nconst StarBlockStartState_1 = require(\"./StarBlockStartState\");\r\nconst StarLoopbackState_1 = require(\"./StarLoopbackState\");\r\nconst StarLoopEntryState_1 = require(\"./StarLoopEntryState\");\r\nconst Token_1 = require(\"../Token\");\r\nconst TokensStartState_1 = require(\"./TokensStartState\");\r\nconst UUID_1 = require(\"../misc/UUID\");\r\nconst WildcardTransition_1 = require(\"./WildcardTransition\");\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass ATNDeserializer {\r\n constructor(deserializationOptions) {\r\n if (deserializationOptions == null) {\r\n deserializationOptions = ATNDeserializationOptions_1.ATNDeserializationOptions.defaultOptions;\r\n }\r\n this.deserializationOptions = deserializationOptions;\r\n }\r\n static get SERIALIZED_VERSION() {\r\n /* This value should never change. Updates following this version are\r\n * reflected as change in the unique ID SERIALIZED_UUID.\r\n */\r\n return 3;\r\n }\r\n /**\r\n * Determines if a particular serialized representation of an ATN supports\r\n * a particular feature, identified by the {@link UUID} used for serializing\r\n * the ATN at the time the feature was first introduced.\r\n *\r\n * @param feature The {@link UUID} marking the first time the feature was\r\n * supported in the serialized ATN.\r\n * @param actualUuid The {@link UUID} of the actual serialized ATN which is\r\n * currently being deserialized.\r\n * @return {@code true} if the {@code actualUuid} value represents a\r\n * serialized ATN at or after the feature identified by {@code feature} was\r\n * introduced; otherwise, {@code false}.\r\n */\r\n isFeatureSupported(feature, actualUuid) {\r\n let featureIndex = ATNDeserializer.SUPPORTED_UUIDS.findIndex(e => e.equals(feature));\r\n if (featureIndex < 0) {\r\n return false;\r\n }\r\n return ATNDeserializer.SUPPORTED_UUIDS.findIndex(e => e.equals(actualUuid)) >= featureIndex;\r\n }\r\n deserialize(data) {\r\n data = data.slice(0);\r\n // Each Uint16 value in data is shifted by +2 at the entry to this method. This is an encoding optimization\r\n // targeting the serialized values 0 and -1 (serialized to 0xFFFF), each of which are very common in the\r\n // serialized form of the ATN. In the modified UTF-8 that Java uses for compiled string literals, these two\r\n // character values have multi-byte forms. By shifting each value by +2, they become characters 2 and 1 prior\r\n // to writing the string, each of which have single-byte representations. Since the shift occurs in the tool\r\n // during ATN serialization, each target is responsible for adjusting the values during deserialization.\r\n //\r\n // As a special case, note that the first element of data is not adjusted because it contains the major version\r\n // number of the serialized ATN, which was fixed at 3 at the time the value shifting was implemented.\r\n for (let i = 1; i < data.length; i++) {\r\n data[i] = (data[i] - 2) & 0xFFFF;\r\n }\r\n let p = 0;\r\n let version = ATNDeserializer.toInt(data[p++]);\r\n if (version != ATNDeserializer.SERIALIZED_VERSION) {\r\n let reason = `Could not deserialize ATN with version ${version} (expected ${ATNDeserializer.SERIALIZED_VERSION}).`;\r\n throw new Error(reason);\r\n }\r\n let uuid = ATNDeserializer.toUUID(data, p);\r\n p += 8;\r\n if (ATNDeserializer.SUPPORTED_UUIDS.findIndex(e => e.equals(uuid)) < 0) {\r\n let reason = `Could not deserialize ATN with UUID ${uuid} (expected ${ATNDeserializer.SERIALIZED_UUID} or a legacy UUID).`;\r\n throw new Error(reason);\r\n }\r\n let supportsLexerActions = this.isFeatureSupported(ATNDeserializer.ADDED_LEXER_ACTIONS, uuid);\r\n let grammarType = ATNDeserializer.toInt(data[p++]);\r\n let maxTokenType = ATNDeserializer.toInt(data[p++]);\r\n let atn = new ATN_1.ATN(grammarType, maxTokenType);\r\n //\r\n // STATES\r\n //\r\n let loopBackStateNumbers = [];\r\n let endStateNumbers = [];\r\n let nstates = ATNDeserializer.toInt(data[p++]);\r\n for (let i = 0; i < nstates; i++) {\r\n let stype = ATNDeserializer.toInt(data[p++]);\r\n // ignore bad type of states\r\n if (stype === 0 /* INVALID_TYPE */) {\r\n atn.addState(new InvalidState_1.InvalidState());\r\n continue;\r\n }\r\n let ruleIndex = ATNDeserializer.toInt(data[p++]);\r\n if (ruleIndex === 0xFFFF) {\r\n ruleIndex = -1;\r\n }\r\n let s = this.stateFactory(stype, ruleIndex);\r\n if (stype === 12 /* LOOP_END */) {\r\n let loopBackStateNumber = ATNDeserializer.toInt(data[p++]);\r\n loopBackStateNumbers.push([s, loopBackStateNumber]);\r\n }\r\n else if (s instanceof BlockStartState_1.BlockStartState) {\r\n let endStateNumber = ATNDeserializer.toInt(data[p++]);\r\n endStateNumbers.push([s, endStateNumber]);\r\n }\r\n atn.addState(s);\r\n }\r\n // delay the assignment of loop back and end states until we know all the state instances have been initialized\r\n for (let pair of loopBackStateNumbers) {\r\n pair[0].loopBackState = atn.states[pair[1]];\r\n }\r\n for (let pair of endStateNumbers) {\r\n pair[0].endState = atn.states[pair[1]];\r\n }\r\n let numNonGreedyStates = ATNDeserializer.toInt(data[p++]);\r\n for (let i = 0; i < numNonGreedyStates; i++) {\r\n let stateNumber = ATNDeserializer.toInt(data[p++]);\r\n atn.states[stateNumber].nonGreedy = true;\r\n }\r\n let numSllDecisions = ATNDeserializer.toInt(data[p++]);\r\n for (let i = 0; i < numSllDecisions; i++) {\r\n let stateNumber = ATNDeserializer.toInt(data[p++]);\r\n atn.states[stateNumber].sll = true;\r\n }\r\n let numPrecedenceStates = ATNDeserializer.toInt(data[p++]);\r\n for (let i = 0; i < numPrecedenceStates; i++) {\r\n let stateNumber = ATNDeserializer.toInt(data[p++]);\r\n atn.states[stateNumber].isPrecedenceRule = true;\r\n }\r\n //\r\n // RULES\r\n //\r\n let nrules = ATNDeserializer.toInt(data[p++]);\r\n if (atn.grammarType === 0 /* LEXER */) {\r\n atn.ruleToTokenType = new Int32Array(nrules);\r\n }\r\n atn.ruleToStartState = new Array(nrules);\r\n for (let i = 0; i < nrules; i++) {\r\n let s = ATNDeserializer.toInt(data[p++]);\r\n let startState = atn.states[s];\r\n startState.leftFactored = ATNDeserializer.toInt(data[p++]) != 0;\r\n atn.ruleToStartState[i] = startState;\r\n if (atn.grammarType === 0 /* LEXER */) {\r\n let tokenType = ATNDeserializer.toInt(data[p++]);\r\n if (tokenType === 0xFFFF) {\r\n tokenType = Token_1.Token.EOF;\r\n }\r\n atn.ruleToTokenType[i] = tokenType;\r\n if (!this.isFeatureSupported(ATNDeserializer.ADDED_LEXER_ACTIONS, uuid)) {\r\n // this piece of unused metadata was serialized prior to the\r\n // addition of LexerAction\r\n let actionIndexIgnored = ATNDeserializer.toInt(data[p++]);\r\n if (actionIndexIgnored === 0xFFFF) {\r\n actionIndexIgnored = -1;\r\n }\r\n }\r\n }\r\n }\r\n atn.ruleToStopState = new Array(nrules);\r\n for (let state of atn.states) {\r\n if (!(state instanceof RuleStopState_1.RuleStopState)) {\r\n continue;\r\n }\r\n atn.ruleToStopState[state.ruleIndex] = state;\r\n atn.ruleToStartState[state.ruleIndex].stopState = state;\r\n }\r\n //\r\n // MODES\r\n //\r\n let nmodes = ATNDeserializer.toInt(data[p++]);\r\n for (let i = 0; i < nmodes; i++) {\r\n let s = ATNDeserializer.toInt(data[p++]);\r\n atn.modeToStartState.push(atn.states[s]);\r\n }\r\n atn.modeToDFA = new Array(nmodes);\r\n for (let i = 0; i < nmodes; i++) {\r\n atn.modeToDFA[i] = new DFA_1.DFA(atn.modeToStartState[i]);\r\n }\r\n //\r\n // SETS\r\n //\r\n let sets = [];\r\n let nsets = ATNDeserializer.toInt(data[p++]);\r\n for (let i = 0; i < nsets; i++) {\r\n let nintervals = ATNDeserializer.toInt(data[p]);\r\n p++;\r\n let set = new IntervalSet_1.IntervalSet();\r\n sets.push(set);\r\n let containsEof = ATNDeserializer.toInt(data[p++]) != 0;\r\n if (containsEof) {\r\n set.add(-1);\r\n }\r\n for (let j = 0; j < nintervals; j++) {\r\n set.add(ATNDeserializer.toInt(data[p]), ATNDeserializer.toInt(data[p + 1]));\r\n p += 2;\r\n }\r\n }\r\n //\r\n // EDGES\r\n //\r\n let nedges = ATNDeserializer.toInt(data[p++]);\r\n for (let i = 0; i < nedges; i++) {\r\n let src = ATNDeserializer.toInt(data[p]);\r\n let trg = ATNDeserializer.toInt(data[p + 1]);\r\n let ttype = ATNDeserializer.toInt(data[p + 2]);\r\n let arg1 = ATNDeserializer.toInt(data[p + 3]);\r\n let arg2 = ATNDeserializer.toInt(data[p + 4]);\r\n let arg3 = ATNDeserializer.toInt(data[p + 5]);\r\n let trans = this.edgeFactory(atn, ttype, src, trg, arg1, arg2, arg3, sets);\r\n // console.log(`EDGE ${trans.constructor.name} ${src}->${trg} ${Transition.serializationNames[ttype]} ${arg1},${arg2},${arg3}`);\r\n let srcState = atn.states[src];\r\n srcState.addTransition(trans);\r\n p += 6;\r\n }\r\n let returnTransitionsSet = new Array2DHashSet_1.Array2DHashSet({\r\n hashCode: (o) => o.stopState ^ o.returnState ^ o.outermostPrecedenceReturn,\r\n equals: function (a, b) {\r\n return a.stopState === b.stopState\r\n && a.returnState === b.returnState\r\n && a.outermostPrecedenceReturn === b.outermostPrecedenceReturn;\r\n }\r\n });\r\n let returnTransitions = [];\r\n for (let state of atn.states) {\r\n let returningToLeftFactored = state.ruleIndex >= 0 && atn.ruleToStartState[state.ruleIndex].leftFactored;\r\n for (let i = 0; i < state.numberOfTransitions; i++) {\r\n let t = state.transition(i);\r\n if (!(t instanceof RuleTransition_1.RuleTransition)) {\r\n continue;\r\n }\r\n let ruleTransition = t;\r\n let returningFromLeftFactored = atn.ruleToStartState[ruleTransition.target.ruleIndex].leftFactored;\r\n if (!returningFromLeftFactored && returningToLeftFactored) {\r\n continue;\r\n }\r\n let outermostPrecedenceReturn = -1;\r\n if (atn.ruleToStartState[ruleTransition.target.ruleIndex].isPrecedenceRule) {\r\n if (ruleTransition.precedence === 0) {\r\n outermostPrecedenceReturn = ruleTransition.target.ruleIndex;\r\n }\r\n }\r\n let current = { stopState: ruleTransition.target.ruleIndex, returnState: ruleTransition.followState.stateNumber, outermostPrecedenceReturn: outermostPrecedenceReturn };\r\n if (returnTransitionsSet.add(current)) {\r\n returnTransitions.push(current);\r\n }\r\n }\r\n }\r\n // Add all elements from returnTransitions to the ATN\r\n for (let returnTransition of returnTransitions) {\r\n let transition = new EpsilonTransition_1.EpsilonTransition(atn.states[returnTransition.returnState], returnTransition.outermostPrecedenceReturn);\r\n atn.ruleToStopState[returnTransition.stopState].addTransition(transition);\r\n }\r\n for (let state of atn.states) {\r\n if (state instanceof BlockStartState_1.BlockStartState) {\r\n // we need to know the end state to set its start state\r\n if (state.endState == null) {\r\n throw new Error(\"IllegalStateException\");\r\n }\r\n // block end states can only be associated to a single block start state\r\n if (state.endState.startState != null) {\r\n throw new Error(\"IllegalStateException\");\r\n }\r\n state.endState.startState = state;\r\n }\r\n if (state instanceof PlusLoopbackState_1.PlusLoopbackState) {\r\n let loopbackState = state;\r\n for (let i = 0; i < loopbackState.numberOfTransitions; i++) {\r\n let target = loopbackState.transition(i).target;\r\n if (target instanceof PlusBlockStartState_1.PlusBlockStartState) {\r\n target.loopBackState = loopbackState;\r\n }\r\n }\r\n }\r\n else if (state instanceof StarLoopbackState_1.StarLoopbackState) {\r\n let loopbackState = state;\r\n for (let i = 0; i < loopbackState.numberOfTransitions; i++) {\r\n let target = loopbackState.transition(i).target;\r\n if (target instanceof StarLoopEntryState_1.StarLoopEntryState) {\r\n target.loopBackState = loopbackState;\r\n }\r\n }\r\n }\r\n }\r\n //\r\n // DECISIONS\r\n //\r\n let ndecisions = ATNDeserializer.toInt(data[p++]);\r\n for (let i = 1; i <= ndecisions; i++) {\r\n let s = ATNDeserializer.toInt(data[p++]);\r\n let decState = atn.states[s];\r\n atn.decisionToState.push(decState);\r\n decState.decision = i - 1;\r\n }\r\n //\r\n // LEXER ACTIONS\r\n //\r\n if (atn.grammarType === 0 /* LEXER */) {\r\n if (supportsLexerActions) {\r\n atn.lexerActions = new Array(ATNDeserializer.toInt(data[p++]));\r\n for (let i = 0; i < atn.lexerActions.length; i++) {\r\n let actionType = ATNDeserializer.toInt(data[p++]);\r\n let data1 = ATNDeserializer.toInt(data[p++]);\r\n if (data1 == 0xFFFF) {\r\n data1 = -1;\r\n }\r\n let data2 = ATNDeserializer.toInt(data[p++]);\r\n if (data2 == 0xFFFF) {\r\n data2 = -1;\r\n }\r\n let lexerAction = this.lexerActionFactory(actionType, data1, data2);\r\n atn.lexerActions[i] = lexerAction;\r\n }\r\n }\r\n else {\r\n // for compatibility with older serialized ATNs, convert the old\r\n // serialized action index for action transitions to the new\r\n // form, which is the index of a LexerCustomAction\r\n let legacyLexerActions = [];\r\n for (let state of atn.states) {\r\n for (let i = 0; i < state.numberOfTransitions; i++) {\r\n let transition = state.transition(i);\r\n if (!(transition instanceof ActionTransition_1.ActionTransition)) {\r\n continue;\r\n }\r\n let ruleIndex = transition.ruleIndex;\r\n let actionIndex = transition.actionIndex;\r\n let lexerAction = new LexerCustomAction_1.LexerCustomAction(ruleIndex, actionIndex);\r\n state.setTransition(i, new ActionTransition_1.ActionTransition(transition.target, ruleIndex, legacyLexerActions.length, false));\r\n legacyLexerActions.push(lexerAction);\r\n }\r\n }\r\n atn.lexerActions = legacyLexerActions;\r\n }\r\n }\r\n this.markPrecedenceDecisions(atn);\r\n atn.decisionToDFA = new Array(ndecisions);\r\n for (let i = 0; i < ndecisions; i++) {\r\n atn.decisionToDFA[i] = new DFA_1.DFA(atn.decisionToState[i], i);\r\n }\r\n if (this.deserializationOptions.isVerifyATN) {\r\n this.verifyATN(atn);\r\n }\r\n if (this.deserializationOptions.isGenerateRuleBypassTransitions && atn.grammarType === 1 /* PARSER */) {\r\n atn.ruleToTokenType = new Int32Array(atn.ruleToStartState.length);\r\n for (let i = 0; i < atn.ruleToStartState.length; i++) {\r\n atn.ruleToTokenType[i] = atn.maxTokenType + i + 1;\r\n }\r\n for (let i = 0; i < atn.ruleToStartState.length; i++) {\r\n let bypassStart = new BasicBlockStartState_1.BasicBlockStartState();\r\n bypassStart.ruleIndex = i;\r\n atn.addState(bypassStart);\r\n let bypassStop = new BlockEndState_1.BlockEndState();\r\n bypassStop.ruleIndex = i;\r\n atn.addState(bypassStop);\r\n bypassStart.endState = bypassStop;\r\n atn.defineDecisionState(bypassStart);\r\n bypassStop.startState = bypassStart;\r\n let endState;\r\n let excludeTransition;\r\n if (atn.ruleToStartState[i].isPrecedenceRule) {\r\n // wrap from the beginning of the rule to the StarLoopEntryState\r\n endState = undefined;\r\n for (let state of atn.states) {\r\n if (state.ruleIndex !== i) {\r\n continue;\r\n }\r\n if (!(state instanceof StarLoopEntryState_1.StarLoopEntryState)) {\r\n continue;\r\n }\r\n let maybeLoopEndState = state.transition(state.numberOfTransitions - 1).target;\r\n if (!(maybeLoopEndState instanceof LoopEndState_1.LoopEndState)) {\r\n continue;\r\n }\r\n if (maybeLoopEndState.epsilonOnlyTransitions && maybeLoopEndState.transition(0).target instanceof RuleStopState_1.RuleStopState) {\r\n endState = state;\r\n break;\r\n }\r\n }\r\n if (!endState) {\r\n throw new Error(\"Couldn't identify final state of the precedence rule prefix section.\");\r\n }\r\n excludeTransition = endState.loopBackState.transition(0);\r\n }\r\n else {\r\n endState = atn.ruleToStopState[i];\r\n }\r\n // all non-excluded transitions that currently target end state need to target blockEnd instead\r\n for (let state of atn.states) {\r\n for (let i = 0; i < state.numberOfTransitions; i++) {\r\n let transition = state.transition(i);\r\n if (transition === excludeTransition) {\r\n continue;\r\n }\r\n if (transition.target === endState) {\r\n transition.target = bypassStop;\r\n }\r\n }\r\n }\r\n // all transitions leaving the rule start state need to leave blockStart instead\r\n while (atn.ruleToStartState[i].numberOfTransitions > 0) {\r\n let transition = atn.ruleToStartState[i].removeTransition(atn.ruleToStartState[i].numberOfTransitions - 1);\r\n bypassStart.addTransition(transition);\r\n }\r\n // link the new states\r\n atn.ruleToStartState[i].addTransition(new EpsilonTransition_1.EpsilonTransition(bypassStart));\r\n bypassStop.addTransition(new EpsilonTransition_1.EpsilonTransition(endState));\r\n let matchState = new BasicState_1.BasicState();\r\n atn.addState(matchState);\r\n matchState.addTransition(new AtomTransition_1.AtomTransition(bypassStop, atn.ruleToTokenType[i]));\r\n bypassStart.addTransition(new EpsilonTransition_1.EpsilonTransition(matchState));\r\n }\r\n if (this.deserializationOptions.isVerifyATN) {\r\n // reverify after modification\r\n this.verifyATN(atn);\r\n }\r\n }\r\n if (this.deserializationOptions.isOptimize) {\r\n while (true) {\r\n let optimizationCount = 0;\r\n optimizationCount += ATNDeserializer.inlineSetRules(atn);\r\n optimizationCount += ATNDeserializer.combineChainedEpsilons(atn);\r\n let preserveOrder = atn.grammarType === 0 /* LEXER */;\r\n optimizationCount += ATNDeserializer.optimizeSets(atn, preserveOrder);\r\n if (optimizationCount === 0) {\r\n break;\r\n }\r\n }\r\n if (this.deserializationOptions.isVerifyATN) {\r\n // reverify after modification\r\n this.verifyATN(atn);\r\n }\r\n }\r\n ATNDeserializer.identifyTailCalls(atn);\r\n return atn;\r\n }\r\n /**\r\n * Analyze the {@link StarLoopEntryState} states in the specified ATN to set\r\n * the {@link StarLoopEntryState#precedenceRuleDecision} field to the\r\n * correct value.\r\n *\r\n * @param atn The ATN.\r\n */\r\n markPrecedenceDecisions(atn) {\r\n // Map rule index -> precedence decision for that rule\r\n let rulePrecedenceDecisions = new Map();\r\n for (let state of atn.states) {\r\n if (!(state instanceof StarLoopEntryState_1.StarLoopEntryState)) {\r\n continue;\r\n }\r\n /* We analyze the ATN to determine if this ATN decision state is the\r\n * decision for the closure block that determines whether a\r\n * precedence rule should continue or complete.\r\n */\r\n if (atn.ruleToStartState[state.ruleIndex].isPrecedenceRule) {\r\n let maybeLoopEndState = state.transition(state.numberOfTransitions - 1).target;\r\n if (maybeLoopEndState instanceof LoopEndState_1.LoopEndState) {\r\n if (maybeLoopEndState.epsilonOnlyTransitions && maybeLoopEndState.transition(0).target instanceof RuleStopState_1.RuleStopState) {\r\n rulePrecedenceDecisions.set(state.ruleIndex, state);\r\n state.precedenceRuleDecision = true;\r\n state.precedenceLoopbackStates = new BitSet_1.BitSet(atn.states.length);\r\n }\r\n }\r\n }\r\n }\r\n // After marking precedence decisions, we go back through and fill in\r\n // StarLoopEntryState.precedenceLoopbackStates.\r\n for (let precedenceDecision of rulePrecedenceDecisions) {\r\n for (let transition of atn.ruleToStopState[precedenceDecision[0]].getTransitions()) {\r\n if (transition.serializationType !== 1 /* EPSILON */) {\r\n continue;\r\n }\r\n let epsilonTransition = transition;\r\n if (epsilonTransition.outermostPrecedenceReturn !== -1) {\r\n continue;\r\n }\r\n precedenceDecision[1].precedenceLoopbackStates.set(transition.target.stateNumber);\r\n }\r\n }\r\n }\r\n verifyATN(atn) {\r\n // verify assumptions\r\n for (let state of atn.states) {\r\n this.checkCondition(state != null, \"ATN states should not be null.\");\r\n if (state.stateType === 0 /* INVALID_TYPE */) {\r\n continue;\r\n }\r\n this.checkCondition(state.onlyHasEpsilonTransitions || state.numberOfTransitions <= 1);\r\n if (state instanceof PlusBlockStartState_1.PlusBlockStartState) {\r\n this.checkCondition(state.loopBackState != null);\r\n }\r\n if (state instanceof StarLoopEntryState_1.StarLoopEntryState) {\r\n let starLoopEntryState = state;\r\n this.checkCondition(starLoopEntryState.loopBackState != null);\r\n this.checkCondition(starLoopEntryState.numberOfTransitions === 2);\r\n if (starLoopEntryState.transition(0).target instanceof StarBlockStartState_1.StarBlockStartState) {\r\n this.checkCondition(starLoopEntryState.transition(1).target instanceof LoopEndState_1.LoopEndState);\r\n this.checkCondition(!starLoopEntryState.nonGreedy);\r\n }\r\n else if (starLoopEntryState.transition(0).target instanceof LoopEndState_1.LoopEndState) {\r\n this.checkCondition(starLoopEntryState.transition(1).target instanceof StarBlockStartState_1.StarBlockStartState);\r\n this.checkCondition(starLoopEntryState.nonGreedy);\r\n }\r\n else {\r\n throw new Error(\"IllegalStateException\");\r\n }\r\n }\r\n if (state instanceof StarLoopbackState_1.StarLoopbackState) {\r\n this.checkCondition(state.numberOfTransitions === 1);\r\n this.checkCondition(state.transition(0).target instanceof StarLoopEntryState_1.StarLoopEntryState);\r\n }\r\n if (state instanceof LoopEndState_1.LoopEndState) {\r\n this.checkCondition(state.loopBackState != null);\r\n }\r\n if (state instanceof RuleStartState_1.RuleStartState) {\r\n this.checkCondition(state.stopState != null);\r\n }\r\n if (state instanceof BlockStartState_1.BlockStartState) {\r\n this.checkCondition(state.endState != null);\r\n }\r\n if (state instanceof BlockEndState_1.BlockEndState) {\r\n this.checkCondition(state.startState != null);\r\n }\r\n if (state instanceof DecisionState_1.DecisionState) {\r\n let decisionState = state;\r\n this.checkCondition(decisionState.numberOfTransitions <= 1 || decisionState.decision >= 0);\r\n }\r\n else {\r\n this.checkCondition(state.numberOfTransitions <= 1 || state instanceof RuleStopState_1.RuleStopState);\r\n }\r\n }\r\n }\r\n checkCondition(condition, message) {\r\n if (!condition) {\r\n throw new Error(\"IllegalStateException: \" + message);\r\n }\r\n }\r\n static inlineSetRules(atn) {\r\n let inlinedCalls = 0;\r\n let ruleToInlineTransition = new Array(atn.ruleToStartState.length);\r\n for (let i = 0; i < atn.ruleToStartState.length; i++) {\r\n let startState = atn.ruleToStartState[i];\r\n let middleState = startState;\r\n while (middleState.onlyHasEpsilonTransitions\r\n && middleState.numberOfOptimizedTransitions === 1\r\n && middleState.getOptimizedTransition(0).serializationType === 1 /* EPSILON */) {\r\n middleState = middleState.getOptimizedTransition(0).target;\r\n }\r\n if (middleState.numberOfOptimizedTransitions !== 1) {\r\n continue;\r\n }\r\n let matchTransition = middleState.getOptimizedTransition(0);\r\n let matchTarget = matchTransition.target;\r\n if (matchTransition.isEpsilon\r\n || !matchTarget.onlyHasEpsilonTransitions\r\n || matchTarget.numberOfOptimizedTransitions !== 1\r\n || !(matchTarget.getOptimizedTransition(0).target instanceof RuleStopState_1.RuleStopState)) {\r\n continue;\r\n }\r\n switch (matchTransition.serializationType) {\r\n case 5 /* ATOM */:\r\n case 2 /* RANGE */:\r\n case 7 /* SET */:\r\n ruleToInlineTransition[i] = matchTransition;\r\n break;\r\n case 8 /* NOT_SET */:\r\n case 9 /* WILDCARD */:\r\n // not implemented yet\r\n continue;\r\n default:\r\n continue;\r\n }\r\n }\r\n for (let stateNumber = 0; stateNumber < atn.states.length; stateNumber++) {\r\n let state = atn.states[stateNumber];\r\n if (state.ruleIndex < 0) {\r\n continue;\r\n }\r\n let optimizedTransitions;\r\n for (let i = 0; i < state.numberOfOptimizedTransitions; i++) {\r\n let transition = state.getOptimizedTransition(i);\r\n if (!(transition instanceof RuleTransition_1.RuleTransition)) {\r\n if (optimizedTransitions != null) {\r\n optimizedTransitions.push(transition);\r\n }\r\n continue;\r\n }\r\n let ruleTransition = transition;\r\n let effective = ruleToInlineTransition[ruleTransition.target.ruleIndex];\r\n if (effective == null) {\r\n if (optimizedTransitions != null) {\r\n optimizedTransitions.push(transition);\r\n }\r\n continue;\r\n }\r\n if (optimizedTransitions == null) {\r\n optimizedTransitions = [];\r\n for (let j = 0; j < i; j++) {\r\n optimizedTransitions.push(state.getOptimizedTransition(i));\r\n }\r\n }\r\n inlinedCalls++;\r\n let target = ruleTransition.followState;\r\n let intermediateState = new BasicState_1.BasicState();\r\n intermediateState.setRuleIndex(target.ruleIndex);\r\n atn.addState(intermediateState);\r\n optimizedTransitions.push(new EpsilonTransition_1.EpsilonTransition(intermediateState));\r\n switch (effective.serializationType) {\r\n case 5 /* ATOM */:\r\n intermediateState.addTransition(new AtomTransition_1.AtomTransition(target, effective._label));\r\n break;\r\n case 2 /* RANGE */:\r\n intermediateState.addTransition(new RangeTransition_1.RangeTransition(target, effective.from, effective.to));\r\n break;\r\n case 7 /* SET */:\r\n intermediateState.addTransition(new SetTransition_1.SetTransition(target, effective.label));\r\n break;\r\n default:\r\n throw new Error(\"UnsupportedOperationException\");\r\n }\r\n }\r\n if (optimizedTransitions != null) {\r\n if (state.isOptimized) {\r\n while (state.numberOfOptimizedTransitions > 0) {\r\n state.removeOptimizedTransition(state.numberOfOptimizedTransitions - 1);\r\n }\r\n }\r\n for (let transition of optimizedTransitions) {\r\n state.addOptimizedTransition(transition);\r\n }\r\n }\r\n }\r\n if (ParserATNSimulator_1.ParserATNSimulator.debug) {\r\n console.log(\"ATN runtime optimizer removed \" + inlinedCalls + \" rule invocations by inlining sets.\");\r\n }\r\n return inlinedCalls;\r\n }\r\n static combineChainedEpsilons(atn) {\r\n let removedEdges = 0;\r\n for (let state of atn.states) {\r\n if (!state.onlyHasEpsilonTransitions || state instanceof RuleStopState_1.RuleStopState) {\r\n continue;\r\n }\r\n let optimizedTransitions;\r\n nextTransition: for (let i = 0; i < state.numberOfOptimizedTransitions; i++) {\r\n let transition = state.getOptimizedTransition(i);\r\n let intermediate = transition.target;\r\n if (transition.serializationType !== 1 /* EPSILON */\r\n || transition.outermostPrecedenceReturn !== -1\r\n || intermediate.stateType !== 1 /* BASIC */\r\n || !intermediate.onlyHasEpsilonTransitions) {\r\n if (optimizedTransitions != null) {\r\n optimizedTransitions.push(transition);\r\n }\r\n continue nextTransition;\r\n }\r\n for (let j = 0; j < intermediate.numberOfOptimizedTransitions; j++) {\r\n if (intermediate.getOptimizedTransition(j).serializationType !== 1 /* EPSILON */\r\n || intermediate.getOptimizedTransition(j).outermostPrecedenceReturn !== -1) {\r\n if (optimizedTransitions != null) {\r\n optimizedTransitions.push(transition);\r\n }\r\n continue nextTransition;\r\n }\r\n }\r\n removedEdges++;\r\n if (optimizedTransitions == null) {\r\n optimizedTransitions = [];\r\n for (let j = 0; j < i; j++) {\r\n optimizedTransitions.push(state.getOptimizedTransition(j));\r\n }\r\n }\r\n for (let j = 0; j < intermediate.numberOfOptimizedTransitions; j++) {\r\n let target = intermediate.getOptimizedTransition(j).target;\r\n optimizedTransitions.push(new EpsilonTransition_1.EpsilonTransition(target));\r\n }\r\n }\r\n if (optimizedTransitions != null) {\r\n if (state.isOptimized) {\r\n while (state.numberOfOptimizedTransitions > 0) {\r\n state.removeOptimizedTransition(state.numberOfOptimizedTransitions - 1);\r\n }\r\n }\r\n for (let transition of optimizedTransitions) {\r\n state.addOptimizedTransition(transition);\r\n }\r\n }\r\n }\r\n if (ParserATNSimulator_1.ParserATNSimulator.debug) {\r\n console.log(\"ATN runtime optimizer removed \" + removedEdges + \" transitions by combining chained epsilon transitions.\");\r\n }\r\n return removedEdges;\r\n }\r\n static optimizeSets(atn, preserveOrder) {\r\n if (preserveOrder) {\r\n // this optimization currently doesn't preserve edge order.\r\n return 0;\r\n }\r\n let removedPaths = 0;\r\n let decisions = atn.decisionToState;\r\n for (let decision of decisions) {\r\n let setTransitions = new IntervalSet_1.IntervalSet();\r\n for (let i = 0; i < decision.numberOfOptimizedTransitions; i++) {\r\n let epsTransition = decision.getOptimizedTransition(i);\r\n if (!(epsTransition instanceof EpsilonTransition_1.EpsilonTransition)) {\r\n continue;\r\n }\r\n if (epsTransition.target.numberOfOptimizedTransitions !== 1) {\r\n continue;\r\n }\r\n let transition = epsTransition.target.getOptimizedTransition(0);\r\n if (!(transition.target instanceof BlockEndState_1.BlockEndState)) {\r\n continue;\r\n }\r\n if (transition instanceof NotSetTransition_1.NotSetTransition) {\r\n // TODO: not yet implemented\r\n continue;\r\n }\r\n if (transition instanceof AtomTransition_1.AtomTransition\r\n || transition instanceof RangeTransition_1.RangeTransition\r\n || transition instanceof SetTransition_1.SetTransition) {\r\n setTransitions.add(i);\r\n }\r\n }\r\n if (setTransitions.size <= 1) {\r\n continue;\r\n }\r\n let optimizedTransitions = [];\r\n for (let i = 0; i < decision.numberOfOptimizedTransitions; i++) {\r\n if (!setTransitions.contains(i)) {\r\n optimizedTransitions.push(decision.getOptimizedTransition(i));\r\n }\r\n }\r\n let blockEndState = decision.getOptimizedTransition(setTransitions.minElement).target.getOptimizedTransition(0).target;\r\n let matchSet = new IntervalSet_1.IntervalSet();\r\n for (let i = 0; i < setTransitions.intervals.length; i++) {\r\n let interval = setTransitions.intervals[i];\r\n for (let j = interval.a; j <= interval.b; j++) {\r\n let matchTransition = decision.getOptimizedTransition(j).target.getOptimizedTransition(0);\r\n if (matchTransition instanceof NotSetTransition_1.NotSetTransition) {\r\n throw new Error(\"Not yet implemented.\");\r\n }\r\n else {\r\n matchSet.addAll(matchTransition.label);\r\n }\r\n }\r\n }\r\n let newTransition;\r\n if (matchSet.intervals.length === 1) {\r\n if (matchSet.size === 1) {\r\n newTransition = new AtomTransition_1.AtomTransition(blockEndState, matchSet.minElement);\r\n }\r\n else {\r\n let matchInterval = matchSet.intervals[0];\r\n newTransition = new RangeTransition_1.RangeTransition(blockEndState, matchInterval.a, matchInterval.b);\r\n }\r\n }\r\n else {\r\n newTransition = new SetTransition_1.SetTransition(blockEndState, matchSet);\r\n }\r\n let setOptimizedState = new BasicState_1.BasicState();\r\n setOptimizedState.setRuleIndex(decision.ruleIndex);\r\n atn.addState(setOptimizedState);\r\n setOptimizedState.addTransition(newTransition);\r\n optimizedTransitions.push(new EpsilonTransition_1.EpsilonTransition(setOptimizedState));\r\n removedPaths += decision.numberOfOptimizedTransitions - optimizedTransitions.length;\r\n if (decision.isOptimized) {\r\n while (decision.numberOfOptimizedTransitions > 0) {\r\n decision.removeOptimizedTransition(decision.numberOfOptimizedTransitions - 1);\r\n }\r\n }\r\n for (let transition of optimizedTransitions) {\r\n decision.addOptimizedTransition(transition);\r\n }\r\n }\r\n if (ParserATNSimulator_1.ParserATNSimulator.debug) {\r\n console.log(\"ATN runtime optimizer removed \" + removedPaths + \" paths by collapsing sets.\");\r\n }\r\n return removedPaths;\r\n }\r\n static identifyTailCalls(atn) {\r\n for (let state of atn.states) {\r\n for (let i = 0; i < state.numberOfTransitions; i++) {\r\n let transition = state.transition(i);\r\n if (!(transition instanceof RuleTransition_1.RuleTransition)) {\r\n continue;\r\n }\r\n transition.tailCall = this.testTailCall(atn, transition, false);\r\n transition.optimizedTailCall = this.testTailCall(atn, transition, true);\r\n }\r\n if (!state.isOptimized) {\r\n continue;\r\n }\r\n for (let i = 0; i < state.numberOfOptimizedTransitions; i++) {\r\n let transition = state.getOptimizedTransition(i);\r\n if (!(transition instanceof RuleTransition_1.RuleTransition)) {\r\n continue;\r\n }\r\n transition.tailCall = this.testTailCall(atn, transition, false);\r\n transition.optimizedTailCall = this.testTailCall(atn, transition, true);\r\n }\r\n }\r\n }\r\n static testTailCall(atn, transition, optimizedPath) {\r\n if (!optimizedPath && transition.tailCall) {\r\n return true;\r\n }\r\n if (optimizedPath && transition.optimizedTailCall) {\r\n return true;\r\n }\r\n let reachable = new BitSet_1.BitSet(atn.states.length);\r\n let worklist = [];\r\n worklist.push(transition.followState);\r\n while (true) {\r\n let state = worklist.pop();\r\n if (!state) {\r\n break;\r\n }\r\n if (reachable.get(state.stateNumber)) {\r\n continue;\r\n }\r\n if (state instanceof RuleStopState_1.RuleStopState) {\r\n continue;\r\n }\r\n if (!state.onlyHasEpsilonTransitions) {\r\n return false;\r\n }\r\n let transitionCount = optimizedPath ? state.numberOfOptimizedTransitions : state.numberOfTransitions;\r\n for (let i = 0; i < transitionCount; i++) {\r\n let t = optimizedPath ? state.getOptimizedTransition(i) : state.transition(i);\r\n if (t.serializationType !== 1 /* EPSILON */) {\r\n return false;\r\n }\r\n worklist.push(t.target);\r\n }\r\n }\r\n return true;\r\n }\r\n static toInt(c) {\r\n return c;\r\n }\r\n static toInt32(data, offset) {\r\n return (data[offset] | (data[offset + 1] << 16)) >>> 0;\r\n }\r\n static toUUID(data, offset) {\r\n let leastSigBits = ATNDeserializer.toInt32(data, offset);\r\n let lessSigBits = ATNDeserializer.toInt32(data, offset + 2);\r\n let moreSigBits = ATNDeserializer.toInt32(data, offset + 4);\r\n let mostSigBits = ATNDeserializer.toInt32(data, offset + 6);\r\n return new UUID_1.UUID(mostSigBits, moreSigBits, lessSigBits, leastSigBits);\r\n }\r\n edgeFactory(atn, type, src, trg, arg1, arg2, arg3, sets) {\r\n let target = atn.states[trg];\r\n switch (type) {\r\n case 1 /* EPSILON */: return new EpsilonTransition_1.EpsilonTransition(target);\r\n case 2 /* RANGE */:\r\n if (arg3 !== 0) {\r\n return new RangeTransition_1.RangeTransition(target, Token_1.Token.EOF, arg2);\r\n }\r\n else {\r\n return new RangeTransition_1.RangeTransition(target, arg1, arg2);\r\n }\r\n case 3 /* RULE */:\r\n let rt = new RuleTransition_1.RuleTransition(atn.states[arg1], arg2, arg3, target);\r\n return rt;\r\n case 4 /* PREDICATE */:\r\n let pt = new PredicateTransition_1.PredicateTransition(target, arg1, arg2, arg3 !== 0);\r\n return pt;\r\n case 10 /* PRECEDENCE */:\r\n return new PrecedencePredicateTransition_1.PrecedencePredicateTransition(target, arg1);\r\n case 5 /* ATOM */:\r\n if (arg3 !== 0) {\r\n return new AtomTransition_1.AtomTransition(target, Token_1.Token.EOF);\r\n }\r\n else {\r\n return new AtomTransition_1.AtomTransition(target, arg1);\r\n }\r\n case 6 /* ACTION */:\r\n let a = new ActionTransition_1.ActionTransition(target, arg1, arg2, arg3 !== 0);\r\n return a;\r\n case 7 /* SET */: return new SetTransition_1.SetTransition(target, sets[arg1]);\r\n case 8 /* NOT_SET */: return new NotSetTransition_1.NotSetTransition(target, sets[arg1]);\r\n case 9 /* WILDCARD */: return new WildcardTransition_1.WildcardTransition(target);\r\n }\r\n throw new Error(\"The specified transition type is not valid.\");\r\n }\r\n stateFactory(type, ruleIndex) {\r\n let s;\r\n switch (type) {\r\n case 0 /* INVALID_TYPE */: return new InvalidState_1.InvalidState();\r\n case 1 /* BASIC */:\r\n s = new BasicState_1.BasicState();\r\n break;\r\n case 2 /* RULE_START */:\r\n s = new RuleStartState_1.RuleStartState();\r\n break;\r\n case 3 /* BLOCK_START */:\r\n s = new BasicBlockStartState_1.BasicBlockStartState();\r\n break;\r\n case 4 /* PLUS_BLOCK_START */:\r\n s = new PlusBlockStartState_1.PlusBlockStartState();\r\n break;\r\n case 5 /* STAR_BLOCK_START */:\r\n s = new StarBlockStartState_1.StarBlockStartState();\r\n break;\r\n case 6 /* TOKEN_START */:\r\n s = new TokensStartState_1.TokensStartState();\r\n break;\r\n case 7 /* RULE_STOP */:\r\n s = new RuleStopState_1.RuleStopState();\r\n break;\r\n case 8 /* BLOCK_END */:\r\n s = new BlockEndState_1.BlockEndState();\r\n break;\r\n case 9 /* STAR_LOOP_BACK */:\r\n s = new StarLoopbackState_1.StarLoopbackState();\r\n break;\r\n case 10 /* STAR_LOOP_ENTRY */:\r\n s = new StarLoopEntryState_1.StarLoopEntryState();\r\n break;\r\n case 11 /* PLUS_LOOP_BACK */:\r\n s = new PlusLoopbackState_1.PlusLoopbackState();\r\n break;\r\n case 12 /* LOOP_END */:\r\n s = new LoopEndState_1.LoopEndState();\r\n break;\r\n default:\r\n let message = `The specified state type ${type} is not valid.`;\r\n throw new Error(message);\r\n }\r\n s.ruleIndex = ruleIndex;\r\n return s;\r\n }\r\n lexerActionFactory(type, data1, data2) {\r\n switch (type) {\r\n case 0 /* CHANNEL */:\r\n return new LexerChannelAction_1.LexerChannelAction(data1);\r\n case 1 /* CUSTOM */:\r\n return new LexerCustomAction_1.LexerCustomAction(data1, data2);\r\n case 2 /* MODE */:\r\n return new LexerModeAction_1.LexerModeAction(data1);\r\n case 3 /* MORE */:\r\n return LexerMoreAction_1.LexerMoreAction.INSTANCE;\r\n case 4 /* POP_MODE */:\r\n return LexerPopModeAction_1.LexerPopModeAction.INSTANCE;\r\n case 5 /* PUSH_MODE */:\r\n return new LexerPushModeAction_1.LexerPushModeAction(data1);\r\n case 6 /* SKIP */:\r\n return LexerSkipAction_1.LexerSkipAction.INSTANCE;\r\n case 7 /* TYPE */:\r\n return new LexerTypeAction_1.LexerTypeAction(data1);\r\n default:\r\n let message = `The specified lexer action type ${type} is not valid.`;\r\n throw new Error(message);\r\n }\r\n }\r\n}\r\n/* WARNING: DO NOT MERGE THESE LINES. If UUIDs differ during a merge,\r\n * resolve the conflict by generating a new ID!\r\n */\r\n/**\r\n * This is the earliest supported serialized UUID.\r\n */\r\nATNDeserializer.BASE_SERIALIZED_UUID = UUID_1.UUID.fromString(\"E4178468-DF95-44D0-AD87-F22A5D5FB6D3\");\r\n/**\r\n * This UUID indicates an extension of {@link #ADDED_PRECEDENCE_TRANSITIONS}\r\n * for the addition of lexer actions encoded as a sequence of\r\n * {@link LexerAction} instances.\r\n */\r\nATNDeserializer.ADDED_LEXER_ACTIONS = UUID_1.UUID.fromString(\"AB35191A-1603-487E-B75A-479B831EAF6D\");\r\n/**\r\n * This list contains all of the currently supported UUIDs, ordered by when\r\n * the feature first appeared in this branch.\r\n */\r\nATNDeserializer.SUPPORTED_UUIDS = [\r\n ATNDeserializer.BASE_SERIALIZED_UUID,\r\n ATNDeserializer.ADDED_LEXER_ACTIONS\r\n];\r\n/**\r\n * This is the current serialized UUID.\r\n */\r\nATNDeserializer.SERIALIZED_UUID = ATNDeserializer.ADDED_LEXER_ACTIONS;\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATNDeserializer.prototype, \"deserializationOptions\", void 0);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ATNDeserializer.prototype, \"deserialize\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ATNDeserializer.prototype, \"markPrecedenceDecisions\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], ATNDeserializer.prototype, \"edgeFactory\", null);\r\nexports.ATNDeserializer = ATNDeserializer;\r\n//# sourceMappingURL=ATNDeserializer.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst RecognitionException_1 = require(\"./RecognitionException\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst Interval_1 = require(\"./misc/Interval\");\r\nconst Utils = require(\"./misc/Utils\");\r\nlet LexerNoViableAltException = class LexerNoViableAltException extends RecognitionException_1.RecognitionException {\r\n constructor(lexer, input, startIndex, deadEndConfigs) {\r\n super(lexer, input);\r\n this._startIndex = startIndex;\r\n this._deadEndConfigs = deadEndConfigs;\r\n }\r\n get startIndex() {\r\n return this._startIndex;\r\n }\r\n get deadEndConfigs() {\r\n return this._deadEndConfigs;\r\n }\r\n get inputStream() {\r\n return super.inputStream;\r\n }\r\n toString() {\r\n let symbol = \"\";\r\n if (this._startIndex >= 0 && this._startIndex < this.inputStream.size) {\r\n symbol = this.inputStream.getText(Interval_1.Interval.of(this._startIndex, this._startIndex));\r\n symbol = Utils.escapeWhitespace(symbol, false);\r\n }\r\n // return String.format(Locale.getDefault(), \"%s('%s')\", LexerNoViableAltException.class.getSimpleName(), symbol);\r\n return `LexerNoViableAltException('${symbol}')`;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerNoViableAltException.prototype, \"inputStream\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerNoViableAltException.prototype, \"toString\", null);\r\nLexerNoViableAltException = __decorate([\r\n __param(1, Decorators_1.NotNull)\r\n], LexerNoViableAltException);\r\nexports.LexerNoViableAltException = LexerNoViableAltException;\r\n//# sourceMappingURL=LexerNoViableAltException.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst Transition_1 = require(\"./Transition\");\r\n/** */\r\nlet RuleTransition = class RuleTransition extends Transition_1.Transition {\r\n constructor(ruleStart, ruleIndex, precedence, followState) {\r\n super(ruleStart);\r\n this.tailCall = false;\r\n this.optimizedTailCall = false;\r\n this.ruleIndex = ruleIndex;\r\n this.precedence = precedence;\r\n this.followState = followState;\r\n }\r\n get serializationType() {\r\n return 3 /* RULE */;\r\n }\r\n get isEpsilon() {\r\n return true;\r\n }\r\n matches(symbol, minVocabSymbol, maxVocabSymbol) {\r\n return false;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], RuleTransition.prototype, \"followState\", void 0);\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleTransition.prototype, \"serializationType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleTransition.prototype, \"isEpsilon\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleTransition.prototype, \"matches\", null);\r\nRuleTransition = __decorate([\r\n __param(0, Decorators_1.NotNull), __param(3, Decorators_1.NotNull)\r\n], RuleTransition);\r\nexports.RuleTransition = RuleTransition;\r\n//# sourceMappingURL=RuleTransition.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst IntervalSet_1 = require(\"../misc/IntervalSet\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst Token_1 = require(\"../Token\");\r\nconst Transition_1 = require(\"./Transition\");\r\n/** A transition containing a set of values. */\r\nlet SetTransition = class SetTransition extends Transition_1.Transition {\r\n // TODO (sam): should we really allow null here?\r\n constructor(target, set) {\r\n super(target);\r\n if (set == null) {\r\n set = IntervalSet_1.IntervalSet.of(Token_1.Token.INVALID_TYPE);\r\n }\r\n this.set = set;\r\n }\r\n get serializationType() {\r\n return 7 /* SET */;\r\n }\r\n get label() {\r\n return this.set;\r\n }\r\n matches(symbol, minVocabSymbol, maxVocabSymbol) {\r\n return this.set.contains(symbol);\r\n }\r\n toString() {\r\n return this.set.toString();\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], SetTransition.prototype, \"set\", void 0);\r\n__decorate([\r\n Decorators_1.Override\r\n], SetTransition.prototype, \"serializationType\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n Decorators_1.NotNull\r\n], SetTransition.prototype, \"label\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], SetTransition.prototype, \"matches\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n Decorators_1.NotNull\r\n], SetTransition.prototype, \"toString\", null);\r\nSetTransition = __decorate([\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.Nullable)\r\n], SetTransition);\r\nexports.SetTransition = SetTransition;\r\n//# sourceMappingURL=SetTransition.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst SetTransition_1 = require(\"./SetTransition\");\r\nlet NotSetTransition = class NotSetTransition extends SetTransition_1.SetTransition {\r\n constructor(target, set) {\r\n super(target, set);\r\n }\r\n get serializationType() {\r\n return 8 /* NOT_SET */;\r\n }\r\n matches(symbol, minVocabSymbol, maxVocabSymbol) {\r\n return symbol >= minVocabSymbol\r\n && symbol <= maxVocabSymbol\r\n && !super.matches(symbol, minVocabSymbol, maxVocabSymbol);\r\n }\r\n toString() {\r\n return '~' + super.toString();\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override\r\n], NotSetTransition.prototype, \"serializationType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], NotSetTransition.prototype, \"matches\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], NotSetTransition.prototype, \"toString\", null);\r\nNotSetTransition = __decorate([\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.Nullable)\r\n], NotSetTransition);\r\nexports.NotSetTransition = NotSetTransition;\r\n//# sourceMappingURL=NotSetTransition.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst BitSet_1 = require(\"../misc/BitSet\");\r\nconst DecisionState_1 = require(\"./DecisionState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nclass StarLoopEntryState extends DecisionState_1.DecisionState {\r\n constructor() {\r\n super(...arguments);\r\n /**\r\n * Indicates whether this state can benefit from a precedence DFA during SLL\r\n * decision making.\r\n *\r\n * <p>This is a computed property that is calculated during ATN deserialization\r\n * and stored for use in {@link ParserATNSimulator} and\r\n * {@link ParserInterpreter}.</p>\r\n *\r\n * @see `DFA.isPrecedenceDfa`\r\n */\r\n this.precedenceRuleDecision = false;\r\n /**\r\n * For precedence decisions, this set marks states <em>S</em> which have all\r\n * of the following characteristics:\r\n *\r\n * <ul>\r\n * <li>One or more invocation sites of the current rule returns to\r\n * <em>S</em>.</li>\r\n * <li>The closure from <em>S</em> includes the current decision without\r\n * passing through any rule invocations or stepping out of the current\r\n * rule.</li>\r\n * </ul>\r\n *\r\n * <p>This field is not used when {@link #isPrecedenceDecision} is\r\n * {@code false}.</p>\r\n */\r\n this.precedenceLoopbackStates = new BitSet_1.BitSet();\r\n }\r\n get stateType() {\r\n return 10 /* STAR_LOOP_ENTRY */;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], StarLoopEntryState.prototype, \"stateType\", null);\r\nexports.StarLoopEntryState = StarLoopEntryState;\r\n//# sourceMappingURL=StarLoopEntryState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst Decorators_1 = require(\"./Decorators\");\r\n/**\r\n * This implementation of {@link ANTLRErrorListener} dispatches all calls to a\r\n * collection of delegate listeners. This reduces the effort required to support multiple\r\n * listeners.\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass ProxyErrorListener {\r\n constructor(delegates) {\r\n this.delegates = delegates;\r\n if (!delegates) {\r\n throw new Error(\"Invalid delegates\");\r\n }\r\n }\r\n getDelegates() {\r\n return this.delegates;\r\n }\r\n syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {\r\n this.delegates.forEach(listener => {\r\n listener.syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e);\r\n });\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull),\r\n __param(4, Decorators_1.NotNull)\r\n], ProxyErrorListener.prototype, \"syntaxError\", null);\r\nexports.ProxyErrorListener = ProxyErrorListener;\r\n//# sourceMappingURL=ProxyErrorListener.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst ATNConfigSet_1 = require(\"./ATNConfigSet\");\r\nconst DFAState_1 = require(\"../dfa/DFAState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst PredictionContext_1 = require(\"./PredictionContext\");\r\nlet ATNSimulator = class ATNSimulator {\r\n constructor(atn) {\r\n this.atn = atn;\r\n }\r\n static get ERROR() {\r\n if (!ATNSimulator._ERROR) {\r\n ATNSimulator._ERROR = new DFAState_1.DFAState(new ATNConfigSet_1.ATNConfigSet());\r\n ATNSimulator._ERROR.stateNumber = PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY;\r\n }\r\n return ATNSimulator._ERROR;\r\n }\r\n /**\r\n * Clear the DFA cache used by the current instance. Since the DFA cache may\r\n * be shared by multiple ATN simulators, this method may affect the\r\n * performance (but not accuracy) of other parsers which are being used\r\n * concurrently.\r\n *\r\n * @ if the current instance does not\r\n * support clearing the DFA.\r\n *\r\n * @since 4.3\r\n */\r\n clearDFA() {\r\n this.atn.clearDFA();\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATNSimulator.prototype, \"atn\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATNSimulator, \"ERROR\", null);\r\nATNSimulator = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ATNSimulator);\r\nexports.ATNSimulator = ATNSimulator;\r\n(function (ATNSimulator) {\r\n const RULE_VARIANT_DELIMITER = '$';\r\n const RULE_LF_VARIANT_MARKER = \"$lf$\";\r\n const RULE_NOLF_VARIANT_MARKER = \"$nolf$\";\r\n})(ATNSimulator = exports.ATNSimulator || (exports.ATNSimulator = {}));\r\nexports.ATNSimulator = ATNSimulator;\r\n//# sourceMappingURL=ATNSimulator.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:35.6390614-07:00\r\nconst Array2DHashMap_1 = require(\"../misc/Array2DHashMap\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst ObjectEqualityComparator_1 = require(\"../misc/ObjectEqualityComparator\");\r\nconst PredictionContext_1 = require(\"./PredictionContext\");\r\nconst assert = require(\"assert\");\r\n/** Used to cache {@link PredictionContext} objects. Its used for the shared\r\n * context cash associated with contexts in DFA states. This cache\r\n * can be used for both lexers and parsers.\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass PredictionContextCache {\r\n constructor(enableCache = true) {\r\n this.contexts = new Array2DHashMap_1.Array2DHashMap(ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE);\r\n this.childContexts = new Array2DHashMap_1.Array2DHashMap(ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE);\r\n this.joinContexts = new Array2DHashMap_1.Array2DHashMap(ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE);\r\n this.enableCache = enableCache;\r\n }\r\n getAsCached(context) {\r\n if (!this.enableCache) {\r\n return context;\r\n }\r\n let result = this.contexts.get(context);\r\n if (!result) {\r\n result = context;\r\n this.contexts.put(context, context);\r\n }\r\n return result;\r\n }\r\n getChild(context, invokingState) {\r\n if (!this.enableCache) {\r\n return context.getChild(invokingState);\r\n }\r\n let operands = new PredictionContextCache.PredictionContextAndInt(context, invokingState);\r\n let result = this.childContexts.get(operands);\r\n if (!result) {\r\n result = context.getChild(invokingState);\r\n result = this.getAsCached(result);\r\n this.childContexts.put(operands, result);\r\n }\r\n return result;\r\n }\r\n join(x, y) {\r\n if (!this.enableCache) {\r\n return PredictionContext_1.PredictionContext.join(x, y, this);\r\n }\r\n let operands = new PredictionContextCache.IdentityCommutativePredictionContextOperands(x, y);\r\n let result = this.joinContexts.get(operands);\r\n if (result) {\r\n return result;\r\n }\r\n result = PredictionContext_1.PredictionContext.join(x, y, this);\r\n result = this.getAsCached(result);\r\n this.joinContexts.put(operands, result);\r\n return result;\r\n }\r\n}\r\nPredictionContextCache.UNCACHED = new PredictionContextCache(false);\r\nexports.PredictionContextCache = PredictionContextCache;\r\n(function (PredictionContextCache) {\r\n class PredictionContextAndInt {\r\n constructor(obj, value) {\r\n this.obj = obj;\r\n this.value = value;\r\n }\r\n equals(obj) {\r\n if (!(obj instanceof PredictionContextAndInt)) {\r\n return false;\r\n }\r\n else if (obj == this) {\r\n return true;\r\n }\r\n let other = obj;\r\n return this.value === other.value\r\n && (this.obj === other.obj || (this.obj != null && this.obj.equals(other.obj)));\r\n }\r\n hashCode() {\r\n let hashCode = 5;\r\n hashCode = 7 * hashCode + (this.obj != null ? this.obj.hashCode() : 0);\r\n hashCode = 7 * hashCode + this.value;\r\n return hashCode;\r\n }\r\n }\r\n __decorate([\r\n Decorators_1.Override\r\n ], PredictionContextAndInt.prototype, \"equals\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], PredictionContextAndInt.prototype, \"hashCode\", null);\r\n PredictionContextCache.PredictionContextAndInt = PredictionContextAndInt;\r\n class IdentityCommutativePredictionContextOperands {\r\n constructor(x, y) {\r\n assert(x != null);\r\n assert(y != null);\r\n this._x = x;\r\n this._y = y;\r\n }\r\n get x() {\r\n return this._x;\r\n }\r\n get y() {\r\n return this._y;\r\n }\r\n equals(o) {\r\n if (!(o instanceof IdentityCommutativePredictionContextOperands)) {\r\n return false;\r\n }\r\n else if (this === o) {\r\n return true;\r\n }\r\n let other = o;\r\n return (this._x === other._x && this._y === other._y) || (this._x === other._y && this._y === other._x);\r\n }\r\n hashCode() {\r\n return this._x.hashCode() ^ this._y.hashCode();\r\n }\r\n }\r\n __decorate([\r\n Decorators_1.Override\r\n ], IdentityCommutativePredictionContextOperands.prototype, \"equals\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], IdentityCommutativePredictionContextOperands.prototype, \"hashCode\", null);\r\n PredictionContextCache.IdentityCommutativePredictionContextOperands = IdentityCommutativePredictionContextOperands;\r\n})(PredictionContextCache = exports.PredictionContextCache || (exports.PredictionContextCache = {}));\r\n//# sourceMappingURL=PredictionContextCache.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:38.3567094-07:00\r\nconst Array2DHashSet_1 = require(\"../misc/Array2DHashSet\");\r\nconst ATNConfigSet_1 = require(\"../atn/ATNConfigSet\");\r\nconst DFASerializer_1 = require(\"./DFASerializer\");\r\nconst DFAState_1 = require(\"./DFAState\");\r\nconst LexerDFASerializer_1 = require(\"./LexerDFASerializer\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst ObjectEqualityComparator_1 = require(\"../misc/ObjectEqualityComparator\");\r\nconst StarLoopEntryState_1 = require(\"../atn/StarLoopEntryState\");\r\nconst VocabularyImpl_1 = require(\"../VocabularyImpl\");\r\nlet DFA = class DFA {\r\n constructor(atnStartState, decision = 0) {\r\n /**\r\n * A set of all states in the `DFA`.\r\n */\r\n this.states = new Array2DHashSet_1.Array2DHashSet(ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE);\r\n this.nextStateNumber = 0;\r\n if (!atnStartState.atn) {\r\n throw new Error(\"The ATNState must be associated with an ATN\");\r\n }\r\n this.atnStartState = atnStartState;\r\n this.atn = atnStartState.atn;\r\n this.decision = decision;\r\n let isPrecedenceDfa = false;\r\n if (atnStartState instanceof StarLoopEntryState_1.StarLoopEntryState) {\r\n if (atnStartState.precedenceRuleDecision) {\r\n isPrecedenceDfa = true;\r\n this.s0 = new DFAState_1.DFAState(new ATNConfigSet_1.ATNConfigSet());\r\n this.s0full = new DFAState_1.DFAState(new ATNConfigSet_1.ATNConfigSet());\r\n }\r\n }\r\n this.precedenceDfa = isPrecedenceDfa;\r\n }\r\n /**\r\n * Gets whether this DFA is a precedence DFA. Precedence DFAs use a special\r\n * start state {@link #s0} which is not stored in {@link #states}. The\r\n * {@link DFAState#edges} array for this start state contains outgoing edges\r\n * supplying individual start states corresponding to specific precedence\r\n * values.\r\n *\r\n * @return {@code true} if this is a precedence DFA; otherwise,\r\n * {@code false}.\r\n * @see Parser.precedence\r\n */\r\n get isPrecedenceDfa() {\r\n return this.precedenceDfa;\r\n }\r\n /**\r\n * Get the start state for a specific precedence value.\r\n *\r\n * @param precedence The current precedence.\r\n * @return The start state corresponding to the specified precedence, or\r\n * {@code null} if no start state exists for the specified precedence.\r\n *\r\n * @ if this is not a precedence DFA.\r\n * @see `isPrecedenceDfa`\r\n */\r\n getPrecedenceStartState(precedence, fullContext) {\r\n if (!this.isPrecedenceDfa) {\r\n throw new Error(\"Only precedence DFAs may contain a precedence start state.\");\r\n }\r\n // s0 and s0full are never null for a precedence DFA\r\n if (fullContext) {\r\n return this.s0full.getTarget(precedence);\r\n }\r\n else {\r\n return this.s0.getTarget(precedence);\r\n }\r\n }\r\n /**\r\n * Set the start state for a specific precedence value.\r\n *\r\n * @param precedence The current precedence.\r\n * @param startState The start state corresponding to the specified\r\n * precedence.\r\n *\r\n * @ if this is not a precedence DFA.\r\n * @see `isPrecedenceDfa`\r\n */\r\n setPrecedenceStartState(precedence, fullContext, startState) {\r\n if (!this.isPrecedenceDfa) {\r\n throw new Error(\"Only precedence DFAs may contain a precedence start state.\");\r\n }\r\n if (precedence < 0) {\r\n return;\r\n }\r\n if (fullContext) {\r\n // s0full is never null for a precedence DFA\r\n this.s0full.setTarget(precedence, startState);\r\n }\r\n else {\r\n // s0 is never null for a precedence DFA\r\n this.s0.setTarget(precedence, startState);\r\n }\r\n }\r\n get isEmpty() {\r\n if (this.isPrecedenceDfa) {\r\n // s0 and s0full are never null for a precedence DFA\r\n return this.s0.getEdgeMap().size === 0 && this.s0full.getEdgeMap().size === 0;\r\n }\r\n return this.s0 == null && this.s0full == null;\r\n }\r\n get isContextSensitive() {\r\n if (this.isPrecedenceDfa) {\r\n // s0full is never null for a precedence DFA\r\n return this.s0full.getEdgeMap().size > 0;\r\n }\r\n return this.s0full != null;\r\n }\r\n addState(state) {\r\n state.stateNumber = this.nextStateNumber++;\r\n return this.states.getOrAdd(state);\r\n }\r\n toString(vocabulary, ruleNames) {\r\n if (!vocabulary) {\r\n vocabulary = VocabularyImpl_1.VocabularyImpl.EMPTY_VOCABULARY;\r\n }\r\n if (!this.s0) {\r\n return \"\";\r\n }\r\n let serializer;\r\n if (ruleNames) {\r\n serializer = new DFASerializer_1.DFASerializer(this, vocabulary, ruleNames, this.atnStartState.atn);\r\n }\r\n else {\r\n serializer = new DFASerializer_1.DFASerializer(this, vocabulary);\r\n }\r\n return serializer.toString();\r\n }\r\n toLexerString() {\r\n if (!this.s0) {\r\n return \"\";\r\n }\r\n let serializer = new LexerDFASerializer_1.LexerDFASerializer(this);\r\n return serializer.toString();\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], DFA.prototype, \"states\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], DFA.prototype, \"atnStartState\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], DFA.prototype, \"atn\", void 0);\r\nDFA = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], DFA);\r\nexports.DFA = DFA;\r\n//# sourceMappingURL=DFA.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:29.1083066-07:00\r\nconst AcceptStateInfo_1 = require(\"../dfa/AcceptStateInfo\");\r\nconst Stubs_1 = require(\"../misc/Stubs\");\r\nconst ATN_1 = require(\"./ATN\");\r\nconst ATNConfig_1 = require(\"./ATNConfig\");\r\nconst ATNConfigSet_1 = require(\"./ATNConfigSet\");\r\nconst ATNSimulator_1 = require(\"./ATNSimulator\");\r\nconst DFAState_1 = require(\"../dfa/DFAState\");\r\nconst Interval_1 = require(\"../misc/Interval\");\r\nconst IntStream_1 = require(\"../IntStream\");\r\nconst Lexer_1 = require(\"../Lexer\");\r\nconst LexerActionExecutor_1 = require(\"./LexerActionExecutor\");\r\nconst LexerNoViableAltException_1 = require(\"../LexerNoViableAltException\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst OrderedATNConfigSet_1 = require(\"./OrderedATNConfigSet\");\r\nconst PredictionContext_1 = require(\"./PredictionContext\");\r\nconst RuleStopState_1 = require(\"./RuleStopState\");\r\nconst Token_1 = require(\"../Token\");\r\nconst assert = require(\"assert\");\r\n/** \"dup\" of ParserInterpreter */\r\nlet LexerATNSimulator = class LexerATNSimulator extends ATNSimulator_1.ATNSimulator {\r\n constructor(atn, recog) {\r\n super(atn);\r\n this.optimize_tail_calls = true;\r\n /** The current token's starting index into the character stream.\r\n * Shared across DFA to ATN simulation in case the ATN fails and the\r\n * DFA did not have a previous accept state. In this case, we use the\r\n * ATN-generated exception object.\r\n */\r\n this.startIndex = -1;\r\n /** line number 1..n within the input */\r\n this._line = 1;\r\n /** The index of the character relative to the beginning of the line 0..n-1 */\r\n this._charPositionInLine = 0;\r\n this.mode = Lexer_1.Lexer.DEFAULT_MODE;\r\n /** Used during DFA/ATN exec to record the most recent accept configuration info */\r\n this.prevAccept = new LexerATNSimulator.SimState();\r\n this.recog = recog;\r\n }\r\n copyState(simulator) {\r\n this._charPositionInLine = simulator.charPositionInLine;\r\n this._line = simulator._line;\r\n this.mode = simulator.mode;\r\n this.startIndex = simulator.startIndex;\r\n }\r\n match(input, mode) {\r\n LexerATNSimulator.match_calls++;\r\n this.mode = mode;\r\n let mark = input.mark();\r\n try {\r\n this.startIndex = input.index;\r\n this.prevAccept.reset();\r\n let s0 = this.atn.modeToDFA[mode].s0;\r\n if (s0 == null) {\r\n return this.matchATN(input);\r\n }\r\n else {\r\n return this.execATN(input, s0);\r\n }\r\n }\r\n finally {\r\n input.release(mark);\r\n }\r\n }\r\n reset() {\r\n this.prevAccept.reset();\r\n this.startIndex = -1;\r\n this._line = 1;\r\n this._charPositionInLine = 0;\r\n this.mode = Lexer_1.Lexer.DEFAULT_MODE;\r\n }\r\n matchATN(input) {\r\n let startState = this.atn.modeToStartState[this.mode];\r\n if (LexerATNSimulator.debug) {\r\n console.log(`matchATN mode ${this.mode} start: ${startState}`);\r\n }\r\n let old_mode = this.mode;\r\n let s0_closure = this.computeStartState(input, startState);\r\n let suppressEdge = s0_closure.hasSemanticContext;\r\n if (suppressEdge) {\r\n s0_closure.hasSemanticContext = false;\r\n }\r\n let next = this.addDFAState(s0_closure);\r\n if (!suppressEdge) {\r\n let dfa = this.atn.modeToDFA[this.mode];\r\n if (!dfa.s0) {\r\n dfa.s0 = next;\r\n }\r\n else {\r\n next = dfa.s0;\r\n }\r\n }\r\n let predict = this.execATN(input, next);\r\n if (LexerATNSimulator.debug) {\r\n console.log(`DFA after matchATN: ${this.atn.modeToDFA[old_mode].toLexerString()}`);\r\n }\r\n return predict;\r\n }\r\n execATN(input, ds0) {\r\n // console.log(\"enter exec index \"+input.index+\" from \"+ds0.configs);\r\n if (LexerATNSimulator.debug) {\r\n console.log(`start state closure=${ds0.configs}`);\r\n }\r\n if (ds0.isAcceptState) {\r\n // allow zero-length tokens\r\n this.captureSimState(this.prevAccept, input, ds0);\r\n }\r\n let t = input.LA(1);\r\n // @NotNull\r\n let s = ds0; // s is current/from DFA state\r\n while (true) {\r\n if (LexerATNSimulator.debug) {\r\n console.log(`execATN loop starting closure: ${s.configs}`);\r\n }\r\n // As we move src->trg, src->trg, we keep track of the previous trg to\r\n // avoid looking up the DFA state again, which is expensive.\r\n // If the previous target was already part of the DFA, we might\r\n // be able to avoid doing a reach operation upon t. If s!=null,\r\n // it means that semantic predicates didn't prevent us from\r\n // creating a DFA state. Once we know s!=null, we check to see if\r\n // the DFA state has an edge already for t. If so, we can just reuse\r\n // it's configuration set; there's no point in re-computing it.\r\n // This is kind of like doing DFA simulation within the ATN\r\n // simulation because DFA simulation is really just a way to avoid\r\n // computing reach/closure sets. Technically, once we know that\r\n // we have a previously added DFA state, we could jump over to\r\n // the DFA simulator. But, that would mean popping back and forth\r\n // a lot and making things more complicated algorithmically.\r\n // This optimization makes a lot of sense for loops within DFA.\r\n // A character will take us back to an existing DFA state\r\n // that already has lots of edges out of it. e.g., .* in comments.\r\n let target = this.getExistingTargetState(s, t);\r\n if (target == null) {\r\n target = this.computeTargetState(input, s, t);\r\n }\r\n if (target === ATNSimulator_1.ATNSimulator.ERROR) {\r\n break;\r\n }\r\n // If this is a consumable input element, make sure to consume before\r\n // capturing the accept state so the input index, line, and char\r\n // position accurately reflect the state of the interpreter at the\r\n // end of the token.\r\n if (t !== IntStream_1.IntStream.EOF) {\r\n this.consume(input);\r\n }\r\n if (target.isAcceptState) {\r\n this.captureSimState(this.prevAccept, input, target);\r\n if (t === IntStream_1.IntStream.EOF) {\r\n break;\r\n }\r\n }\r\n t = input.LA(1);\r\n s = target; // flip; current DFA target becomes new src/from state\r\n }\r\n return this.failOrAccept(this.prevAccept, input, s.configs, t);\r\n }\r\n /**\r\n * Get an existing target state for an edge in the DFA. If the target state\r\n * for the edge has not yet been computed or is otherwise not available,\r\n * this method returns {@code null}.\r\n *\r\n * @param s The current DFA state\r\n * @param t The next input symbol\r\n * @return The existing target DFA state for the given input symbol\r\n * {@code t}, or {@code null} if the target state for this edge is not\r\n * already cached\r\n */\r\n getExistingTargetState(s, t) {\r\n let target = s.getTarget(t);\r\n if (LexerATNSimulator.debug && target != null) {\r\n console.log(\"reuse state \" + s.stateNumber +\r\n \" edge to \" + target.stateNumber);\r\n }\r\n return target;\r\n }\r\n /**\r\n * Compute a target state for an edge in the DFA, and attempt to add the\r\n * computed state and corresponding edge to the DFA.\r\n *\r\n * @param input The input stream\r\n * @param s The current DFA state\r\n * @param t The next input symbol\r\n *\r\n * @return The computed target DFA state for the given input symbol\r\n * {@code t}. If {@code t} does not lead to a valid DFA state, this method\r\n * returns {@link #ERROR}.\r\n */\r\n computeTargetState(input, s, t) {\r\n let reach = new OrderedATNConfigSet_1.OrderedATNConfigSet();\r\n // if we don't find an existing DFA state\r\n // Fill reach starting from closure, following t transitions\r\n this.getReachableConfigSet(input, s.configs, reach, t);\r\n if (reach.isEmpty) {\r\n if (!reach.hasSemanticContext) {\r\n // we got nowhere on t, don't throw out this knowledge; it'd\r\n // cause a failover from DFA later.\r\n this.addDFAEdge(s, t, ATNSimulator_1.ATNSimulator.ERROR);\r\n }\r\n // stop when we can't match any more char\r\n return ATNSimulator_1.ATNSimulator.ERROR;\r\n }\r\n // Add an edge from s to target DFA found/created for reach\r\n return this.addDFAEdge(s, t, reach);\r\n }\r\n failOrAccept(prevAccept, input, reach, t) {\r\n if (prevAccept.dfaState != null) {\r\n let lexerActionExecutor = prevAccept.dfaState.lexerActionExecutor;\r\n this.accept(input, lexerActionExecutor, this.startIndex, prevAccept.index, prevAccept.line, prevAccept.charPos);\r\n return prevAccept.dfaState.prediction;\r\n }\r\n else {\r\n // if no accept and EOF is first char, return EOF\r\n if (t === IntStream_1.IntStream.EOF && input.index === this.startIndex) {\r\n return Token_1.Token.EOF;\r\n }\r\n throw new LexerNoViableAltException_1.LexerNoViableAltException(this.recog, input, this.startIndex, reach);\r\n }\r\n }\r\n /** Given a starting configuration set, figure out all ATN configurations\r\n * we can reach upon input {@code t}. Parameter {@code reach} is a return\r\n * parameter.\r\n */\r\n getReachableConfigSet(input, closure, reach, t) {\r\n // this is used to skip processing for configs which have a lower priority\r\n // than a config that already reached an accept state for the same rule\r\n let skipAlt = ATN_1.ATN.INVALID_ALT_NUMBER;\r\n for (let c of Stubs_1.asIterable(closure)) {\r\n let currentAltReachedAcceptState = c.alt === skipAlt;\r\n if (currentAltReachedAcceptState && c.hasPassedThroughNonGreedyDecision) {\r\n continue;\r\n }\r\n if (LexerATNSimulator.debug) {\r\n console.log(`testing ${this.getTokenName(t)} at ${c.toString(this.recog, true)}`);\r\n }\r\n let n = c.state.numberOfOptimizedTransitions;\r\n for (let ti = 0; ti < n; ti++) {\r\n let trans = c.state.getOptimizedTransition(ti);\r\n let target = this.getReachableTarget(trans, t);\r\n if (target != null) {\r\n let lexerActionExecutor = c.lexerActionExecutor;\r\n let config;\r\n if (lexerActionExecutor != null) {\r\n lexerActionExecutor = lexerActionExecutor.fixOffsetBeforeMatch(input.index - this.startIndex);\r\n config = c.transform(target, true, lexerActionExecutor);\r\n }\r\n else {\r\n assert(c.lexerActionExecutor == null);\r\n config = c.transform(target, true);\r\n }\r\n let treatEofAsEpsilon = t === IntStream_1.IntStream.EOF;\r\n if (this.closure(input, config, reach, currentAltReachedAcceptState, true, treatEofAsEpsilon)) {\r\n // any remaining configs for this alt have a lower priority than\r\n // the one that just reached an accept state.\r\n skipAlt = c.alt;\r\n break;\r\n }\r\n }\r\n }\r\n }\r\n }\r\n accept(input, lexerActionExecutor, startIndex, index, line, charPos) {\r\n if (LexerATNSimulator.debug) {\r\n console.log(`ACTION ${lexerActionExecutor}`);\r\n }\r\n // seek to after last char in token\r\n input.seek(index);\r\n this._line = line;\r\n this._charPositionInLine = charPos;\r\n if (lexerActionExecutor != null && this.recog != null) {\r\n lexerActionExecutor.execute(this.recog, input, startIndex);\r\n }\r\n }\r\n getReachableTarget(trans, t) {\r\n if (trans.matches(t, Lexer_1.Lexer.MIN_CHAR_VALUE, Lexer_1.Lexer.MAX_CHAR_VALUE)) {\r\n return trans.target;\r\n }\r\n return undefined;\r\n }\r\n computeStartState(input, p) {\r\n let initialContext = PredictionContext_1.PredictionContext.EMPTY_FULL;\r\n let configs = new OrderedATNConfigSet_1.OrderedATNConfigSet();\r\n for (let i = 0; i < p.numberOfTransitions; i++) {\r\n let target = p.transition(i).target;\r\n let c = ATNConfig_1.ATNConfig.create(target, i + 1, initialContext);\r\n this.closure(input, c, configs, false, false, false);\r\n }\r\n return configs;\r\n }\r\n /**\r\n * Since the alternatives within any lexer decision are ordered by\r\n * preference, this method stops pursuing the closure as soon as an accept\r\n * state is reached. After the first accept state is reached by depth-first\r\n * search from {@code config}, all other (potentially reachable) states for\r\n * this rule would have a lower priority.\r\n *\r\n * @return {@code true} if an accept state is reached, otherwise\r\n * {@code false}.\r\n */\r\n closure(input, config, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon) {\r\n if (LexerATNSimulator.debug) {\r\n console.log(\"closure(\" + config.toString(this.recog, true) + \")\");\r\n }\r\n if (config.state instanceof RuleStopState_1.RuleStopState) {\r\n if (LexerATNSimulator.debug) {\r\n if (this.recog != null) {\r\n console.log(`closure at ${this.recog.ruleNames[config.state.ruleIndex]} rule stop ${config}`);\r\n }\r\n else {\r\n console.log(`closure at rule stop ${config}`);\r\n }\r\n }\r\n let context = config.context;\r\n if (context.isEmpty) {\r\n configs.add(config);\r\n return true;\r\n }\r\n else if (context.hasEmpty) {\r\n configs.add(config.transform(config.state, true, PredictionContext_1.PredictionContext.EMPTY_FULL));\r\n currentAltReachedAcceptState = true;\r\n }\r\n for (let i = 0; i < context.size; i++) {\r\n let returnStateNumber = context.getReturnState(i);\r\n if (returnStateNumber == PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY) {\r\n continue;\r\n }\r\n let newContext = context.getParent(i); // \"pop\" return state\r\n let returnState = this.atn.states[returnStateNumber];\r\n let c = config.transform(returnState, false, newContext);\r\n currentAltReachedAcceptState = this.closure(input, c, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon);\r\n }\r\n return currentAltReachedAcceptState;\r\n }\r\n // optimization\r\n if (!config.state.onlyHasEpsilonTransitions) {\r\n if (!currentAltReachedAcceptState || !config.hasPassedThroughNonGreedyDecision) {\r\n configs.add(config);\r\n }\r\n }\r\n let p = config.state;\r\n for (let i = 0; i < p.numberOfOptimizedTransitions; i++) {\r\n let t = p.getOptimizedTransition(i);\r\n let c = this.getEpsilonTarget(input, config, t, configs, speculative, treatEofAsEpsilon);\r\n if (c != null) {\r\n currentAltReachedAcceptState = this.closure(input, c, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon);\r\n }\r\n }\r\n return currentAltReachedAcceptState;\r\n }\r\n // side-effect: can alter configs.hasSemanticContext\r\n getEpsilonTarget(input, config, t, configs, speculative, treatEofAsEpsilon) {\r\n let c;\r\n switch (t.serializationType) {\r\n case 3 /* RULE */:\r\n let ruleTransition = t;\r\n if (this.optimize_tail_calls && ruleTransition.optimizedTailCall && !config.context.hasEmpty) {\r\n c = config.transform(t.target, true);\r\n }\r\n else {\r\n let newContext = config.context.getChild(ruleTransition.followState.stateNumber);\r\n c = config.transform(t.target, true, newContext);\r\n }\r\n break;\r\n case 10 /* PRECEDENCE */:\r\n throw new Error(\"Precedence predicates are not supported in lexers.\");\r\n case 4 /* PREDICATE */:\r\n /* Track traversing semantic predicates. If we traverse,\r\n we cannot add a DFA state for this \"reach\" computation\r\n because the DFA would not test the predicate again in the\r\n future. Rather than creating collections of semantic predicates\r\n like v3 and testing them on prediction, v4 will test them on the\r\n fly all the time using the ATN not the DFA. This is slower but\r\n semantically it's not used that often. One of the key elements to\r\n this predicate mechanism is not adding DFA states that see\r\n predicates immediately afterwards in the ATN. For example,\r\n \r\n a : ID {p1}? | ID {p2}? ;\r\n \r\n should create the start state for rule 'a' (to save start state\r\n competition), but should not create target of ID state. The\r\n collection of ATN states the following ID references includes\r\n states reached by traversing predicates. Since this is when we\r\n test them, we cannot cash the DFA state target of ID.\r\n */\r\n let pt = t;\r\n if (LexerATNSimulator.debug) {\r\n console.log(\"EVAL rule \" + pt.ruleIndex + \":\" + pt.predIndex);\r\n }\r\n configs.hasSemanticContext = true;\r\n if (this.evaluatePredicate(input, pt.ruleIndex, pt.predIndex, speculative)) {\r\n c = config.transform(t.target, true);\r\n }\r\n else {\r\n c = undefined;\r\n }\r\n break;\r\n case 6 /* ACTION */:\r\n if (config.context.hasEmpty) {\r\n // execute actions anywhere in the start rule for a token.\r\n //\r\n // TODO: if the entry rule is invoked recursively, some\r\n // actions may be executed during the recursive call. The\r\n // problem can appear when hasEmpty is true but\r\n // isEmpty is false. In this case, the config needs to be\r\n // split into two contexts - one with just the empty path\r\n // and another with everything but the empty path.\r\n // Unfortunately, the current algorithm does not allow\r\n // getEpsilonTarget to return two configurations, so\r\n // additional modifications are needed before we can support\r\n // the split operation.\r\n let lexerActionExecutor = LexerActionExecutor_1.LexerActionExecutor.append(config.lexerActionExecutor, this.atn.lexerActions[t.actionIndex]);\r\n c = config.transform(t.target, true, lexerActionExecutor);\r\n break;\r\n }\r\n else {\r\n // ignore actions in referenced rules\r\n c = config.transform(t.target, true);\r\n break;\r\n }\r\n case 1 /* EPSILON */:\r\n c = config.transform(t.target, true);\r\n break;\r\n case 5 /* ATOM */:\r\n case 2 /* RANGE */:\r\n case 7 /* SET */:\r\n if (treatEofAsEpsilon) {\r\n if (t.matches(IntStream_1.IntStream.EOF, Lexer_1.Lexer.MIN_CHAR_VALUE, Lexer_1.Lexer.MAX_CHAR_VALUE)) {\r\n c = config.transform(t.target, false);\r\n break;\r\n }\r\n }\r\n c = undefined;\r\n break;\r\n default:\r\n c = undefined;\r\n break;\r\n }\r\n return c;\r\n }\r\n /**\r\n * Evaluate a predicate specified in the lexer.\r\n *\r\n * <p>If {@code speculative} is {@code true}, this method was called before\r\n * {@link #consume} for the matched character. This method should call\r\n * {@link #consume} before evaluating the predicate to ensure position\r\n * sensitive values, including {@link Lexer#getText}, {@link Lexer#getLine},\r\n * and {@link Lexer#getCharPositionInLine}, properly reflect the current\r\n * lexer state. This method should restore {@code input} and the simulator\r\n * to the original state before returning (i.e. undo the actions made by the\r\n * call to {@link #consume}.</p>\r\n *\r\n * @param input The input stream.\r\n * @param ruleIndex The rule containing the predicate.\r\n * @param predIndex The index of the predicate within the rule.\r\n * @param speculative {@code true} if the current index in {@code input} is\r\n * one character before the predicate's location.\r\n *\r\n * @return {@code true} if the specified predicate evaluates to\r\n * {@code true}.\r\n */\r\n evaluatePredicate(input, ruleIndex, predIndex, speculative) {\r\n // assume true if no recognizer was provided\r\n if (this.recog == null) {\r\n return true;\r\n }\r\n if (!speculative) {\r\n return this.recog.sempred(undefined, ruleIndex, predIndex);\r\n }\r\n let savedCharPositionInLine = this._charPositionInLine;\r\n let savedLine = this._line;\r\n let index = input.index;\r\n let marker = input.mark();\r\n try {\r\n this.consume(input);\r\n return this.recog.sempred(undefined, ruleIndex, predIndex);\r\n }\r\n finally {\r\n this._charPositionInLine = savedCharPositionInLine;\r\n this._line = savedLine;\r\n input.seek(index);\r\n input.release(marker);\r\n }\r\n }\r\n captureSimState(settings, input, dfaState) {\r\n settings.index = input.index;\r\n settings.line = this._line;\r\n settings.charPos = this._charPositionInLine;\r\n settings.dfaState = dfaState;\r\n }\r\n addDFAEdge(p, t, q) {\r\n if (q instanceof ATNConfigSet_1.ATNConfigSet) {\r\n /* leading to this call, ATNConfigSet.hasSemanticContext is used as a\r\n * marker indicating dynamic predicate evaluation makes this edge\r\n * dependent on the specific input sequence, so the static edge in the\r\n * DFA should be omitted. The target DFAState is still created since\r\n * execATN has the ability to resynchronize with the DFA state cache\r\n * following the predicate evaluation step.\r\n *\r\n * TJP notes: next time through the DFA, we see a pred again and eval.\r\n * If that gets us to a previously created (but dangling) DFA\r\n * state, we can continue in pure DFA mode from there.\r\n */\r\n let suppressEdge = q.hasSemanticContext;\r\n if (suppressEdge) {\r\n q.hasSemanticContext = false;\r\n }\r\n // @NotNull\r\n let to = this.addDFAState(q);\r\n if (suppressEdge) {\r\n return to;\r\n }\r\n this.addDFAEdge(p, t, to);\r\n return to;\r\n }\r\n else {\r\n if (LexerATNSimulator.debug) {\r\n console.log(\"EDGE \" + p + \" -> \" + q + \" upon \" + String.fromCharCode(t));\r\n }\r\n if (p != null) {\r\n p.setTarget(t, q);\r\n }\r\n }\r\n }\r\n /** Add a new DFA state if there isn't one with this set of\r\n configurations already. This method also detects the first\r\n configuration containing an ATN rule stop state. Later, when\r\n traversing the DFA, we will know which rule to accept.\r\n */\r\n addDFAState(configs) {\r\n /* the lexer evaluates predicates on-the-fly; by this point configs\r\n * should not contain any configurations with unevaluated predicates.\r\n */\r\n assert(!configs.hasSemanticContext);\r\n let proposed = new DFAState_1.DFAState(this.atn.modeToDFA[this.mode], configs);\r\n let existing = this.atn.modeToDFA[this.mode].states.get(proposed);\r\n if (existing != null)\r\n return existing;\r\n configs.optimizeConfigs(this);\r\n let newState = new DFAState_1.DFAState(this.atn.modeToDFA[this.mode], configs.clone(true));\r\n let firstConfigWithRuleStopState = undefined;\r\n for (let c of Stubs_1.asIterable(configs)) {\r\n if (c.state instanceof RuleStopState_1.RuleStopState) {\r\n firstConfigWithRuleStopState = c;\r\n break;\r\n }\r\n }\r\n if (firstConfigWithRuleStopState != null) {\r\n let prediction = this.atn.ruleToTokenType[firstConfigWithRuleStopState.state.ruleIndex];\r\n let lexerActionExecutor = firstConfigWithRuleStopState.lexerActionExecutor;\r\n newState.acceptStateInfo = new AcceptStateInfo_1.AcceptStateInfo(prediction, lexerActionExecutor);\r\n }\r\n return this.atn.modeToDFA[this.mode].addState(newState);\r\n }\r\n getDFA(mode) {\r\n return this.atn.modeToDFA[mode];\r\n }\r\n /** Get the text matched so far for the current token.\r\n */\r\n getText(input) {\r\n // index is first lookahead char, don't include.\r\n return input.getText(Interval_1.Interval.of(this.startIndex, input.index - 1));\r\n }\r\n get line() {\r\n return this._line;\r\n }\r\n set line(line) {\r\n this._line = line;\r\n }\r\n get charPositionInLine() {\r\n return this._charPositionInLine;\r\n }\r\n set charPositionInLine(charPositionInLine) {\r\n this._charPositionInLine = charPositionInLine;\r\n }\r\n consume(input) {\r\n let curChar = input.LA(1);\r\n if (curChar == '\\n'.charCodeAt(0)) {\r\n this._line++;\r\n this._charPositionInLine = 0;\r\n }\r\n else {\r\n this._charPositionInLine++;\r\n }\r\n input.consume();\r\n }\r\n getTokenName(t) {\r\n if (t === -1)\r\n return \"EOF\";\r\n //if ( atn.g!=null ) return atn.g.getTokenDisplayName(t);\r\n return \"'\" + String.fromCharCode(t) + \"'\";\r\n }\r\n};\r\nLexerATNSimulator.match_calls = 0;\r\n__decorate([\r\n Decorators_1.NotNull\r\n], LexerATNSimulator.prototype, \"prevAccept\", void 0);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"copyState\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"match\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerATNSimulator.prototype, \"reset\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"matchATN\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"execATN\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"getExistingTargetState\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"computeTargetState\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"getReachableConfigSet\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"accept\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"computeStartState\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull), __param(2, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"closure\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(2, Decorators_1.NotNull),\r\n __param(3, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"getEpsilonTarget\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"evaluatePredicate\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(2, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"captureSimState\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"addDFAState\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], LexerATNSimulator.prototype, \"getDFA\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"getText\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], LexerATNSimulator.prototype, \"consume\", null);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], LexerATNSimulator.prototype, \"getTokenName\", null);\r\nLexerATNSimulator = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], LexerATNSimulator);\r\nexports.LexerATNSimulator = LexerATNSimulator;\r\n(function (LexerATNSimulator) {\r\n LexerATNSimulator.debug = false;\r\n LexerATNSimulator.dfa_debug = false;\r\n /** When we hit an accept state in either the DFA or the ATN, we\r\n * have to notify the character stream to start buffering characters\r\n * via {@link IntStream#mark} and record the current state. The current sim state\r\n * includes the current index into the input, the current line,\r\n * and current character position in that line. Note that the Lexer is\r\n * tracking the starting line and characterization of the token. These\r\n * variables track the \"state\" of the simulator when it hits an accept state.\r\n *\r\n * <p>We track these variables separately for the DFA and ATN simulation\r\n * because the DFA simulation often has to fail over to the ATN\r\n * simulation. If the ATN simulation fails, we need the DFA to fall\r\n * back to its previously accepted state, if any. If the ATN succeeds,\r\n * then the ATN does the accept and the DFA simulator that invoked it\r\n * can simply return the predicted token type.</p>\r\n */\r\n class SimState {\r\n constructor() {\r\n this.index = -1;\r\n this.line = 0;\r\n this.charPos = -1;\r\n }\r\n reset() {\r\n this.index = -1;\r\n this.line = 0;\r\n this.charPos = -1;\r\n this.dfaState = undefined;\r\n }\r\n }\r\n LexerATNSimulator.SimState = SimState;\r\n})(LexerATNSimulator = exports.LexerATNSimulator || (exports.LexerATNSimulator = {}));\r\nexports.LexerATNSimulator = LexerATNSimulator;\r\n//# sourceMappingURL=LexerATNSimulator.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst CommonToken_1 = require(\"./CommonToken\");\r\nconst Interval_1 = require(\"./misc/Interval\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\n/**\r\n * This default implementation of {@link TokenFactory} creates\r\n * {@link CommonToken} objects.\r\n */\r\nclass CommonTokenFactory {\r\n /**\r\n * Constructs a {@link CommonTokenFactory} with the specified value for\r\n * {@link #copyText}.\r\n *\r\n * <p>\r\n * When {@code copyText} is {@code false}, the {@link #DEFAULT} instance\r\n * should be used instead of constructing a new instance.</p>\r\n *\r\n * @param copyText The value for {@link #copyText}.\r\n */\r\n constructor(copyText = false) {\r\n this.copyText = copyText;\r\n }\r\n create(source, type, text, channel, start, stop, line, charPositionInLine) {\r\n let t = new CommonToken_1.CommonToken(type, text, source, channel, start, stop);\r\n t.line = line;\r\n t.charPositionInLine = charPositionInLine;\r\n if (text == null && this.copyText && source.stream != null) {\r\n t.text = source.stream.getText(Interval_1.Interval.of(start, stop));\r\n }\r\n return t;\r\n }\r\n createSimple(type, text) {\r\n return new CommonToken_1.CommonToken(type, text);\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonTokenFactory.prototype, \"create\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonTokenFactory.prototype, \"createSimple\", null);\r\nexports.CommonTokenFactory = CommonTokenFactory;\r\n(function (CommonTokenFactory) {\r\n /**\r\n * The default {@link CommonTokenFactory} instance.\r\n *\r\n * <p>\r\n * This token factory does not explicitly copy token text when constructing\r\n * tokens.</p>\r\n */\r\n CommonTokenFactory.DEFAULT = new CommonTokenFactory();\r\n})(CommonTokenFactory = exports.CommonTokenFactory || (exports.CommonTokenFactory = {}));\r\n//# sourceMappingURL=CommonTokenFactory.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar Arrays;\r\n(function (Arrays) {\r\n /**\r\n * Searches the specified array of numbers for the specified value using the binary search algorithm. The array must\r\n * be sorted prior to making this call. If it is not sorted, the results are unspecified. If the array contains\r\n * multiple elements with the specified value, there is no guarantee which one will be found.\r\n *\r\n * @return index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The\r\n * insertion point is defined as the point at which the key would be inserted into the array: the index of the first\r\n * element greater than the key, or array.length if all elements in the array are less than the specified key. Note\r\n * that this guarantees that the return value will be >= 0 if and only if the key is found.\r\n */\r\n function binarySearch(array, key, fromIndex, toIndex) {\r\n return binarySearch0(array, fromIndex !== undefined ? fromIndex : 0, toIndex !== undefined ? toIndex : array.length, key);\r\n }\r\n Arrays.binarySearch = binarySearch;\r\n function binarySearch0(array, fromIndex, toIndex, key) {\r\n let low = fromIndex;\r\n let high = toIndex - 1;\r\n while (low <= high) {\r\n let mid = (low + high) >>> 1;\r\n let midVal = array[mid];\r\n if (midVal < key) {\r\n low = mid + 1;\r\n }\r\n else if (midVal > key) {\r\n high = mid - 1;\r\n }\r\n else {\r\n // key found\r\n return mid;\r\n }\r\n }\r\n // key not found.\r\n return -(low + 1);\r\n }\r\n function toString(array) {\r\n let result = \"[\";\r\n let first = true;\r\n for (let i = 0; i < array.length; i++) {\r\n if (first) {\r\n first = false;\r\n }\r\n else {\r\n result += \", \";\r\n }\r\n let element = array[i];\r\n if (element === null) {\r\n result += \"null\";\r\n }\r\n else if (element === undefined) {\r\n result += \"undefined\";\r\n }\r\n else {\r\n result += element;\r\n }\r\n }\r\n result += \"]\";\r\n return result;\r\n }\r\n Arrays.toString = toString;\r\n})(Arrays = exports.Arrays || (exports.Arrays = {}));\r\n//# sourceMappingURL=Arrays.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:40.5099429-07:00\r\nconst Arrays_1 = require(\"./Arrays\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst EMPTY_DATA = new Int32Array(0);\r\nconst INITIAL_SIZE = 4;\r\nconst MAX_ARRAY_SIZE = (((1 << 31) >>> 0) - 1) - 8;\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass IntegerList {\r\n constructor(arg) {\r\n if (!arg) {\r\n this._data = EMPTY_DATA;\r\n this._size = 0;\r\n }\r\n else if (arg instanceof IntegerList) {\r\n this._data = arg._data.slice(0);\r\n this._size = arg._size;\r\n }\r\n else if (typeof arg === 'number') {\r\n if (arg === 0) {\r\n this._data = EMPTY_DATA;\r\n this._size = 0;\r\n }\r\n else {\r\n this._data = new Int32Array(arg);\r\n this._size = 0;\r\n }\r\n }\r\n else {\r\n // arg is Iterable<number>\r\n this._data = EMPTY_DATA;\r\n this._size = 0;\r\n for (let value of arg) {\r\n this.add(value);\r\n }\r\n }\r\n }\r\n add(value) {\r\n if (this._data.length === this._size) {\r\n this.ensureCapacity(this._size + 1);\r\n }\r\n this._data[this._size] = value;\r\n this._size++;\r\n }\r\n addAll(list) {\r\n if (Array.isArray(list)) {\r\n this.ensureCapacity(this._size + list.length);\r\n this._data.subarray(this._size, this._size + list.length).set(list);\r\n this._size += list.length;\r\n }\r\n else if (list instanceof IntegerList) {\r\n this.ensureCapacity(this._size + list._size);\r\n this._data.subarray(this._size, this._size + list.size).set(list._data);\r\n this._size += list._size;\r\n }\r\n else {\r\n // list is JavaCollection<number>\r\n this.ensureCapacity(this._size + list.size);\r\n let current = 0;\r\n for (let xi = list.iterator(); xi.hasNext();) {\r\n this._data[this._size + current] = xi.next();\r\n current++;\r\n }\r\n this._size += list.size;\r\n }\r\n }\r\n get(index) {\r\n if (index < 0 || index >= this._size) {\r\n throw RangeError();\r\n }\r\n return this._data[index];\r\n }\r\n contains(value) {\r\n for (let i = 0; i < this._size; i++) {\r\n if (this._data[i] === value) {\r\n return true;\r\n }\r\n }\r\n return false;\r\n }\r\n set(index, value) {\r\n if (index < 0 || index >= this._size) {\r\n throw RangeError();\r\n }\r\n let previous = this._data[index];\r\n this._data[index] = value;\r\n return previous;\r\n }\r\n removeAt(index) {\r\n let value = this.get(index);\r\n this._data.copyWithin(index, index + 1, this._size);\r\n this._data[this._size - 1] = 0;\r\n this._size--;\r\n return value;\r\n }\r\n removeRange(fromIndex, toIndex) {\r\n if (fromIndex < 0 || toIndex < 0 || fromIndex > this._size || toIndex > this._size) {\r\n throw RangeError();\r\n }\r\n if (fromIndex > toIndex) {\r\n throw RangeError();\r\n }\r\n this._data.copyWithin(toIndex, fromIndex, this._size);\r\n this._data.fill(0, this._size - (toIndex - fromIndex), this._size);\r\n this._size -= (toIndex - fromIndex);\r\n }\r\n get isEmpty() {\r\n return this._size === 0;\r\n }\r\n get size() {\r\n return this._size;\r\n }\r\n trimToSize() {\r\n if (this._data.length === this._size) {\r\n return;\r\n }\r\n this._data = this._data.slice(0, this._size);\r\n }\r\n clear() {\r\n this._data.fill(0, 0, this._size);\r\n this._size = 0;\r\n }\r\n toArray() {\r\n if (this._size === 0) {\r\n return [];\r\n }\r\n return Array.from(this._data.subarray(0, this._size));\r\n }\r\n sort() {\r\n this._data.subarray(0, this._size).sort();\r\n }\r\n /**\r\n * Compares the specified object with this list for equality. Returns\r\n * {@code true} if and only if the specified object is also an {@link IntegerList},\r\n * both lists have the same size, and all corresponding pairs of elements in\r\n * the two lists are equal. In other words, two lists are defined to be\r\n * equal if they contain the same elements in the same order.\r\n * <p>\r\n * This implementation first checks if the specified object is this\r\n * list. If so, it returns {@code true}; if not, it checks if the\r\n * specified object is an {@link IntegerList}. If not, it returns {@code false};\r\n * if so, it checks the size of both lists. If the lists are not the same size,\r\n * it returns {@code false}; otherwise it iterates over both lists, comparing\r\n * corresponding pairs of elements. If any comparison returns {@code false},\r\n * this method returns {@code false}.\r\n *\r\n * @param o the object to be compared for equality with this list\r\n * @return {@code true} if the specified object is equal to this list\r\n */\r\n equals(o) {\r\n if (o === this) {\r\n return true;\r\n }\r\n if (!(o instanceof IntegerList)) {\r\n return false;\r\n }\r\n if (this._size !== o._size) {\r\n return false;\r\n }\r\n for (let i = 0; i < this._size; i++) {\r\n if (this._data[i] !== o._data[i]) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }\r\n /**\r\n * Returns the hash code value for this list.\r\n *\r\n * <p>This implementation uses exactly the code that is used to define the\r\n * list hash function in the documentation for the {@link List#hashCode}\r\n * method.</p>\r\n *\r\n * @return the hash code value for this list\r\n */\r\n hashCode() {\r\n let hashCode = 1;\r\n for (let i = 0; i < this._size; i++) {\r\n hashCode = 31 * hashCode + this._data[i];\r\n }\r\n return hashCode;\r\n }\r\n /**\r\n * Returns a string representation of this list.\r\n */\r\n toString() {\r\n return this._data.toString();\r\n }\r\n binarySearch(key, fromIndex, toIndex) {\r\n if (fromIndex === undefined) {\r\n fromIndex = 0;\r\n }\r\n if (toIndex === undefined) {\r\n toIndex = this._size;\r\n }\r\n if (fromIndex < 0 || toIndex < 0 || fromIndex > this._size || toIndex > this._size) {\r\n throw new RangeError();\r\n }\r\n if (fromIndex > toIndex) {\r\n throw new RangeError();\r\n }\r\n return Arrays_1.Arrays.binarySearch(this._data, key, fromIndex, toIndex);\r\n }\r\n ensureCapacity(capacity) {\r\n if (capacity < 0 || capacity > MAX_ARRAY_SIZE) {\r\n throw new RangeError();\r\n }\r\n let newLength;\r\n if (this._data.length === 0) {\r\n newLength = INITIAL_SIZE;\r\n }\r\n else {\r\n newLength = this._data.length;\r\n }\r\n while (newLength < capacity) {\r\n newLength = newLength * 2;\r\n if (newLength < 0 || newLength > MAX_ARRAY_SIZE) {\r\n newLength = MAX_ARRAY_SIZE;\r\n }\r\n }\r\n let tmp = new Int32Array(newLength);\r\n tmp.set(this._data);\r\n this._data = tmp;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.NotNull\r\n], IntegerList.prototype, \"_data\", void 0);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntegerList.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntegerList.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], IntegerList.prototype, \"toString\", null);\r\nexports.IntegerList = IntegerList;\r\n//# sourceMappingURL=IntegerList.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nconst Transition_1 = require(\"./Transition\");\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass AbstractPredicateTransition extends Transition_1.Transition {\r\n constructor(target) {\r\n super(target);\r\n }\r\n}\r\nexports.AbstractPredicateTransition = AbstractPredicateTransition;\r\n//# sourceMappingURL=AbstractPredicateTransition.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst FailedPredicateException_1 = require(\"./FailedPredicateException\");\r\nconst InputMismatchException_1 = require(\"./InputMismatchException\");\r\nconst IntervalSet_1 = require(\"./misc/IntervalSet\");\r\nconst NoViableAltException_1 = require(\"./NoViableAltException\");\r\nconst PredictionContext_1 = require(\"./atn/PredictionContext\");\r\nconst Token_1 = require(\"./Token\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nclass DefaultErrorStrategy {\r\n constructor() {\r\n /**\r\n * Indicates whether the error strategy is currently \"recovering from an\r\n * error\". This is used to suppress reporting multiple error messages while\r\n * attempting to recover from a detected syntax error.\r\n *\r\n * @see #inErrorRecoveryMode\r\n */\r\n this.errorRecoveryMode = false;\r\n /** The index into the input stream where the last error occurred.\r\n * \tThis is used to prevent infinite loops where an error is found\r\n * but no token is consumed during recovery...another error is found,\r\n * ad nauseum. This is a failsafe mechanism to guarantee that at least\r\n * one token/tree node is consumed for two errors.\r\n */\r\n this.lastErrorIndex = -1;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>The default implementation simply calls {@link #endErrorCondition} to\r\n * ensure that the handler is not in error recovery mode.</p>\r\n */\r\n reset(recognizer) {\r\n this.endErrorCondition(recognizer);\r\n }\r\n /**\r\n * This method is called to enter error recovery mode when a recognition\r\n * exception is reported.\r\n *\r\n * @param recognizer the parser instance\r\n */\r\n beginErrorCondition(recognizer) {\r\n this.errorRecoveryMode = true;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n */\r\n inErrorRecoveryMode(recognizer) {\r\n return this.errorRecoveryMode;\r\n }\r\n /**\r\n * This method is called to leave error recovery mode after recovering from\r\n * a recognition exception.\r\n *\r\n * @param recognizer\r\n */\r\n endErrorCondition(recognizer) {\r\n this.errorRecoveryMode = false;\r\n this.lastErrorStates = undefined;\r\n this.lastErrorIndex = -1;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>The default implementation simply calls {@link #endErrorCondition}.</p>\r\n */\r\n reportMatch(recognizer) {\r\n this.endErrorCondition(recognizer);\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>The default implementation returns immediately if the handler is already\r\n * in error recovery mode. Otherwise, it calls {@link #beginErrorCondition}\r\n * and dispatches the reporting task based on the runtime type of {@code e}\r\n * according to the following table.</p>\r\n *\r\n * <ul>\r\n * <li>{@link NoViableAltException}: Dispatches the call to\r\n * {@link #reportNoViableAlternative}</li>\r\n * <li>{@link InputMismatchException}: Dispatches the call to\r\n * {@link #reportInputMismatch}</li>\r\n * <li>{@link FailedPredicateException}: Dispatches the call to\r\n * {@link #reportFailedPredicate}</li>\r\n * <li>All other types: calls {@link Parser#notifyErrorListeners} to report\r\n * the exception</li>\r\n * </ul>\r\n */\r\n reportError(recognizer, e) {\r\n // if we've already reported an error and have not matched a token\r\n // yet successfully, don't report any errors.\r\n if (this.inErrorRecoveryMode(recognizer)) {\r\n //\t\t\tSystem.err.print(\"[SPURIOUS] \");\r\n return; // don't report spurious errors\r\n }\r\n this.beginErrorCondition(recognizer);\r\n if (e instanceof NoViableAltException_1.NoViableAltException) {\r\n this.reportNoViableAlternative(recognizer, e);\r\n }\r\n else if (e instanceof InputMismatchException_1.InputMismatchException) {\r\n this.reportInputMismatch(recognizer, e);\r\n }\r\n else if (e instanceof FailedPredicateException_1.FailedPredicateException) {\r\n this.reportFailedPredicate(recognizer, e);\r\n }\r\n else {\r\n console.error(`unknown recognition error type: ${e}`);\r\n this.notifyErrorListeners(recognizer, e.toString(), e);\r\n }\r\n }\r\n notifyErrorListeners(recognizer, message, e) {\r\n let offendingToken = e.getOffendingToken(recognizer);\r\n if (offendingToken === undefined) {\r\n // Pass null to notifyErrorListeners so it in turn calls the error listeners with undefined as the offending\r\n // token. If we passed undefined, it would instead call the listeners with currentToken from the parser.\r\n offendingToken = null;\r\n }\r\n recognizer.notifyErrorListeners(message, offendingToken, e);\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>The default implementation resynchronizes the parser by consuming tokens\r\n * until we find one in the resynchronization set--loosely the set of tokens\r\n * that can follow the current rule.</p>\r\n */\r\n recover(recognizer, e) {\r\n //\t\tSystem.out.println(\"recover in \"+recognizer.getRuleInvocationStack()+\r\n //\t\t\t\t\t\t \" index=\"+recognizer.inputStream.index+\r\n //\t\t\t\t\t\t \", lastErrorIndex=\"+\r\n //\t\t\t\t\t\t lastErrorIndex+\r\n //\t\t\t\t\t\t \", states=\"+lastErrorStates);\r\n if (this.lastErrorIndex === recognizer.inputStream.index &&\r\n this.lastErrorStates &&\r\n this.lastErrorStates.contains(recognizer.state)) {\r\n // uh oh, another error at same token index and previously-visited\r\n // state in ATN; must be a case where LT(1) is in the recovery\r\n // token set so nothing got consumed. Consume a single token\r\n // at least to prevent an infinite loop; this is a failsafe.\r\n //\t\t\tSystem.err.println(\"seen error condition before index=\"+\r\n //\t\t\t\t\t\t\t lastErrorIndex+\", states=\"+lastErrorStates);\r\n //\t\t\tSystem.err.println(\"FAILSAFE consumes \"+recognizer.getTokenNames()[recognizer.inputStream.LA(1)]);\r\n recognizer.consume();\r\n }\r\n this.lastErrorIndex = recognizer.inputStream.index;\r\n if (!this.lastErrorStates)\r\n this.lastErrorStates = new IntervalSet_1.IntervalSet();\r\n this.lastErrorStates.add(recognizer.state);\r\n let followSet = this.getErrorRecoverySet(recognizer);\r\n this.consumeUntil(recognizer, followSet);\r\n }\r\n /**\r\n * The default implementation of {@link ANTLRErrorStrategy#sync} makes sure\r\n * that the current lookahead symbol is consistent with what were expecting\r\n * at this point in the ATN. You can call this anytime but ANTLR only\r\n * generates code to check before subrules/loops and each iteration.\r\n *\r\n * <p>Implements Jim Idle's magic sync mechanism in closures and optional\r\n * subrules. E.g.,</p>\r\n *\r\n * <pre>\r\n * a : sync ( stuff sync )* ;\r\n * sync : {consume to what can follow sync} ;\r\n * </pre>\r\n *\r\n * At the start of a sub rule upon error, {@link #sync} performs single\r\n * token deletion, if possible. If it can't do that, it bails on the current\r\n * rule and uses the default error recovery, which consumes until the\r\n * resynchronization set of the current rule.\r\n *\r\n * <p>If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block\r\n * with an empty alternative), then the expected set includes what follows\r\n * the subrule.</p>\r\n *\r\n * <p>During loop iteration, it consumes until it sees a token that can start a\r\n * sub rule or what follows loop. Yes, that is pretty aggressive. We opt to\r\n * stay in the loop as long as possible.</p>\r\n *\r\n * <p><strong>ORIGINS</strong></p>\r\n *\r\n * <p>Previous versions of ANTLR did a poor job of their recovery within loops.\r\n * A single mismatch token or missing token would force the parser to bail\r\n * out of the entire rules surrounding the loop. So, for rule</p>\r\n *\r\n * <pre>\r\n * classDef : 'class' ID '{' member* '}'\r\n * </pre>\r\n *\r\n * input with an extra token between members would force the parser to\r\n * consume until it found the next class definition rather than the next\r\n * member definition of the current class.\r\n *\r\n * <p>This functionality cost a little bit of effort because the parser has to\r\n * compare token set at the start of the loop and at each iteration. If for\r\n * some reason speed is suffering for you, you can turn off this\r\n * functionality by simply overriding this method as a blank { }.</p>\r\n */\r\n sync(recognizer) {\r\n let s = recognizer.interpreter.atn.states[recognizer.state];\r\n //\t\tSystem.err.println(\"sync @ \"+s.stateNumber+\"=\"+s.getClass().getSimpleName());\r\n // If already recovering, don't try to sync\r\n if (this.inErrorRecoveryMode(recognizer)) {\r\n return;\r\n }\r\n let tokens = recognizer.inputStream;\r\n let la = tokens.LA(1);\r\n // try cheaper subset first; might get lucky. seems to shave a wee bit off\r\n let nextTokens = recognizer.atn.nextTokens(s);\r\n if (nextTokens.contains(Token_1.Token.EPSILON) || nextTokens.contains(la)) {\r\n return;\r\n }\r\n switch (s.stateType) {\r\n case 3 /* BLOCK_START */:\r\n case 5 /* STAR_BLOCK_START */:\r\n case 4 /* PLUS_BLOCK_START */:\r\n case 10 /* STAR_LOOP_ENTRY */:\r\n // report error and recover if possible\r\n if (this.singleTokenDeletion(recognizer)) {\r\n return;\r\n }\r\n throw new InputMismatchException_1.InputMismatchException(recognizer);\r\n case 11 /* PLUS_LOOP_BACK */:\r\n case 9 /* STAR_LOOP_BACK */:\r\n //\t\t\tSystem.err.println(\"at loop back: \"+s.getClass().getSimpleName());\r\n this.reportUnwantedToken(recognizer);\r\n let expecting = recognizer.getExpectedTokens();\r\n let whatFollowsLoopIterationOrRule = expecting.or(this.getErrorRecoverySet(recognizer));\r\n this.consumeUntil(recognizer, whatFollowsLoopIterationOrRule);\r\n break;\r\n default:\r\n // do nothing if we can't identify the exact kind of ATN state\r\n break;\r\n }\r\n }\r\n /**\r\n * This is called by {@link #reportError} when the exception is a\r\n * {@link NoViableAltException}.\r\n *\r\n * @see #reportError\r\n *\r\n * @param recognizer the parser instance\r\n * @param e the recognition exception\r\n */\r\n reportNoViableAlternative(recognizer, e) {\r\n let tokens = recognizer.inputStream;\r\n let input;\r\n if (tokens) {\r\n if (e.startToken.type === Token_1.Token.EOF)\r\n input = \"<EOF>\";\r\n else\r\n input = tokens.getTextFromRange(e.startToken, e.getOffendingToken());\r\n }\r\n else {\r\n input = \"<unknown input>\";\r\n }\r\n let msg = \"no viable alternative at input \" + this.escapeWSAndQuote(input);\r\n this.notifyErrorListeners(recognizer, msg, e);\r\n }\r\n /**\r\n * This is called by {@link #reportError} when the exception is an\r\n * {@link InputMismatchException}.\r\n *\r\n * @see #reportError\r\n *\r\n * @param recognizer the parser instance\r\n * @param e the recognition exception\r\n */\r\n reportInputMismatch(recognizer, e) {\r\n let expected = e.expectedTokens;\r\n let expectedString = expected ? expected.toStringVocabulary(recognizer.vocabulary) : \"\";\r\n let msg = \"mismatched input \" + this.getTokenErrorDisplay(e.getOffendingToken(recognizer)) +\r\n \" expecting \" + expectedString;\r\n this.notifyErrorListeners(recognizer, msg, e);\r\n }\r\n /**\r\n * This is called by {@link #reportError} when the exception is a\r\n * {@link FailedPredicateException}.\r\n *\r\n * @see #reportError\r\n *\r\n * @param recognizer the parser instance\r\n * @param e the recognition exception\r\n */\r\n reportFailedPredicate(recognizer, e) {\r\n let ruleName = recognizer.ruleNames[recognizer.context.ruleIndex];\r\n let msg = \"rule \" + ruleName + \" \" + e.message;\r\n this.notifyErrorListeners(recognizer, msg, e);\r\n }\r\n /**\r\n * This method is called to report a syntax error which requires the removal\r\n * of a token from the input stream. At the time this method is called, the\r\n * erroneous symbol is current {@code LT(1)} symbol and has not yet been\r\n * removed from the input stream. When this method returns,\r\n * {@code recognizer} is in error recovery mode.\r\n *\r\n * <p>This method is called when {@link #singleTokenDeletion} identifies\r\n * single-token deletion as a viable recovery strategy for a mismatched\r\n * input error.</p>\r\n *\r\n * <p>The default implementation simply returns if the handler is already in\r\n * error recovery mode. Otherwise, it calls {@link #beginErrorCondition} to\r\n * enter error recovery mode, followed by calling\r\n * {@link Parser#notifyErrorListeners}.</p>\r\n *\r\n * @param recognizer the parser instance\r\n */\r\n reportUnwantedToken(recognizer) {\r\n if (this.inErrorRecoveryMode(recognizer)) {\r\n return;\r\n }\r\n this.beginErrorCondition(recognizer);\r\n let t = recognizer.currentToken;\r\n let tokenName = this.getTokenErrorDisplay(t);\r\n let expecting = this.getExpectedTokens(recognizer);\r\n let msg = \"extraneous input \" + tokenName + \" expecting \" +\r\n expecting.toStringVocabulary(recognizer.vocabulary);\r\n recognizer.notifyErrorListeners(msg, t, undefined);\r\n }\r\n /**\r\n * This method is called to report a syntax error which requires the\r\n * insertion of a missing token into the input stream. At the time this\r\n * method is called, the missing token has not yet been inserted. When this\r\n * method returns, {@code recognizer} is in error recovery mode.\r\n *\r\n * <p>This method is called when {@link #singleTokenInsertion} identifies\r\n * single-token insertion as a viable recovery strategy for a mismatched\r\n * input error.</p>\r\n *\r\n * <p>The default implementation simply returns if the handler is already in\r\n * error recovery mode. Otherwise, it calls {@link #beginErrorCondition} to\r\n * enter error recovery mode, followed by calling\r\n * {@link Parser#notifyErrorListeners}.</p>\r\n *\r\n * @param recognizer the parser instance\r\n */\r\n reportMissingToken(recognizer) {\r\n if (this.inErrorRecoveryMode(recognizer)) {\r\n return;\r\n }\r\n this.beginErrorCondition(recognizer);\r\n let t = recognizer.currentToken;\r\n let expecting = this.getExpectedTokens(recognizer);\r\n let msg = \"missing \" + expecting.toStringVocabulary(recognizer.vocabulary) +\r\n \" at \" + this.getTokenErrorDisplay(t);\r\n recognizer.notifyErrorListeners(msg, t, undefined);\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>The default implementation attempts to recover from the mismatched input\r\n * by using single token insertion and deletion as described below. If the\r\n * recovery attempt fails, this method\r\n * {@link InputMismatchException}.</p>\r\n *\r\n * <p><strong>EXTRA TOKEN</strong> (single token deletion)</p>\r\n *\r\n * <p>{@code LA(1)} is not what we are looking for. If {@code LA(2)} has the\r\n * right token, however, then assume {@code LA(1)} is some extra spurious\r\n * token and delete it. Then consume and return the next token (which was\r\n * the {@code LA(2)} token) as the successful result of the match operation.</p>\r\n *\r\n * <p>This recovery strategy is implemented by {@link #singleTokenDeletion}.</p>\r\n *\r\n * <p><strong>MISSING TOKEN</strong> (single token insertion)</p>\r\n *\r\n * <p>If current token (at {@code LA(1)}) is consistent with what could come\r\n * after the expected {@code LA(1)} token, then assume the token is missing\r\n * and use the parser's {@link TokenFactory} to create it on the fly. The\r\n * \"insertion\" is performed by returning the created token as the successful\r\n * result of the match operation.</p>\r\n *\r\n * <p>This recovery strategy is implemented by {@link #singleTokenInsertion}.</p>\r\n *\r\n * <p><strong>EXAMPLE</strong></p>\r\n *\r\n * <p>For example, Input {@code i=(3;} is clearly missing the {@code ')'}. When\r\n * the parser returns from the nested call to {@code expr}, it will have\r\n * call chain:</p>\r\n *\r\n * <pre>\r\n * stat → expr → atom\r\n * </pre>\r\n *\r\n * and it will be trying to match the {@code ')'} at this point in the\r\n * derivation:\r\n *\r\n * <pre>\r\n * => ID '=' '(' INT ')' ('+' atom)* ';'\r\n * ^\r\n * </pre>\r\n *\r\n * The attempt to match {@code ')'} will fail when it sees {@code ';'} and\r\n * call {@link #recoverInline}. To recover, it sees that {@code LA(1)==';'}\r\n * is in the set of tokens that can follow the {@code ')'} token reference\r\n * in rule {@code atom}. It can assume that you forgot the {@code ')'}.\r\n */\r\n recoverInline(recognizer) {\r\n // SINGLE TOKEN DELETION\r\n let matchedSymbol = this.singleTokenDeletion(recognizer);\r\n if (matchedSymbol) {\r\n // we have deleted the extra token.\r\n // now, move past ttype token as if all were ok\r\n recognizer.consume();\r\n return matchedSymbol;\r\n }\r\n // SINGLE TOKEN INSERTION\r\n if (this.singleTokenInsertion(recognizer)) {\r\n return this.getMissingSymbol(recognizer);\r\n }\r\n // even that didn't work; must throw the exception\r\n throw new InputMismatchException_1.InputMismatchException(recognizer);\r\n }\r\n /**\r\n * This method implements the single-token insertion inline error recovery\r\n * strategy. It is called by {@link #recoverInline} if the single-token\r\n * deletion strategy fails to recover from the mismatched input. If this\r\n * method returns {@code true}, {@code recognizer} will be in error recovery\r\n * mode.\r\n *\r\n * <p>This method determines whether or not single-token insertion is viable by\r\n * checking if the {@code LA(1)} input symbol could be successfully matched\r\n * if it were instead the {@code LA(2)} symbol. If this method returns\r\n * {@code true}, the caller is responsible for creating and inserting a\r\n * token with the correct type to produce this behavior.</p>\r\n *\r\n * @param recognizer the parser instance\r\n * @return {@code true} if single-token insertion is a viable recovery\r\n * strategy for the current mismatched input, otherwise {@code false}\r\n */\r\n singleTokenInsertion(recognizer) {\r\n let currentSymbolType = recognizer.inputStream.LA(1);\r\n // if current token is consistent with what could come after current\r\n // ATN state, then we know we're missing a token; error recovery\r\n // is free to conjure up and insert the missing token\r\n let currentState = recognizer.interpreter.atn.states[recognizer.state];\r\n let next = currentState.transition(0).target;\r\n let atn = recognizer.interpreter.atn;\r\n let expectingAtLL2 = atn.nextTokens(next, PredictionContext_1.PredictionContext.fromRuleContext(atn, recognizer.context));\r\n //\t\tconsole.warn(\"LT(2) set=\"+expectingAtLL2.toString(recognizer.getTokenNames()));\r\n if (expectingAtLL2.contains(currentSymbolType)) {\r\n this.reportMissingToken(recognizer);\r\n return true;\r\n }\r\n return false;\r\n }\r\n /**\r\n * This method implements the single-token deletion inline error recovery\r\n * strategy. It is called by {@link #recoverInline} to attempt to recover\r\n * from mismatched input. If this method returns null, the parser and error\r\n * handler state will not have changed. If this method returns non-null,\r\n * {@code recognizer} will <em>not</em> be in error recovery mode since the\r\n * returned token was a successful match.\r\n *\r\n * <p>If the single-token deletion is successful, this method calls\r\n * {@link #reportUnwantedToken} to report the error, followed by\r\n * {@link Parser#consume} to actually \"delete\" the extraneous token. Then,\r\n * before returning {@link #reportMatch} is called to signal a successful\r\n * match.</p>\r\n *\r\n * @param recognizer the parser instance\r\n * @return the successfully matched {@link Token} instance if single-token\r\n * deletion successfully recovers from the mismatched input, otherwise\r\n * {@code null}\r\n */\r\n singleTokenDeletion(recognizer) {\r\n let nextTokenType = recognizer.inputStream.LA(2);\r\n let expecting = this.getExpectedTokens(recognizer);\r\n if (expecting.contains(nextTokenType)) {\r\n this.reportUnwantedToken(recognizer);\r\n /*\r\n System.err.println(\"recoverFromMismatchedToken deleting \"+\r\n ((TokenStream)recognizer.inputStream).LT(1)+\r\n \" since \"+((TokenStream)recognizer.inputStream).LT(2)+\r\n \" is what we want\");\r\n */\r\n recognizer.consume(); // simply delete extra token\r\n // we want to return the token we're actually matching\r\n let matchedSymbol = recognizer.currentToken;\r\n this.reportMatch(recognizer); // we know current token is correct\r\n return matchedSymbol;\r\n }\r\n return undefined;\r\n }\r\n /** Conjure up a missing token during error recovery.\r\n *\r\n * The recognizer attempts to recover from single missing\r\n * symbols. But, actions might refer to that missing symbol.\r\n * For example, x=ID {f($x);}. The action clearly assumes\r\n * that there has been an identifier matched previously and that\r\n * $x points at that token. If that token is missing, but\r\n * the next token in the stream is what we want we assume that\r\n * this token is missing and we keep going. Because we\r\n * have to return some token to replace the missing token,\r\n * we have to conjure one up. This method gives the user control\r\n * over the tokens returned for missing tokens. Mostly,\r\n * you will want to create something special for identifier\r\n * tokens. For literals such as '{' and ',', the default\r\n * action in the parser or tree parser works. It simply creates\r\n * a CommonToken of the appropriate type. The text will be the token.\r\n * If you change what tokens must be created by the lexer,\r\n * override this method to create the appropriate tokens.\r\n */\r\n getMissingSymbol(recognizer) {\r\n let currentSymbol = recognizer.currentToken;\r\n let expecting = this.getExpectedTokens(recognizer);\r\n let expectedTokenType = expecting.minElement; // get any element\r\n let tokenText;\r\n if (expectedTokenType === Token_1.Token.EOF)\r\n tokenText = \"<missing EOF>\";\r\n else\r\n tokenText = \"<missing \" + recognizer.vocabulary.getDisplayName(expectedTokenType) + \">\";\r\n let current = currentSymbol;\r\n let lookback = recognizer.inputStream.tryLT(-1);\r\n if (current.type === Token_1.Token.EOF && lookback != null) {\r\n current = lookback;\r\n }\r\n return this.constructToken(recognizer.inputStream.tokenSource, expectedTokenType, tokenText, current);\r\n }\r\n constructToken(tokenSource, expectedTokenType, tokenText, current) {\r\n let factory = tokenSource.tokenFactory;\r\n let x = current.tokenSource;\r\n let stream = x ? x.inputStream : undefined;\r\n return factory.create({ source: tokenSource, stream: stream }, expectedTokenType, tokenText, Token_1.Token.DEFAULT_CHANNEL, -1, -1, current.line, current.charPositionInLine);\r\n }\r\n getExpectedTokens(recognizer) {\r\n return recognizer.getExpectedTokens();\r\n }\r\n /** How should a token be displayed in an error message? The default\r\n * is to display just the text, but during development you might\r\n * want to have a lot of information spit out. Override in that case\r\n * to use t.toString() (which, for CommonToken, dumps everything about\r\n * the token). This is better than forcing you to override a method in\r\n * your token objects because you don't have to go modify your lexer\r\n * so that it creates a new Java type.\r\n */\r\n getTokenErrorDisplay(t) {\r\n if (!t)\r\n return \"<no token>\";\r\n let s = this.getSymbolText(t);\r\n if (!s) {\r\n if (this.getSymbolType(t) === Token_1.Token.EOF) {\r\n s = \"<EOF>\";\r\n }\r\n else {\r\n s = `<${this.getSymbolType(t)}>`;\r\n }\r\n }\r\n return this.escapeWSAndQuote(s);\r\n }\r\n getSymbolText(symbol) {\r\n return symbol.text;\r\n }\r\n getSymbolType(symbol) {\r\n return symbol.type;\r\n }\r\n escapeWSAndQuote(s) {\r\n //\t\tif ( s==null ) return s;\r\n s = s.replace(\"\\n\", \"\\\\n\");\r\n s = s.replace(\"\\r\", \"\\\\r\");\r\n s = s.replace(\"\\t\", \"\\\\t\");\r\n return \"'\" + s + \"'\";\r\n }\r\n /* Compute the error recovery set for the current rule. During\r\n * rule invocation, the parser pushes the set of tokens that can\r\n * follow that rule reference on the stack; this amounts to\r\n * computing FIRST of what follows the rule reference in the\r\n * enclosing rule. See LinearApproximator.FIRST().\r\n * This local follow set only includes tokens\r\n * from within the rule; i.e., the FIRST computation done by\r\n * ANTLR stops at the end of a rule.\r\n *\r\n * EXAMPLE\r\n *\r\n * When you find a \"no viable alt exception\", the input is not\r\n * consistent with any of the alternatives for rule r. The best\r\n * thing to do is to consume tokens until you see something that\r\n * can legally follow a call to r *or* any rule that called r.\r\n * You don't want the exact set of viable next tokens because the\r\n * input might just be missing a token--you might consume the\r\n * rest of the input looking for one of the missing tokens.\r\n *\r\n * Consider grammar:\r\n *\r\n * a : '[' b ']'\r\n * | '(' b ')'\r\n * ;\r\n * b : c '^' INT ;\r\n * c : ID\r\n * | INT\r\n * ;\r\n *\r\n * At each rule invocation, the set of tokens that could follow\r\n * that rule is pushed on a stack. Here are the various\r\n * context-sensitive follow sets:\r\n *\r\n * FOLLOW(b1_in_a) = FIRST(']') = ']'\r\n * FOLLOW(b2_in_a) = FIRST(')') = ')'\r\n * FOLLOW(c_in_b) = FIRST('^') = '^'\r\n *\r\n * Upon erroneous input \"[]\", the call chain is\r\n *\r\n * a -> b -> c\r\n *\r\n * and, hence, the follow context stack is:\r\n *\r\n * depth follow set start of rule execution\r\n * 0 <EOF> a (from main())\r\n * 1 ']' b\r\n * 2 '^' c\r\n *\r\n * Notice that ')' is not included, because b would have to have\r\n * been called from a different context in rule a for ')' to be\r\n * included.\r\n *\r\n * For error recovery, we cannot consider FOLLOW(c)\r\n * (context-sensitive or otherwise). We need the combined set of\r\n * all context-sensitive FOLLOW sets--the set of all tokens that\r\n * could follow any reference in the call chain. We need to\r\n * resync to one of those tokens. Note that FOLLOW(c)='^' and if\r\n * we resync'd to that token, we'd consume until EOF. We need to\r\n * sync to context-sensitive FOLLOWs for a, b, and c: {']','^'}.\r\n * In this case, for input \"[]\", LA(1) is ']' and in the set, so we would\r\n * not consume anything. After printing an error, rule c would\r\n * return normally. Rule b would not find the required '^' though.\r\n * At this point, it gets a mismatched token error and\r\n * exception (since LA(1) is not in the viable following token\r\n * set). The rule exception handler tries to recover, but finds\r\n * the same recovery set and doesn't consume anything. Rule b\r\n * exits normally returning to rule a. Now it finds the ']' (and\r\n * with the successful match exits errorRecovery mode).\r\n *\r\n * So, you can see that the parser walks up the call chain looking\r\n * for the token that was a member of the recovery set.\r\n *\r\n * Errors are not generated in errorRecovery mode.\r\n *\r\n * ANTLR's error recovery mechanism is based upon original ideas:\r\n *\r\n * \"Algorithms + Data Structures = Programs\" by Niklaus Wirth\r\n *\r\n * and\r\n *\r\n * \"A note on error recovery in recursive descent parsers\":\r\n * http://portal.acm.org/citation.cfm?id=947902.947905\r\n *\r\n * Later, Josef Grosch had some good ideas:\r\n *\r\n * \"Efficient and Comfortable Error Recovery in Recursive Descent\r\n * Parsers\":\r\n * ftp://www.cocolab.com/products/cocktail/doca4.ps/ell.ps.zip\r\n *\r\n * Like Grosch I implement context-sensitive FOLLOW sets that are combined\r\n * at run-time upon error to avoid overhead during parsing.\r\n */\r\n getErrorRecoverySet(recognizer) {\r\n let atn = recognizer.interpreter.atn;\r\n let ctx = recognizer.context;\r\n let recoverSet = new IntervalSet_1.IntervalSet();\r\n while (ctx && ctx.invokingState >= 0) {\r\n // compute what follows who invoked us\r\n let invokingState = atn.states[ctx.invokingState];\r\n let rt = invokingState.transition(0);\r\n let follow = atn.nextTokens(rt.followState);\r\n recoverSet.addAll(follow);\r\n ctx = ctx._parent;\r\n }\r\n recoverSet.remove(Token_1.Token.EPSILON);\r\n //\t\tSystem.out.println(\"recover set \"+recoverSet.toString(recognizer.getTokenNames()));\r\n return recoverSet;\r\n }\r\n /** Consume tokens until one matches the given token set. */\r\n consumeUntil(recognizer, set) {\r\n //\t\tSystem.err.println(\"consumeUntil(\"+set.toString(recognizer.getTokenNames())+\")\");\r\n let ttype = recognizer.inputStream.LA(1);\r\n while (ttype !== Token_1.Token.EOF && !set.contains(ttype)) {\r\n //System.out.println(\"consume during recover LA(1)=\"+getTokenNames()[input.LA(1)]);\r\n //\t\t\trecognizer.inputStream.consume();\r\n recognizer.consume();\r\n ttype = recognizer.inputStream.LA(1);\r\n }\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], DefaultErrorStrategy.prototype, \"reset\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"beginErrorCondition\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], DefaultErrorStrategy.prototype, \"inErrorRecoveryMode\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"endErrorCondition\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], DefaultErrorStrategy.prototype, \"reportMatch\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], DefaultErrorStrategy.prototype, \"reportError\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"notifyErrorListeners\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], DefaultErrorStrategy.prototype, \"recover\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], DefaultErrorStrategy.prototype, \"sync\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"reportNoViableAlternative\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"reportInputMismatch\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"reportFailedPredicate\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"reportUnwantedToken\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"reportMissingToken\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], DefaultErrorStrategy.prototype, \"recoverInline\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"singleTokenInsertion\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"singleTokenDeletion\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"getMissingSymbol\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"getExpectedTokens\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"getSymbolText\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"getSymbolType\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"escapeWSAndQuote\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"getErrorRecoverySet\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n], DefaultErrorStrategy.prototype, \"consumeUntil\", null);\r\nexports.DefaultErrorStrategy = DefaultErrorStrategy;\r\n//# sourceMappingURL=DefaultErrorStrategy.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:51.5898546-07:00\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst ParserRuleContext_1 = require(\"./ParserRuleContext\");\r\n/**\r\n * This class extends {@link ParserRuleContext} by allowing the value of\r\n * {@link #getRuleIndex} to be explicitly set for the context.\r\n *\r\n * <p>\r\n * {@link ParserRuleContext} does not include field storage for the rule index\r\n * since the context classes created by the code generator override the\r\n * {@link #getRuleIndex} method to return the correct value for that context.\r\n * Since the parser interpreter does not use the context classes generated for a\r\n * parser, this class (with slightly more memory overhead per node) is used to\r\n * provide equivalent functionality.</p>\r\n */\r\nclass InterpreterRuleContext extends ParserRuleContext_1.ParserRuleContext {\r\n constructor(ruleIndex, parent, invokingStateNumber) {\r\n if (invokingStateNumber !== undefined) {\r\n super(parent, invokingStateNumber);\r\n }\r\n else {\r\n super();\r\n }\r\n this._ruleIndex = ruleIndex;\r\n }\r\n get ruleIndex() {\r\n return this._ruleIndex;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], InterpreterRuleContext.prototype, \"ruleIndex\", null);\r\nexports.InterpreterRuleContext = InterpreterRuleContext;\r\n//# sourceMappingURL=InterpreterRuleContext.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:49.6074365-07:00\r\nconst assert = require(\"assert\");\r\nconst CommonToken_1 = require(\"./CommonToken\");\r\nconst Interval_1 = require(\"./misc/Interval\");\r\nconst Lexer_1 = require(\"./Lexer\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst Token_1 = require(\"./Token\");\r\n/**\r\n * This implementation of {@link TokenStream} loads tokens from a\r\n * {@link TokenSource} on-demand, and places the tokens in a buffer to provide\r\n * access to any previous token by index.\r\n *\r\n * <p>\r\n * This token stream ignores the value of {@link Token#getChannel}. If your\r\n * parser requires the token stream filter tokens to only those on a particular\r\n * channel, such as {@link Token#DEFAULT_CHANNEL} or\r\n * {@link Token#HIDDEN_CHANNEL}, use a filtering token stream such a\r\n * {@link CommonTokenStream}.</p>\r\n */\r\nlet BufferedTokenStream = class BufferedTokenStream {\r\n constructor(tokenSource) {\r\n /**\r\n * A collection of all tokens fetched from the token source. The list is\r\n * considered a complete view of the input once {@link #fetchedEOF} is set\r\n * to {@code true}.\r\n */\r\n this.tokens = [];\r\n /**\r\n * The index into {@link #tokens} of the current token (next token to\r\n * {@link #consume}). {@link #tokens}{@code [}{@link #p}{@code ]} should be\r\n * {@link #LT LT(1)}.\r\n *\r\n * <p>This field is set to -1 when the stream is first constructed or when\r\n * {@link #setTokenSource} is called, indicating that the first token has\r\n * not yet been fetched from the token source. For additional information,\r\n * see the documentation of {@link IntStream} for a description of\r\n * Initializing Methods.</p>\r\n */\r\n this.p = -1;\r\n /**\r\n * Indicates whether the {@link Token#EOF} token has been fetched from\r\n * {@link #tokenSource} and added to {@link #tokens}. This field improves\r\n * performance for the following cases:\r\n *\r\n * <ul>\r\n * <li>{@link #consume}: The lookahead check in {@link #consume} to prevent\r\n * consuming the EOF symbol is optimized by checking the values of\r\n * {@link #fetchedEOF} and {@link #p} instead of calling {@link #LA}.</li>\r\n * <li>{@link #fetch}: The check to prevent adding multiple EOF symbols into\r\n * {@link #tokens} is trivial with this field.</li>\r\n * <ul>\r\n */\r\n this.fetchedEOF = false;\r\n if (tokenSource == null) {\r\n throw new Error(\"tokenSource cannot be null\");\r\n }\r\n this._tokenSource = tokenSource;\r\n }\r\n get tokenSource() {\r\n return this._tokenSource;\r\n }\r\n get index() {\r\n return this.p;\r\n }\r\n mark() {\r\n return 0;\r\n }\r\n release(marker) {\r\n // no resources to release\r\n }\r\n reset() {\r\n this.seek(0);\r\n }\r\n seek(index) {\r\n this.lazyInit();\r\n this.p = this.adjustSeekIndex(index);\r\n }\r\n get size() {\r\n return this.tokens.length;\r\n }\r\n consume() {\r\n let skipEofCheck;\r\n if (this.p >= 0) {\r\n if (this.fetchedEOF) {\r\n // the last token in tokens is EOF. skip check if p indexes any\r\n // fetched token except the last.\r\n skipEofCheck = this.p < this.tokens.length - 1;\r\n }\r\n else {\r\n // no EOF token in tokens. skip check if p indexes a fetched token.\r\n skipEofCheck = this.p < this.tokens.length;\r\n }\r\n }\r\n else {\r\n // not yet initialized\r\n skipEofCheck = false;\r\n }\r\n if (!skipEofCheck && this.LA(1) === Token_1.Token.EOF) {\r\n throw new Error(\"cannot consume EOF\");\r\n }\r\n if (this.sync(this.p + 1)) {\r\n this.p = this.adjustSeekIndex(this.p + 1);\r\n }\r\n }\r\n /** Make sure index {@code i} in tokens has a token.\r\n *\r\n * @return {@code true} if a token is located at index {@code i}, otherwise\r\n * {@code false}.\r\n * @see #get(int i)\r\n */\r\n sync(i) {\r\n assert(i >= 0);\r\n let n = i - this.tokens.length + 1; // how many more elements we need?\r\n //System.out.println(\"sync(\"+i+\") needs \"+n);\r\n if (n > 0) {\r\n let fetched = this.fetch(n);\r\n return fetched >= n;\r\n }\r\n return true;\r\n }\r\n /** Add {@code n} elements to buffer.\r\n *\r\n * @return The actual number of elements added to the buffer.\r\n */\r\n fetch(n) {\r\n if (this.fetchedEOF) {\r\n return 0;\r\n }\r\n for (let i = 0; i < n; i++) {\r\n let t = this.tokenSource.nextToken();\r\n if (this.isWritableToken(t)) {\r\n t.tokenIndex = this.tokens.length;\r\n }\r\n this.tokens.push(t);\r\n if (t.type === Token_1.Token.EOF) {\r\n this.fetchedEOF = true;\r\n return i + 1;\r\n }\r\n }\r\n return n;\r\n }\r\n get(i) {\r\n if (i < 0 || i >= this.tokens.length) {\r\n throw new RangeError(\"token index \" + i + \" out of range 0..\" + (this.tokens.length - 1));\r\n }\r\n return this.tokens[i];\r\n }\r\n /** Get all tokens from start..stop inclusively. */\r\n getRange(start, stop) {\r\n if (start < 0 || stop < 0) {\r\n return [];\r\n }\r\n this.lazyInit();\r\n let subset = new Array();\r\n if (stop >= this.tokens.length) {\r\n stop = this.tokens.length - 1;\r\n }\r\n for (let i = start; i <= stop; i++) {\r\n let t = this.tokens[i];\r\n if (t.type === Token_1.Token.EOF) {\r\n break;\r\n }\r\n subset.push(t);\r\n }\r\n return subset;\r\n }\r\n LA(i) {\r\n let token = this.LT(i);\r\n if (!token) {\r\n return Token_1.Token.INVALID_TYPE;\r\n }\r\n return token.type;\r\n }\r\n tryLB(k) {\r\n if ((this.p - k) < 0) {\r\n return undefined;\r\n }\r\n return this.tokens[this.p - k];\r\n }\r\n LT(k) {\r\n let result = this.tryLT(k);\r\n if (result === undefined) {\r\n throw new RangeError(\"requested lookback index out of range\");\r\n }\r\n return result;\r\n }\r\n tryLT(k) {\r\n this.lazyInit();\r\n if (k === 0) {\r\n throw new RangeError(\"0 is not a valid lookahead index\");\r\n }\r\n if (k < 0) {\r\n return this.tryLB(-k);\r\n }\r\n let i = this.p + k - 1;\r\n this.sync(i);\r\n if (i >= this.tokens.length) {\r\n // return EOF token\r\n // EOF must be last token\r\n return this.tokens[this.tokens.length - 1];\r\n }\r\n //\t\tif ( i>range ) range = i;\r\n return this.tokens[i];\r\n }\r\n /**\r\n * Allowed derived classes to modify the behavior of operations which change\r\n * the current stream position by adjusting the target token index of a seek\r\n * operation. The default implementation simply returns {@code i}. If an\r\n * exception is thrown in this method, the current stream index should not be\r\n * changed.\r\n *\r\n * <p>For example, {@link CommonTokenStream} overrides this method to ensure that\r\n * the seek target is always an on-channel token.</p>\r\n *\r\n * @param i The target token index.\r\n * @return The adjusted target token index.\r\n */\r\n adjustSeekIndex(i) {\r\n return i;\r\n }\r\n lazyInit() {\r\n if (this.p === -1) {\r\n this.setup();\r\n }\r\n }\r\n setup() {\r\n this.sync(0);\r\n this.p = this.adjustSeekIndex(0);\r\n }\r\n /** Reset this token stream by setting its token source. */\r\n set tokenSource(tokenSource) {\r\n this._tokenSource = tokenSource;\r\n this.tokens.length = 0;\r\n this.p = -1;\r\n }\r\n /** Given a start and stop index, return a {@code List} of all tokens in\r\n * the token type {@code BitSet}. Return {@code null} if no tokens were found. This\r\n * method looks at both on and off channel tokens.\r\n */\r\n getTokens(start, stop, types) {\r\n this.lazyInit();\r\n start = start || 0;\r\n stop = stop || this.tokens.length - 1;\r\n if (start < 0 || stop >= this.tokens.length || stop < 0 || start >= this.tokens.length) {\r\n throw new RangeError(\"start \" + start + \" or stop \" + stop + \" not in 0..\" + (this.tokens.length - 1));\r\n }\r\n if (start === 0 && stop === this.tokens.length - 1) {\r\n return this.tokens;\r\n }\r\n if (start > stop) {\r\n return [];\r\n }\r\n if (types == null) {\r\n return this.tokens.slice(start, stop + 1);\r\n }\r\n else if (typeof types === 'number') {\r\n types = new Set().add(types);\r\n }\r\n let typesSet = types;\r\n // list = tokens[start:stop]:{T t, t.type in types}\r\n let filteredTokens = this.tokens.slice(start, stop + 1);\r\n filteredTokens = filteredTokens.filter((value) => { return typesSet.has(value.type); });\r\n return filteredTokens;\r\n }\r\n /**\r\n * Given a starting index, return the index of the next token on channel.\r\n * Return {@code i} if {@code tokens[i]} is on channel. Return the index of\r\n * the EOF token if there are no tokens on channel between {@code i} and\r\n * EOF.\r\n */\r\n nextTokenOnChannel(i, channel) {\r\n this.sync(i);\r\n if (i >= this.size) {\r\n return this.size - 1;\r\n }\r\n let token = this.tokens[i];\r\n while (token.channel !== channel) {\r\n if (token.type === Token_1.Token.EOF) {\r\n return i;\r\n }\r\n i++;\r\n this.sync(i);\r\n token = this.tokens[i];\r\n }\r\n return i;\r\n }\r\n /**\r\n * Given a starting index, return the index of the previous token on\r\n * channel. Return {@code i} if {@code tokens[i]} is on channel. Return -1\r\n * if there are no tokens on channel between {@code i} and 0.\r\n *\r\n * <p>\r\n * If {@code i} specifies an index at or after the EOF token, the EOF token\r\n * index is returned. This is due to the fact that the EOF token is treated\r\n * as though it were on every channel.</p>\r\n */\r\n previousTokenOnChannel(i, channel) {\r\n this.sync(i);\r\n if (i >= this.size) {\r\n // the EOF token is on every channel\r\n return this.size - 1;\r\n }\r\n while (i >= 0) {\r\n let token = this.tokens[i];\r\n if (token.type === Token_1.Token.EOF || token.channel === channel) {\r\n return i;\r\n }\r\n i--;\r\n }\r\n return i;\r\n }\r\n /** Collect all tokens on specified channel to the right of\r\n * the current token up until we see a token on {@link Lexer#DEFAULT_TOKEN_CHANNEL} or\r\n * EOF. If {@code channel} is {@code -1}, find any non default channel token.\r\n */\r\n getHiddenTokensToRight(tokenIndex, channel = -1) {\r\n this.lazyInit();\r\n if (tokenIndex < 0 || tokenIndex >= this.tokens.length) {\r\n throw new RangeError(tokenIndex + \" not in 0..\" + (this.tokens.length - 1));\r\n }\r\n let nextOnChannel = this.nextTokenOnChannel(tokenIndex + 1, Lexer_1.Lexer.DEFAULT_TOKEN_CHANNEL);\r\n let to;\r\n let from = tokenIndex + 1;\r\n // if none onchannel to right, nextOnChannel=-1 so set to = last token\r\n if (nextOnChannel === -1) {\r\n to = this.size - 1;\r\n }\r\n else {\r\n to = nextOnChannel;\r\n }\r\n return this.filterForChannel(from, to, channel);\r\n }\r\n /** Collect all tokens on specified channel to the left of\r\n * the current token up until we see a token on {@link Lexer#DEFAULT_TOKEN_CHANNEL}.\r\n * If {@code channel} is {@code -1}, find any non default channel token.\r\n */\r\n getHiddenTokensToLeft(tokenIndex, channel = -1) {\r\n this.lazyInit();\r\n if (tokenIndex < 0 || tokenIndex >= this.tokens.length) {\r\n throw new RangeError(tokenIndex + \" not in 0..\" + (this.tokens.length - 1));\r\n }\r\n if (tokenIndex === 0) {\r\n // obviously no tokens can appear before the first token\r\n return [];\r\n }\r\n let prevOnChannel = this.previousTokenOnChannel(tokenIndex - 1, Lexer_1.Lexer.DEFAULT_TOKEN_CHANNEL);\r\n if (prevOnChannel === tokenIndex - 1) {\r\n return [];\r\n }\r\n // if none onchannel to left, prevOnChannel=-1 then from=0\r\n let from = prevOnChannel + 1;\r\n let to = tokenIndex - 1;\r\n return this.filterForChannel(from, to, channel);\r\n }\r\n filterForChannel(from, to, channel) {\r\n let hidden = new Array();\r\n for (let i = from; i <= to; i++) {\r\n let t = this.tokens[i];\r\n if (channel === -1) {\r\n if (t.channel !== Lexer_1.Lexer.DEFAULT_TOKEN_CHANNEL) {\r\n hidden.push(t);\r\n }\r\n }\r\n else {\r\n if (t.channel === channel) {\r\n hidden.push(t);\r\n }\r\n }\r\n }\r\n return hidden;\r\n }\r\n get sourceName() {\r\n return this.tokenSource.sourceName;\r\n }\r\n getText(interval) {\r\n if (interval === undefined) {\r\n interval = Interval_1.Interval.of(0, this.size - 1);\r\n }\r\n else if (!(interval instanceof Interval_1.Interval)) {\r\n // Note: the more obvious check for 'instanceof RuleContext' results in a circular dependency problem\r\n interval = interval.sourceInterval;\r\n }\r\n let start = interval.a;\r\n let stop = interval.b;\r\n if (start < 0 || stop < 0) {\r\n return \"\";\r\n }\r\n this.fill();\r\n if (stop >= this.tokens.length) {\r\n stop = this.tokens.length - 1;\r\n }\r\n let buf = \"\";\r\n for (let i = start; i <= stop; i++) {\r\n let t = this.tokens[i];\r\n if (t.type === Token_1.Token.EOF) {\r\n break;\r\n }\r\n buf += t.text;\r\n }\r\n return buf.toString();\r\n }\r\n getTextFromRange(start, stop) {\r\n if (this.isToken(start) && this.isToken(stop)) {\r\n return this.getText(Interval_1.Interval.of(start.tokenIndex, stop.tokenIndex));\r\n }\r\n return \"\";\r\n }\r\n /** Get all tokens from lexer until EOF. */\r\n fill() {\r\n this.lazyInit();\r\n const blockSize = 1000;\r\n while (true) {\r\n let fetched = this.fetch(blockSize);\r\n if (fetched < blockSize) {\r\n return;\r\n }\r\n }\r\n }\r\n // TODO: Figure out a way to make this more flexible?\r\n isWritableToken(t) {\r\n return t instanceof CommonToken_1.CommonToken;\r\n }\r\n // TODO: Figure out a way to make this more flexible?\r\n isToken(t) {\r\n return t instanceof CommonToken_1.CommonToken;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], BufferedTokenStream.prototype, \"_tokenSource\", void 0);\r\n__decorate([\r\n Decorators_1.Override\r\n], BufferedTokenStream.prototype, \"tokenSource\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], BufferedTokenStream.prototype, \"index\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], BufferedTokenStream.prototype, \"mark\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], BufferedTokenStream.prototype, \"release\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], BufferedTokenStream.prototype, \"seek\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], BufferedTokenStream.prototype, \"size\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], BufferedTokenStream.prototype, \"consume\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], BufferedTokenStream.prototype, \"get\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], BufferedTokenStream.prototype, \"LA\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n Decorators_1.Override\r\n], BufferedTokenStream.prototype, \"LT\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], BufferedTokenStream.prototype, \"sourceName\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n Decorators_1.Override\r\n], BufferedTokenStream.prototype, \"getText\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n Decorators_1.Override\r\n], BufferedTokenStream.prototype, \"getTextFromRange\", null);\r\nBufferedTokenStream = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], BufferedTokenStream);\r\nexports.BufferedTokenStream = BufferedTokenStream;\r\n//# sourceMappingURL=BufferedTokenStream.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst Decorators_1 = require(\"./Decorators\");\r\n// This class seems unused, but might clean up ParserProxyErrorListener a little bit if used consistently.\r\nclass BaseErrorListener {\r\n syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {\r\n }\r\n reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {\r\n }\r\n reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, conflictState) {\r\n }\r\n reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, acceptState) {\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull),\r\n __param(4, Decorators_1.NotNull)\r\n], BaseErrorListener.prototype, \"syntaxError\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(6, Decorators_1.NotNull)\r\n], BaseErrorListener.prototype, \"reportAmbiguity\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(5, Decorators_1.NotNull)\r\n], BaseErrorListener.prototype, \"reportAttemptingFullContext\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(5, Decorators_1.NotNull)\r\n], BaseErrorListener.prototype, \"reportContextSensitivity\", null);\r\nexports.BaseErrorListener = BaseErrorListener;\r\n//# sourceMappingURL=BaseErrorListener.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst ProxyErrorListener_1 = require(\"./ProxyErrorListener\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\n/**\r\n * @author Sam Harwell\r\n */\r\nclass ProxyParserErrorListener extends ProxyErrorListener_1.ProxyErrorListener {\r\n constructor(delegates) {\r\n super(delegates);\r\n }\r\n reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {\r\n this.getDelegates()\r\n .forEach(listener => {\r\n if (ProxyParserErrorListener.isParserErrorListener(listener)) {\r\n listener.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs);\r\n }\r\n });\r\n }\r\n reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, conflictState) {\r\n this.getDelegates()\r\n .forEach(listener => {\r\n if (ProxyParserErrorListener.isParserErrorListener(listener)) {\r\n listener.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, conflictState);\r\n }\r\n });\r\n }\r\n reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, acceptState) {\r\n this.getDelegates()\r\n .forEach(listener => {\r\n if (ProxyParserErrorListener.isParserErrorListener(listener)) {\r\n listener.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, acceptState);\r\n }\r\n });\r\n }\r\n static isParserErrorListener(listener) {\r\n return listener.reportAmbiguity;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], ProxyParserErrorListener.prototype, \"reportAmbiguity\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ProxyParserErrorListener.prototype, \"reportAttemptingFullContext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ProxyParserErrorListener.prototype, \"reportContextSensitivity\", null);\r\nexports.ProxyParserErrorListener = ProxyParserErrorListener;\r\n//# sourceMappingURL=ProxyParserErrorListener.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nclass RuleNode {\r\n}\r\nexports.RuleNode = RuleNode;\r\n//# sourceMappingURL=RuleNode.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:57.3490837-07:00\r\n/** A rule context is a record of a single rule invocation.\r\n *\r\n * We form a stack of these context objects using the parent\r\n * pointer. A parent pointer of null indicates that the current\r\n * context is the bottom of the stack. The ParserRuleContext subclass\r\n * as a children list so that we can turn this data structure into a\r\n * tree.\r\n *\r\n * The root node always has a null pointer and invokingState of -1.\r\n *\r\n * Upon entry to parsing, the first invoked rule function creates a\r\n * context object (a subclass specialized for that rule such as\r\n * SContext) and makes it the root of a parse tree, recorded by field\r\n * Parser._ctx.\r\n *\r\n * public final SContext s() throws RecognitionException {\r\n * SContext _localctx = new SContext(_ctx, state); <-- create new node\r\n * enterRule(_localctx, 0, RULE_s); <-- push it\r\n * ...\r\n * exitRule(); <-- pop back to _localctx\r\n * return _localctx;\r\n * }\r\n *\r\n * A subsequent rule invocation of r from the start rule s pushes a\r\n * new context object for r whose parent points at s and use invoking\r\n * state is the state with r emanating as edge label.\r\n *\r\n * The invokingState fields from a context object to the root\r\n * together form a stack of rule indication states where the root\r\n * (bottom of the stack) has a -1 sentinel value. If we invoke start\r\n * symbol s then call r1, which calls r2, the would look like\r\n * this:\r\n *\r\n * SContext[-1] <- root node (bottom of the stack)\r\n * R1Context[p] <- p in rule s called r1\r\n * R2Context[q] <- q in rule r1 called r2\r\n *\r\n * So the top of the stack, _ctx, represents a call to the current\r\n * rule and it holds the return address from another rule that invoke\r\n * to this rule. To invoke a rule, we must always have a current context.\r\n *\r\n * The parent contexts are useful for computing lookahead sets and\r\n * getting error information.\r\n *\r\n * These objects are used during parsing and prediction.\r\n * For the special case of parsers, we use the subclass\r\n * ParserRuleContext.\r\n *\r\n * @see ParserRuleContext\r\n */\r\nconst ATN_1 = require(\"./atn/ATN\");\r\nconst Recognizer_1 = require(\"./Recognizer\");\r\nconst RuleNode_1 = require(\"./tree/RuleNode\");\r\nconst Interval_1 = require(\"./misc/Interval\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst Trees_1 = require(\"./tree/Trees\");\r\nconst ParserRuleContext_1 = require(\"./ParserRuleContext\");\r\nclass RuleContext extends RuleNode_1.RuleNode {\r\n constructor(parent, invokingState) {\r\n super();\r\n this._parent = parent;\r\n this.invokingState = invokingState != null ? invokingState : -1;\r\n }\r\n static getChildContext(parent, invokingState) {\r\n return new RuleContext(parent, invokingState);\r\n }\r\n depth() {\r\n let n = 0;\r\n let p = this;\r\n while (p) {\r\n p = p._parent;\r\n n++;\r\n }\r\n return n;\r\n }\r\n /** A context is empty if there is no invoking state; meaning nobody called\r\n * current context.\r\n */\r\n get isEmpty() {\r\n return this.invokingState === -1;\r\n }\r\n // satisfy the ParseTree / SyntaxTree interface\r\n get sourceInterval() {\r\n return Interval_1.Interval.INVALID;\r\n }\r\n get ruleContext() { return this; }\r\n get parent() { return this._parent; }\r\n get payload() { return this; }\r\n /** Return the combined text of all child nodes. This method only considers\r\n * tokens which have been added to the parse tree.\r\n * <p>\r\n * Since tokens on hidden channels (e.g. whitespace or comments) are not\r\n * added to the parse trees, they will not appear in the output of this\r\n * method.\r\n */\r\n get text() {\r\n if (this.childCount === 0) {\r\n return \"\";\r\n }\r\n let builder = \"\";\r\n for (let i = 0; i < this.childCount; i++) {\r\n builder += this.getChild(i).text;\r\n }\r\n return builder.toString();\r\n }\r\n get ruleIndex() { return -1; }\r\n /** For rule associated with this parse tree internal node, return\r\n * the outer alternative number used to match the input. Default\r\n * implementation does not compute nor store this alt num. Create\r\n * a subclass of ParserRuleContext with backing field and set\r\n * option contextSuperClass.\r\n * to set it.\r\n *\r\n * @since 4.5.3\r\n */\r\n get altNumber() { return ATN_1.ATN.INVALID_ALT_NUMBER; }\r\n /** Set the outer alternative number for this context node. Default\r\n * implementation does nothing to avoid backing field overhead for\r\n * trees that don't need it. Create\r\n * a subclass of ParserRuleContext with backing field and set\r\n * option contextSuperClass.\r\n *\r\n * @since 4.5.3\r\n */\r\n set altNumber(altNumber) { }\r\n getChild(i) {\r\n throw new RangeError(\"i must be greater than or equal to 0 and less than childCount\");\r\n }\r\n get childCount() {\r\n return 0;\r\n }\r\n accept(visitor) {\r\n return visitor.visitChildren(this);\r\n }\r\n toStringTree(recog) {\r\n return Trees_1.Trees.toStringTree(this, recog);\r\n }\r\n toString(arg1, stop) {\r\n const ruleNames = (arg1 instanceof Recognizer_1.Recognizer) ? arg1.ruleNames : arg1;\r\n stop = stop || ParserRuleContext_1.ParserRuleContext.emptyContext();\r\n let buf = \"\";\r\n let p = this;\r\n buf += (\"[\");\r\n while (p && p !== stop) {\r\n if (!ruleNames) {\r\n if (!p.isEmpty) {\r\n buf += (p.invokingState);\r\n }\r\n }\r\n else {\r\n let ruleIndex = p.ruleIndex;\r\n let ruleName = (ruleIndex >= 0 && ruleIndex < ruleNames.length)\r\n ? ruleNames[ruleIndex] : ruleIndex.toString();\r\n buf += (ruleName);\r\n }\r\n if (p._parent && (ruleNames || !p._parent.isEmpty)) {\r\n buf += (\" \");\r\n }\r\n p = p._parent;\r\n }\r\n buf += (\"]\");\r\n return buf.toString();\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleContext.prototype, \"sourceInterval\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleContext.prototype, \"ruleContext\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleContext.prototype, \"parent\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleContext.prototype, \"payload\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleContext.prototype, \"text\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleContext.prototype, \"getChild\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleContext.prototype, \"childCount\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleContext.prototype, \"accept\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleContext.prototype, \"toStringTree\", null);\r\nexports.RuleContext = RuleContext;\r\n//# sourceMappingURL=RuleContext.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:47.4646355-07:00\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst TerminalNode_1 = require(\"./TerminalNode\");\r\n/** Represents a token that was consumed during resynchronization\r\n * rather than during a valid match operation. For example,\r\n * we will create this kind of a node during single token insertion\r\n * and deletion as well as during \"consume until error recovery set\"\r\n * upon no viable alternative exceptions.\r\n */\r\nclass ErrorNode extends TerminalNode_1.TerminalNode {\r\n constructor(token) {\r\n super(token);\r\n }\r\n accept(visitor) {\r\n return visitor.visitErrorNode(this);\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], ErrorNode.prototype, \"accept\", null);\r\nexports.ErrorNode = ErrorNode;\r\n//# sourceMappingURL=ErrorNode.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:30.7737978-07:00\r\nconst ATNState_1 = require(\"./ATNState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/** Mark the end of a * or + loop. */\r\nclass LoopEndState extends ATNState_1.ATNState {\r\n get stateType() {\r\n return 12 /* LOOP_END */;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], LoopEndState.prototype, \"stateType\", null);\r\nexports.LoopEndState = LoopEndState;\r\n//# sourceMappingURL=LoopEndState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst IntervalSet_1 = require(\"../misc/IntervalSet\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst Transition_1 = require(\"./Transition\");\r\n/** TODO: make all transitions sets? no, should remove set edges */\r\nlet AtomTransition = class AtomTransition extends Transition_1.Transition {\r\n constructor(target, label) {\r\n super(target);\r\n this._label = label;\r\n }\r\n get serializationType() {\r\n return 5 /* ATOM */;\r\n }\r\n get label() {\r\n return IntervalSet_1.IntervalSet.of(this._label);\r\n }\r\n matches(symbol, minVocabSymbol, maxVocabSymbol) {\r\n return this._label === symbol;\r\n }\r\n toString() {\r\n return String(this.label);\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override\r\n], AtomTransition.prototype, \"serializationType\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n Decorators_1.NotNull\r\n], AtomTransition.prototype, \"label\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], AtomTransition.prototype, \"matches\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n Decorators_1.NotNull\r\n], AtomTransition.prototype, \"toString\", null);\r\nAtomTransition = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], AtomTransition);\r\nexports.AtomTransition = AtomTransition;\r\n//# sourceMappingURL=AtomTransition.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst Transition_1 = require(\"./Transition\");\r\nlet ActionTransition = class ActionTransition extends Transition_1.Transition {\r\n constructor(target, ruleIndex, actionIndex = -1, isCtxDependent = false) {\r\n super(target);\r\n this.ruleIndex = ruleIndex;\r\n this.actionIndex = actionIndex;\r\n this.isCtxDependent = isCtxDependent;\r\n }\r\n get serializationType() {\r\n return 6 /* ACTION */;\r\n }\r\n get isEpsilon() {\r\n return true; // we are to be ignored by analysis 'cept for predicates\r\n }\r\n matches(symbol, minVocabSymbol, maxVocabSymbol) {\r\n return false;\r\n }\r\n toString() {\r\n return \"action_\" + this.ruleIndex + \":\" + this.actionIndex;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override\r\n], ActionTransition.prototype, \"serializationType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ActionTransition.prototype, \"isEpsilon\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ActionTransition.prototype, \"matches\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ActionTransition.prototype, \"toString\", null);\r\nActionTransition = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ActionTransition);\r\nexports.ActionTransition = ActionTransition;\r\n//# sourceMappingURL=ActionTransition.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:25.8187912-07:00\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass ATNDeserializationOptions {\r\n constructor(options) {\r\n this.readOnly = false;\r\n if (options) {\r\n this.verifyATN = options.verifyATN;\r\n this.generateRuleBypassTransitions = options.generateRuleBypassTransitions;\r\n this.optimize = options.optimize;\r\n }\r\n else {\r\n this.verifyATN = true;\r\n this.generateRuleBypassTransitions = false;\r\n this.optimize = true;\r\n }\r\n }\r\n static get defaultOptions() {\r\n if (ATNDeserializationOptions._defaultOptions == null) {\r\n ATNDeserializationOptions._defaultOptions = new ATNDeserializationOptions();\r\n ATNDeserializationOptions._defaultOptions.makeReadOnly();\r\n }\r\n return ATNDeserializationOptions._defaultOptions;\r\n }\r\n get isReadOnly() {\r\n return this.readOnly;\r\n }\r\n makeReadOnly() {\r\n this.readOnly = true;\r\n }\r\n get isVerifyATN() {\r\n return this.verifyATN;\r\n }\r\n set isVerifyATN(verifyATN) {\r\n this.throwIfReadOnly();\r\n this.verifyATN = verifyATN;\r\n }\r\n get isGenerateRuleBypassTransitions() {\r\n return this.generateRuleBypassTransitions;\r\n }\r\n set isGenerateRuleBypassTransitions(generateRuleBypassTransitions) {\r\n this.throwIfReadOnly();\r\n this.generateRuleBypassTransitions = generateRuleBypassTransitions;\r\n }\r\n get isOptimize() {\r\n return this.optimize;\r\n }\r\n set isOptimize(optimize) {\r\n this.throwIfReadOnly();\r\n this.optimize = optimize;\r\n }\r\n throwIfReadOnly() {\r\n if (this.isReadOnly) {\r\n throw \"The object is read only.\";\r\n }\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ATNDeserializationOptions, \"defaultOptions\", null);\r\nexports.ATNDeserializationOptions = ATNDeserializationOptions;\r\n//# sourceMappingURL=ATNDeserializationOptions.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst Transition_1 = require(\"./Transition\");\r\nlet WildcardTransition = class WildcardTransition extends Transition_1.Transition {\r\n constructor(target) {\r\n super(target);\r\n }\r\n get serializationType() {\r\n return 9 /* WILDCARD */;\r\n }\r\n matches(symbol, minVocabSymbol, maxVocabSymbol) {\r\n return symbol >= minVocabSymbol && symbol <= maxVocabSymbol;\r\n }\r\n toString() {\r\n return \".\";\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override\r\n], WildcardTransition.prototype, \"serializationType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], WildcardTransition.prototype, \"matches\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n Decorators_1.NotNull\r\n], WildcardTransition.prototype, \"toString\", null);\r\nWildcardTransition = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], WildcardTransition);\r\nexports.WildcardTransition = WildcardTransition;\r\n//# sourceMappingURL=WildcardTransition.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:27.8389930-07:00\r\nconst ATNState_1 = require(\"./ATNState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass BasicState extends ATNState_1.ATNState {\r\n get stateType() {\r\n return 1 /* BASIC */;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], BasicState.prototype, \"stateType\", null);\r\nexports.BasicState = BasicState;\r\n//# sourceMappingURL=BasicState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst BasicState_1 = require(\"./BasicState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass InvalidState extends BasicState_1.BasicState {\r\n get stateType() {\r\n return 0 /* INVALID_TYPE */;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], InvalidState.prototype, \"stateType\", null);\r\nexports.InvalidState = InvalidState;\r\n//# sourceMappingURL=InvalidState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nclass ConsoleErrorListener {\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>\r\n * This implementation prints messages to {@link System#err} containing the\r\n * values of {@code line}, {@code charPositionInLine}, and {@code msg} using\r\n * the following format.</p>\r\n *\r\n * <pre>\r\n * line <em>line</em>:<em>charPositionInLine</em> <em>msg</em>\r\n * </pre>\r\n */\r\n syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {\r\n console.error(`line ${line}:${charPositionInLine} ${msg}`);\r\n }\r\n}\r\n/**\r\n * Provides a default instance of {@link ConsoleErrorListener}.\r\n */\r\nConsoleErrorListener.INSTANCE = new ConsoleErrorListener();\r\nexports.ConsoleErrorListener = ConsoleErrorListener;\r\n//# sourceMappingURL=ConsoleErrorListener.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:38.5097925-07:00\r\nconst Stubs_1 = require(\"../misc/Stubs\");\r\nconst ATNSimulator_1 = require(\"../atn/ATNSimulator\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst PredictionContext_1 = require(\"../atn/PredictionContext\");\r\nconst Recognizer_1 = require(\"../Recognizer\");\r\nconst VocabularyImpl_1 = require(\"../VocabularyImpl\");\r\n/** A DFA walker that knows how to dump them to serialized strings. */\r\nclass DFASerializer {\r\n constructor(dfa, vocabulary, ruleNames, atn) {\r\n if (vocabulary instanceof Recognizer_1.Recognizer) {\r\n ruleNames = vocabulary.ruleNames;\r\n atn = vocabulary.atn;\r\n vocabulary = vocabulary.vocabulary;\r\n }\r\n else if (!vocabulary) {\r\n vocabulary = VocabularyImpl_1.VocabularyImpl.EMPTY_VOCABULARY;\r\n }\r\n this.dfa = dfa;\r\n this.vocabulary = vocabulary;\r\n this.ruleNames = ruleNames;\r\n this.atn = atn;\r\n }\r\n toString() {\r\n if (!this.dfa.s0) {\r\n return \"\";\r\n }\r\n let buf = \"\";\r\n if (this.dfa.states) {\r\n let states = new Array(...this.dfa.states.toArray());\r\n states.sort((o1, o2) => o1.stateNumber - o2.stateNumber);\r\n for (let s of states) {\r\n let edges = s.getEdgeMap();\r\n let edgeKeys = [...edges.keys()].sort((a, b) => a - b);\r\n let contextEdges = s.getContextEdgeMap();\r\n let contextEdgeKeys = [...contextEdges.keys()].sort((a, b) => a - b);\r\n for (let entry of edgeKeys) {\r\n let value = edges.get(entry);\r\n if ((value == null || value === ATNSimulator_1.ATNSimulator.ERROR) && !s.isContextSymbol(entry)) {\r\n continue;\r\n }\r\n let contextSymbol = false;\r\n buf += (this.getStateString(s)) + (\"-\") + (this.getEdgeLabel(entry)) + (\"->\");\r\n if (s.isContextSymbol(entry)) {\r\n buf += (\"!\");\r\n contextSymbol = true;\r\n }\r\n let t = value;\r\n if (t && t.stateNumber !== ATNSimulator_1.ATNSimulator.ERROR.stateNumber) {\r\n buf += (this.getStateString(t)) + ('\\n');\r\n }\r\n else if (contextSymbol) {\r\n buf += (\"ctx\\n\");\r\n }\r\n }\r\n if (s.isContextSensitive) {\r\n for (let entry of contextEdgeKeys) {\r\n buf += (this.getStateString(s))\r\n + (\"-\")\r\n + (this.getContextLabel(entry))\r\n + (\"->\")\r\n + (this.getStateString(contextEdges.get(entry)))\r\n + (\"\\n\");\r\n }\r\n }\r\n }\r\n }\r\n let output = buf;\r\n if (output.length === 0)\r\n return \"\";\r\n //return Utils.sortLinesInString(output);\r\n return output;\r\n }\r\n getContextLabel(i) {\r\n if (i === PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY) {\r\n return \"ctx:EMPTY_FULL\";\r\n }\r\n else if (i === PredictionContext_1.PredictionContext.EMPTY_LOCAL_STATE_KEY) {\r\n return \"ctx:EMPTY_LOCAL\";\r\n }\r\n if (this.atn && i > 0 && i <= this.atn.states.length) {\r\n let state = this.atn.states[i];\r\n let ruleIndex = state.ruleIndex;\r\n if (this.ruleNames && ruleIndex >= 0 && ruleIndex < this.ruleNames.length) {\r\n return \"ctx:\" + String(i) + \"(\" + this.ruleNames[ruleIndex] + \")\";\r\n }\r\n }\r\n return \"ctx:\" + String(i);\r\n }\r\n getEdgeLabel(i) {\r\n return this.vocabulary.getDisplayName(i);\r\n }\r\n getStateString(s) {\r\n if (s === ATNSimulator_1.ATNSimulator.ERROR) {\r\n return \"ERROR\";\r\n }\r\n let n = s.stateNumber;\r\n let stateStr = \"s\" + n;\r\n if (s.isAcceptState) {\r\n if (s.predicates) {\r\n stateStr = \":s\" + n + \"=>\" + s.predicates;\r\n }\r\n else {\r\n stateStr = \":s\" + n + \"=>\" + s.prediction;\r\n }\r\n }\r\n if (s.isContextSensitive) {\r\n stateStr += \"*\";\r\n for (let config of Stubs_1.asIterable(s.configs)) {\r\n if (config.reachesIntoOuterContext) {\r\n stateStr += \"*\";\r\n break;\r\n }\r\n }\r\n }\r\n return stateStr;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.NotNull\r\n], DFASerializer.prototype, \"dfa\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], DFASerializer.prototype, \"vocabulary\", void 0);\r\n__decorate([\r\n Decorators_1.Override\r\n], DFASerializer.prototype, \"toString\", null);\r\nexports.DFASerializer = DFASerializer;\r\n//# sourceMappingURL=DFASerializer.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\n/**\r\n * Stores information about a {@link DFAState} which is an accept state under\r\n * some condition. Certain settings, such as\r\n * {@link ParserATNSimulator#getPredictionMode()}, may be used in addition to\r\n * this information to determine whether or not a particular state is an accept\r\n * state.\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass AcceptStateInfo {\r\n constructor(prediction, lexerActionExecutor) {\r\n this._prediction = prediction;\r\n this._lexerActionExecutor = lexerActionExecutor;\r\n }\r\n /**\r\n * Gets the prediction made by this accept state. Note that this value\r\n * assumes the predicates, if any, in the {@link DFAState} evaluate to\r\n * {@code true}. If predicate evaluation is enabled, the final prediction of\r\n * the accept state will be determined by the result of predicate\r\n * evaluation.\r\n */\r\n get prediction() {\r\n return this._prediction;\r\n }\r\n /**\r\n * Gets the {@link LexerActionExecutor} which can be used to execute actions\r\n * and/or commands after the lexer matches a token.\r\n */\r\n get lexerActionExecutor() {\r\n return this._lexerActionExecutor;\r\n }\r\n}\r\nexports.AcceptStateInfo = AcceptStateInfo;\r\n//# sourceMappingURL=AcceptStateInfo.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\n// ConvertTo-TS run at 2016-10-04T11:26:40.6647101-07:00\r\nconst IntegerList_1 = require(\"./IntegerList\");\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass IntegerStack extends IntegerList_1.IntegerList {\r\n constructor(arg) {\r\n super(arg);\r\n }\r\n push(value) {\r\n this.add(value);\r\n }\r\n pop() {\r\n return this.removeAt(this.size - 1);\r\n }\r\n peek() {\r\n return this.get(this.size - 1);\r\n }\r\n}\r\nexports.IntegerStack = IntegerStack;\r\n//# sourceMappingURL=IntegerStack.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst MurmurHash_1 = require(\"./MurmurHash\");\r\nconst ObjectEqualityComparator_1 = require(\"./ObjectEqualityComparator\");\r\n/**\r\n * This default implementation of {@link EqualityComparator} uses object equality\r\n * for comparisons by calling {@link Object#hashCode} and {@link Object#equals}.\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass DefaultEqualityComparator {\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This implementation returns\r\n * {@code obj.}{@link Object#hashCode hashCode()}.</p>\r\n */\r\n hashCode(obj) {\r\n if (obj == null) {\r\n return 0;\r\n }\r\n else if (typeof obj === 'string' || typeof obj === 'number') {\r\n return MurmurHash_1.MurmurHash.hashCode([obj]);\r\n }\r\n else {\r\n return ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE.hashCode(obj);\r\n }\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This implementation relies on object equality. If both objects are\r\n * {@code null}, this method returns {@code true}. Otherwise if only\r\n * {@code a} is {@code null}, this method returns {@code false}. Otherwise,\r\n * this method returns the result of\r\n * {@code a.}{@link Object#equals equals}{@code (b)}.</p>\r\n */\r\n equals(a, b) {\r\n if (a == null) {\r\n return b == null;\r\n }\r\n else if (typeof a === 'string' || typeof a === 'number') {\r\n return a === b;\r\n }\r\n else {\r\n return ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE.equals(a, b);\r\n }\r\n }\r\n}\r\nDefaultEqualityComparator.INSTANCE = new DefaultEqualityComparator();\r\n__decorate([\r\n Decorators_1.Override\r\n], DefaultEqualityComparator.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], DefaultEqualityComparator.prototype, \"equals\", null);\r\nexports.DefaultEqualityComparator = DefaultEqualityComparator;\r\n//# sourceMappingURL=DefaultEqualityComparator.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:35.2826960-07:00\r\nconst AbstractPredicateTransition_1 = require(\"./AbstractPredicateTransition\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst SemanticContext_1 = require(\"./SemanticContext\");\r\n/** TODO: this is old comment:\r\n * A tree of semantic predicates from the grammar AST if label==SEMPRED.\r\n * In the ATN, labels will always be exactly one predicate, but the DFA\r\n * may have to combine a bunch of them as it collects predicates from\r\n * multiple ATN configurations into a single DFA state.\r\n */\r\nlet PredicateTransition = class PredicateTransition extends AbstractPredicateTransition_1.AbstractPredicateTransition {\r\n constructor(target, ruleIndex, predIndex, isCtxDependent) {\r\n super(target);\r\n this.ruleIndex = ruleIndex;\r\n this.predIndex = predIndex;\r\n this.isCtxDependent = isCtxDependent;\r\n }\r\n get serializationType() {\r\n return 4 /* PREDICATE */;\r\n }\r\n get isEpsilon() { return true; }\r\n matches(symbol, minVocabSymbol, maxVocabSymbol) {\r\n return false;\r\n }\r\n get predicate() {\r\n return new SemanticContext_1.SemanticContext.Predicate(this.ruleIndex, this.predIndex, this.isCtxDependent);\r\n }\r\n toString() {\r\n return \"pred_\" + this.ruleIndex + \":\" + this.predIndex;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override\r\n], PredicateTransition.prototype, \"serializationType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], PredicateTransition.prototype, \"isEpsilon\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], PredicateTransition.prototype, \"matches\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n Decorators_1.NotNull\r\n], PredicateTransition.prototype, \"toString\", null);\r\nPredicateTransition = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], PredicateTransition);\r\nexports.PredicateTransition = PredicateTransition;\r\n//# sourceMappingURL=PredicateTransition.js.map","export interface Api {\n endpoints: Endpoint[];\n typeDefs: TypeDef[];\n}\n\nexport interface Endpoint {\n name: EndpointName;\n method: Method;\n route: RouteSubpath[];\n headers?: TypeName;\n input: TypeName;\n output: TypeName;\n}\n\nexport type EndpointName = string;\n\nexport type Method = \"GET\" | \"POST\" | \"PUT\" | \"DELETE\";\n\nexport interface RouteSubpath {\n name: string;\n dynamic: boolean;\n}\n\nexport interface TypeDef {\n name: TypeName;\n type: Type;\n}\n\nexport type Type =\n | ArrayType\n | UnionType\n | StructType\n | OptionalType\n | SymbolType\n | TypeName;\n\nexport interface ArrayType {\n kind: \"array\";\n items: Type;\n}\n\nexport interface UnionType {\n kind: \"union\";\n items: Type[];\n}\n\nexport interface StructType {\n kind: \"struct\";\n items: {\n [name: string]: Type;\n };\n}\n\nexport interface OptionalType {\n kind: \"optional\";\n type: Type;\n}\n\nexport interface SymbolType {\n kind: \"symbol\";\n value: string;\n}\n\nexport type TypeName = string;\n\nexport type PrimitiveType =\n | \"bool\"\n | \"int\"\n | \"long\"\n | \"float\"\n | \"double\"\n | \"string\"\n | \"null\";\n\nexport const PRIMITIVE_TYPES = new Set([\n \"bool\",\n \"int\",\n \"long\",\n \"float\",\n \"double\",\n \"string\",\n \"null\",\n]);\n","module.exports = require(\"util\");","module.exports = require(\"fs\");","import { Api, Endpoint, PRIMITIVE_TYPES, Type } from \"./defs\";\n\nexport interface EndpointDefinitions {\n [name: string]: Endpoint;\n}\n\nexport interface TypeDefinitions {\n [name: string]: Type;\n}\n\nexport type ResolveResult =\n | {\n kind: \"success\";\n definedEndpoints: EndpointDefinitions;\n definedTypes: TypeDefinitions;\n }\n | {\n kind: \"failure\";\n errors: string[];\n };\n\nexport function resolve(api: Api): ResolveResult {\n const recordedErrors: string[] = [];\n const definedEndpoints: EndpointDefinitions = {};\n const definedTypes: TypeDefinitions = {};\n for (const typeDef of api.typeDefs) {\n let error = false;\n if (PRIMITIVE_TYPES.has(typeDef.name)) {\n recordedErrors.push(`Cannot redefine known type ${typeDef.name}.`);\n error = true;\n }\n if (typeDef.name in definedTypes) {\n recordedErrors.push(`Type ${typeDef.name} is defined multiple times.`);\n error = true;\n }\n if (!error) {\n definedTypes[typeDef.name] = typeDef.type;\n }\n }\n for (const [name, type] of Object.entries(definedTypes)) {\n checkType(name, type, recordedErrors);\n }\n for (const endpoint of api.endpoints) {\n let error = false;\n if (endpoint.name in definedEndpoints) {\n recordedErrors.push(`Cannot redefine endpoint ${endpoint.name}.`);\n error = true;\n }\n if (\n endpoint.headers &&\n !PRIMITIVE_TYPES.has(endpoint.headers) &&\n !(endpoint.headers in definedTypes)\n ) {\n recordedErrors.push(`No such type ${endpoint.headers}.`);\n error = true;\n }\n if (\n endpoint.input !== \"void\" &&\n !PRIMITIVE_TYPES.has(endpoint.input) &&\n !(endpoint.input in definedTypes)\n ) {\n recordedErrors.push(`No such type ${endpoint.input}.`);\n error = true;\n }\n if (\n endpoint.output !== \"void\" &&\n !PRIMITIVE_TYPES.has(endpoint.output) &&\n !(endpoint.output in definedTypes)\n ) {\n recordedErrors.push(`No such type ${endpoint.output}.`);\n error = true;\n }\n if (!error) {\n definedEndpoints[endpoint.name] = endpoint;\n }\n }\n if (recordedErrors.length === 0) {\n return {\n kind: \"success\",\n definedEndpoints,\n definedTypes,\n };\n } else {\n return {\n kind: \"failure\",\n errors: recordedErrors,\n };\n }\n\n function checkType(name: string, type: Type, errors: string[]) {\n if (typeof type === \"string\") {\n if (!PRIMITIVE_TYPES.has(type) && !(type in definedTypes)) {\n errors.push(`Type ${name} refers to unknown type ${type}.`);\n }\n } else if (type.kind === \"array\") {\n checkType(name, type.items, errors);\n } else if (type.kind === \"union\") {\n for (const possibleType of type.items) {\n checkType(name, possibleType, errors);\n }\n } else if (type.kind === \"struct\") {\n for (const [fieldName, fieldType] of Object.entries(type.items)) {\n checkType(`${name}.${fieldName}`, fieldType, errors);\n }\n } else if (type.kind === \"optional\") {\n checkType(name, type.type, errors);\n } else if (type.kind === \"symbol\") {\n // Always valid.\n } else {\n throw new Error();\n }\n }\n}\n","// Generated from src/grammar/ApiDef.g4 by ANTLR 4.6-SNAPSHOT\n\nimport { ATN } from \"antlr4ts/atn/ATN\";\nimport { ATNDeserializer } from \"antlr4ts/atn/ATNDeserializer\";\nimport { FailedPredicateException } from \"antlr4ts/FailedPredicateException\";\nimport { NotNull } from \"antlr4ts/Decorators\";\nimport { NoViableAltException } from \"antlr4ts/NoViableAltException\";\nimport { Override } from \"antlr4ts/Decorators\";\nimport { Parser } from \"antlr4ts/Parser\";\nimport { ParserRuleContext } from \"antlr4ts/ParserRuleContext\";\nimport { ParserATNSimulator } from \"antlr4ts/atn/ParserATNSimulator\";\nimport { RecognitionException } from \"antlr4ts/RecognitionException\";\nimport { RuleContext } from \"antlr4ts/RuleContext\";\nimport { TerminalNode } from \"antlr4ts/tree/TerminalNode\";\nimport { Token } from \"antlr4ts/Token\";\nimport { TokenStream } from \"antlr4ts/TokenStream\";\nimport { Vocabulary } from \"antlr4ts/Vocabulary\";\nimport { VocabularyImpl } from \"antlr4ts/VocabularyImpl\";\n\nimport * as Utils from \"antlr4ts/misc/Utils\";\n\nexport class ApiDefParser extends Parser {\n public static readonly T__0 = 1;\n public static readonly T__1 = 2;\n public static readonly T__2 = 3;\n public static readonly T__3 = 4;\n public static readonly T__4 = 5;\n public static readonly T__5 = 6;\n public static readonly T__6 = 7;\n public static readonly T__7 = 8;\n public static readonly T__8 = 9;\n public static readonly T__9 = 10;\n public static readonly T__10 = 11;\n public static readonly T__11 = 12;\n public static readonly T__12 = 13;\n public static readonly T__13 = 14;\n public static readonly T__14 = 15;\n public static readonly T__15 = 16;\n public static readonly T__16 = 17;\n public static readonly T__17 = 18;\n public static readonly T__18 = 19;\n public static readonly T__19 = 20;\n public static readonly NAME = 21;\n public static readonly LINEBREAK = 22;\n public static readonly WHITESPACE = 23;\n public static readonly BLOCK_COMMENT = 24;\n public static readonly LINE_COMMENT = 25;\n public static readonly RULE_api = 0;\n public static readonly RULE_endpoint = 1;\n public static readonly RULE_headers = 2;\n public static readonly RULE_endpointname = 3;\n public static readonly RULE_method = 4;\n public static readonly RULE_route = 5;\n public static readonly RULE_subpath = 6;\n public static readonly RULE_typedef = 7;\n public static readonly RULE_type = 8;\n public static readonly RULE_array = 9;\n public static readonly RULE_struct = 10;\n public static readonly RULE_structfield = 11;\n public static readonly RULE_fieldname = 12;\n public static readonly RULE_typename = 13;\n public static readonly RULE_symbol = 14;\n public static readonly RULE_name = 15;\n public static readonly RULE_separator = 16;\n public static readonly ruleNames: string[] = [\n \"api\",\n \"endpoint\",\n \"headers\",\n \"endpointname\",\n \"method\",\n \"route\",\n \"subpath\",\n \"typedef\",\n \"type\",\n \"array\",\n \"struct\",\n \"structfield\",\n \"fieldname\",\n \"typename\",\n \"symbol\",\n \"name\",\n \"separator\",\n ];\n\n private static readonly _LITERAL_NAMES: (string | undefined)[] = [\n undefined,\n \"'endpoint'\",\n \"':'\",\n \"'->'\",\n \"'@headers'\",\n \"'('\",\n \"')'\",\n \"'GET'\",\n \"'POST'\",\n \"'PUT'\",\n \"'DELETE'\",\n \"'/'\",\n \"'type'\",\n \"'='\",\n \"'|'\",\n \"'[]'\",\n \"'{'\",\n \"'}'\",\n \"'?'\",\n \"'@'\",\n \"';'\",\n ];\n private static readonly _SYMBOLIC_NAMES: (string | undefined)[] = [\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n \"NAME\",\n \"LINEBREAK\",\n \"WHITESPACE\",\n \"BLOCK_COMMENT\",\n \"LINE_COMMENT\",\n ];\n public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(\n ApiDefParser._LITERAL_NAMES,\n ApiDefParser._SYMBOLIC_NAMES,\n [],\n );\n\n @Override\n @NotNull\n public get vocabulary(): Vocabulary {\n return ApiDefParser.VOCABULARY;\n }\n\n @Override\n public get grammarFileName(): string {\n return \"ApiDef.g4\";\n }\n\n @Override\n public get ruleNames(): string[] {\n return ApiDefParser.ruleNames;\n }\n\n @Override\n public get serializedATN(): string {\n return ApiDefParser._serializedATN;\n }\n\n constructor(input: TokenStream) {\n super(input);\n this._interp = new ParserATNSimulator(ApiDefParser._ATN, this);\n }\n\n public api(): ApiContext {\n let _localctx: ApiContext = new ApiContext(this._ctx, this.state);\n this.enterRule(_localctx, 0, ApiDefParser.RULE_api);\n let _la: number;\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 37;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 34;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 39;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 44;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (\n (_la & ~0x1f) === 0 &&\n ((1 << _la) &\n ((1 << ApiDefParser.T__0) |\n (1 << ApiDefParser.T__3) |\n (1 << ApiDefParser.T__11))) !==\n 0\n ) {\n {\n this.state = 42;\n this._errHandler.sync(this);\n switch (this._input.LA(1)) {\n case ApiDefParser.T__0:\n case ApiDefParser.T__3:\n {\n this.state = 40;\n this.endpoint();\n }\n break;\n case ApiDefParser.T__11:\n {\n this.state = 41;\n this.typedef();\n }\n break;\n default:\n throw new NoViableAltException(this);\n }\n }\n this.state = 46;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 47;\n this.match(ApiDefParser.EOF);\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public endpoint(): EndpointContext {\n let _localctx: EndpointContext = new EndpointContext(this._ctx, this.state);\n this.enterRule(_localctx, 2, ApiDefParser.RULE_endpoint);\n let _la: number;\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 50;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n if (_la === ApiDefParser.T__3) {\n {\n this.state = 49;\n this.headers();\n }\n }\n\n this.state = 52;\n this.match(ApiDefParser.T__0);\n this.state = 56;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 53;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 58;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 59;\n this.endpointname();\n this.state = 63;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 60;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 65;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 66;\n this.match(ApiDefParser.T__1);\n this.state = 70;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 67;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 72;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 73;\n this.method();\n this.state = 77;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 74;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 79;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 80;\n this.route();\n this.state = 84;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 81;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 86;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 87;\n this.typename();\n this.state = 91;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 88;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 93;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 94;\n this.match(ApiDefParser.T__2);\n this.state = 98;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 95;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 100;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 101;\n this.typename();\n this.state = 102;\n this.separator();\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public headers(): HeadersContext {\n let _localctx: HeadersContext = new HeadersContext(this._ctx, this.state);\n this.enterRule(_localctx, 4, ApiDefParser.RULE_headers);\n let _la: number;\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 104;\n this.match(ApiDefParser.T__3);\n this.state = 105;\n this.match(ApiDefParser.T__4);\n this.state = 106;\n this.typename();\n this.state = 107;\n this.match(ApiDefParser.T__5);\n this.state = 111;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 108;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 113;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public endpointname(): EndpointnameContext {\n let _localctx: EndpointnameContext = new EndpointnameContext(\n this._ctx,\n this.state,\n );\n this.enterRule(_localctx, 6, ApiDefParser.RULE_endpointname);\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 114;\n this.name();\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public method(): MethodContext {\n let _localctx: MethodContext = new MethodContext(this._ctx, this.state);\n this.enterRule(_localctx, 8, ApiDefParser.RULE_method);\n let _la: number;\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 116;\n _la = this._input.LA(1);\n if (\n !(\n (_la & ~0x1f) === 0 &&\n ((1 << _la) &\n ((1 << ApiDefParser.T__6) |\n (1 << ApiDefParser.T__7) |\n (1 << ApiDefParser.T__8) |\n (1 << ApiDefParser.T__9))) !==\n 0\n )\n ) {\n this._errHandler.recoverInline(this);\n } else {\n if (this._input.LA(1) === Token.EOF) {\n this.matchedEOF = true;\n }\n\n this._errHandler.reportMatch(this);\n this.consume();\n }\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public route(): RouteContext {\n let _localctx: RouteContext = new RouteContext(this._ctx, this.state);\n this.enterRule(_localctx, 10, ApiDefParser.RULE_route);\n let _la: number;\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 120;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n do {\n {\n {\n this.state = 118;\n this.match(ApiDefParser.T__10);\n this.state = 119;\n this.subpath();\n }\n }\n this.state = 122;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n } while (_la === ApiDefParser.T__10);\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public subpath(): SubpathContext {\n let _localctx: SubpathContext = new SubpathContext(this._ctx, this.state);\n this.enterRule(_localctx, 12, ApiDefParser.RULE_subpath);\n let _la: number;\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 125;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n if (_la === ApiDefParser.T__1) {\n {\n this.state = 124;\n _localctx._dynamic = this.match(ApiDefParser.T__1);\n }\n }\n\n this.state = 127;\n this.name();\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public typedef(): TypedefContext {\n let _localctx: TypedefContext = new TypedefContext(this._ctx, this.state);\n this.enterRule(_localctx, 14, ApiDefParser.RULE_typedef);\n let _la: number;\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 129;\n this.match(ApiDefParser.T__11);\n this.state = 130;\n this.typename();\n this.state = 134;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 131;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 136;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 137;\n this.match(ApiDefParser.T__12);\n this.state = 141;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 138;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 143;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 144;\n this.type(0);\n this.state = 145;\n this.separator();\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public type(): TypeContext;\n public type(_p: number): TypeContext;\n\n public type(_p?: number): TypeContext {\n if (_p === undefined) {\n _p = 0;\n }\n\n let _parentctx: ParserRuleContext = this._ctx;\n let _parentState: number = this.state;\n let _localctx: TypeContext = new TypeContext(this._ctx, _parentState);\n let _startState: number = 16;\n this.enterRecursionRule(_localctx, 16, ApiDefParser.RULE_type, _p);\n let _la: number;\n try {\n let _alt: number;\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 176;\n this._errHandler.sync(this);\n switch (this.interpreter.adaptivePredict(this._input, 20, this._ctx)) {\n case 1:\n {\n this.state = 148;\n this.array();\n this.state = 152;\n this._errHandler.sync(this);\n _alt = this.interpreter.adaptivePredict(\n this._input,\n 16,\n this._ctx,\n );\n while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {\n if (_alt === 1) {\n {\n {\n this.state = 149;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n }\n this.state = 154;\n this._errHandler.sync(this);\n _alt = this.interpreter.adaptivePredict(\n this._input,\n 16,\n this._ctx,\n );\n }\n }\n break;\n\n case 2:\n {\n this.state = 155;\n this.struct();\n this.state = 159;\n this._errHandler.sync(this);\n _alt = this.interpreter.adaptivePredict(\n this._input,\n 17,\n this._ctx,\n );\n while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {\n if (_alt === 1) {\n {\n {\n this.state = 156;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n }\n this.state = 161;\n this._errHandler.sync(this);\n _alt = this.interpreter.adaptivePredict(\n this._input,\n 17,\n this._ctx,\n );\n }\n }\n break;\n\n case 3:\n {\n this.state = 162;\n this.symbol();\n this.state = 166;\n this._errHandler.sync(this);\n _alt = this.interpreter.adaptivePredict(\n this._input,\n 18,\n this._ctx,\n );\n while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {\n if (_alt === 1) {\n {\n {\n this.state = 163;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n }\n this.state = 168;\n this._errHandler.sync(this);\n _alt = this.interpreter.adaptivePredict(\n this._input,\n 18,\n this._ctx,\n );\n }\n }\n break;\n\n case 4:\n {\n this.state = 169;\n this.typename();\n this.state = 173;\n this._errHandler.sync(this);\n _alt = this.interpreter.adaptivePredict(\n this._input,\n 19,\n this._ctx,\n );\n while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {\n if (_alt === 1) {\n {\n {\n this.state = 170;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n }\n this.state = 175;\n this._errHandler.sync(this);\n _alt = this.interpreter.adaptivePredict(\n this._input,\n 19,\n this._ctx,\n );\n }\n }\n break;\n }\n this._ctx._stop = this._input.tryLT(-1);\n this.state = 189;\n this._errHandler.sync(this);\n _alt = this.interpreter.adaptivePredict(this._input, 22, this._ctx);\n while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {\n if (_alt === 1) {\n if (this._parseListeners != null) this.triggerExitRuleEvent();\n {\n {\n _localctx = new TypeContext(_parentctx, _parentState);\n this.pushNewRecursionContext(\n _localctx,\n _startState,\n ApiDefParser.RULE_type,\n );\n this.state = 178;\n if (!this.precpred(this._ctx, 4))\n throw new FailedPredicateException(\n this,\n \"this.precpred(this._ctx, 4)\",\n );\n this.state = 179;\n this.match(ApiDefParser.T__13);\n this.state = 183;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 180;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 185;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 186;\n this.type(5);\n }\n }\n }\n this.state = 191;\n this._errHandler.sync(this);\n _alt = this.interpreter.adaptivePredict(this._input, 22, this._ctx);\n }\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.unrollRecursionContexts(_parentctx);\n }\n return _localctx;\n }\n\n public array(): ArrayContext {\n let _localctx: ArrayContext = new ArrayContext(this._ctx, this.state);\n this.enterRule(_localctx, 18, ApiDefParser.RULE_array);\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 192;\n this.typename();\n this.state = 193;\n this.match(ApiDefParser.T__14);\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public struct(): StructContext {\n let _localctx: StructContext = new StructContext(this._ctx, this.state);\n this.enterRule(_localctx, 20, ApiDefParser.RULE_struct);\n let _la: number;\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 195;\n this.match(ApiDefParser.T__15);\n this.state = 199;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 196;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 201;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 207;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (\n (_la & ~0x1f) === 0 &&\n ((1 << _la) &\n ((1 << ApiDefParser.T__0) |\n (1 << ApiDefParser.T__11) |\n (1 << ApiDefParser.NAME))) !==\n 0\n ) {\n {\n {\n this.state = 202;\n this.structfield();\n this.state = 203;\n this.separator();\n }\n }\n this.state = 209;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 210;\n this.match(ApiDefParser.T__16);\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public structfield(): StructfieldContext {\n let _localctx: StructfieldContext = new StructfieldContext(\n this._ctx,\n this.state,\n );\n this.enterRule(_localctx, 22, ApiDefParser.RULE_structfield);\n let _la: number;\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 212;\n this.fieldname();\n this.state = 214;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n if (_la === ApiDefParser.T__17) {\n {\n this.state = 213;\n _localctx._optional = this.match(ApiDefParser.T__17);\n }\n }\n\n this.state = 216;\n this.match(ApiDefParser.T__1);\n this.state = 217;\n this.type(0);\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public fieldname(): FieldnameContext {\n let _localctx: FieldnameContext = new FieldnameContext(\n this._ctx,\n this.state,\n );\n this.enterRule(_localctx, 24, ApiDefParser.RULE_fieldname);\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 219;\n this.name();\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public typename(): TypenameContext {\n let _localctx: TypenameContext = new TypenameContext(this._ctx, this.state);\n this.enterRule(_localctx, 26, ApiDefParser.RULE_typename);\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 221;\n this.name();\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public symbol(): SymbolContext {\n let _localctx: SymbolContext = new SymbolContext(this._ctx, this.state);\n this.enterRule(_localctx, 28, ApiDefParser.RULE_symbol);\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 223;\n this.match(ApiDefParser.T__18);\n this.state = 224;\n this.name();\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public name(): NameContext {\n let _localctx: NameContext = new NameContext(this._ctx, this.state);\n this.enterRule(_localctx, 30, ApiDefParser.RULE_name);\n let _la: number;\n try {\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 226;\n _la = this._input.LA(1);\n if (\n !(\n (_la & ~0x1f) === 0 &&\n ((1 << _la) &\n ((1 << ApiDefParser.T__0) |\n (1 << ApiDefParser.T__11) |\n (1 << ApiDefParser.NAME))) !==\n 0\n )\n ) {\n this._errHandler.recoverInline(this);\n } else {\n if (this._input.LA(1) === Token.EOF) {\n this.matchedEOF = true;\n }\n\n this._errHandler.reportMatch(this);\n this.consume();\n }\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public separator(): SeparatorContext {\n let _localctx: SeparatorContext = new SeparatorContext(\n this._ctx,\n this.state,\n );\n this.enterRule(_localctx, 32, ApiDefParser.RULE_separator);\n let _la: number;\n try {\n this.state = 246;\n this._errHandler.sync(this);\n switch (this.interpreter.adaptivePredict(this._input, 29, this._ctx)) {\n case 1:\n this.enterOuterAlt(_localctx, 1);\n {\n this.state = 231;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 228;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 233;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n this.state = 234;\n this.match(ApiDefParser.T__19);\n this.state = 238;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n while (_la === ApiDefParser.LINEBREAK) {\n {\n {\n this.state = 235;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 240;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n }\n }\n break;\n\n case 2:\n this.enterOuterAlt(_localctx, 2);\n {\n this.state = 242;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n do {\n {\n {\n this.state = 241;\n this.match(ApiDefParser.LINEBREAK);\n }\n }\n this.state = 244;\n this._errHandler.sync(this);\n _la = this._input.LA(1);\n } while (_la === ApiDefParser.LINEBREAK);\n }\n break;\n }\n } catch (re) {\n if (re instanceof RecognitionException) {\n _localctx.exception = re;\n this._errHandler.reportError(this, re);\n this._errHandler.recover(this, re);\n } else {\n throw re;\n }\n } finally {\n this.exitRule();\n }\n return _localctx;\n }\n\n public sempred(\n _localctx: RuleContext,\n ruleIndex: number,\n predIndex: number,\n ): boolean {\n switch (ruleIndex) {\n case 8:\n return this.type_sempred(_localctx as TypeContext, predIndex);\n }\n return true;\n }\n private type_sempred(_localctx: TypeContext, predIndex: number): boolean {\n switch (predIndex) {\n case 0:\n return this.precpred(this._ctx, 4);\n }\n return true;\n }\n\n public static readonly _serializedATN: string = \"\\x03\\uAF6F\\u8320\\u479D\\uB75C\\u4880\\u1605\\u191C\\uAB37\\x03\\x1B\\xFB\\x04\\x02\" +\n \"\\t\\x02\\x04\\x03\\t\\x03\\x04\\x04\\t\\x04\\x04\\x05\\t\\x05\\x04\\x06\\t\\x06\\x04\\x07\" +\n \"\\t\\x07\\x04\\b\\t\\b\\x04\\t\\t\\t\\x04\\n\\t\\n\\x04\\v\\t\\v\\x04\\f\\t\\f\\x04\\r\\t\\r\\x04\" +\n \"\\x0E\\t\\x0E\\x04\\x0F\\t\\x0F\\x04\\x10\\t\\x10\\x04\\x11\\t\\x11\\x04\\x12\\t\\x12\\x03\" +\n \"\\x02\\x07\\x02&\\n\\x02\\f\\x02\\x0E\\x02)\\v\\x02\\x03\\x02\\x03\\x02\\x07\\x02-\\n\\x02\" +\n \"\\f\\x02\\x0E\\x020\\v\\x02\\x03\\x02\\x03\\x02\\x03\\x03\\x05\\x035\\n\\x03\\x03\\x03\\x03\" +\n \"\\x03\\x07\\x039\\n\\x03\\f\\x03\\x0E\\x03<\\v\\x03\\x03\\x03\\x03\\x03\\x07\\x03@\\n\\x03\" +\n \"\\f\\x03\\x0E\\x03C\\v\\x03\\x03\\x03\\x03\\x03\\x07\\x03G\\n\\x03\\f\\x03\\x0E\\x03J\\v\" +\n \"\\x03\\x03\\x03\\x03\\x03\\x07\\x03N\\n\\x03\\f\\x03\\x0E\\x03Q\\v\\x03\\x03\\x03\\x03\\x03\" +\n \"\\x07\\x03U\\n\\x03\\f\\x03\\x0E\\x03X\\v\\x03\\x03\\x03\\x03\\x03\\x07\\x03\\\\\\n\\x03\\f\" +\n \"\\x03\\x0E\\x03_\\v\\x03\\x03\\x03\\x03\\x03\\x07\\x03c\\n\\x03\\f\\x03\\x0E\\x03f\\v\\x03\" +\n \"\\x03\\x03\\x03\\x03\\x03\\x03\\x03\\x04\\x03\\x04\\x03\\x04\\x03\\x04\\x03\\x04\\x07\\x04\" +\n \"p\\n\\x04\\f\\x04\\x0E\\x04s\\v\\x04\\x03\\x05\\x03\\x05\\x03\\x06\\x03\\x06\\x03\\x07\\x03\" +\n \"\\x07\\x06\\x07{\\n\\x07\\r\\x07\\x0E\\x07|\\x03\\b\\x05\\b\\x80\\n\\b\\x03\\b\\x03\\b\\x03\" +\n \"\\t\\x03\\t\\x03\\t\\x07\\t\\x87\\n\\t\\f\\t\\x0E\\t\\x8A\\v\\t\\x03\\t\\x03\\t\\x07\\t\\x8E\\n\" +\n \"\\t\\f\\t\\x0E\\t\\x91\\v\\t\\x03\\t\\x03\\t\\x03\\t\\x03\\n\\x03\\n\\x03\\n\\x07\\n\\x99\\n\\n\" +\n \"\\f\\n\\x0E\\n\\x9C\\v\\n\\x03\\n\\x03\\n\\x07\\n\\xA0\\n\\n\\f\\n\\x0E\\n\\xA3\\v\\n\\x03\\n\\x03\" +\n \"\\n\\x07\\n\\xA7\\n\\n\\f\\n\\x0E\\n\\xAA\\v\\n\\x03\\n\\x03\\n\\x07\\n\\xAE\\n\\n\\f\\n\\x0E\\n\" +\n \"\\xB1\\v\\n\\x05\\n\\xB3\\n\\n\\x03\\n\\x03\\n\\x03\\n\\x07\\n\\xB8\\n\\n\\f\\n\\x0E\\n\\xBB\\v\" +\n \"\\n\\x03\\n\\x07\\n\\xBE\\n\\n\\f\\n\\x0E\\n\\xC1\\v\\n\\x03\\v\\x03\\v\\x03\\v\\x03\\f\\x03\\f\" +\n \"\\x07\\f\\xC8\\n\\f\\f\\f\\x0E\\f\\xCB\\v\\f\\x03\\f\\x03\\f\\x03\\f\\x07\\f\\xD0\\n\\f\\f\\f\\x0E\" +\n \"\\f\\xD3\\v\\f\\x03\\f\\x03\\f\\x03\\r\\x03\\r\\x05\\r\\xD9\\n\\r\\x03\\r\\x03\\r\\x03\\r\\x03\" +\n \"\\x0E\\x03\\x0E\\x03\\x0F\\x03\\x0F\\x03\\x10\\x03\\x10\\x03\\x10\\x03\\x11\\x03\\x11\\x03\" +\n \"\\x12\\x07\\x12\\xE8\\n\\x12\\f\\x12\\x0E\\x12\\xEB\\v\\x12\\x03\\x12\\x03\\x12\\x07\\x12\" +\n \"\\xEF\\n\\x12\\f\\x12\\x0E\\x12\\xF2\\v\\x12\\x03\\x12\\x06\\x12\\xF5\\n\\x12\\r\\x12\\x0E\" +\n \"\\x12\\xF6\\x05\\x12\\xF9\\n\\x12\\x03\\x12\\x02\\x02\\x03\\x12\\x13\\x02\\x02\\x04\\x02\" +\n \"\\x06\\x02\\b\\x02\\n\\x02\\f\\x02\\x0E\\x02\\x10\\x02\\x12\\x02\\x14\\x02\\x16\\x02\\x18\" +\n '\\x02\\x1A\\x02\\x1C\\x02\\x1E\\x02 \\x02\"\\x02\\x02\\x04\\x03\\x02\\t\\f\\x05\\x02\\x03' +\n \"\\x03\\x0E\\x0E\\x17\\x17\\u0109\\x02'\\x03\\x02\\x02\\x02\\x044\\x03\\x02\\x02\\x02\" +\n \"\\x06j\\x03\\x02\\x02\\x02\\bt\\x03\\x02\\x02\\x02\\nv\\x03\\x02\\x02\\x02\\fz\\x03\\x02\" +\n \"\\x02\\x02\\x0E\\x7F\\x03\\x02\\x02\\x02\\x10\\x83\\x03\\x02\\x02\\x02\\x12\\xB2\\x03\\x02\" +\n \"\\x02\\x02\\x14\\xC2\\x03\\x02\\x02\\x02\\x16\\xC5\\x03\\x02\\x02\\x02\\x18\\xD6\\x03\\x02\" +\n \"\\x02\\x02\\x1A\\xDD\\x03\\x02\\x02\\x02\\x1C\\xDF\\x03\\x02\\x02\\x02\\x1E\\xE1\\x03\\x02\" +\n '\\x02\\x02 \\xE4\\x03\\x02\\x02\\x02\"\\xF8\\x03\\x02\\x02\\x02$&\\x07\\x18\\x02\\x02' +\n \"%$\\x03\\x02\\x02\\x02&)\\x03\\x02\\x02\\x02'%\\x03\\x02\\x02\\x02'(\\x03\\x02\\x02\" +\n \"\\x02(.\\x03\\x02\\x02\\x02)'\\x03\\x02\\x02\\x02*-\\x05\\x04\\x03\\x02+-\\x05\\x10\" +\n \"\\t\\x02,*\\x03\\x02\\x02\\x02,+\\x03\\x02\\x02\\x02-0\\x03\\x02\\x02\\x02.,\\x03\\x02\" +\n \"\\x02\\x02./\\x03\\x02\\x02\\x02/1\\x03\\x02\\x02\\x020.\\x03\\x02\\x02\\x0212\\x07\\x02\" +\n \"\\x02\\x032\\x03\\x03\\x02\\x02\\x0235\\x05\\x06\\x04\\x0243\\x03\\x02\\x02\\x0245\\x03\" +\n \"\\x02\\x02\\x0256\\x03\\x02\\x02\\x026:\\x07\\x03\\x02\\x0279\\x07\\x18\\x02\\x0287\\x03\" +\n \"\\x02\\x02\\x029<\\x03\\x02\\x02\\x02:8\\x03\\x02\\x02\\x02:;\\x03\\x02\\x02\\x02;=\\x03\" +\n \"\\x02\\x02\\x02<:\\x03\\x02\\x02\\x02=A\\x05\\b\\x05\\x02>@\\x07\\x18\\x02\\x02?>\\x03\" +\n \"\\x02\\x02\\x02@C\\x03\\x02\\x02\\x02A?\\x03\\x02\\x02\\x02AB\\x03\\x02\\x02\\x02BD\\x03\" +\n \"\\x02\\x02\\x02CA\\x03\\x02\\x02\\x02DH\\x07\\x04\\x02\\x02EG\\x07\\x18\\x02\\x02FE\\x03\" +\n \"\\x02\\x02\\x02GJ\\x03\\x02\\x02\\x02HF\\x03\\x02\\x02\\x02HI\\x03\\x02\\x02\\x02IK\\x03\" +\n \"\\x02\\x02\\x02JH\\x03\\x02\\x02\\x02KO\\x05\\n\\x06\\x02LN\\x07\\x18\\x02\\x02ML\\x03\" +\n \"\\x02\\x02\\x02NQ\\x03\\x02\\x02\\x02OM\\x03\\x02\\x02\\x02OP\\x03\\x02\\x02\\x02PR\\x03\" +\n \"\\x02\\x02\\x02QO\\x03\\x02\\x02\\x02RV\\x05\\f\\x07\\x02SU\\x07\\x18\\x02\\x02TS\\x03\" +\n \"\\x02\\x02\\x02UX\\x03\\x02\\x02\\x02VT\\x03\\x02\\x02\\x02VW\\x03\\x02\\x02\\x02WY\\x03\" +\n \"\\x02\\x02\\x02XV\\x03\\x02\\x02\\x02Y]\\x05\\x1C\\x0F\\x02Z\\\\\\x07\\x18\\x02\\x02[Z\" +\n \"\\x03\\x02\\x02\\x02\\\\_\\x03\\x02\\x02\\x02][\\x03\\x02\\x02\\x02]^\\x03\\x02\\x02\\x02\" +\n \"^`\\x03\\x02\\x02\\x02_]\\x03\\x02\\x02\\x02`d\\x07\\x05\\x02\\x02ac\\x07\\x18\\x02\\x02\" +\n \"ba\\x03\\x02\\x02\\x02cf\\x03\\x02\\x02\\x02db\\x03\\x02\\x02\\x02de\\x03\\x02\\x02\\x02\" +\n 'eg\\x03\\x02\\x02\\x02fd\\x03\\x02\\x02\\x02gh\\x05\\x1C\\x0F\\x02hi\\x05\"\\x12\\x02' +\n \"i\\x05\\x03\\x02\\x02\\x02jk\\x07\\x06\\x02\\x02kl\\x07\\x07\\x02\\x02lm\\x05\\x1C\\x0F\" +\n \"\\x02mq\\x07\\b\\x02\\x02np\\x07\\x18\\x02\\x02on\\x03\\x02\\x02\\x02ps\\x03\\x02\\x02\" +\n \"\\x02qo\\x03\\x02\\x02\\x02qr\\x03\\x02\\x02\\x02r\\x07\\x03\\x02\\x02\\x02sq\\x03\\x02\" +\n \"\\x02\\x02tu\\x05 \\x11\\x02u\\t\\x03\\x02\\x02\\x02vw\\t\\x02\\x02\\x02w\\v\\x03\\x02\" +\n \"\\x02\\x02xy\\x07\\r\\x02\\x02y{\\x05\\x0E\\b\\x02zx\\x03\\x02\\x02\\x02{|\\x03\\x02\\x02\" +\n \"\\x02|z\\x03\\x02\\x02\\x02|}\\x03\\x02\\x02\\x02}\\r\\x03\\x02\\x02\\x02~\\x80\\x07\\x04\" +\n \"\\x02\\x02\\x7F~\\x03\\x02\\x02\\x02\\x7F\\x80\\x03\\x02\\x02\\x02\\x80\\x81\\x03\\x02\" +\n \"\\x02\\x02\\x81\\x82\\x05 \\x11\\x02\\x82\\x0F\\x03\\x02\\x02\\x02\\x83\\x84\\x07\\x0E\" +\n \"\\x02\\x02\\x84\\x88\\x05\\x1C\\x0F\\x02\\x85\\x87\\x07\\x18\\x02\\x02\\x86\\x85\\x03\\x02\" +\n \"\\x02\\x02\\x87\\x8A\\x03\\x02\\x02\\x02\\x88\\x86\\x03\\x02\\x02\\x02\\x88\\x89\\x03\\x02\" +\n \"\\x02\\x02\\x89\\x8B\\x03\\x02\\x02\\x02\\x8A\\x88\\x03\\x02\\x02\\x02\\x8B\\x8F\\x07\\x0F\" +\n \"\\x02\\x02\\x8C\\x8E\\x07\\x18\\x02\\x02\\x8D\\x8C\\x03\\x02\\x02\\x02\\x8E\\x91\\x03\\x02\" +\n \"\\x02\\x02\\x8F\\x8D\\x03\\x02\\x02\\x02\\x8F\\x90\\x03\\x02\\x02\\x02\\x90\\x92\\x03\\x02\" +\n '\\x02\\x02\\x91\\x8F\\x03\\x02\\x02\\x02\\x92\\x93\\x05\\x12\\n\\x02\\x93\\x94\\x05\"\\x12' +\n \"\\x02\\x94\\x11\\x03\\x02\\x02\\x02\\x95\\x96\\b\\n\\x01\\x02\\x96\\x9A\\x05\\x14\\v\\x02\" +\n \"\\x97\\x99\\x07\\x18\\x02\\x02\\x98\\x97\\x03\\x02\\x02\\x02\\x99\\x9C\\x03\\x02\\x02\\x02\" +\n \"\\x9A\\x98\\x03\\x02\\x02\\x02\\x9A\\x9B\\x03\\x02\\x02\\x02\\x9B\\xB3\\x03\\x02\\x02\\x02\" +\n \"\\x9C\\x9A\\x03\\x02\\x02\\x02\\x9D\\xA1\\x05\\x16\\f\\x02\\x9E\\xA0\\x07\\x18\\x02\\x02\" +\n \"\\x9F\\x9E\\x03\\x02\\x02\\x02\\xA0\\xA3\\x03\\x02\\x02\\x02\\xA1\\x9F\\x03\\x02\\x02\\x02\" +\n \"\\xA1\\xA2\\x03\\x02\\x02\\x02\\xA2\\xB3\\x03\\x02\\x02\\x02\\xA3\\xA1\\x03\\x02\\x02\\x02\" +\n \"\\xA4\\xA8\\x05\\x1E\\x10\\x02\\xA5\\xA7\\x07\\x18\\x02\\x02\\xA6\\xA5\\x03\\x02\\x02\\x02\" +\n \"\\xA7\\xAA\\x03\\x02\\x02\\x02\\xA8\\xA6\\x03\\x02\\x02\\x02\\xA8\\xA9\\x03\\x02\\x02\\x02\" +\n \"\\xA9\\xB3\\x03\\x02\\x02\\x02\\xAA\\xA8\\x03\\x02\\x02\\x02\\xAB\\xAF\\x05\\x1C\\x0F\\x02\" +\n \"\\xAC\\xAE\\x07\\x18\\x02\\x02\\xAD\\xAC\\x03\\x02\\x02\\x02\\xAE\\xB1\\x03\\x02\\x02\\x02\" +\n \"\\xAF\\xAD\\x03\\x02\\x02\\x02\\xAF\\xB0\\x03\\x02\\x02\\x02\\xB0\\xB3\\x03\\x02\\x02\\x02\" +\n \"\\xB1\\xAF\\x03\\x02\\x02\\x02\\xB2\\x95\\x03\\x02\\x02\\x02\\xB2\\x9D\\x03\\x02\\x02\\x02\" +\n \"\\xB2\\xA4\\x03\\x02\\x02\\x02\\xB2\\xAB\\x03\\x02\\x02\\x02\\xB3\\xBF\\x03\\x02\\x02\\x02\" +\n \"\\xB4\\xB5\\f\\x06\\x02\\x02\\xB5\\xB9\\x07\\x10\\x02\\x02\\xB6\\xB8\\x07\\x18\\x02\\x02\" +\n \"\\xB7\\xB6\\x03\\x02\\x02\\x02\\xB8\\xBB\\x03\\x02\\x02\\x02\\xB9\\xB7\\x03\\x02\\x02\\x02\" +\n \"\\xB9\\xBA\\x03\\x02\\x02\\x02\\xBA\\xBC\\x03\\x02\\x02\\x02\\xBB\\xB9\\x03\\x02\\x02\\x02\" +\n \"\\xBC\\xBE\\x05\\x12\\n\\x07\\xBD\\xB4\\x03\\x02\\x02\\x02\\xBE\\xC1\\x03\\x02\\x02\\x02\" +\n \"\\xBF\\xBD\\x03\\x02\\x02\\x02\\xBF\\xC0\\x03\\x02\\x02\\x02\\xC0\\x13\\x03\\x02\\x02\\x02\" +\n \"\\xC1\\xBF\\x03\\x02\\x02\\x02\\xC2\\xC3\\x05\\x1C\\x0F\\x02\\xC3\\xC4\\x07\\x11\\x02\\x02\" +\n \"\\xC4\\x15\\x03\\x02\\x02\\x02\\xC5\\xC9\\x07\\x12\\x02\\x02\\xC6\\xC8\\x07\\x18\\x02\\x02\" +\n \"\\xC7\\xC6\\x03\\x02\\x02\\x02\\xC8\\xCB\\x03\\x02\\x02\\x02\\xC9\\xC7\\x03\\x02\\x02\\x02\" +\n \"\\xC9\\xCA\\x03\\x02\\x02\\x02\\xCA\\xD1\\x03\\x02\\x02\\x02\\xCB\\xC9\\x03\\x02\\x02\\x02\" +\n '\\xCC\\xCD\\x05\\x18\\r\\x02\\xCD\\xCE\\x05\"\\x12\\x02\\xCE\\xD0\\x03\\x02\\x02\\x02\\xCF' +\n \"\\xCC\\x03\\x02\\x02\\x02\\xD0\\xD3\\x03\\x02\\x02\\x02\\xD1\\xCF\\x03\\x02\\x02\\x02\\xD1\" +\n \"\\xD2\\x03\\x02\\x02\\x02\\xD2\\xD4\\x03\\x02\\x02\\x02\\xD3\\xD1\\x03\\x02\\x02\\x02\\xD4\" +\n \"\\xD5\\x07\\x13\\x02\\x02\\xD5\\x17\\x03\\x02\\x02\\x02\\xD6\\xD8\\x05\\x1A\\x0E\\x02\\xD7\" +\n \"\\xD9\\x07\\x14\\x02\\x02\\xD8\\xD7\\x03\\x02\\x02\\x02\\xD8\\xD9\\x03\\x02\\x02\\x02\\xD9\" +\n \"\\xDA\\x03\\x02\\x02\\x02\\xDA\\xDB\\x07\\x04\\x02\\x02\\xDB\\xDC\\x05\\x12\\n\\x02\\xDC\" +\n \"\\x19\\x03\\x02\\x02\\x02\\xDD\\xDE\\x05 \\x11\\x02\\xDE\\x1B\\x03\\x02\\x02\\x02\\xDF\" +\n \"\\xE0\\x05 \\x11\\x02\\xE0\\x1D\\x03\\x02\\x02\\x02\\xE1\\xE2\\x07\\x15\\x02\\x02\\xE2\" +\n \"\\xE3\\x05 \\x11\\x02\\xE3\\x1F\\x03\\x02\\x02\\x02\\xE4\\xE5\\t\\x03\\x02\\x02\\xE5!\\x03\" +\n \"\\x02\\x02\\x02\\xE6\\xE8\\x07\\x18\\x02\\x02\\xE7\\xE6\\x03\\x02\\x02\\x02\\xE8\\xEB\\x03\" +\n \"\\x02\\x02\\x02\\xE9\\xE7\\x03\\x02\\x02\\x02\\xE9\\xEA\\x03\\x02\\x02\\x02\\xEA\\xEC\\x03\" +\n \"\\x02\\x02\\x02\\xEB\\xE9\\x03\\x02\\x02\\x02\\xEC\\xF0\\x07\\x16\\x02\\x02\\xED\\xEF\\x07\" +\n \"\\x18\\x02\\x02\\xEE\\xED\\x03\\x02\\x02\\x02\\xEF\\xF2\\x03\\x02\\x02\\x02\\xF0\\xEE\\x03\" +\n \"\\x02\\x02\\x02\\xF0\\xF1\\x03\\x02\\x02\\x02\\xF1\\xF9\\x03\\x02\\x02\\x02\\xF2\\xF0\\x03\" +\n \"\\x02\\x02\\x02\\xF3\\xF5\\x07\\x18\\x02\\x02\\xF4\\xF3\\x03\\x02\\x02\\x02\\xF5\\xF6\\x03\" +\n \"\\x02\\x02\\x02\\xF6\\xF4\\x03\\x02\\x02\\x02\\xF6\\xF7\\x03\\x02\\x02\\x02\\xF7\\xF9\\x03\" +\n \"\\x02\\x02\\x02\\xF8\\xE9\\x03\\x02\\x02\\x02\\xF8\\xF4\\x03\\x02\\x02\\x02\\xF9#\\x03\" +\n \"\\x02\\x02\\x02 ',.4:AHOV]dq|\\x7F\\x88\\x8F\\x9A\\xA1\\xA8\\xAF\\xB2\\xB9\\xBF\\xC9\" +\n \"\\xD1\\xD8\\xE9\\xF0\\xF6\\xF8\";\n public static __ATN: ATN;\n public static get _ATN(): ATN {\n if (!ApiDefParser.__ATN) {\n ApiDefParser.__ATN = new ATNDeserializer().deserialize(\n Utils.toCharArray(ApiDefParser._serializedATN),\n );\n }\n\n return ApiDefParser.__ATN;\n }\n}\n\nexport class ApiContext extends ParserRuleContext {\n public EOF(): TerminalNode {\n return this.getToken(ApiDefParser.EOF, 0);\n }\n public LINEBREAK(): TerminalNode[];\n public LINEBREAK(i: number): TerminalNode;\n public LINEBREAK(i?: number): TerminalNode | TerminalNode[] {\n if (i === undefined) {\n return this.getTokens(ApiDefParser.LINEBREAK);\n } else {\n return this.getToken(ApiDefParser.LINEBREAK, i);\n }\n }\n public endpoint(): EndpointContext[];\n public endpoint(i: number): EndpointContext;\n public endpoint(i?: number): EndpointContext | EndpointContext[] {\n if (i === undefined) {\n return this.getRuleContexts(EndpointContext);\n } else {\n return this.getRuleContext(i, EndpointContext);\n }\n }\n public typedef(): TypedefContext[];\n public typedef(i: number): TypedefContext;\n public typedef(i?: number): TypedefContext | TypedefContext[] {\n if (i === undefined) {\n return this.getRuleContexts(TypedefContext);\n } else {\n return this.getRuleContext(i, TypedefContext);\n }\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_api;\n }\n}\n\nexport class EndpointContext extends ParserRuleContext {\n public endpointname(): EndpointnameContext {\n return this.getRuleContext(0, EndpointnameContext);\n }\n public method(): MethodContext {\n return this.getRuleContext(0, MethodContext);\n }\n public route(): RouteContext {\n return this.getRuleContext(0, RouteContext);\n }\n public typename(): TypenameContext[];\n public typename(i: number): TypenameContext;\n public typename(i?: number): TypenameContext | TypenameContext[] {\n if (i === undefined) {\n return this.getRuleContexts(TypenameContext);\n } else {\n return this.getRuleContext(i, TypenameContext);\n }\n }\n public separator(): SeparatorContext {\n return this.getRuleContext(0, SeparatorContext);\n }\n public headers(): HeadersContext | undefined {\n return this.tryGetRuleContext(0, HeadersContext);\n }\n public LINEBREAK(): TerminalNode[];\n public LINEBREAK(i: number): TerminalNode;\n public LINEBREAK(i?: number): TerminalNode | TerminalNode[] {\n if (i === undefined) {\n return this.getTokens(ApiDefParser.LINEBREAK);\n } else {\n return this.getToken(ApiDefParser.LINEBREAK, i);\n }\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_endpoint;\n }\n}\n\nexport class HeadersContext extends ParserRuleContext {\n public typename(): TypenameContext {\n return this.getRuleContext(0, TypenameContext);\n }\n public LINEBREAK(): TerminalNode[];\n public LINEBREAK(i: number): TerminalNode;\n public LINEBREAK(i?: number): TerminalNode | TerminalNode[] {\n if (i === undefined) {\n return this.getTokens(ApiDefParser.LINEBREAK);\n } else {\n return this.getToken(ApiDefParser.LINEBREAK, i);\n }\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_headers;\n }\n}\n\nexport class EndpointnameContext extends ParserRuleContext {\n public name(): NameContext {\n return this.getRuleContext(0, NameContext);\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_endpointname;\n }\n}\n\nexport class MethodContext extends ParserRuleContext {\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_method;\n }\n}\n\nexport class RouteContext extends ParserRuleContext {\n public subpath(): SubpathContext[];\n public subpath(i: number): SubpathContext;\n public subpath(i?: number): SubpathContext | SubpathContext[] {\n if (i === undefined) {\n return this.getRuleContexts(SubpathContext);\n } else {\n return this.getRuleContext(i, SubpathContext);\n }\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_route;\n }\n}\n\nexport class SubpathContext extends ParserRuleContext {\n public _dynamic!: Token;\n public name(): NameContext {\n return this.getRuleContext(0, NameContext);\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_subpath;\n }\n}\n\nexport class TypedefContext extends ParserRuleContext {\n public typename(): TypenameContext {\n return this.getRuleContext(0, TypenameContext);\n }\n public type(): TypeContext {\n return this.getRuleContext(0, TypeContext);\n }\n public separator(): SeparatorContext {\n return this.getRuleContext(0, SeparatorContext);\n }\n public LINEBREAK(): TerminalNode[];\n public LINEBREAK(i: number): TerminalNode;\n public LINEBREAK(i?: number): TerminalNode | TerminalNode[] {\n if (i === undefined) {\n return this.getTokens(ApiDefParser.LINEBREAK);\n } else {\n return this.getToken(ApiDefParser.LINEBREAK, i);\n }\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_typedef;\n }\n}\n\nexport class TypeContext extends ParserRuleContext {\n public array(): ArrayContext | undefined {\n return this.tryGetRuleContext(0, ArrayContext);\n }\n public LINEBREAK(): TerminalNode[];\n public LINEBREAK(i: number): TerminalNode;\n public LINEBREAK(i?: number): TerminalNode | TerminalNode[] {\n if (i === undefined) {\n return this.getTokens(ApiDefParser.LINEBREAK);\n } else {\n return this.getToken(ApiDefParser.LINEBREAK, i);\n }\n }\n public type(): TypeContext[];\n public type(i: number): TypeContext;\n public type(i?: number): TypeContext | TypeContext[] {\n if (i === undefined) {\n return this.getRuleContexts(TypeContext);\n } else {\n return this.getRuleContext(i, TypeContext);\n }\n }\n public struct(): StructContext | undefined {\n return this.tryGetRuleContext(0, StructContext);\n }\n public symbol(): SymbolContext | undefined {\n return this.tryGetRuleContext(0, SymbolContext);\n }\n public typename(): TypenameContext | undefined {\n return this.tryGetRuleContext(0, TypenameContext);\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_type;\n }\n}\n\nexport class ArrayContext extends ParserRuleContext {\n public typename(): TypenameContext {\n return this.getRuleContext(0, TypenameContext);\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_array;\n }\n}\n\nexport class StructContext extends ParserRuleContext {\n public LINEBREAK(): TerminalNode[];\n public LINEBREAK(i: number): TerminalNode;\n public LINEBREAK(i?: number): TerminalNode | TerminalNode[] {\n if (i === undefined) {\n return this.getTokens(ApiDefParser.LINEBREAK);\n } else {\n return this.getToken(ApiDefParser.LINEBREAK, i);\n }\n }\n public structfield(): StructfieldContext[];\n public structfield(i: number): StructfieldContext;\n public structfield(i?: number): StructfieldContext | StructfieldContext[] {\n if (i === undefined) {\n return this.getRuleContexts(StructfieldContext);\n } else {\n return this.getRuleContext(i, StructfieldContext);\n }\n }\n public separator(): SeparatorContext[];\n public separator(i: number): SeparatorContext;\n public separator(i?: number): SeparatorContext | SeparatorContext[] {\n if (i === undefined) {\n return this.getRuleContexts(SeparatorContext);\n } else {\n return this.getRuleContext(i, SeparatorContext);\n }\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_struct;\n }\n}\n\nexport class StructfieldContext extends ParserRuleContext {\n public _optional!: Token;\n public fieldname(): FieldnameContext {\n return this.getRuleContext(0, FieldnameContext);\n }\n public type(): TypeContext {\n return this.getRuleContext(0, TypeContext);\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_structfield;\n }\n}\n\nexport class FieldnameContext extends ParserRuleContext {\n public name(): NameContext {\n return this.getRuleContext(0, NameContext);\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_fieldname;\n }\n}\n\nexport class TypenameContext extends ParserRuleContext {\n public name(): NameContext {\n return this.getRuleContext(0, NameContext);\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_typename;\n }\n}\n\nexport class SymbolContext extends ParserRuleContext {\n public name(): NameContext {\n return this.getRuleContext(0, NameContext);\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_symbol;\n }\n}\n\nexport class NameContext extends ParserRuleContext {\n public NAME(): TerminalNode {\n return this.getToken(ApiDefParser.NAME, 0);\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_name;\n }\n}\n\nexport class SeparatorContext extends ParserRuleContext {\n public LINEBREAK(): TerminalNode[];\n public LINEBREAK(i: number): TerminalNode;\n public LINEBREAK(i?: number): TerminalNode | TerminalNode[] {\n if (i === undefined) {\n return this.getTokens(ApiDefParser.LINEBREAK);\n } else {\n return this.getToken(ApiDefParser.LINEBREAK, i);\n }\n }\n constructor(parent: ParserRuleContext, invokingState: number);\n constructor(parent: ParserRuleContext, invokingState: number) {\n super(parent, invokingState);\n }\n @Override\n public get ruleIndex(): number {\n return ApiDefParser.RULE_separator;\n }\n}\n","// Generated from src/grammar/ApiDef.g4 by ANTLR 4.6-SNAPSHOT\n\nimport { ATN } from \"antlr4ts/atn/ATN\";\nimport { ATNDeserializer } from \"antlr4ts/atn/ATNDeserializer\";\nimport { CharStream } from \"antlr4ts/CharStream\";\nimport { Lexer } from \"antlr4ts/Lexer\";\nimport { LexerATNSimulator } from \"antlr4ts/atn/LexerATNSimulator\";\nimport { NotNull } from \"antlr4ts/Decorators\";\nimport { Override } from \"antlr4ts/Decorators\";\nimport { Vocabulary } from \"antlr4ts/Vocabulary\";\nimport { VocabularyImpl } from \"antlr4ts/VocabularyImpl\";\n\nimport * as Utils from \"antlr4ts/misc/Utils\";\n\nexport class ApiDefLexer extends Lexer {\n public static readonly T__0 = 1;\n public static readonly T__1 = 2;\n public static readonly T__2 = 3;\n public static readonly T__3 = 4;\n public static readonly T__4 = 5;\n public static readonly T__5 = 6;\n public static readonly T__6 = 7;\n public static readonly T__7 = 8;\n public static readonly T__8 = 9;\n public static readonly T__9 = 10;\n public static readonly T__10 = 11;\n public static readonly T__11 = 12;\n public static readonly T__12 = 13;\n public static readonly T__13 = 14;\n public static readonly T__14 = 15;\n public static readonly T__15 = 16;\n public static readonly T__16 = 17;\n public static readonly T__17 = 18;\n public static readonly T__18 = 19;\n public static readonly T__19 = 20;\n public static readonly NAME = 21;\n public static readonly LINEBREAK = 22;\n public static readonly WHITESPACE = 23;\n public static readonly BLOCK_COMMENT = 24;\n public static readonly LINE_COMMENT = 25;\n public static readonly modeNames: string[] = [\"DEFAULT_MODE\"];\n\n public static readonly ruleNames: string[] = [\n \"T__0\",\n \"T__1\",\n \"T__2\",\n \"T__3\",\n \"T__4\",\n \"T__5\",\n \"T__6\",\n \"T__7\",\n \"T__8\",\n \"T__9\",\n \"T__10\",\n \"T__11\",\n \"T__12\",\n \"T__13\",\n \"T__14\",\n \"T__15\",\n \"T__16\",\n \"T__17\",\n \"T__18\",\n \"T__19\",\n \"NAME\",\n \"LINEBREAK\",\n \"WHITESPACE\",\n \"BLOCK_COMMENT\",\n \"LINE_COMMENT\",\n ];\n\n private static readonly _LITERAL_NAMES: (string | undefined)[] = [\n undefined,\n \"'endpoint'\",\n \"':'\",\n \"'->'\",\n \"'@headers'\",\n \"'('\",\n \"')'\",\n \"'GET'\",\n \"'POST'\",\n \"'PUT'\",\n \"'DELETE'\",\n \"'/'\",\n \"'type'\",\n \"'='\",\n \"'|'\",\n \"'[]'\",\n \"'{'\",\n \"'}'\",\n \"'?'\",\n \"'@'\",\n \"';'\",\n ];\n private static readonly _SYMBOLIC_NAMES: (string | undefined)[] = [\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n undefined,\n \"NAME\",\n \"LINEBREAK\",\n \"WHITESPACE\",\n \"BLOCK_COMMENT\",\n \"LINE_COMMENT\",\n ];\n public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(\n ApiDefLexer._LITERAL_NAMES,\n ApiDefLexer._SYMBOLIC_NAMES,\n [],\n );\n\n @Override\n @NotNull\n public get vocabulary(): Vocabulary {\n return ApiDefLexer.VOCABULARY;\n }\n\n constructor(input: CharStream) {\n super(input);\n this._interp = new LexerATNSimulator(ApiDefLexer._ATN, this);\n }\n\n @Override\n public get grammarFileName(): string {\n return \"ApiDef.g4\";\n }\n\n @Override\n public get ruleNames(): string[] {\n return ApiDefLexer.ruleNames;\n }\n\n @Override\n public get serializedATN(): string {\n return ApiDefLexer._serializedATN;\n }\n\n @Override\n public get modeNames(): string[] {\n return ApiDefLexer.modeNames;\n }\n\n public static readonly _serializedATN: string = \"\\x03\\uAF6F\\u8320\\u479D\\uB75C\\u4880\\u1605\\u191C\\uAB37\\x02\\x1B\\xA5\\b\\x01\" +\n \"\\x04\\x02\\t\\x02\\x04\\x03\\t\\x03\\x04\\x04\\t\\x04\\x04\\x05\\t\\x05\\x04\\x06\\t\\x06\" +\n \"\\x04\\x07\\t\\x07\\x04\\b\\t\\b\\x04\\t\\t\\t\\x04\\n\\t\\n\\x04\\v\\t\\v\\x04\\f\\t\\f\\x04\\r\" +\n \"\\t\\r\\x04\\x0E\\t\\x0E\\x04\\x0F\\t\\x0F\\x04\\x10\\t\\x10\\x04\\x11\\t\\x11\\x04\\x12\\t\" +\n \"\\x12\\x04\\x13\\t\\x13\\x04\\x14\\t\\x14\\x04\\x15\\t\\x15\\x04\\x16\\t\\x16\\x04\\x17\\t\" +\n \"\\x17\\x04\\x18\\t\\x18\\x04\\x19\\t\\x19\\x04\\x1A\\t\\x1A\\x03\\x02\\x03\\x02\\x03\\x02\" +\n \"\\x03\\x02\\x03\\x02\\x03\\x02\\x03\\x02\\x03\\x02\\x03\\x02\\x03\\x03\\x03\\x03\\x03\\x04\" +\n \"\\x03\\x04\\x03\\x04\\x03\\x05\\x03\\x05\\x03\\x05\\x03\\x05\\x03\\x05\\x03\\x05\\x03\\x05\" +\n \"\\x03\\x05\\x03\\x05\\x03\\x06\\x03\\x06\\x03\\x07\\x03\\x07\\x03\\b\\x03\\b\\x03\\b\\x03\" +\n \"\\b\\x03\\t\\x03\\t\\x03\\t\\x03\\t\\x03\\t\\x03\\n\\x03\\n\\x03\\n\\x03\\n\\x03\\v\\x03\\v\\x03\" +\n \"\\v\\x03\\v\\x03\\v\\x03\\v\\x03\\v\\x03\\f\\x03\\f\\x03\\r\\x03\\r\\x03\\r\\x03\\r\\x03\\r\\x03\" +\n \"\\x0E\\x03\\x0E\\x03\\x0F\\x03\\x0F\\x03\\x10\\x03\\x10\\x03\\x10\\x03\\x11\\x03\\x11\\x03\" +\n \"\\x12\\x03\\x12\\x03\\x13\\x03\\x13\\x03\\x14\\x03\\x14\\x03\\x15\\x03\\x15\\x03\\x16\\x03\" +\n \"\\x16\\x07\\x16\\x7F\\n\\x16\\f\\x16\\x0E\\x16\\x82\\v\\x16\\x03\\x17\\x03\\x17\\x03\\x18\" +\n \"\\x06\\x18\\x87\\n\\x18\\r\\x18\\x0E\\x18\\x88\\x03\\x18\\x03\\x18\\x03\\x19\\x03\\x19\\x03\" +\n \"\\x19\\x03\\x19\\x07\\x19\\x91\\n\\x19\\f\\x19\\x0E\\x19\\x94\\v\\x19\\x03\\x19\\x03\\x19\" +\n \"\\x03\\x19\\x03\\x19\\x03\\x19\\x03\\x1A\\x03\\x1A\\x03\\x1A\\x03\\x1A\\x07\\x1A\\x9F\\n\" +\n \"\\x1A\\f\\x1A\\x0E\\x1A\\xA2\\v\\x1A\\x03\\x1A\\x03\\x1A\\x03\\x92\\x02\\x02\\x1B\\x03\\x02\" +\n \"\\x03\\x05\\x02\\x04\\x07\\x02\\x05\\t\\x02\\x06\\v\\x02\\x07\\r\\x02\\b\\x0F\\x02\\t\\x11\" +\n \"\\x02\\n\\x13\\x02\\v\\x15\\x02\\f\\x17\\x02\\r\\x19\\x02\\x0E\\x1B\\x02\\x0F\\x1D\\x02\\x10\" +\n \"\\x1F\\x02\\x11!\\x02\\x12#\\x02\\x13%\\x02\\x14'\\x02\\x15)\\x02\\x16+\\x02\\x17-\\x02\" +\n \"\\x18/\\x02\\x191\\x02\\x1A3\\x02\\x1B\\x03\\x02\\x06\\x04\\x02C\\\\c|\\x05\\x022;C\\\\\" +\n 'c|\\x04\\x02\\f\\f\\x0F\\x0F\\x05\\x02\\v\\v\\x0E\\x0E\"\"\\xA8\\x02\\x03\\x03\\x02\\x02' +\n \"\\x02\\x02\\x05\\x03\\x02\\x02\\x02\\x02\\x07\\x03\\x02\\x02\\x02\\x02\\t\\x03\\x02\\x02\" +\n \"\\x02\\x02\\v\\x03\\x02\\x02\\x02\\x02\\r\\x03\\x02\\x02\\x02\\x02\\x0F\\x03\\x02\\x02\\x02\" +\n \"\\x02\\x11\\x03\\x02\\x02\\x02\\x02\\x13\\x03\\x02\\x02\\x02\\x02\\x15\\x03\\x02\\x02\\x02\" +\n \"\\x02\\x17\\x03\\x02\\x02\\x02\\x02\\x19\\x03\\x02\\x02\\x02\\x02\\x1B\\x03\\x02\\x02\\x02\" +\n \"\\x02\\x1D\\x03\\x02\\x02\\x02\\x02\\x1F\\x03\\x02\\x02\\x02\\x02!\\x03\\x02\\x02\\x02\" +\n \"\\x02#\\x03\\x02\\x02\\x02\\x02%\\x03\\x02\\x02\\x02\\x02'\\x03\\x02\\x02\\x02\\x02)\" +\n \"\\x03\\x02\\x02\\x02\\x02+\\x03\\x02\\x02\\x02\\x02-\\x03\\x02\\x02\\x02\\x02/\\x03\\x02\" +\n \"\\x02\\x02\\x021\\x03\\x02\\x02\\x02\\x023\\x03\\x02\\x02\\x02\\x035\\x03\\x02\\x02\\x02\" +\n \"\\x05>\\x03\\x02\\x02\\x02\\x07@\\x03\\x02\\x02\\x02\\tC\\x03\\x02\\x02\\x02\\vL\\x03\\x02\" +\n \"\\x02\\x02\\rN\\x03\\x02\\x02\\x02\\x0FP\\x03\\x02\\x02\\x02\\x11T\\x03\\x02\\x02\\x02\" +\n \"\\x13Y\\x03\\x02\\x02\\x02\\x15]\\x03\\x02\\x02\\x02\\x17d\\x03\\x02\\x02\\x02\\x19f\\x03\" +\n \"\\x02\\x02\\x02\\x1Bk\\x03\\x02\\x02\\x02\\x1Dm\\x03\\x02\\x02\\x02\\x1Fo\\x03\\x02\\x02\" +\n \"\\x02!r\\x03\\x02\\x02\\x02#t\\x03\\x02\\x02\\x02%v\\x03\\x02\\x02\\x02'x\\x03\\x02\" +\n \"\\x02\\x02)z\\x03\\x02\\x02\\x02+|\\x03\\x02\\x02\\x02-\\x83\\x03\\x02\\x02\\x02/\\x86\" +\n \"\\x03\\x02\\x02\\x021\\x8C\\x03\\x02\\x02\\x023\\x9A\\x03\\x02\\x02\\x0256\\x07g\\x02\" +\n \"\\x0267\\x07p\\x02\\x0278\\x07f\\x02\\x0289\\x07r\\x02\\x029:\\x07q\\x02\\x02:;\\x07\" +\n \"k\\x02\\x02;<\\x07p\\x02\\x02<=\\x07v\\x02\\x02=\\x04\\x03\\x02\\x02\\x02>?\\x07<\\x02\" +\n \"\\x02?\\x06\\x03\\x02\\x02\\x02@A\\x07/\\x02\\x02AB\\x07@\\x02\\x02B\\b\\x03\\x02\\x02\" +\n \"\\x02CD\\x07B\\x02\\x02DE\\x07j\\x02\\x02EF\\x07g\\x02\\x02FG\\x07c\\x02\\x02GH\\x07\" +\n \"f\\x02\\x02HI\\x07g\\x02\\x02IJ\\x07t\\x02\\x02JK\\x07u\\x02\\x02K\\n\\x03\\x02\\x02\" +\n \"\\x02LM\\x07*\\x02\\x02M\\f\\x03\\x02\\x02\\x02NO\\x07+\\x02\\x02O\\x0E\\x03\\x02\\x02\" +\n \"\\x02PQ\\x07I\\x02\\x02QR\\x07G\\x02\\x02RS\\x07V\\x02\\x02S\\x10\\x03\\x02\\x02\\x02\" +\n \"TU\\x07R\\x02\\x02UV\\x07Q\\x02\\x02VW\\x07U\\x02\\x02WX\\x07V\\x02\\x02X\\x12\\x03\" +\n \"\\x02\\x02\\x02YZ\\x07R\\x02\\x02Z[\\x07W\\x02\\x02[\\\\\\x07V\\x02\\x02\\\\\\x14\\x03\\x02\" +\n \"\\x02\\x02]^\\x07F\\x02\\x02^_\\x07G\\x02\\x02_`\\x07N\\x02\\x02`a\\x07G\\x02\\x02a\" +\n \"b\\x07V\\x02\\x02bc\\x07G\\x02\\x02c\\x16\\x03\\x02\\x02\\x02de\\x071\\x02\\x02e\\x18\" +\n \"\\x03\\x02\\x02\\x02fg\\x07v\\x02\\x02gh\\x07{\\x02\\x02hi\\x07r\\x02\\x02ij\\x07g\\x02\" +\n \"\\x02j\\x1A\\x03\\x02\\x02\\x02kl\\x07?\\x02\\x02l\\x1C\\x03\\x02\\x02\\x02mn\\x07~\\x02\" +\n \"\\x02n\\x1E\\x03\\x02\\x02\\x02op\\x07]\\x02\\x02pq\\x07_\\x02\\x02q \\x03\\x02\\x02\" +\n '\\x02rs\\x07}\\x02\\x02s\"\\x03\\x02\\x02\\x02tu\\x07\\x7F\\x02\\x02u$\\x03\\x02\\x02' +\n \"\\x02vw\\x07A\\x02\\x02w&\\x03\\x02\\x02\\x02xy\\x07B\\x02\\x02y(\\x03\\x02\\x02\\x02\" +\n \"z{\\x07=\\x02\\x02{*\\x03\\x02\\x02\\x02|\\x80\\t\\x02\\x02\\x02}\\x7F\\t\\x03\\x02\\x02\" +\n \"~}\\x03\\x02\\x02\\x02\\x7F\\x82\\x03\\x02\\x02\\x02\\x80~\\x03\\x02\\x02\\x02\\x80\\x81\" +\n \"\\x03\\x02\\x02\\x02\\x81,\\x03\\x02\\x02\\x02\\x82\\x80\\x03\\x02\\x02\\x02\\x83\\x84\" +\n \"\\t\\x04\\x02\\x02\\x84.\\x03\\x02\\x02\\x02\\x85\\x87\\t\\x05\\x02\\x02\\x86\\x85\\x03\" +\n \"\\x02\\x02\\x02\\x87\\x88\\x03\\x02\\x02\\x02\\x88\\x86\\x03\\x02\\x02\\x02\\x88\\x89\\x03\" +\n \"\\x02\\x02\\x02\\x89\\x8A\\x03\\x02\\x02\\x02\\x8A\\x8B\\b\\x18\\x02\\x02\\x8B0\\x03\\x02\" +\n \"\\x02\\x02\\x8C\\x8D\\x071\\x02\\x02\\x8D\\x8E\\x07,\\x02\\x02\\x8E\\x92\\x03\\x02\\x02\" +\n \"\\x02\\x8F\\x91\\v\\x02\\x02\\x02\\x90\\x8F\\x03\\x02\\x02\\x02\\x91\\x94\\x03\\x02\\x02\" +\n \"\\x02\\x92\\x93\\x03\\x02\\x02\\x02\\x92\\x90\\x03\\x02\\x02\\x02\\x93\\x95\\x03\\x02\\x02\" +\n \"\\x02\\x94\\x92\\x03\\x02\\x02\\x02\\x95\\x96\\x07,\\x02\\x02\\x96\\x97\\x071\\x02\\x02\" +\n \"\\x97\\x98\\x03\\x02\\x02\\x02\\x98\\x99\\b\\x19\\x03\\x02\\x992\\x03\\x02\\x02\\x02\\x9A\" +\n \"\\x9B\\x071\\x02\\x02\\x9B\\x9C\\x071\\x02\\x02\\x9C\\xA0\\x03\\x02\\x02\\x02\\x9D\\x9F\" +\n \"\\n\\x04\\x02\\x02\\x9E\\x9D\\x03\\x02\\x02\\x02\\x9F\\xA2\\x03\\x02\\x02\\x02\\xA0\\x9E\" +\n \"\\x03\\x02\\x02\\x02\\xA0\\xA1\\x03\\x02\\x02\\x02\\xA1\\xA3\\x03\\x02\\x02\\x02\\xA2\\xA0\" +\n \"\\x03\\x02\\x02\\x02\\xA3\\xA4\\b\\x1A\\x03\\x02\\xA44\\x03\\x02\\x02\\x02\\x07\\x02\\x80\" +\n \"\\x88\\x92\\xA0\\x04\\b\\x02\\x02\\x02\\x03\\x02\";\n public static __ATN: ATN;\n public static get _ATN(): ATN {\n if (!ApiDefLexer.__ATN) {\n ApiDefLexer.__ATN = new ATNDeserializer().deserialize(\n Utils.toCharArray(ApiDefLexer._serializedATN),\n );\n }\n\n return ApiDefLexer.__ATN;\n }\n}\n","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nfunction RuleVersion(version) {\r\n return function (target, propertyKey, propertyDescriptor) {\r\n };\r\n}\r\nexports.RuleVersion = RuleVersion;\r\n//# sourceMappingURL=RuleVersion.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\n/**\r\n * Declares a dependency upon a grammar rule, along with a set of zero or more dependent rules.\r\n *\r\n * Version numbers within a grammar should be assigned on a monotonically increasing basis to allow for accurate\r\n * tracking of dependent rules.\r\n *\r\n * @author Sam Harwell\r\n */\r\nfunction RuleDependency(dependency) {\r\n return function (target, propertyKey, propertyDescriptor) {\r\n };\r\n}\r\nexports.RuleDependency = RuleDependency;\r\n//# sourceMappingURL=RuleDependency.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:57.4741196-07:00\r\nconst ATN_1 = require(\"./atn/ATN\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst ParserRuleContext_1 = require(\"./ParserRuleContext\");\r\n/** A handy class for use with\r\n *\r\n * options {contextSuperClass=org.antlr.v4.runtime.RuleContextWithAltNum;}\r\n *\r\n * that provides a backing field / impl for the outer alternative number\r\n * matched for an internal parse tree node.\r\n *\r\n * I'm only putting into Java runtime as I'm certain I'm the only one that\r\n * will really every use this.\r\n */\r\nclass RuleContextWithAltNum extends ParserRuleContext_1.ParserRuleContext {\r\n constructor(parent, invokingStateNumber) {\r\n if (invokingStateNumber !== undefined) {\r\n super(parent, invokingStateNumber);\r\n }\r\n else {\r\n super();\r\n }\r\n this._altNumber = ATN_1.ATN.INVALID_ALT_NUMBER;\r\n }\r\n get altNumber() {\r\n return this._altNumber;\r\n }\r\n // @Override\r\n set altNumber(altNum) {\r\n this._altNumber = altNum;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleContextWithAltNum.prototype, \"altNumber\", null);\r\nexports.RuleContextWithAltNum = RuleContextWithAltNum;\r\n//# sourceMappingURL=RuleContextWithAltNum.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst ATNState_1 = require(\"./atn/ATNState\");\r\nconst BitSet_1 = require(\"./misc/BitSet\");\r\nconst FailedPredicateException_1 = require(\"./FailedPredicateException\");\r\nconst InputMismatchException_1 = require(\"./InputMismatchException\");\r\nconst InterpreterRuleContext_1 = require(\"./InterpreterRuleContext\");\r\nconst LoopEndState_1 = require(\"./atn/LoopEndState\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst Decorators_2 = require(\"./Decorators\");\r\nconst Parser_1 = require(\"./Parser\");\r\nconst ParserATNSimulator_1 = require(\"./atn/ParserATNSimulator\");\r\nconst RecognitionException_1 = require(\"./RecognitionException\");\r\nconst StarLoopEntryState_1 = require(\"./atn/StarLoopEntryState\");\r\nconst Token_1 = require(\"./Token\");\r\n/** A parser simulator that mimics what ANTLR's generated\r\n * parser code does. A ParserATNSimulator is used to make\r\n * predictions via adaptivePredict but this class moves a pointer through the\r\n * ATN to simulate parsing. ParserATNSimulator just\r\n * makes us efficient rather than having to backtrack, for example.\r\n *\r\n * This properly creates parse trees even for left recursive rules.\r\n *\r\n * We rely on the left recursive rule invocation and special predicate\r\n * transitions to make left recursive rules work.\r\n *\r\n * See TestParserInterpreter for examples.\r\n */\r\nlet ParserInterpreter = class ParserInterpreter extends Parser_1.Parser {\r\n constructor(grammarFileName, vocabulary, ruleNames, atn, input) {\r\n super(grammarFileName instanceof ParserInterpreter ? grammarFileName.inputStream : input);\r\n /** This stack corresponds to the _parentctx, _parentState pair of locals\r\n * that would exist on call stack frames with a recursive descent parser;\r\n * in the generated function for a left-recursive rule you'd see:\r\n *\r\n * private EContext e(int _p) {\r\n * ParserRuleContext _parentctx = _ctx; // Pair.a\r\n * int _parentState = state; // Pair.b\r\n * ...\r\n * }\r\n *\r\n * Those values are used to create new recursive rule invocation contexts\r\n * associated with left operand of an alt like \"expr '*' expr\".\r\n */\r\n this._parentContextStack = [];\r\n /** We need a map from (decision,inputIndex)->forced alt for computing ambiguous\r\n * parse trees. For now, we allow exactly one override.\r\n */\r\n this.overrideDecision = -1;\r\n this.overrideDecisionInputIndex = -1;\r\n this.overrideDecisionAlt = -1;\r\n this.overrideDecisionReached = false; // latch and only override once; error might trigger infinite loop\r\n /** What is the current context when we override a decisions? This tells\r\n * us what the root of the parse tree is when using override\r\n * for an ambiguity/lookahead check.\r\n */\r\n this._overrideDecisionRoot = undefined;\r\n if (grammarFileName instanceof ParserInterpreter) {\r\n let old = grammarFileName;\r\n this._grammarFileName = old._grammarFileName;\r\n this._atn = old._atn;\r\n this.pushRecursionContextStates = old.pushRecursionContextStates;\r\n this._ruleNames = old._ruleNames;\r\n this._vocabulary = old._vocabulary;\r\n this.interpreter = new ParserATNSimulator_1.ParserATNSimulator(this._atn, this);\r\n }\r\n else {\r\n // The second constructor requires non-null arguments\r\n vocabulary = vocabulary;\r\n ruleNames = ruleNames;\r\n atn = atn;\r\n this._grammarFileName = grammarFileName;\r\n this._atn = atn;\r\n this._ruleNames = ruleNames.slice(0);\r\n this._vocabulary = vocabulary;\r\n // identify the ATN states where pushNewRecursionContext() must be called\r\n this.pushRecursionContextStates = new BitSet_1.BitSet(atn.states.length);\r\n for (let state of atn.states) {\r\n if (!(state instanceof StarLoopEntryState_1.StarLoopEntryState)) {\r\n continue;\r\n }\r\n if (state.precedenceRuleDecision) {\r\n this.pushRecursionContextStates.set(state.stateNumber);\r\n }\r\n }\r\n // get atn simulator that knows how to do predictions\r\n this.interpreter = new ParserATNSimulator_1.ParserATNSimulator(atn, this);\r\n }\r\n }\r\n reset(resetInput) {\r\n if (resetInput === undefined) {\r\n super.reset();\r\n }\r\n else {\r\n super.reset(resetInput);\r\n }\r\n this.overrideDecisionReached = false;\r\n this._overrideDecisionRoot = undefined;\r\n }\r\n get atn() {\r\n return this._atn;\r\n }\r\n get vocabulary() {\r\n return this._vocabulary;\r\n }\r\n get ruleNames() {\r\n return this._ruleNames;\r\n }\r\n get grammarFileName() {\r\n return this._grammarFileName;\r\n }\r\n /** Begin parsing at startRuleIndex */\r\n parse(startRuleIndex) {\r\n let startRuleStartState = this._atn.ruleToStartState[startRuleIndex];\r\n this._rootContext = this.createInterpreterRuleContext(undefined, ATNState_1.ATNState.INVALID_STATE_NUMBER, startRuleIndex);\r\n if (startRuleStartState.isPrecedenceRule) {\r\n this.enterRecursionRule(this._rootContext, startRuleStartState.stateNumber, startRuleIndex, 0);\r\n }\r\n else {\r\n this.enterRule(this._rootContext, startRuleStartState.stateNumber, startRuleIndex);\r\n }\r\n while (true) {\r\n let p = this.atnState;\r\n switch (p.stateType) {\r\n case 7 /* RULE_STOP */:\r\n // pop; return from rule\r\n if (this._ctx.isEmpty) {\r\n if (startRuleStartState.isPrecedenceRule) {\r\n let result = this._ctx;\r\n let parentContext = this._parentContextStack.pop();\r\n this.unrollRecursionContexts(parentContext[0]);\r\n return result;\r\n }\r\n else {\r\n this.exitRule();\r\n return this._rootContext;\r\n }\r\n }\r\n this.visitRuleStopState(p);\r\n break;\r\n default:\r\n try {\r\n this.visitState(p);\r\n }\r\n catch (e) {\r\n if (e instanceof RecognitionException_1.RecognitionException) {\r\n this.state = this._atn.ruleToStopState[p.ruleIndex].stateNumber;\r\n this.context.exception = e;\r\n this.errorHandler.reportError(this, e);\r\n this.recover(e);\r\n }\r\n else {\r\n throw e;\r\n }\r\n }\r\n break;\r\n }\r\n }\r\n }\r\n enterRecursionRule(localctx, state, ruleIndex, precedence) {\r\n this._parentContextStack.push([this._ctx, localctx.invokingState]);\r\n super.enterRecursionRule(localctx, state, ruleIndex, precedence);\r\n }\r\n get atnState() {\r\n return this._atn.states[this.state];\r\n }\r\n visitState(p) {\r\n let predictedAlt = 1;\r\n if (p.numberOfTransitions > 1) {\r\n predictedAlt = this.visitDecisionState(p);\r\n }\r\n let transition = p.transition(predictedAlt - 1);\r\n switch (transition.serializationType) {\r\n case 1 /* EPSILON */:\r\n if (this.pushRecursionContextStates.get(p.stateNumber) &&\r\n !(transition.target instanceof LoopEndState_1.LoopEndState)) {\r\n // We are at the start of a left recursive rule's (...)* loop\r\n // and we're not taking the exit branch of loop.\r\n let parentContext = this._parentContextStack[this._parentContextStack.length - 1];\r\n let localctx = this.createInterpreterRuleContext(parentContext[0], parentContext[1], this._ctx.ruleIndex);\r\n this.pushNewRecursionContext(localctx, this._atn.ruleToStartState[p.ruleIndex].stateNumber, this._ctx.ruleIndex);\r\n }\r\n break;\r\n case 5 /* ATOM */:\r\n this.match(transition._label);\r\n break;\r\n case 2 /* RANGE */:\r\n case 7 /* SET */:\r\n case 8 /* NOT_SET */:\r\n if (!transition.matches(this._input.LA(1), Token_1.Token.MIN_USER_TOKEN_TYPE, 65535)) {\r\n this.recoverInline();\r\n }\r\n this.matchWildcard();\r\n break;\r\n case 9 /* WILDCARD */:\r\n this.matchWildcard();\r\n break;\r\n case 3 /* RULE */:\r\n let ruleStartState = transition.target;\r\n let ruleIndex = ruleStartState.ruleIndex;\r\n let newctx = this.createInterpreterRuleContext(this._ctx, p.stateNumber, ruleIndex);\r\n if (ruleStartState.isPrecedenceRule) {\r\n this.enterRecursionRule(newctx, ruleStartState.stateNumber, ruleIndex, transition.precedence);\r\n }\r\n else {\r\n this.enterRule(newctx, transition.target.stateNumber, ruleIndex);\r\n }\r\n break;\r\n case 4 /* PREDICATE */:\r\n let predicateTransition = transition;\r\n if (!this.sempred(this._ctx, predicateTransition.ruleIndex, predicateTransition.predIndex)) {\r\n throw new FailedPredicateException_1.FailedPredicateException(this);\r\n }\r\n break;\r\n case 6 /* ACTION */:\r\n let actionTransition = transition;\r\n this.action(this._ctx, actionTransition.ruleIndex, actionTransition.actionIndex);\r\n break;\r\n case 10 /* PRECEDENCE */:\r\n if (!this.precpred(this._ctx, transition.precedence)) {\r\n let precedence = transition.precedence;\r\n throw new FailedPredicateException_1.FailedPredicateException(this, `precpred(_ctx, ${precedence})`);\r\n }\r\n break;\r\n default:\r\n throw new Error(\"UnsupportedOperationException: Unrecognized ATN transition type.\");\r\n }\r\n this.state = transition.target.stateNumber;\r\n }\r\n /** Method visitDecisionState() is called when the interpreter reaches\r\n * a decision state (instance of DecisionState). It gives an opportunity\r\n * for subclasses to track interesting things.\r\n */\r\n visitDecisionState(p) {\r\n let edge = 1;\r\n let predictedAlt;\r\n this.errorHandler.sync(this);\r\n let decision = p.decision;\r\n if (decision === this.overrideDecision && this._input.index === this.overrideDecisionInputIndex && !this.overrideDecisionReached) {\r\n predictedAlt = this.overrideDecisionAlt;\r\n this.overrideDecisionReached = true;\r\n }\r\n else {\r\n predictedAlt = this.interpreter.adaptivePredict(this._input, decision, this._ctx);\r\n }\r\n return predictedAlt;\r\n }\r\n /** Provide simple \"factory\" for InterpreterRuleContext's.\r\n * @since 4.5.1\r\n */\r\n createInterpreterRuleContext(parent, invokingStateNumber, ruleIndex) {\r\n return new InterpreterRuleContext_1.InterpreterRuleContext(ruleIndex, parent, invokingStateNumber);\r\n }\r\n visitRuleStopState(p) {\r\n let ruleStartState = this._atn.ruleToStartState[p.ruleIndex];\r\n if (ruleStartState.isPrecedenceRule) {\r\n let parentContext = this._parentContextStack.pop();\r\n this.unrollRecursionContexts(parentContext[0]);\r\n this.state = parentContext[1];\r\n }\r\n else {\r\n this.exitRule();\r\n }\r\n let ruleTransition = this._atn.states[this.state].transition(0);\r\n this.state = ruleTransition.followState.stateNumber;\r\n }\r\n /** Override this parser interpreters normal decision-making process\r\n * at a particular decision and input token index. Instead of\r\n * allowing the adaptive prediction mechanism to choose the\r\n * first alternative within a block that leads to a successful parse,\r\n * force it to take the alternative, 1..n for n alternatives.\r\n *\r\n * As an implementation limitation right now, you can only specify one\r\n * override. This is sufficient to allow construction of different\r\n * parse trees for ambiguous input. It means re-parsing the entire input\r\n * in general because you're never sure where an ambiguous sequence would\r\n * live in the various parse trees. For example, in one interpretation,\r\n * an ambiguous input sequence would be matched completely in expression\r\n * but in another it could match all the way back to the root.\r\n *\r\n * s : e '!'? ;\r\n * e : ID\r\n * | ID '!'\r\n * ;\r\n *\r\n * Here, x! can be matched as (s (e ID) !) or (s (e ID !)). In the first\r\n * case, the ambiguous sequence is fully contained only by the root.\r\n * In the second case, the ambiguous sequences fully contained within just\r\n * e, as in: (e ID !).\r\n *\r\n * Rather than trying to optimize this and make\r\n * some intelligent decisions for optimization purposes, I settled on\r\n * just re-parsing the whole input and then using\r\n * {link Trees#getRootOfSubtreeEnclosingRegion} to find the minimal\r\n * subtree that contains the ambiguous sequence. I originally tried to\r\n * record the call stack at the point the parser detected and ambiguity but\r\n * left recursive rules create a parse tree stack that does not reflect\r\n * the actual call stack. That impedance mismatch was enough to make\r\n * it it challenging to restart the parser at a deeply nested rule\r\n * invocation.\r\n *\r\n * Only parser interpreters can override decisions so as to avoid inserting\r\n * override checking code in the critical ALL(*) prediction execution path.\r\n *\r\n * @since 4.5\r\n */\r\n addDecisionOverride(decision, tokenIndex, forcedAlt) {\r\n this.overrideDecision = decision;\r\n this.overrideDecisionInputIndex = tokenIndex;\r\n this.overrideDecisionAlt = forcedAlt;\r\n }\r\n get overrideDecisionRoot() {\r\n return this._overrideDecisionRoot;\r\n }\r\n /** Rely on the error handler for this parser but, if no tokens are consumed\r\n * to recover, add an error node. Otherwise, nothing is seen in the parse\r\n * tree.\r\n */\r\n recover(e) {\r\n let i = this._input.index;\r\n this.errorHandler.recover(this, e);\r\n if (this._input.index === i) {\r\n // no input consumed, better add an error node\r\n let tok = e.getOffendingToken();\r\n if (!tok) {\r\n throw new Error(\"Expected exception to have an offending token\");\r\n }\r\n let source = tok.tokenSource;\r\n let stream = source !== undefined ? source.inputStream : undefined;\r\n let sourcePair = { source: source, stream: stream };\r\n if (e instanceof InputMismatchException_1.InputMismatchException) {\r\n let expectedTokens = e.expectedTokens;\r\n if (expectedTokens === undefined) {\r\n throw new Error(\"Expected the exception to provide expected tokens\");\r\n }\r\n let expectedTokenType = expectedTokens.minElement; // get any element\r\n let errToken = this.tokenFactory.create(sourcePair, expectedTokenType, tok.text, Token_1.Token.DEFAULT_CHANNEL, -1, -1, // invalid start/stop\r\n tok.line, tok.charPositionInLine);\r\n this._ctx.addErrorNode(errToken);\r\n }\r\n else {\r\n let source = tok.tokenSource;\r\n let errToken = this.tokenFactory.create(sourcePair, Token_1.Token.INVALID_TYPE, tok.text, Token_1.Token.DEFAULT_CHANNEL, -1, -1, // invalid start/stop\r\n tok.line, tok.charPositionInLine);\r\n this._ctx.addErrorNode(errToken);\r\n }\r\n }\r\n }\r\n recoverInline() {\r\n return this._errHandler.recoverInline(this);\r\n }\r\n /** Return the root of the parse, which can be useful if the parser\r\n * bails out. You still can access the top node. Note that,\r\n * because of the way left recursive rules add children, it's possible\r\n * that the root will not have any children if the start rule immediately\r\n * called and left recursive rule that fails.\r\n *\r\n * @since 4.5.1\r\n */\r\n get rootContext() {\r\n return this._rootContext;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], ParserInterpreter.prototype, \"_vocabulary\", void 0);\r\n__decorate([\r\n Decorators_2.Override\r\n], ParserInterpreter.prototype, \"reset\", null);\r\n__decorate([\r\n Decorators_2.Override\r\n], ParserInterpreter.prototype, \"atn\", null);\r\n__decorate([\r\n Decorators_2.Override\r\n], ParserInterpreter.prototype, \"vocabulary\", null);\r\n__decorate([\r\n Decorators_2.Override\r\n], ParserInterpreter.prototype, \"ruleNames\", null);\r\n__decorate([\r\n Decorators_2.Override\r\n], ParserInterpreter.prototype, \"grammarFileName\", null);\r\n__decorate([\r\n Decorators_2.Override\r\n], ParserInterpreter.prototype, \"enterRecursionRule\", null);\r\nParserInterpreter = __decorate([\r\n __param(1, Decorators_1.NotNull)\r\n], ParserInterpreter);\r\nexports.ParserInterpreter = ParserInterpreter;\r\n//# sourceMappingURL=ParserInterpreter.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst CommonTokenFactory_1 = require(\"./CommonTokenFactory\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst Token_1 = require(\"./Token\");\r\n/**\r\n * Provides an implementation of {@link TokenSource} as a wrapper around a list\r\n * of {@link Token} objects.\r\n *\r\n * <p>If the final token in the list is an {@link Token#EOF} token, it will be used\r\n * as the EOF token for every call to {@link #nextToken} after the end of the\r\n * list is reached. Otherwise, an EOF token will be created.</p>\r\n */\r\nlet ListTokenSource = class ListTokenSource {\r\n /**\r\n * Constructs a new {@link ListTokenSource} instance from the specified\r\n * collection of {@link Token} objects and source name.\r\n *\r\n * @param tokens The collection of {@link Token} objects to provide as a\r\n * {@link TokenSource}.\r\n * @param sourceName The name of the {@link TokenSource}. If this value is\r\n * {@code null}, {@link #getSourceName} will attempt to infer the name from\r\n * the next {@link Token} (or the previous token if the end of the input has\r\n * been reached).\r\n *\r\n * @exception NullPointerException if {@code tokens} is {@code null}\r\n */\r\n constructor(tokens, sourceName) {\r\n /**\r\n * The index into {@link #tokens} of token to return by the next call to\r\n * {@link #nextToken}. The end of the input is indicated by this value\r\n * being greater than or equal to the number of items in {@link #tokens}.\r\n */\r\n this.i = 0;\r\n /**\r\n * This is the backing field for {@link #getTokenFactory} and\r\n * {@link setTokenFactory}.\r\n */\r\n this._factory = CommonTokenFactory_1.CommonTokenFactory.DEFAULT;\r\n if (tokens == null) {\r\n throw new Error(\"tokens cannot be null\");\r\n }\r\n this.tokens = tokens;\r\n this._sourceName = sourceName;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n */\r\n get charPositionInLine() {\r\n if (this.i < this.tokens.length) {\r\n return this.tokens[this.i].charPositionInLine;\r\n }\r\n else if (this.eofToken != null) {\r\n return this.eofToken.charPositionInLine;\r\n }\r\n else if (this.tokens.length > 0) {\r\n // have to calculate the result from the line/column of the previous\r\n // token, along with the text of the token.\r\n let lastToken = this.tokens[this.tokens.length - 1];\r\n let tokenText = lastToken.text;\r\n if (tokenText != null) {\r\n let lastNewLine = tokenText.lastIndexOf('\\n');\r\n if (lastNewLine >= 0) {\r\n return tokenText.length - lastNewLine - 1;\r\n }\r\n }\r\n return lastToken.charPositionInLine + lastToken.stopIndex - lastToken.startIndex + 1;\r\n }\r\n // only reach this if tokens is empty, meaning EOF occurs at the first\r\n // position in the input\r\n return 0;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n */\r\n nextToken() {\r\n if (this.i >= this.tokens.length) {\r\n if (this.eofToken == null) {\r\n let start = -1;\r\n if (this.tokens.length > 0) {\r\n let previousStop = this.tokens[this.tokens.length - 1].stopIndex;\r\n if (previousStop !== -1) {\r\n start = previousStop + 1;\r\n }\r\n }\r\n let stop = Math.max(-1, start - 1);\r\n this.eofToken = this._factory.create({ source: this, stream: this.inputStream }, Token_1.Token.EOF, \"EOF\", Token_1.Token.DEFAULT_CHANNEL, start, stop, this.line, this.charPositionInLine);\r\n }\r\n return this.eofToken;\r\n }\r\n let t = this.tokens[this.i];\r\n if (this.i === this.tokens.length - 1 && t.type === Token_1.Token.EOF) {\r\n this.eofToken = t;\r\n }\r\n this.i++;\r\n return t;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n */\r\n get line() {\r\n if (this.i < this.tokens.length) {\r\n return this.tokens[this.i].line;\r\n }\r\n else if (this.eofToken != null) {\r\n return this.eofToken.line;\r\n }\r\n else if (this.tokens.length > 0) {\r\n // have to calculate the result from the line/column of the previous\r\n // token, along with the text of the token.\r\n let lastToken = this.tokens[this.tokens.length - 1];\r\n let line = lastToken.line;\r\n let tokenText = lastToken.text;\r\n if (tokenText != null) {\r\n for (let i = 0; i < tokenText.length; i++) {\r\n if (tokenText.charAt(i) == '\\n') {\r\n line++;\r\n }\r\n }\r\n }\r\n // if no text is available, assume the token did not contain any newline characters.\r\n return line;\r\n }\r\n // only reach this if tokens is empty, meaning EOF occurs at the first\r\n // position in the input\r\n return 1;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n */\r\n get inputStream() {\r\n if (this.i < this.tokens.length) {\r\n return this.tokens[this.i].inputStream;\r\n }\r\n else if (this.eofToken != null) {\r\n return this.eofToken.inputStream;\r\n }\r\n else if (this.tokens.length > 0) {\r\n return this.tokens[this.tokens.length - 1].inputStream;\r\n }\r\n // no input stream information is available\r\n return undefined;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n */\r\n get sourceName() {\r\n if (this._sourceName) {\r\n return this._sourceName;\r\n }\r\n let inputStream = this.inputStream;\r\n if (inputStream != null) {\r\n return inputStream.sourceName;\r\n }\r\n return \"List\";\r\n }\r\n /**\r\n * {@inheritDoc}\r\n */\r\n // @Override\r\n set tokenFactory(factory) {\r\n this._factory = factory;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n */\r\n get tokenFactory() {\r\n return this._factory;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override\r\n], ListTokenSource.prototype, \"charPositionInLine\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ListTokenSource.prototype, \"nextToken\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ListTokenSource.prototype, \"line\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ListTokenSource.prototype, \"inputStream\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ListTokenSource.prototype, \"sourceName\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], ListTokenSource.prototype, \"tokenFactory\", null);\r\nListTokenSource = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], ListTokenSource);\r\nexports.ListTokenSource = ListTokenSource;\r\n//# sourceMappingURL=ListTokenSource.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst Lexer_1 = require(\"./Lexer\");\r\nconst LexerATNSimulator_1 = require(\"./atn/LexerATNSimulator\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst Decorators_2 = require(\"./Decorators\");\r\nlet LexerInterpreter = class LexerInterpreter extends Lexer_1.Lexer {\r\n constructor(grammarFileName, vocabulary, modeNames, ruleNames, atn, input) {\r\n super(input);\r\n if (atn.grammarType != 0 /* LEXER */) {\r\n throw new Error(\"IllegalArgumentException: The ATN must be a lexer ATN.\");\r\n }\r\n this._grammarFileName = grammarFileName;\r\n this._atn = atn;\r\n this._ruleNames = ruleNames.slice(0);\r\n this._modeNames = modeNames.slice(0);\r\n this._vocabulary = vocabulary;\r\n this._interp = new LexerATNSimulator_1.LexerATNSimulator(atn, this);\r\n }\r\n get atn() {\r\n return this._atn;\r\n }\r\n get grammarFileName() {\r\n return this._grammarFileName;\r\n }\r\n get ruleNames() {\r\n return this._ruleNames;\r\n }\r\n get modeNames() {\r\n return this._modeNames;\r\n }\r\n get vocabulary() {\r\n return this._vocabulary;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], LexerInterpreter.prototype, \"_vocabulary\", void 0);\r\n__decorate([\r\n Decorators_2.Override\r\n], LexerInterpreter.prototype, \"atn\", null);\r\n__decorate([\r\n Decorators_2.Override\r\n], LexerInterpreter.prototype, \"grammarFileName\", null);\r\n__decorate([\r\n Decorators_2.Override\r\n], LexerInterpreter.prototype, \"ruleNames\", null);\r\n__decorate([\r\n Decorators_2.Override\r\n], LexerInterpreter.prototype, \"modeNames\", null);\r\n__decorate([\r\n Decorators_2.Override\r\n], LexerInterpreter.prototype, \"vocabulary\", null);\r\nLexerInterpreter = __decorate([\r\n __param(1, Decorators_1.NotNull)\r\n], LexerInterpreter);\r\nexports.LexerInterpreter = LexerInterpreter;\r\n//# sourceMappingURL=LexerInterpreter.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst BaseErrorListener_1 = require(\"./BaseErrorListener\");\r\nconst BitSet_1 = require(\"./misc/BitSet\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst Interval_1 = require(\"./misc/Interval\");\r\nconst Stubs_1 = require(\"./misc/Stubs\");\r\nclass DiagnosticErrorListener extends BaseErrorListener_1.BaseErrorListener {\r\n /**\r\n * Initializes a new instance of {@link DiagnosticErrorListener}, specifying\r\n * whether all ambiguities or only exact ambiguities are reported.\r\n *\r\n * @param exactOnly {@code true} to report only exact ambiguities, otherwise\r\n * {@code false} to report all ambiguities. Defaults to true.\r\n */\r\n constructor(exactOnly = true) {\r\n super();\r\n this.exactOnly = exactOnly;\r\n this.exactOnly = exactOnly;\r\n }\r\n reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {\r\n if (this.exactOnly && !exact) {\r\n return;\r\n }\r\n let decision = this.getDecisionDescription(recognizer, dfa);\r\n let conflictingAlts = this.getConflictingAlts(ambigAlts, configs);\r\n let text = recognizer.inputStream.getText(Interval_1.Interval.of(startIndex, stopIndex));\r\n let message = `reportAmbiguity d=${decision}: ambigAlts=${conflictingAlts}, input='${text}'`;\r\n recognizer.notifyErrorListeners(message);\r\n }\r\n reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, conflictState) {\r\n let format = \"reportAttemptingFullContext d=%s, input='%s'\";\r\n let decision = this.getDecisionDescription(recognizer, dfa);\r\n let text = recognizer.inputStream.getText(Interval_1.Interval.of(startIndex, stopIndex));\r\n let message = `reportAttemptingFullContext d=${decision}, input='${text}'`;\r\n recognizer.notifyErrorListeners(message);\r\n }\r\n reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, acceptState) {\r\n let format = \"reportContextSensitivity d=%s, input='%s'\";\r\n let decision = this.getDecisionDescription(recognizer, dfa);\r\n let text = recognizer.inputStream.getText(Interval_1.Interval.of(startIndex, stopIndex));\r\n let message = `reportContextSensitivity d=${decision}, input='${text}'`;\r\n recognizer.notifyErrorListeners(message);\r\n }\r\n getDecisionDescription(recognizer, dfa) {\r\n let decision = dfa.decision;\r\n let ruleIndex = dfa.atnStartState.ruleIndex;\r\n let ruleNames = recognizer.ruleNames;\r\n if (ruleIndex < 0 || ruleIndex >= ruleNames.length) {\r\n return decision.toString();\r\n }\r\n let ruleName = ruleNames[ruleIndex];\r\n if (!ruleName) {\r\n return decision.toString();\r\n }\r\n return `${decision} (${ruleName})`;\r\n }\r\n /**\r\n * Computes the set of conflicting or ambiguous alternatives from a\r\n * configuration set, if that information was not already provided by the\r\n * parser.\r\n *\r\n * @param reportedAlts The set of conflicting or ambiguous alternatives, as\r\n * reported by the parser.\r\n * @param configs The conflicting or ambiguous configuration set.\r\n * @return Returns {@code reportedAlts} if it is not {@code null}, otherwise\r\n * returns the set of alternatives represented in {@code configs}.\r\n */\r\n getConflictingAlts(reportedAlts, configs) {\r\n if (reportedAlts != null) {\r\n return reportedAlts;\r\n }\r\n let result = new BitSet_1.BitSet();\r\n for (let config of Stubs_1.asIterable(configs)) {\r\n result.set(config.alt);\r\n }\r\n return result;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(6, Decorators_1.NotNull)\r\n], DiagnosticErrorListener.prototype, \"reportAmbiguity\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(5, Decorators_1.NotNull)\r\n], DiagnosticErrorListener.prototype, \"reportAttemptingFullContext\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull),\r\n __param(5, Decorators_1.NotNull)\r\n], DiagnosticErrorListener.prototype, \"reportContextSensitivity\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(1, Decorators_1.NotNull)\r\n], DiagnosticErrorListener.prototype, \"getDecisionDescription\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(1, Decorators_1.NotNull)\r\n], DiagnosticErrorListener.prototype, \"getConflictingAlts\", null);\r\nexports.DiagnosticErrorListener = DiagnosticErrorListener;\r\n//# sourceMappingURL=DiagnosticErrorListener.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\n// ConvertTo-TS run at 2016-10-04T11:26:51.1349829-07:00\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nvar Dependents;\r\n(function (Dependents) {\r\n /**\r\n * The element is dependent upon the specified rule.\r\n */\r\n Dependents[Dependents[\"SELF\"] = 0] = \"SELF\";\r\n /**\r\n * The element is dependent upon the set of the specified rule's parents\r\n * (rules which directly reference it).\r\n */\r\n Dependents[Dependents[\"PARENTS\"] = 1] = \"PARENTS\";\r\n /**\r\n * The element is dependent upon the set of the specified rule's children\r\n * (rules which it directly references).\r\n */\r\n Dependents[Dependents[\"CHILDREN\"] = 2] = \"CHILDREN\";\r\n /**\r\n * The element is dependent upon the set of the specified rule's ancestors\r\n * (the transitive closure of `PARENTS` rules).\r\n */\r\n Dependents[Dependents[\"ANCESTORS\"] = 3] = \"ANCESTORS\";\r\n /**\r\n * The element is dependent upon the set of the specified rule's descendants\r\n * (the transitive closure of `CHILDREN` rules).\r\n */\r\n Dependents[Dependents[\"DESCENDANTS\"] = 4] = \"DESCENDANTS\";\r\n /**\r\n * The element is dependent upon the set of the specified rule's siblings\r\n * (the union of `CHILDREN` of its `PARENTS`).\r\n */\r\n Dependents[Dependents[\"SIBLINGS\"] = 5] = \"SIBLINGS\";\r\n /**\r\n * The element is dependent upon the set of the specified rule's preceeding\r\n * siblings (the union of `CHILDREN` of its `PARENTS` which\r\n * appear before a reference to the rule).\r\n */\r\n Dependents[Dependents[\"PRECEEDING_SIBLINGS\"] = 6] = \"PRECEEDING_SIBLINGS\";\r\n /**\r\n * The element is dependent upon the set of the specified rule's following\r\n * siblings (the union of `CHILDREN` of its `PARENTS` which\r\n * appear after a reference to the rule).\r\n */\r\n Dependents[Dependents[\"FOLLOWING_SIBLINGS\"] = 7] = \"FOLLOWING_SIBLINGS\";\r\n /**\r\n * The element is dependent upon the set of the specified rule's preceeding\r\n * elements (rules which might end before the start of the specified rule\r\n * while parsing). This is calculated by taking the\r\n * `PRECEEDING_SIBLINGS` of the rule and each of its\r\n * `ANCESTORS`, along with the `DESCENDANTS` of those\r\n * elements.\r\n */\r\n Dependents[Dependents[\"PRECEEDING\"] = 8] = \"PRECEEDING\";\r\n /**\r\n * The element is dependent upon the set of the specified rule's following\r\n * elements (rules which might start after the end of the specified rule\r\n * while parsing). This is calculated by taking the\r\n * `FOLLOWING_SIBLINGS` of the rule and each of its\r\n * `ANCESTORS`, along with the `DESCENDANTS` of those\r\n * elements.\r\n */\r\n Dependents[Dependents[\"FOLLOWING\"] = 9] = \"FOLLOWING\";\r\n})(Dependents = exports.Dependents || (exports.Dependents = {}));\r\n//# sourceMappingURL=Dependents.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:50.3953157-07:00\r\nconst BufferedTokenStream_1 = require(\"./BufferedTokenStream\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst Token_1 = require(\"./Token\");\r\n/**\r\n * This class extends {@link BufferedTokenStream} with functionality to filter\r\n * token streams to tokens on a particular channel (tokens where\r\n * {@link Token#getChannel} returns a particular value).\r\n *\r\n * <p>\r\n * This token stream provides access to all tokens by index or when calling\r\n * methods like {@link #getText}. The channel filtering is only used for code\r\n * accessing tokens via the lookahead methods {@link #LA}, {@link #LT}, and\r\n * {@link #LB}.</p>\r\n *\r\n * <p>\r\n * By default, tokens are placed on the default channel\r\n * ({@link Token#DEFAULT_CHANNEL}), but may be reassigned by using the\r\n * {@code ->channel(HIDDEN)} lexer command, or by using an embedded action to\r\n * call {@link Lexer#setChannel}.\r\n * </p>\r\n *\r\n * <p>\r\n * Note: lexer rules which use the {@code ->skip} lexer command or call\r\n * {@link Lexer#skip} do not produce tokens at all, so input text matched by\r\n * such a rule will not be available as part of the token stream, regardless of\r\n * channel.</p>\r\n */\r\nlet CommonTokenStream = class CommonTokenStream extends BufferedTokenStream_1.BufferedTokenStream {\r\n /**\r\n * Constructs a new {@link CommonTokenStream} using the specified token\r\n * source and filtering tokens to the specified channel. Only tokens whose\r\n * {@link Token#getChannel} matches {@code channel} or have the\r\n * `Token.type` equal to {@link Token#EOF} will be returned by the\r\n * token stream lookahead methods.\r\n *\r\n * @param tokenSource The token source.\r\n * @param channel The channel to use for filtering tokens.\r\n */\r\n constructor(tokenSource, channel = Token_1.Token.DEFAULT_CHANNEL) {\r\n super(tokenSource);\r\n this.channel = channel;\r\n }\r\n adjustSeekIndex(i) {\r\n return this.nextTokenOnChannel(i, this.channel);\r\n }\r\n tryLB(k) {\r\n if ((this.p - k) < 0) {\r\n return undefined;\r\n }\r\n let i = this.p;\r\n let n = 1;\r\n // find k good tokens looking backwards\r\n while (n <= k && i > 0) {\r\n // skip off-channel tokens\r\n i = this.previousTokenOnChannel(i - 1, this.channel);\r\n n++;\r\n }\r\n if (i < 0) {\r\n return undefined;\r\n }\r\n return this.tokens[i];\r\n }\r\n tryLT(k) {\r\n //System.out.println(\"enter LT(\"+k+\")\");\r\n this.lazyInit();\r\n if (k === 0) {\r\n throw new RangeError(\"0 is not a valid lookahead index\");\r\n }\r\n if (k < 0) {\r\n return this.tryLB(-k);\r\n }\r\n let i = this.p;\r\n let n = 1; // we know tokens[p] is a good one\r\n // find k good tokens\r\n while (n < k) {\r\n // skip off-channel tokens, but make sure to not look past EOF\r\n if (this.sync(i + 1)) {\r\n i = this.nextTokenOnChannel(i + 1, this.channel);\r\n }\r\n n++;\r\n }\r\n //\t\tif ( i>range ) range = i;\r\n return this.tokens[i];\r\n }\r\n /** Count EOF just once. */\r\n getNumberOfOnChannelTokens() {\r\n let n = 0;\r\n this.fill();\r\n for (let i = 0; i < this.tokens.length; i++) {\r\n let t = this.tokens[i];\r\n if (t.channel === this.channel) {\r\n n++;\r\n }\r\n if (t.type === Token_1.Token.EOF) {\r\n break;\r\n }\r\n }\r\n return n;\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonTokenStream.prototype, \"adjustSeekIndex\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonTokenStream.prototype, \"tryLB\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], CommonTokenStream.prototype, \"tryLT\", null);\r\nCommonTokenStream = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], CommonTokenStream);\r\nexports.CommonTokenStream = CommonTokenStream;\r\n//# sourceMappingURL=CommonTokenStream.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\n// ConvertTo-TS run at 2016-10-04T11:26:42.5447085-07:00\r\n/**\r\n * This exception is thrown to cancel a parsing operation. This exception does\r\n * not extend {@link RecognitionException}, allowing it to bypass the standard\r\n * error recovery mechanisms. {@link BailErrorStrategy} throws this exception in\r\n * response to a parse error.\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass ParseCancellationException extends Error {\r\n constructor(cause) {\r\n super(cause.message);\r\n this.cause = cause;\r\n this.stack = cause.stack;\r\n }\r\n getCause() {\r\n return this.cause;\r\n }\r\n}\r\nexports.ParseCancellationException = ParseCancellationException;\r\n//# sourceMappingURL=ParseCancellationException.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nconst MurmurHash_1 = require(\"./MurmurHash\");\r\nclass UUID {\r\n constructor(mostSigBits, moreSigBits, lessSigBits, leastSigBits) {\r\n this.data = new Uint32Array(4);\r\n this.data[0] = mostSigBits;\r\n this.data[1] = moreSigBits;\r\n this.data[2] = lessSigBits;\r\n this.data[3] = leastSigBits;\r\n }\r\n static fromString(data) {\r\n if (!/^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/.test(data)) {\r\n throw new Error(\"Incorrectly formatted UUID\");\r\n }\r\n let segments = data.split('-');\r\n let mostSigBits = parseInt(segments[0], 16);\r\n let moreSigBits = ((parseInt(segments[1], 16) << 16) >>> 0) + parseInt(segments[2], 16);\r\n let lessSigBits = ((parseInt(segments[3], 16) << 16) >>> 0) + parseInt(segments[4].substr(0, 4), 16);\r\n let leastSigBits = parseInt(segments[4].substr(-8), 16);\r\n return new UUID(mostSigBits, moreSigBits, lessSigBits, leastSigBits);\r\n }\r\n hashCode() {\r\n return MurmurHash_1.MurmurHash.hashCode([this.data[0], this.data[1], this.data[2], this.data[3]]);\r\n }\r\n equals(obj) {\r\n if (obj === this) {\r\n return true;\r\n }\r\n else if (!(obj instanceof UUID)) {\r\n return false;\r\n }\r\n return this.data[0] === obj.data[0]\r\n && this.data[1] === obj.data[1]\r\n && this.data[2] === obj.data[2]\r\n && this.data[3] === obj.data[3];\r\n }\r\n toString() {\r\n return (\"00000000\" + this.data[0].toString(16)).substr(-8)\r\n + \"-\" + (\"0000\" + (this.data[1] >>> 16).toString(16)).substr(-4)\r\n + \"-\" + (\"0000\" + this.data[1].toString(16)).substr(-4)\r\n + \"-\" + (\"0000\" + (this.data[2] >>> 16).toString(16)).substr(-4)\r\n + \"-\" + (\"0000\" + this.data[2].toString(16)).substr(-4)\r\n + (\"00000000\" + this.data[3].toString(16)).substr(-8);\r\n }\r\n}\r\nexports.UUID = UUID;\r\n//# sourceMappingURL=UUID.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst DecisionState_1 = require(\"./DecisionState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/** The Tokens rule start state linking to each lexer rule start state */\r\nclass TokensStartState extends DecisionState_1.DecisionState {\r\n get stateType() {\r\n return 6 /* TOKEN_START */;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], TokensStartState.prototype, \"stateType\", null);\r\nexports.TokensStartState = TokensStartState;\r\n//# sourceMappingURL=TokensStartState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:37.6368726-07:00\r\nconst ATNState_1 = require(\"./ATNState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nclass StarLoopbackState extends ATNState_1.ATNState {\r\n get loopEntryState() {\r\n return this.transition(0).target;\r\n }\r\n get stateType() {\r\n return 9 /* STAR_LOOP_BACK */;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], StarLoopbackState.prototype, \"stateType\", null);\r\nexports.StarLoopbackState = StarLoopbackState;\r\n//# sourceMappingURL=StarLoopbackState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst BlockStartState_1 = require(\"./BlockStartState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/** The block that begins a closure loop. */\r\nclass StarBlockStartState extends BlockStartState_1.BlockStartState {\r\n get stateType() {\r\n return 5 /* STAR_BLOCK_START */;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], StarBlockStartState.prototype, \"stateType\", null);\r\nexports.StarBlockStartState = StarBlockStartState;\r\n//# sourceMappingURL=StarBlockStartState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:36.6806851-07:00\r\nconst ATNState_1 = require(\"./ATNState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nclass RuleStartState extends ATNState_1.ATNState {\r\n constructor() {\r\n super(...arguments);\r\n this.isPrecedenceRule = false;\r\n this.leftFactored = false;\r\n }\r\n get stateType() {\r\n return 2 /* RULE_START */;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], RuleStartState.prototype, \"stateType\", null);\r\nexports.RuleStartState = RuleStartState;\r\n//# sourceMappingURL=RuleStartState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst IntervalSet_1 = require(\"../misc/IntervalSet\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst Transition_1 = require(\"./Transition\");\r\nlet RangeTransition = class RangeTransition extends Transition_1.Transition {\r\n constructor(target, from, to) {\r\n super(target);\r\n this.from = from;\r\n this.to = to;\r\n }\r\n get serializationType() {\r\n return 2 /* RANGE */;\r\n }\r\n get label() {\r\n return IntervalSet_1.IntervalSet.of(this.from, this.to);\r\n }\r\n matches(symbol, minVocabSymbol, maxVocabSymbol) {\r\n return symbol >= this.from && symbol <= this.to;\r\n }\r\n toString() {\r\n return \"'\" + String.fromCharCode(this.from) + \"'..'\" + String.fromCharCode(this.to) + \"'\";\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override\r\n], RangeTransition.prototype, \"serializationType\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n Decorators_1.NotNull\r\n], RangeTransition.prototype, \"label\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], RangeTransition.prototype, \"matches\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n Decorators_1.NotNull\r\n], RangeTransition.prototype, \"toString\", null);\r\nRangeTransition = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], RangeTransition);\r\nexports.RangeTransition = RangeTransition;\r\n//# sourceMappingURL=RangeTransition.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:35.0994191-07:00\r\nconst AbstractPredicateTransition_1 = require(\"./AbstractPredicateTransition\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst SemanticContext_1 = require(\"./SemanticContext\");\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nlet PrecedencePredicateTransition = class PrecedencePredicateTransition extends AbstractPredicateTransition_1.AbstractPredicateTransition {\r\n constructor(target, precedence) {\r\n super(target);\r\n this.precedence = precedence;\r\n }\r\n get serializationType() {\r\n return 10 /* PRECEDENCE */;\r\n }\r\n get isEpsilon() {\r\n return true;\r\n }\r\n matches(symbol, minVocabSymbol, maxVocabSymbol) {\r\n return false;\r\n }\r\n get predicate() {\r\n return new SemanticContext_1.SemanticContext.PrecedencePredicate(this.precedence);\r\n }\r\n toString() {\r\n return this.precedence + \" >= _p\";\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override\r\n], PrecedencePredicateTransition.prototype, \"serializationType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], PrecedencePredicateTransition.prototype, \"isEpsilon\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], PrecedencePredicateTransition.prototype, \"matches\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], PrecedencePredicateTransition.prototype, \"toString\", null);\r\nPrecedencePredicateTransition = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], PrecedencePredicateTransition);\r\nexports.PrecedencePredicateTransition = PrecedencePredicateTransition;\r\n//# sourceMappingURL=PrecedencePredicateTransition.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst DecisionState_1 = require(\"./DecisionState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/** Decision state for {@code A+} and {@code (A|B)+}. It has two transitions:\r\n * one to the loop back to start of the block and one to exit.\r\n */\r\nclass PlusLoopbackState extends DecisionState_1.DecisionState {\r\n get stateType() {\r\n return 11 /* PLUS_LOOP_BACK */;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], PlusLoopbackState.prototype, \"stateType\", null);\r\nexports.PlusLoopbackState = PlusLoopbackState;\r\n//# sourceMappingURL=PlusLoopbackState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst BlockStartState_1 = require(\"./BlockStartState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/** Start of {@code (A|B|...)+} loop. Technically a decision state, but\r\n * we don't use for code generation; somebody might need it, so I'm defining\r\n * it for completeness. In reality, the {@link PlusLoopbackState} node is the\r\n * real decision-making note for {@code A+}.\r\n */\r\nclass PlusBlockStartState extends BlockStartState_1.BlockStartState {\r\n get stateType() {\r\n return 4 /* PLUS_BLOCK_START */;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], PlusBlockStartState.prototype, \"stateType\", null);\r\nexports.PlusBlockStartState = PlusBlockStartState;\r\n//# sourceMappingURL=PlusBlockStartState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst ParserRuleContext_1 = require(\"../ParserRuleContext\");\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nlet SimulatorState = class SimulatorState {\r\n constructor(outerContext, s0, useContext, remainingOuterContext) {\r\n this.outerContext = outerContext != null ? outerContext : ParserRuleContext_1.ParserRuleContext.emptyContext();\r\n this.s0 = s0;\r\n this.useContext = useContext;\r\n this.remainingOuterContext = remainingOuterContext;\r\n }\r\n};\r\nSimulatorState = __decorate([\r\n __param(1, Decorators_1.NotNull)\r\n], SimulatorState);\r\nexports.SimulatorState = SimulatorState;\r\n//# sourceMappingURL=SimulatorState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:36.2673893-07:00\r\nconst Array2DHashMap_1 = require(\"../misc/Array2DHashMap\");\r\nconst Stubs_1 = require(\"../misc/Stubs\");\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst RuleStopState_1 = require(\"./RuleStopState\");\r\n/**\r\n * This enumeration defines the prediction modes available in ANTLR 4 along with\r\n * utility methods for analyzing configuration sets for conflicts and/or\r\n * ambiguities.\r\n */\r\nvar PredictionMode;\r\n(function (PredictionMode) {\r\n /**\r\n * The SLL(*) prediction mode. This prediction mode ignores the current\r\n * parser context when making predictions. This is the fastest prediction\r\n * mode, and provides correct results for many grammars. This prediction\r\n * mode is more powerful than the prediction mode provided by ANTLR 3, but\r\n * may result in syntax errors for grammar and input combinations which are\r\n * not SLL.\r\n *\r\n * <p>\r\n * When using this prediction mode, the parser will either return a correct\r\n * parse tree (i.e. the same parse tree that would be returned with the\r\n * {@link #LL} prediction mode), or it will report a syntax error. If a\r\n * syntax error is encountered when using the {@link #SLL} prediction mode,\r\n * it may be due to either an actual syntax error in the input or indicate\r\n * that the particular combination of grammar and input requires the more\r\n * powerful {@link #LL} prediction abilities to complete successfully.</p>\r\n *\r\n * <p>\r\n * This prediction mode does not provide any guarantees for prediction\r\n * behavior for syntactically-incorrect inputs.</p>\r\n */\r\n PredictionMode[PredictionMode[\"SLL\"] = 0] = \"SLL\";\r\n /**\r\n * The LL(*) prediction mode. This prediction mode allows the current parser\r\n * context to be used for resolving SLL conflicts that occur during\r\n * prediction. This is the fastest prediction mode that guarantees correct\r\n * parse results for all combinations of grammars with syntactically correct\r\n * inputs.\r\n *\r\n * <p>\r\n * When using this prediction mode, the parser will make correct decisions\r\n * for all syntactically-correct grammar and input combinations. However, in\r\n * cases where the grammar is truly ambiguous this prediction mode might not\r\n * report a precise answer for <em>exactly which</em> alternatives are\r\n * ambiguous.</p>\r\n *\r\n * <p>\r\n * This prediction mode does not provide any guarantees for prediction\r\n * behavior for syntactically-incorrect inputs.</p>\r\n */\r\n PredictionMode[PredictionMode[\"LL\"] = 1] = \"LL\";\r\n /**\r\n * The LL(*) prediction mode with exact ambiguity detection. In addition to\r\n * the correctness guarantees provided by the {@link #LL} prediction mode,\r\n * this prediction mode instructs the prediction algorithm to determine the\r\n * complete and exact set of ambiguous alternatives for every ambiguous\r\n * decision encountered while parsing.\r\n *\r\n * <p>\r\n * This prediction mode may be used for diagnosing ambiguities during\r\n * grammar development. Due to the performance overhead of calculating sets\r\n * of ambiguous alternatives, this prediction mode should be avoided when\r\n * the exact results are not necessary.</p>\r\n *\r\n * <p>\r\n * This prediction mode does not provide any guarantees for prediction\r\n * behavior for syntactically-incorrect inputs.</p>\r\n */\r\n PredictionMode[PredictionMode[\"LL_EXACT_AMBIG_DETECTION\"] = 2] = \"LL_EXACT_AMBIG_DETECTION\";\r\n})(PredictionMode = exports.PredictionMode || (exports.PredictionMode = {}));\r\n(function (PredictionMode) {\r\n /** A Map that uses just the state and the stack context as the key. */\r\n // NOTE: Base type used to be FlexibleHashMap<ATNConfig, BitSet>\r\n class AltAndContextMap extends Array2DHashMap_1.Array2DHashMap {\r\n constructor() {\r\n super(AltAndContextConfigEqualityComparator.INSTANCE);\r\n }\r\n }\r\n class AltAndContextConfigEqualityComparator {\r\n AltAndContextConfigEqualityComparator() {\r\n }\r\n /**\r\n * The hash code is only a function of the {@link ATNState#stateNumber}\r\n * and {@link ATNConfig#context}.\r\n */\r\n hashCode(o) {\r\n let hashCode = MurmurHash_1.MurmurHash.initialize(7);\r\n hashCode = MurmurHash_1.MurmurHash.update(hashCode, o.state.stateNumber);\r\n hashCode = MurmurHash_1.MurmurHash.update(hashCode, o.context);\r\n hashCode = MurmurHash_1.MurmurHash.finish(hashCode, 2);\r\n return hashCode;\r\n }\r\n equals(a, b) {\r\n if (a === b)\r\n return true;\r\n if (a == null || b == null)\r\n return false;\r\n return a.state.stateNumber == b.state.stateNumber\r\n && a.context.equals(b.context);\r\n }\r\n }\r\n AltAndContextConfigEqualityComparator.INSTANCE = new AltAndContextConfigEqualityComparator();\r\n __decorate([\r\n Decorators_1.Override\r\n ], AltAndContextConfigEqualityComparator.prototype, \"hashCode\", null);\r\n __decorate([\r\n Decorators_1.Override\r\n ], AltAndContextConfigEqualityComparator.prototype, \"equals\", null);\r\n /**\r\n * Checks if any configuration in {@code configs} is in a\r\n * {@link RuleStopState}. Configurations meeting this condition have reached\r\n * the end of the decision rule (local context) or end of start rule (full\r\n * context).\r\n *\r\n * @param configs the configuration set to test\r\n * @return {@code true} if any configuration in {@code configs} is in a\r\n * {@link RuleStopState}, otherwise {@code false}\r\n */\r\n function hasConfigInRuleStopState(configs) {\r\n for (let c of Stubs_1.asIterable(configs)) {\r\n if (c.state instanceof RuleStopState_1.RuleStopState) {\r\n return true;\r\n }\r\n }\r\n return false;\r\n }\r\n PredictionMode.hasConfigInRuleStopState = hasConfigInRuleStopState;\r\n /**\r\n * Checks if all configurations in {@code configs} are in a\r\n * {@link RuleStopState}. Configurations meeting this condition have reached\r\n * the end of the decision rule (local context) or end of start rule (full\r\n * context).\r\n *\r\n * @param configs the configuration set to test\r\n * @return {@code true} if all configurations in {@code configs} are in a\r\n * {@link RuleStopState}, otherwise {@code false}\r\n */\r\n function allConfigsInRuleStopStates(/*@NotNull*/ configs) {\r\n for (let config of Stubs_1.asIterable(configs)) {\r\n if (!(config.state instanceof RuleStopState_1.RuleStopState)) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }\r\n PredictionMode.allConfigsInRuleStopStates = allConfigsInRuleStopStates;\r\n})(PredictionMode = exports.PredictionMode || (exports.PredictionMode = {}));\r\n//# sourceMappingURL=PredictionMode.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst ATN_1 = require(\"../atn/ATN\");\r\nconst CommonToken_1 = require(\"../CommonToken\");\r\nconst ErrorNode_1 = require(\"./ErrorNode\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst Parser_1 = require(\"../Parser\");\r\nconst ParserRuleContext_1 = require(\"../ParserRuleContext\");\r\nconst RuleNode_1 = require(\"./RuleNode\");\r\nconst TerminalNode_1 = require(\"./TerminalNode\");\r\nconst Token_1 = require(\"../Token\");\r\nconst Utils = require(\"../misc/Utils\");\r\n/** A set of utility routines useful for all kinds of ANTLR trees. */\r\nclass Trees {\r\n /** Print out a whole tree in LISP form. {@link #getNodeText} is used on the\r\n * node payloads to get the text for the nodes. Detect\r\n * parse trees and extract data appropriately.\r\n */\r\n /** Print out a whole tree in LISP form. {@link #getNodeText} is used on the\r\n * node payloads to get the text for the nodes. Detect\r\n * parse trees and extract data appropriately.\r\n */\r\n /** Print out a whole tree in LISP form. {@link #getNodeText} is used on the\r\n * node payloads to get the text for the nodes.\r\n */\r\n static toStringTree(t, arg2) {\r\n let ruleNames;\r\n if (arg2 instanceof Parser_1.Parser) {\r\n ruleNames = arg2.ruleNames;\r\n }\r\n else {\r\n ruleNames = arg2;\r\n }\r\n let s = Utils.escapeWhitespace(this.getNodeText(t, ruleNames), false);\r\n if (t.childCount == 0)\r\n return s;\r\n let buf = \"\";\r\n buf += (\"(\");\r\n s = Utils.escapeWhitespace(this.getNodeText(t, ruleNames), false);\r\n buf += (s);\r\n buf += (' ');\r\n for (let i = 0; i < t.childCount; i++) {\r\n if (i > 0)\r\n buf += (' ');\r\n buf += (this.toStringTree(t.getChild(i), ruleNames));\r\n }\r\n buf += (\")\");\r\n return buf;\r\n }\r\n static getNodeText(t, arg2) {\r\n let ruleNames;\r\n if (arg2 instanceof Parser_1.Parser) {\r\n ruleNames = arg2.ruleNames;\r\n }\r\n else if (arg2) {\r\n ruleNames = arg2;\r\n }\r\n else {\r\n // no recog or rule names\r\n let payload = t.payload;\r\n if (typeof payload.text === 'string') {\r\n return payload.text;\r\n }\r\n return t.payload.toString();\r\n ;\r\n }\r\n if (t instanceof RuleNode_1.RuleNode) {\r\n let ruleContext = t.ruleContext;\r\n let ruleIndex = ruleContext.ruleIndex;\r\n let ruleName = ruleNames[ruleIndex];\r\n let altNumber = ruleContext.altNumber;\r\n if (altNumber !== ATN_1.ATN.INVALID_ALT_NUMBER) {\r\n return ruleName + \":\" + altNumber;\r\n }\r\n return ruleName;\r\n }\r\n else if (t instanceof ErrorNode_1.ErrorNode) {\r\n return t.toString();\r\n }\r\n else if (t instanceof TerminalNode_1.TerminalNode) {\r\n let symbol = t.symbol;\r\n return symbol.text || \"\";\r\n }\r\n throw new TypeError(\"Unexpected node type\");\r\n }\r\n /** Return ordered list of all children of this node */\r\n static getChildren(t) {\r\n let kids = [];\r\n for (let i = 0; i < t.childCount; i++) {\r\n kids.push(t.getChild(i));\r\n }\r\n return kids;\r\n }\r\n /** Return a list of all ancestors of this node. The first node of\r\n * list is the root and the last is the parent of this node.\r\n *\r\n * @since 4.5.1\r\n */\r\n static getAncestors(t) {\r\n let ancestors = [];\r\n let p = t.parent;\r\n while (p) {\r\n ancestors.unshift(p); // insert at start\r\n p = p.parent;\r\n }\r\n return ancestors;\r\n }\r\n /** Return true if t is u's parent or a node on path to root from u.\r\n * Use == not equals().\r\n *\r\n * @since 4.5.1\r\n */\r\n static isAncestorOf(t, u) {\r\n if (!t || !u || !t.parent)\r\n return false;\r\n let p = u.parent;\r\n while (p) {\r\n if (t === p)\r\n return true;\r\n p = p.parent;\r\n }\r\n return false;\r\n }\r\n static findAllTokenNodes(t, ttype) {\r\n return Trees.findAllNodes(t, ttype, true);\r\n }\r\n static findAllRuleNodes(t, ruleIndex) {\r\n return Trees.findAllNodes(t, ruleIndex, false);\r\n }\r\n static findAllNodes(t, index, findTokens) {\r\n let nodes = [];\r\n Trees._findAllNodes(t, index, findTokens, nodes);\r\n return nodes;\r\n }\r\n static _findAllNodes(t, index, findTokens, nodes) {\r\n // check this node (the root) first\r\n if (findTokens && t instanceof TerminalNode_1.TerminalNode) {\r\n if (t.symbol.type === index)\r\n nodes.push(t);\r\n }\r\n else if (!findTokens && t instanceof ParserRuleContext_1.ParserRuleContext) {\r\n if (t.ruleIndex === index)\r\n nodes.push(t);\r\n }\r\n // check children\r\n for (let i = 0; i < t.childCount; i++) {\r\n Trees._findAllNodes(t.getChild(i), index, findTokens, nodes);\r\n }\r\n }\r\n /** Get all descendents; includes t itself.\r\n *\r\n * @since 4.5.1\r\n */\r\n static getDescendants(t) {\r\n let nodes = [];\r\n function recurse(e) {\r\n nodes.push(e);\r\n const n = e.childCount;\r\n for (let i = 0; i < n; i++) {\r\n recurse(e.getChild(i));\r\n }\r\n }\r\n recurse(t);\r\n return nodes;\r\n }\r\n /** Find smallest subtree of t enclosing range startTokenIndex..stopTokenIndex\r\n * inclusively using postorder traversal. Recursive depth-first-search.\r\n *\r\n * @since 4.5\r\n */\r\n static getRootOfSubtreeEnclosingRegion(t, startTokenIndex, // inclusive\r\n stopTokenIndex // inclusive\r\n ) {\r\n let n = t.childCount;\r\n for (let i = 0; i < n; i++) {\r\n let child = t.getChild(i);\r\n let r = Trees.getRootOfSubtreeEnclosingRegion(child, startTokenIndex, stopTokenIndex);\r\n if (r)\r\n return r;\r\n }\r\n if (t instanceof ParserRuleContext_1.ParserRuleContext) {\r\n let stopToken = t.stop;\r\n if (startTokenIndex >= t.start.tokenIndex &&\r\n (stopToken == null || stopTokenIndex <= stopToken.tokenIndex)) {\r\n // note: r.stop==null likely implies that we bailed out of parser and there's nothing to the right\r\n return t;\r\n }\r\n }\r\n return undefined;\r\n }\r\n /** Replace any subtree siblings of root that are completely to left\r\n * or right of lookahead range with a CommonToken(Token.INVALID_TYPE,\"...\")\r\n * node. The source interval for t is not altered to suit smaller range!\r\n *\r\n * WARNING: destructive to t.\r\n *\r\n * @since 4.5.1\r\n */\r\n static stripChildrenOutOfRange(t, root, startIndex, stopIndex) {\r\n if (!t)\r\n return;\r\n let count = t.childCount;\r\n for (let i = 0; i < count; i++) {\r\n let child = t.getChild(i);\r\n let range = child.sourceInterval;\r\n if (child instanceof ParserRuleContext_1.ParserRuleContext && (range.b < startIndex || range.a > stopIndex)) {\r\n if (Trees.isAncestorOf(child, root)) {\r\n let abbrev = new CommonToken_1.CommonToken(Token_1.Token.INVALID_TYPE, \"...\");\r\n t.children[i] = new TerminalNode_1.TerminalNode(abbrev); // HACK access to private\r\n }\r\n }\r\n }\r\n }\r\n}\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], Trees, \"toStringTree\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull)\r\n], Trees, \"getAncestors\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], Trees, \"getRootOfSubtreeEnclosingRegion\", null);\r\nexports.Trees = Trees;\r\n//# sourceMappingURL=Trees.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst Utils = require(\"../misc/Utils\");\r\n/**\r\n * This class stores information about a configuration conflict.\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass ConflictInfo {\r\n constructor(conflictedAlts, exact) {\r\n this._conflictedAlts = conflictedAlts;\r\n this.exact = exact;\r\n }\r\n /**\r\n * Gets the set of conflicting alternatives for the configuration set.\r\n */\r\n get conflictedAlts() {\r\n return this._conflictedAlts;\r\n }\r\n /**\r\n * Gets whether or not the configuration conflict is an exact conflict.\r\n * An exact conflict occurs when the prediction algorithm determines that\r\n * the represented alternatives for a particular configuration set cannot be\r\n * further reduced by consuming additional input. After reaching an exact\r\n * conflict during an SLL prediction, only switch to full-context prediction\r\n * could reduce the set of viable alternatives. In LL prediction, an exact\r\n * conflict indicates a true ambiguity in the input.\r\n *\r\n * <p>\r\n * For the {@link PredictionMode#LL_EXACT_AMBIG_DETECTION} prediction mode,\r\n * accept states are conflicting but not exact are treated as non-accept\r\n * states.</p>\r\n */\r\n get isExact() {\r\n return this.exact;\r\n }\r\n equals(obj) {\r\n if (obj === this) {\r\n return true;\r\n }\r\n else if (!(obj instanceof ConflictInfo)) {\r\n return false;\r\n }\r\n return this.isExact === obj.isExact\r\n && Utils.equals(this.conflictedAlts, obj.conflictedAlts);\r\n }\r\n hashCode() {\r\n return this.conflictedAlts.hashCode();\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], ConflictInfo.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ConflictInfo.prototype, \"hashCode\", null);\r\nexports.ConflictInfo = ConflictInfo;\r\n//# sourceMappingURL=ConflictInfo.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n * Implements the {@code type} lexer action by setting `Lexer.type`\r\n * with the assigned type.\r\n *\r\n * @author Sam Harwell\r\n * @since 4.2\r\n */\r\nclass LexerTypeAction {\r\n /**\r\n * Constructs a new {@code type} action with the specified token type value.\r\n * @param type The type to assign to the token using `Lexer.type`.\r\n */\r\n constructor(type) {\r\n this._type = type;\r\n }\r\n /**\r\n * Gets the type to assign to a token created by the lexer.\r\n * @return The type to assign to a token created by the lexer.\r\n */\r\n get type() {\r\n return this._type;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@link LexerActionType#TYPE}.\r\n */\r\n get actionType() {\r\n return 7 /* TYPE */;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@code false}.\r\n */\r\n get isPositionDependent() {\r\n return false;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This action is implemented by setting `Lexer.type` with the\r\n * value provided by `type`.</p>\r\n */\r\n execute(lexer) {\r\n lexer.type = this._type;\r\n }\r\n hashCode() {\r\n let hash = MurmurHash_1.MurmurHash.initialize();\r\n hash = MurmurHash_1.MurmurHash.update(hash, this.actionType);\r\n hash = MurmurHash_1.MurmurHash.update(hash, this._type);\r\n return MurmurHash_1.MurmurHash.finish(hash, 2);\r\n }\r\n equals(obj) {\r\n if (obj === this) {\r\n return true;\r\n }\r\n else if (!(obj instanceof LexerTypeAction)) {\r\n return false;\r\n }\r\n return this._type === obj._type;\r\n }\r\n toString() {\r\n return `type(${this._type})`;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerTypeAction.prototype, \"actionType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerTypeAction.prototype, \"isPositionDependent\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull)\r\n], LexerTypeAction.prototype, \"execute\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerTypeAction.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerTypeAction.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerTypeAction.prototype, \"toString\", null);\r\nexports.LexerTypeAction = LexerTypeAction;\r\n//# sourceMappingURL=LexerTypeAction.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n * Implements the {@code skip} lexer action by calling {@link Lexer#skip}.\r\n *\r\n * <p>The {@code skip} command does not have any parameters, so this action is\r\n * implemented as a singleton instance exposed by {@link #INSTANCE}.</p>\r\n *\r\n * @author Sam Harwell\r\n * @since 4.2\r\n */\r\nclass LexerSkipAction {\r\n /**\r\n * Constructs the singleton instance of the lexer {@code skip} command.\r\n */\r\n constructor() {\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@link LexerActionType#SKIP}.\r\n */\r\n get actionType() {\r\n return 6 /* SKIP */;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@code false}.\r\n */\r\n get isPositionDependent() {\r\n return false;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This action is implemented by calling {@link Lexer#skip}.</p>\r\n */\r\n execute(lexer) {\r\n lexer.skip();\r\n }\r\n hashCode() {\r\n let hash = MurmurHash_1.MurmurHash.initialize();\r\n hash = MurmurHash_1.MurmurHash.update(hash, this.actionType);\r\n return MurmurHash_1.MurmurHash.finish(hash, 1);\r\n }\r\n equals(obj) {\r\n return obj === this;\r\n }\r\n toString() {\r\n return \"skip\";\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerSkipAction.prototype, \"actionType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerSkipAction.prototype, \"isPositionDependent\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull)\r\n], LexerSkipAction.prototype, \"execute\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerSkipAction.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerSkipAction.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerSkipAction.prototype, \"toString\", null);\r\nexports.LexerSkipAction = LexerSkipAction;\r\n(function (LexerSkipAction) {\r\n /**\r\n * Provides a singleton instance of this parameterless lexer action.\r\n */\r\n LexerSkipAction.INSTANCE = new LexerSkipAction();\r\n})(LexerSkipAction = exports.LexerSkipAction || (exports.LexerSkipAction = {}));\r\n//# sourceMappingURL=LexerSkipAction.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n * Implements the {@code pushMode} lexer action by calling\r\n * {@link Lexer#pushMode} with the assigned mode.\r\n *\r\n * @author Sam Harwell\r\n * @since 4.2\r\n */\r\nclass LexerPushModeAction {\r\n /**\r\n * Constructs a new {@code pushMode} action with the specified mode value.\r\n * @param mode The mode value to pass to {@link Lexer#pushMode}.\r\n */\r\n constructor(mode) {\r\n this._mode = mode;\r\n }\r\n /**\r\n * Get the lexer mode this action should transition the lexer to.\r\n *\r\n * @return The lexer mode for this {@code pushMode} command.\r\n */\r\n get mode() {\r\n return this._mode;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@link LexerActionType#PUSH_MODE}.\r\n */\r\n get actionType() {\r\n return 5 /* PUSH_MODE */;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@code false}.\r\n */\r\n get isPositionDependent() {\r\n return false;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This action is implemented by calling {@link Lexer#pushMode} with the\r\n * value provided by {@link #getMode}.</p>\r\n */\r\n execute(lexer) {\r\n lexer.pushMode(this._mode);\r\n }\r\n hashCode() {\r\n let hash = MurmurHash_1.MurmurHash.initialize();\r\n hash = MurmurHash_1.MurmurHash.update(hash, this.actionType);\r\n hash = MurmurHash_1.MurmurHash.update(hash, this._mode);\r\n return MurmurHash_1.MurmurHash.finish(hash, 2);\r\n }\r\n equals(obj) {\r\n if (obj === this) {\r\n return true;\r\n }\r\n else if (!(obj instanceof LexerPushModeAction)) {\r\n return false;\r\n }\r\n return this._mode === obj._mode;\r\n }\r\n toString() {\r\n return `pushMode(${this._mode})`;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerPushModeAction.prototype, \"actionType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerPushModeAction.prototype, \"isPositionDependent\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull)\r\n], LexerPushModeAction.prototype, \"execute\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerPushModeAction.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerPushModeAction.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerPushModeAction.prototype, \"toString\", null);\r\nexports.LexerPushModeAction = LexerPushModeAction;\r\n//# sourceMappingURL=LexerPushModeAction.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n * Implements the {@code popMode} lexer action by calling {@link Lexer#popMode}.\r\n *\r\n * <p>The {@code popMode} command does not have any parameters, so this action is\r\n * implemented as a singleton instance exposed by {@link #INSTANCE}.</p>\r\n *\r\n * @author Sam Harwell\r\n * @since 4.2\r\n */\r\nclass LexerPopModeAction {\r\n /**\r\n * Constructs the singleton instance of the lexer {@code popMode} command.\r\n */\r\n constructor() {\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@link LexerActionType#POP_MODE}.\r\n */\r\n get actionType() {\r\n return 4 /* POP_MODE */;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@code false}.\r\n */\r\n get isPositionDependent() {\r\n return false;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This action is implemented by calling {@link Lexer#popMode}.</p>\r\n */\r\n execute(lexer) {\r\n lexer.popMode();\r\n }\r\n hashCode() {\r\n let hash = MurmurHash_1.MurmurHash.initialize();\r\n hash = MurmurHash_1.MurmurHash.update(hash, this.actionType);\r\n return MurmurHash_1.MurmurHash.finish(hash, 1);\r\n }\r\n equals(obj) {\r\n return obj === this;\r\n }\r\n toString() {\r\n return \"popMode\";\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerPopModeAction.prototype, \"actionType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerPopModeAction.prototype, \"isPositionDependent\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull)\r\n], LexerPopModeAction.prototype, \"execute\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerPopModeAction.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerPopModeAction.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerPopModeAction.prototype, \"toString\", null);\r\nexports.LexerPopModeAction = LexerPopModeAction;\r\n(function (LexerPopModeAction) {\r\n /**\r\n * Provides a singleton instance of this parameterless lexer action.\r\n */\r\n LexerPopModeAction.INSTANCE = new LexerPopModeAction();\r\n})(LexerPopModeAction = exports.LexerPopModeAction || (exports.LexerPopModeAction = {}));\r\n//# sourceMappingURL=LexerPopModeAction.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n * Implements the {@code more} lexer action by calling {@link Lexer#more}.\r\n *\r\n * <p>The {@code more} command does not have any parameters, so this action is\r\n * implemented as a singleton instance exposed by {@link #INSTANCE}.</p>\r\n *\r\n * @author Sam Harwell\r\n * @since 4.2\r\n */\r\nclass LexerMoreAction {\r\n /**\r\n * Constructs the singleton instance of the lexer {@code more} command.\r\n */\r\n constructor() {\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@link LexerActionType#MORE}.\r\n */\r\n get actionType() {\r\n return 3 /* MORE */;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@code false}.\r\n */\r\n get isPositionDependent() {\r\n return false;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This action is implemented by calling {@link Lexer#more}.</p>\r\n */\r\n execute(lexer) {\r\n lexer.more();\r\n }\r\n hashCode() {\r\n let hash = MurmurHash_1.MurmurHash.initialize();\r\n hash = MurmurHash_1.MurmurHash.update(hash, this.actionType);\r\n return MurmurHash_1.MurmurHash.finish(hash, 1);\r\n }\r\n equals(obj) {\r\n return obj === this;\r\n }\r\n toString() {\r\n return \"more\";\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerMoreAction.prototype, \"actionType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerMoreAction.prototype, \"isPositionDependent\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull)\r\n], LexerMoreAction.prototype, \"execute\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerMoreAction.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerMoreAction.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerMoreAction.prototype, \"toString\", null);\r\nexports.LexerMoreAction = LexerMoreAction;\r\n(function (LexerMoreAction) {\r\n /**\r\n * Provides a singleton instance of this parameterless lexer action.\r\n */\r\n LexerMoreAction.INSTANCE = new LexerMoreAction();\r\n})(LexerMoreAction = exports.LexerMoreAction || (exports.LexerMoreAction = {}));\r\n//# sourceMappingURL=LexerMoreAction.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n * Implements the {@code mode} lexer action by calling {@link Lexer#mode} with\r\n * the assigned mode.\r\n *\r\n * @author Sam Harwell\r\n * @since 4.2\r\n */\r\nclass LexerModeAction {\r\n /**\r\n * Constructs a new {@code mode} action with the specified mode value.\r\n * @param mode The mode value to pass to {@link Lexer#mode}.\r\n */\r\n constructor(mode) {\r\n this._mode = mode;\r\n }\r\n /**\r\n * Get the lexer mode this action should transition the lexer to.\r\n *\r\n * @return The lexer mode for this {@code mode} command.\r\n */\r\n get mode() {\r\n return this._mode;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@link LexerActionType#MODE}.\r\n */\r\n get actionType() {\r\n return 2 /* MODE */;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@code false}.\r\n */\r\n get isPositionDependent() {\r\n return false;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This action is implemented by calling {@link Lexer#mode} with the\r\n * value provided by {@link #getMode}.</p>\r\n */\r\n execute(lexer) {\r\n lexer.mode(this._mode);\r\n }\r\n hashCode() {\r\n let hash = MurmurHash_1.MurmurHash.initialize();\r\n hash = MurmurHash_1.MurmurHash.update(hash, this.actionType);\r\n hash = MurmurHash_1.MurmurHash.update(hash, this._mode);\r\n return MurmurHash_1.MurmurHash.finish(hash, 2);\r\n }\r\n equals(obj) {\r\n if (obj === this) {\r\n return true;\r\n }\r\n else if (!(obj instanceof LexerModeAction)) {\r\n return false;\r\n }\r\n return this._mode === obj._mode;\r\n }\r\n toString() {\r\n return `mode(${this._mode})`;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerModeAction.prototype, \"actionType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerModeAction.prototype, \"isPositionDependent\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull)\r\n], LexerModeAction.prototype, \"execute\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerModeAction.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerModeAction.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerModeAction.prototype, \"toString\", null);\r\nexports.LexerModeAction = LexerModeAction;\r\n//# sourceMappingURL=LexerModeAction.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n * Executes a custom lexer action by calling {@link Recognizer#action} with the\r\n * rule and action indexes assigned to the custom action. The implementation of\r\n * a custom action is added to the generated code for the lexer in an override\r\n * of {@link Recognizer#action} when the grammar is compiled.\r\n *\r\n * <p>This class may represent embedded actions created with the <code>{...}</code>\r\n * syntax in ANTLR 4, as well as actions created for lexer commands where the\r\n * command argument could not be evaluated when the grammar was compiled.</p>\r\n *\r\n * @author Sam Harwell\r\n * @since 4.2\r\n */\r\nclass LexerCustomAction {\r\n /**\r\n * Constructs a custom lexer action with the specified rule and action\r\n * indexes.\r\n *\r\n * @param ruleIndex The rule index to use for calls to\r\n * {@link Recognizer#action}.\r\n * @param actionIndex The action index to use for calls to\r\n * {@link Recognizer#action}.\r\n */\r\n constructor(ruleIndex, actionIndex) {\r\n this._ruleIndex = ruleIndex;\r\n this._actionIndex = actionIndex;\r\n }\r\n /**\r\n * Gets the rule index to use for calls to {@link Recognizer#action}.\r\n *\r\n * @return The rule index for the custom action.\r\n */\r\n get ruleIndex() {\r\n return this._ruleIndex;\r\n }\r\n /**\r\n * Gets the action index to use for calls to {@link Recognizer#action}.\r\n *\r\n * @return The action index for the custom action.\r\n */\r\n get actionIndex() {\r\n return this._actionIndex;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * @return This method returns {@link LexerActionType#CUSTOM}.\r\n */\r\n get actionType() {\r\n return 1 /* CUSTOM */;\r\n }\r\n /**\r\n * Gets whether the lexer action is position-dependent. Position-dependent\r\n * actions may have different semantics depending on the {@link CharStream}\r\n * index at the time the action is executed.\r\n *\r\n * <p>Custom actions are position-dependent since they may represent a\r\n * user-defined embedded action which makes calls to methods like\r\n * {@link Lexer#getText}.</p>\r\n *\r\n * @return This method returns {@code true}.\r\n */\r\n get isPositionDependent() {\r\n return true;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>Custom actions are implemented by calling {@link Lexer#action} with the\r\n * appropriate rule and action indexes.</p>\r\n */\r\n execute(lexer) {\r\n lexer.action(undefined, this._ruleIndex, this._actionIndex);\r\n }\r\n hashCode() {\r\n let hash = MurmurHash_1.MurmurHash.initialize();\r\n hash = MurmurHash_1.MurmurHash.update(hash, this.actionType);\r\n hash = MurmurHash_1.MurmurHash.update(hash, this._ruleIndex);\r\n hash = MurmurHash_1.MurmurHash.update(hash, this._actionIndex);\r\n return MurmurHash_1.MurmurHash.finish(hash, 3);\r\n }\r\n equals(obj) {\r\n if (obj === this) {\r\n return true;\r\n }\r\n else if (!(obj instanceof LexerCustomAction)) {\r\n return false;\r\n }\r\n return this._ruleIndex === obj._ruleIndex\r\n && this._actionIndex === obj._actionIndex;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerCustomAction.prototype, \"actionType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerCustomAction.prototype, \"isPositionDependent\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull)\r\n], LexerCustomAction.prototype, \"execute\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerCustomAction.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerCustomAction.prototype, \"equals\", null);\r\nexports.LexerCustomAction = LexerCustomAction;\r\n//# sourceMappingURL=LexerCustomAction.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n * Implements the {@code channel} lexer action by calling\r\n * {@link Lexer#setChannel} with the assigned channel.\r\n *\r\n * @author Sam Harwell\r\n * @since 4.2\r\n */\r\nclass LexerChannelAction {\r\n /**\r\n * Constructs a new {@code channel} action with the specified channel value.\r\n * @param channel The channel value to pass to {@link Lexer#setChannel}.\r\n */\r\n constructor(channel) {\r\n this._channel = channel;\r\n }\r\n /**\r\n * Gets the channel to use for the {@link Token} created by the lexer.\r\n *\r\n * @return The channel to use for the {@link Token} created by the lexer.\r\n */\r\n get channel() {\r\n return this._channel;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@link LexerActionType#CHANNEL}.\r\n */\r\n get actionType() {\r\n return 0 /* CHANNEL */;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@code false}.\r\n */\r\n get isPositionDependent() {\r\n return false;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This action is implemented by calling {@link Lexer#setChannel} with the\r\n * value provided by {@link #getChannel}.</p>\r\n */\r\n execute(lexer) {\r\n lexer.channel = this._channel;\r\n }\r\n hashCode() {\r\n let hash = MurmurHash_1.MurmurHash.initialize();\r\n hash = MurmurHash_1.MurmurHash.update(hash, this.actionType);\r\n hash = MurmurHash_1.MurmurHash.update(hash, this._channel);\r\n return MurmurHash_1.MurmurHash.finish(hash, 2);\r\n }\r\n equals(obj) {\r\n if (obj === this) {\r\n return true;\r\n }\r\n else if (!(obj instanceof LexerChannelAction)) {\r\n return false;\r\n }\r\n return this._channel === obj._channel;\r\n }\r\n toString() {\r\n return `channel(${this._channel})`;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerChannelAction.prototype, \"actionType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerChannelAction.prototype, \"isPositionDependent\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n __param(0, Decorators_1.NotNull)\r\n], LexerChannelAction.prototype, \"execute\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerChannelAction.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerChannelAction.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerChannelAction.prototype, \"toString\", null);\r\nexports.LexerChannelAction = LexerChannelAction;\r\n//# sourceMappingURL=LexerChannelAction.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst Transition_1 = require(\"./Transition\");\r\nlet EpsilonTransition = class EpsilonTransition extends Transition_1.Transition {\r\n constructor(target, outermostPrecedenceReturn = -1) {\r\n super(target);\r\n this._outermostPrecedenceReturn = outermostPrecedenceReturn;\r\n }\r\n /**\r\n * @return the rule index of a precedence rule for which this transition is\r\n * returning from, where the precedence value is 0; otherwise, -1.\r\n *\r\n * @see ATNConfig.isPrecedenceFilterSuppressed\r\n * @see ParserATNSimulator#applyPrecedenceFilter(ATNConfigSet, ParserRuleContext, PredictionContextCache)\r\n * @since 4.4.1\r\n */\r\n get outermostPrecedenceReturn() {\r\n return this._outermostPrecedenceReturn;\r\n }\r\n get serializationType() {\r\n return 1 /* EPSILON */;\r\n }\r\n get isEpsilon() {\r\n return true;\r\n }\r\n matches(symbol, minVocabSymbol, maxVocabSymbol) {\r\n return false;\r\n }\r\n toString() {\r\n return \"epsilon\";\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override\r\n], EpsilonTransition.prototype, \"serializationType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], EpsilonTransition.prototype, \"isEpsilon\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], EpsilonTransition.prototype, \"matches\", null);\r\n__decorate([\r\n Decorators_1.Override,\r\n Decorators_1.NotNull\r\n], EpsilonTransition.prototype, \"toString\", null);\r\nEpsilonTransition = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], EpsilonTransition);\r\nexports.EpsilonTransition = EpsilonTransition;\r\n//# sourceMappingURL=EpsilonTransition.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:27.9125304-07:00\r\nconst ATNState_1 = require(\"./ATNState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/** Terminal node of a simple {@code (a|b|c)} block. */\r\nclass BlockEndState extends ATNState_1.ATNState {\r\n get stateType() {\r\n return 8 /* BLOCK_END */;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], BlockEndState.prototype, \"stateType\", null);\r\nexports.BlockEndState = BlockEndState;\r\n//# sourceMappingURL=BlockEndState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst BlockStartState_1 = require(\"./BlockStartState\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass BasicBlockStartState extends BlockStartState_1.BlockStartState {\r\n get stateType() {\r\n return 3 /* BLOCK_START */;\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], BasicBlockStartState.prototype, \"stateType\", null);\r\nexports.BasicBlockStartState = BasicBlockStartState;\r\n//# sourceMappingURL=BasicBlockStartState.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nconst ATNConfigSet_1 = require(\"./ATNConfigSet\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n *\r\n * @author Sam Harwell\r\n */\r\nclass OrderedATNConfigSet extends ATNConfigSet_1.ATNConfigSet {\r\n constructor(set, readonly) {\r\n if (set != null && readonly != null) {\r\n super(set, readonly);\r\n }\r\n else {\r\n super();\r\n }\r\n }\r\n clone(readonly) {\r\n let copy = new OrderedATNConfigSet(this, readonly);\r\n if (!readonly && this.isReadOnly) {\r\n copy.addAll(this);\r\n }\r\n return copy;\r\n }\r\n getKey(e) {\r\n // This is a specially crafted key to ensure configurations are only merged if they are equal\r\n return { state: 0, alt: e.hashCode() };\r\n }\r\n canMerge(left, leftKey, right) {\r\n return left.equals(right);\r\n }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], OrderedATNConfigSet.prototype, \"clone\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], OrderedATNConfigSet.prototype, \"getKey\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], OrderedATNConfigSet.prototype, \"canMerge\", null);\r\nexports.OrderedATNConfigSet = OrderedATNConfigSet;\r\n//# sourceMappingURL=OrderedATNConfigSet.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n * This implementation of {@link LexerAction} is used for tracking input offsets\r\n * for position-dependent actions within a {@link LexerActionExecutor}.\r\n *\r\n * <p>This action is not serialized as part of the ATN, and is only required for\r\n * position-dependent lexer actions which appear at a location other than the\r\n * end of a rule. For more information about DFA optimizations employed for\r\n * lexer actions, see {@link LexerActionExecutor#append} and\r\n * {@link LexerActionExecutor#fixOffsetBeforeMatch}.</p>\r\n *\r\n * @author Sam Harwell\r\n * @since 4.2\r\n */\r\nlet LexerIndexedCustomAction = class LexerIndexedCustomAction {\r\n /**\r\n * Constructs a new indexed custom action by associating a character offset\r\n * with a {@link LexerAction}.\r\n *\r\n * <p>Note: This class is only required for lexer actions for which\r\n * {@link LexerAction#isPositionDependent} returns {@code true}.</p>\r\n *\r\n * @param offset The offset into the input {@link CharStream}, relative to\r\n * the token start index, at which the specified lexer action should be\r\n * executed.\r\n * @param action The lexer action to execute at a particular offset in the\r\n * input {@link CharStream}.\r\n */\r\n constructor(offset, action) {\r\n this._offset = offset;\r\n this._action = action;\r\n }\r\n /**\r\n * Gets the location in the input {@link CharStream} at which the lexer\r\n * action should be executed. The value is interpreted as an offset relative\r\n * to the token start index.\r\n *\r\n * @return The location in the input {@link CharStream} at which the lexer\r\n * action should be executed.\r\n */\r\n get offset() {\r\n return this._offset;\r\n }\r\n /**\r\n * Gets the lexer action to execute.\r\n *\r\n * @return A {@link LexerAction} object which executes the lexer action.\r\n */\r\n get action() {\r\n return this._action;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * @return This method returns the result of calling {@link #getActionType}\r\n * on the {@link LexerAction} returned by {@link #getAction}.\r\n */\r\n get actionType() {\r\n return this._action.actionType;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n * @return This method returns {@code true}.\r\n */\r\n get isPositionDependent() {\r\n return true;\r\n }\r\n /**\r\n * {@inheritDoc}\r\n *\r\n * <p>This method calls {@link #execute} on the result of {@link #getAction}\r\n * using the provided {@code lexer}.</p>\r\n */\r\n execute(lexer) {\r\n // assume the input stream position was properly set by the calling code\r\n this._action.execute(lexer);\r\n }\r\n hashCode() {\r\n let hash = MurmurHash_1.MurmurHash.initialize();\r\n hash = MurmurHash_1.MurmurHash.update(hash, this._offset);\r\n hash = MurmurHash_1.MurmurHash.update(hash, this._action);\r\n return MurmurHash_1.MurmurHash.finish(hash, 2);\r\n }\r\n equals(obj) {\r\n if (obj === this) {\r\n return true;\r\n }\r\n else if (!(obj instanceof LexerIndexedCustomAction)) {\r\n return false;\r\n }\r\n return this._offset === obj._offset\r\n && this._action.equals(obj._action);\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], LexerIndexedCustomAction.prototype, \"action\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerIndexedCustomAction.prototype, \"actionType\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerIndexedCustomAction.prototype, \"isPositionDependent\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerIndexedCustomAction.prototype, \"execute\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerIndexedCustomAction.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerIndexedCustomAction.prototype, \"equals\", null);\r\nLexerIndexedCustomAction = __decorate([\r\n __param(1, Decorators_1.NotNull)\r\n], LexerIndexedCustomAction);\r\nexports.LexerIndexedCustomAction = LexerIndexedCustomAction;\r\n//# sourceMappingURL=LexerIndexedCustomAction.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:28.8810453-07:00\r\nconst ArrayEqualityComparator_1 = require(\"../misc/ArrayEqualityComparator\");\r\nconst LexerIndexedCustomAction_1 = require(\"./LexerIndexedCustomAction\");\r\nconst MurmurHash_1 = require(\"../misc/MurmurHash\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\n/**\r\n * Represents an executor for a sequence of lexer actions which traversed during\r\n * the matching operation of a lexer rule (token).\r\n *\r\n * <p>The executor tracks position information for position-dependent lexer actions\r\n * efficiently, ensuring that actions appearing only at the end of the rule do\r\n * not cause bloating of the {@link DFA} created for the lexer.</p>\r\n *\r\n * @author Sam Harwell\r\n * @since 4.2\r\n */\r\nlet LexerActionExecutor = class LexerActionExecutor {\r\n /**\r\n * Constructs an executor for a sequence of {@link LexerAction} actions.\r\n * @param lexerActions The lexer actions to execute.\r\n */\r\n constructor(lexerActions) {\r\n this._lexerActions = lexerActions;\r\n let hash = MurmurHash_1.MurmurHash.initialize();\r\n for (let lexerAction of lexerActions) {\r\n hash = MurmurHash_1.MurmurHash.update(hash, lexerAction);\r\n }\r\n this.cachedHashCode = MurmurHash_1.MurmurHash.finish(hash, lexerActions.length);\r\n }\r\n /**\r\n * Creates a {@link LexerActionExecutor} which executes the actions for\r\n * the input {@code lexerActionExecutor} followed by a specified\r\n * {@code lexerAction}.\r\n *\r\n * @param lexerActionExecutor The executor for actions already traversed by\r\n * the lexer while matching a token within a particular\r\n * {@link ATNConfig}. If this is {@code null}, the method behaves as though\r\n * it were an empty executor.\r\n * @param lexerAction The lexer action to execute after the actions\r\n * specified in {@code lexerActionExecutor}.\r\n *\r\n * @return A {@link LexerActionExecutor} for executing the combine actions\r\n * of {@code lexerActionExecutor} and {@code lexerAction}.\r\n */\r\n static append(lexerActionExecutor, lexerAction) {\r\n if (!lexerActionExecutor) {\r\n return new LexerActionExecutor([lexerAction]);\r\n }\r\n let lexerActions = lexerActionExecutor._lexerActions.slice(0);\r\n lexerActions.push(lexerAction);\r\n return new LexerActionExecutor(lexerActions);\r\n }\r\n /**\r\n * Creates a {@link LexerActionExecutor} which encodes the current offset\r\n * for position-dependent lexer actions.\r\n *\r\n * <p>Normally, when the executor encounters lexer actions where\r\n * {@link LexerAction#isPositionDependent} returns {@code true}, it calls\r\n * {@link IntStream#seek} on the input {@link CharStream} to set the input\r\n * position to the <em>end</em> of the current token. This behavior provides\r\n * for efficient DFA representation of lexer actions which appear at the end\r\n * of a lexer rule, even when the lexer rule matches a variable number of\r\n * characters.</p>\r\n *\r\n * <p>Prior to traversing a match transition in the ATN, the current offset\r\n * from the token start index is assigned to all position-dependent lexer\r\n * actions which have not already been assigned a fixed offset. By storing\r\n * the offsets relative to the token start index, the DFA representation of\r\n * lexer actions which appear in the middle of tokens remains efficient due\r\n * to sharing among tokens of the same length, regardless of their absolute\r\n * position in the input stream.</p>\r\n *\r\n * <p>If the current executor already has offsets assigned to all\r\n * position-dependent lexer actions, the method returns {@code this}.</p>\r\n *\r\n * @param offset The current offset to assign to all position-dependent\r\n * lexer actions which do not already have offsets assigned.\r\n *\r\n * @return A {@link LexerActionExecutor} which stores input stream offsets\r\n * for all position-dependent lexer actions.\r\n */\r\n fixOffsetBeforeMatch(offset) {\r\n let updatedLexerActions;\r\n for (let i = 0; i < this._lexerActions.length; i++) {\r\n if (this._lexerActions[i].isPositionDependent && !(this._lexerActions[i] instanceof LexerIndexedCustomAction_1.LexerIndexedCustomAction)) {\r\n if (!updatedLexerActions) {\r\n updatedLexerActions = this._lexerActions.slice(0);\r\n }\r\n updatedLexerActions[i] = new LexerIndexedCustomAction_1.LexerIndexedCustomAction(offset, this._lexerActions[i]);\r\n }\r\n }\r\n if (!updatedLexerActions) {\r\n return this;\r\n }\r\n return new LexerActionExecutor(updatedLexerActions);\r\n }\r\n /**\r\n * Gets the lexer actions to be executed by this executor.\r\n * @return The lexer actions to be executed by this executor.\r\n */\r\n get lexerActions() {\r\n return this._lexerActions;\r\n }\r\n /**\r\n * Execute the actions encapsulated by this executor within the context of a\r\n * particular {@link Lexer}.\r\n *\r\n * <p>This method calls {@link IntStream#seek} to set the position of the\r\n * {@code input} {@link CharStream} prior to calling\r\n * {@link LexerAction#execute} on a position-dependent action. Before the\r\n * method returns, the input position will be restored to the same position\r\n * it was in when the method was invoked.</p>\r\n *\r\n * @param lexer The lexer instance.\r\n * @param input The input stream which is the source for the current token.\r\n * When this method is called, the current {@link IntStream#index} for\r\n * {@code input} should be the start of the following token, i.e. 1\r\n * character past the end of the current token.\r\n * @param startIndex The token start index. This value may be passed to\r\n * {@link IntStream#seek} to set the {@code input} position to the beginning\r\n * of the token.\r\n */\r\n execute(lexer, input, startIndex) {\r\n let requiresSeek = false;\r\n let stopIndex = input.index;\r\n try {\r\n for (let lexerAction of this._lexerActions) {\r\n if (lexerAction instanceof LexerIndexedCustomAction_1.LexerIndexedCustomAction) {\r\n let offset = lexerAction.offset;\r\n input.seek(startIndex + offset);\r\n lexerAction = lexerAction.action;\r\n requiresSeek = (startIndex + offset) !== stopIndex;\r\n }\r\n else if (lexerAction.isPositionDependent) {\r\n input.seek(stopIndex);\r\n requiresSeek = false;\r\n }\r\n lexerAction.execute(lexer);\r\n }\r\n }\r\n finally {\r\n if (requiresSeek) {\r\n input.seek(stopIndex);\r\n }\r\n }\r\n }\r\n hashCode() {\r\n return this.cachedHashCode;\r\n }\r\n equals(obj) {\r\n if (obj === this) {\r\n return true;\r\n }\r\n else if (!(obj instanceof LexerActionExecutor)) {\r\n return false;\r\n }\r\n return this.cachedHashCode === obj.cachedHashCode\r\n && ArrayEqualityComparator_1.ArrayEqualityComparator.INSTANCE.equals(this._lexerActions, obj._lexerActions);\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.NotNull\r\n], LexerActionExecutor.prototype, \"_lexerActions\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull\r\n], LexerActionExecutor.prototype, \"lexerActions\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], LexerActionExecutor.prototype, \"execute\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerActionExecutor.prototype, \"hashCode\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], LexerActionExecutor.prototype, \"equals\", null);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(1, Decorators_1.NotNull)\r\n], LexerActionExecutor, \"append\", null);\r\nLexerActionExecutor = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], LexerActionExecutor);\r\nexports.LexerActionExecutor = LexerActionExecutor;\r\n//# sourceMappingURL=LexerActionExecutor.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:30.4445360-07:00\r\nconst AbstractPredicateTransition_1 = require(\"./AbstractPredicateTransition\");\r\nconst Array2DHashSet_1 = require(\"../misc/Array2DHashSet\");\r\nconst ATNConfig_1 = require(\"./ATNConfig\");\r\nconst BitSet_1 = require(\"../misc/BitSet\");\r\nconst IntervalSet_1 = require(\"../misc/IntervalSet\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst NotSetTransition_1 = require(\"./NotSetTransition\");\r\nconst ObjectEqualityComparator_1 = require(\"../misc/ObjectEqualityComparator\");\r\nconst PredictionContext_1 = require(\"./PredictionContext\");\r\nconst RuleStopState_1 = require(\"./RuleStopState\");\r\nconst RuleTransition_1 = require(\"./RuleTransition\");\r\nconst Token_1 = require(\"../Token\");\r\nconst WildcardTransition_1 = require(\"./WildcardTransition\");\r\nlet LL1Analyzer = class LL1Analyzer {\r\n constructor(atn) { this.atn = atn; }\r\n /**\r\n * Calculates the SLL(1) expected lookahead set for each outgoing transition\r\n * of an {@link ATNState}. The returned array has one element for each\r\n * outgoing transition in {@code s}. If the closure from transition\r\n * <em>i</em> leads to a semantic predicate before matching a symbol, the\r\n * element at index <em>i</em> of the result will be {@code null}.\r\n *\r\n * @param s the ATN state\r\n * @return the expected symbols for each outgoing transition of {@code s}.\r\n */\r\n getDecisionLookahead(s) {\r\n //\t\tSystem.out.println(\"LOOK(\"+s.stateNumber+\")\");\r\n if (s == null) {\r\n return undefined;\r\n }\r\n let look = new Array(s.numberOfTransitions);\r\n for (let alt = 0; alt < s.numberOfTransitions; alt++) {\r\n let current = new IntervalSet_1.IntervalSet();\r\n look[alt] = current;\r\n let lookBusy = new Array2DHashSet_1.Array2DHashSet(ObjectEqualityComparator_1.ObjectEqualityComparator.INSTANCE);\r\n let seeThruPreds = false; // fail to get lookahead upon pred\r\n this._LOOK(s.transition(alt).target, undefined, PredictionContext_1.PredictionContext.EMPTY_LOCAL, current, lookBusy, new BitSet_1.BitSet(), seeThruPreds, false);\r\n // Wipe out lookahead for this alternative if we found nothing\r\n // or we had a predicate when we !seeThruPreds\r\n if (current.size === 0 || current.contains(LL1Analyzer.HIT_PRED)) {\r\n current = undefined;\r\n look[alt] = current;\r\n }\r\n }\r\n return look;\r\n }\r\n LOOK(s, ctx, stopState) {\r\n if (stopState === undefined) {\r\n if (s.atn == null) {\r\n throw new Error(\"Illegal state\");\r\n }\r\n stopState = s.atn.ruleToStopState[s.ruleIndex];\r\n }\r\n else if (stopState === null) {\r\n // This is an explicit request to pass undefined as the stopState to _LOOK. Used to distinguish an overload\r\n // from the method which simply omits the stopState parameter.\r\n stopState = undefined;\r\n }\r\n let r = new IntervalSet_1.IntervalSet();\r\n let seeThruPreds = true; // ignore preds; get all lookahead\r\n let addEOF = true;\r\n this._LOOK(s, stopState, ctx, r, new Array2DHashSet_1.Array2DHashSet(), new BitSet_1.BitSet(), seeThruPreds, addEOF);\r\n return r;\r\n }\r\n /**\r\n * Compute set of tokens that can follow {@code s} in the ATN in the\r\n * specified {@code ctx}.\r\n * <p/>\r\n * If {@code ctx} is {@link PredictionContext#EMPTY_LOCAL} and\r\n * {@code stopState} or the end of the rule containing {@code s} is reached,\r\n * {@link Token#EPSILON} is added to the result set. If {@code ctx} is not\r\n * {@link PredictionContext#EMPTY_LOCAL} and {@code addEOF} is {@code true}\r\n * and {@code stopState} or the end of the outermost rule is reached,\r\n * {@link Token#EOF} is added to the result set.\r\n *\r\n * @param s the ATN state.\r\n * @param stopState the ATN state to stop at. This can be a\r\n * {@link BlockEndState} to detect epsilon paths through a closure.\r\n * @param ctx The outer context, or {@link PredictionContext#EMPTY_LOCAL} if\r\n * the outer context should not be used.\r\n * @param look The result lookahead set.\r\n * @param lookBusy A set used for preventing epsilon closures in the ATN\r\n * from causing a stack overflow. Outside code should pass\r\n * {@code new HashSet<ATNConfig>} for this argument.\r\n * @param calledRuleStack A set used for preventing left recursion in the\r\n * ATN from causing a stack overflow. Outside code should pass\r\n * {@code new BitSet()} for this argument.\r\n * @param seeThruPreds {@code true} to true semantic predicates as\r\n * implicitly {@code true} and \"see through them\", otherwise {@code false}\r\n * to treat semantic predicates as opaque and add {@link #HIT_PRED} to the\r\n * result if one is encountered.\r\n * @param addEOF Add {@link Token#EOF} to the result if the end of the\r\n * outermost context is reached. This parameter has no effect if {@code ctx}\r\n * is {@link PredictionContext#EMPTY_LOCAL}.\r\n */\r\n _LOOK(s, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF) {\r\n //\t\tSystem.out.println(\"_LOOK(\"+s.stateNumber+\", ctx=\"+ctx);\r\n let c = ATNConfig_1.ATNConfig.create(s, 0, ctx);\r\n if (!lookBusy.add(c))\r\n return;\r\n if (s === stopState) {\r\n if (PredictionContext_1.PredictionContext.isEmptyLocal(ctx)) {\r\n look.add(Token_1.Token.EPSILON);\r\n return;\r\n }\r\n else if (ctx.isEmpty) {\r\n if (addEOF) {\r\n look.add(Token_1.Token.EOF);\r\n }\r\n return;\r\n }\r\n }\r\n if (s instanceof RuleStopState_1.RuleStopState) {\r\n if (ctx.isEmpty && !PredictionContext_1.PredictionContext.isEmptyLocal(ctx)) {\r\n if (addEOF) {\r\n look.add(Token_1.Token.EOF);\r\n }\r\n return;\r\n }\r\n let removed = calledRuleStack.get(s.ruleIndex);\r\n try {\r\n calledRuleStack.clear(s.ruleIndex);\r\n for (let i = 0; i < ctx.size; i++) {\r\n if (ctx.getReturnState(i) === PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY) {\r\n continue;\r\n }\r\n let returnState = this.atn.states[ctx.getReturnState(i)];\r\n //\t\t\t\t\tSystem.out.println(\"popping back to \"+retState);\r\n this._LOOK(returnState, stopState, ctx.getParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF);\r\n }\r\n }\r\n finally {\r\n if (removed) {\r\n calledRuleStack.set(s.ruleIndex);\r\n }\r\n }\r\n }\r\n let n = s.numberOfTransitions;\r\n for (let i = 0; i < n; i++) {\r\n let t = s.transition(i);\r\n if (t instanceof RuleTransition_1.RuleTransition) {\r\n if (calledRuleStack.get(t.ruleIndex)) {\r\n continue;\r\n }\r\n let newContext = ctx.getChild(t.followState.stateNumber);\r\n try {\r\n calledRuleStack.set(t.ruleIndex);\r\n this._LOOK(t.target, stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);\r\n }\r\n finally {\r\n calledRuleStack.clear(t.ruleIndex);\r\n }\r\n }\r\n else if (t instanceof AbstractPredicateTransition_1.AbstractPredicateTransition) {\r\n if (seeThruPreds) {\r\n this._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);\r\n }\r\n else {\r\n look.add(LL1Analyzer.HIT_PRED);\r\n }\r\n }\r\n else if (t.isEpsilon) {\r\n this._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);\r\n }\r\n else if (t instanceof WildcardTransition_1.WildcardTransition) {\r\n look.addAll(IntervalSet_1.IntervalSet.of(Token_1.Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType));\r\n }\r\n else {\r\n //\t\t\t\tSystem.out.println(\"adding \"+ t);\r\n let set = t.label;\r\n if (set != null) {\r\n if (t instanceof NotSetTransition_1.NotSetTransition) {\r\n set = set.complement(IntervalSet_1.IntervalSet.of(Token_1.Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType));\r\n }\r\n look.addAll(set);\r\n }\r\n }\r\n }\r\n }\r\n};\r\n/** Special value added to the lookahead sets to indicate that we hit\r\n * a predicate during analysis if {@code seeThruPreds==false}.\r\n */\r\nLL1Analyzer.HIT_PRED = Token_1.Token.INVALID_TYPE;\r\n__decorate([\r\n Decorators_1.NotNull\r\n], LL1Analyzer.prototype, \"atn\", void 0);\r\n__decorate([\r\n Decorators_1.NotNull,\r\n __param(0, Decorators_1.NotNull), __param(1, Decorators_1.NotNull)\r\n], LL1Analyzer.prototype, \"LOOK\", null);\r\n__decorate([\r\n __param(0, Decorators_1.NotNull),\r\n __param(2, Decorators_1.NotNull),\r\n __param(3, Decorators_1.NotNull),\r\n __param(4, Decorators_1.NotNull),\r\n __param(5, Decorators_1.NotNull)\r\n], LL1Analyzer.prototype, \"_LOOK\", null);\r\nLL1Analyzer = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], LL1Analyzer);\r\nexports.LL1Analyzer = LL1Analyzer;\r\n//# sourceMappingURL=LL1Analyzer.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n};\r\nconst DFASerializer_1 = require(\"./DFASerializer\");\r\nconst Decorators_1 = require(\"../Decorators\");\r\nconst VocabularyImpl_1 = require(\"../VocabularyImpl\");\r\nlet LexerDFASerializer = class LexerDFASerializer extends DFASerializer_1.DFASerializer {\r\n constructor(dfa) {\r\n super(dfa, VocabularyImpl_1.VocabularyImpl.EMPTY_VOCABULARY);\r\n }\r\n getEdgeLabel(i) {\r\n return \"'\" + String.fromCharCode(i) + \"'\";\r\n }\r\n};\r\n__decorate([\r\n Decorators_1.Override,\r\n Decorators_1.NotNull\r\n], LexerDFASerializer.prototype, \"getEdgeLabel\", null);\r\nLexerDFASerializer = __decorate([\r\n __param(0, Decorators_1.NotNull)\r\n], LexerDFASerializer);\r\nexports.LexerDFASerializer = LexerDFASerializer;\r\n//# sourceMappingURL=LexerDFASerializer.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n// ConvertTo-TS run at 2016-10-04T11:26:49.2855056-07:00\r\n/**\r\n * This implementation of {@link ANTLRErrorStrategy} responds to syntax errors\r\n * by immediately canceling the parse operation with a\r\n * {@link ParseCancellationException}. The implementation ensures that the\r\n * {@link ParserRuleContext#exception} field is set for all parse tree nodes\r\n * that were not completed prior to encountering the error.\r\n *\r\n * <p>\r\n * This error strategy is useful in the following scenarios.</p>\r\n *\r\n * <ul>\r\n * <li><strong>Two-stage parsing:</strong> This error strategy allows the first\r\n * stage of two-stage parsing to immediately terminate if an error is\r\n * encountered, and immediately fall back to the second stage. In addition to\r\n * avoiding wasted work by attempting to recover from errors here, the empty\r\n * implementation of {@link BailErrorStrategy#sync} improves the performance of\r\n * the first stage.</li>\r\n * <li><strong>Silent validation:</strong> When syntax errors are not being\r\n * reported or logged, and the parse result is simply ignored if errors occur,\r\n * the {@link BailErrorStrategy} avoids wasting work on recovering from errors\r\n * when the result will be ignored either way.</li>\r\n * </ul>\r\n *\r\n * <p>\r\n * {@code myparser.errorHandler = new BailErrorStrategy();}</p>\r\n *\r\n * @see Parser.errorHandler\r\n */\r\nconst DefaultErrorStrategy_1 = require(\"./DefaultErrorStrategy\");\r\nconst InputMismatchException_1 = require(\"./InputMismatchException\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst ParseCancellationException_1 = require(\"./misc/ParseCancellationException\");\r\nclass BailErrorStrategy extends DefaultErrorStrategy_1.DefaultErrorStrategy {\r\n /** Instead of recovering from exception {@code e}, re-throw it wrapped\r\n * in a {@link ParseCancellationException} so it is not caught by the\r\n * rule function catches. Use {@link Exception#getCause()} to get the\r\n * original {@link RecognitionException}.\r\n */\r\n recover(recognizer, e) {\r\n for (let context = recognizer.context; context; context = context.parent) {\r\n context.exception = e;\r\n }\r\n throw new ParseCancellationException_1.ParseCancellationException(e);\r\n }\r\n /** Make sure we don't attempt to recover inline; if the parser\r\n * successfully recovers, it won't throw an exception.\r\n */\r\n recoverInline(recognizer) {\r\n let e = new InputMismatchException_1.InputMismatchException(recognizer);\r\n for (let context = recognizer.context; context; context = context.parent) {\r\n context.exception = e;\r\n }\r\n throw new ParseCancellationException_1.ParseCancellationException(e);\r\n }\r\n /** Make sure we don't attempt to recover from problems in subrules. */\r\n sync(recognizer) { }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], BailErrorStrategy.prototype, \"recover\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], BailErrorStrategy.prototype, \"recoverInline\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], BailErrorStrategy.prototype, \"sync\", null);\r\nexports.BailErrorStrategy = BailErrorStrategy;\r\n//# sourceMappingURL=BailErrorStrategy.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n// ConvertTo-TS run at 2016-10-04T11:26:49.0828748-07:00\r\n\"use strict\";\r\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n};\r\n/**\r\n * Vacuum all input from a {@link Reader}/{@link InputStream} and then treat it\r\n * like a {@code char[]} buffer. Can also pass in a {@link String} or\r\n * {@code char[]} to use.\r\n *\r\n * <p>If you need encoding, pass in stream/reader with correct encoding.</p>\r\n */\r\nconst assert = require(\"assert\");\r\nconst Decorators_1 = require(\"./Decorators\");\r\nconst IntStream_1 = require(\"./IntStream\");\r\nconst READ_BUFFER_SIZE = 1024;\r\nconst INITIAL_BUFFER_SIZE = 1024;\r\nclass ANTLRInputStream {\r\n /** Copy data in string to a local char array */\r\n constructor(input) {\r\n /** 0..n-1 index into string of next char */\r\n this.p = 0;\r\n this.data = input;\r\n this.n = input.length;\r\n }\r\n /** Reset the stream so that it's in the same state it was\r\n * when the object was created *except* the data array is not\r\n * touched.\r\n */\r\n reset() {\r\n this.p = 0;\r\n }\r\n consume() {\r\n if (this.p >= this.n) {\r\n assert(this.LA(1) === IntStream_1.IntStream.EOF);\r\n throw new Error(\"cannot consume EOF\");\r\n }\r\n //System.out.println(\"prev p=\"+p+\", c=\"+(char)data[p]);\r\n if (this.p < this.n) {\r\n this.p++;\r\n }\r\n }\r\n LA(i) {\r\n if (i === 0) {\r\n return 0; // undefined\r\n }\r\n if (i < 0) {\r\n i++; // e.g., translate LA(-1) to use offset i=0; then data[p+0-1]\r\n if ((this.p + i - 1) < 0) {\r\n return IntStream_1.IntStream.EOF; // invalid; no char before first char\r\n }\r\n }\r\n if ((this.p + i - 1) >= this.n) {\r\n //System.out.println(\"char LA(\"+i+\")=EOF; p=\"+p);\r\n return IntStream_1.IntStream.EOF;\r\n }\r\n //System.out.println(\"char LA(\"+i+\")=\"+(char)data[p+i-1]+\"; p=\"+p);\r\n //System.out.println(\"LA(\"+i+\"); p=\"+p+\" n=\"+n+\" data.length=\"+data.length);\r\n return this.data.charCodeAt(this.p + i - 1);\r\n }\r\n LT(i) {\r\n return this.LA(i);\r\n }\r\n /** Return the current input symbol index 0..n where n indicates the\r\n * last symbol has been read. The index is the index of char to\r\n * be returned from LA(1).\r\n */\r\n get index() {\r\n return this.p;\r\n }\r\n get size() {\r\n return this.n;\r\n }\r\n /** mark/release do nothing; we have entire buffer */\r\n mark() {\r\n return -1;\r\n }\r\n release(marker) {\r\n }\r\n /** consume() ahead until p==index; can't just set p=index as we must\r\n * update line and charPositionInLine. If we seek backwards, just set p\r\n */\r\n seek(index) {\r\n if (index <= this.p) {\r\n this.p = index; // just jump; don't update stream state (line, ...)\r\n return;\r\n }\r\n // seek forward, consume until p hits index or n (whichever comes first)\r\n index = Math.min(index, this.n);\r\n while (this.p < index) {\r\n this.consume();\r\n }\r\n }\r\n getText(interval) {\r\n let start = interval.a;\r\n let stop = interval.b;\r\n if (stop >= this.n)\r\n stop = this.n - 1;\r\n let count = stop - start + 1;\r\n if (start >= this.n)\r\n return \"\";\r\n // System.err.println(\"data: \"+Arrays.toString(data)+\", n=\"+n+\r\n // \t\t\t\t \", start=\"+start+\r\n // \t\t\t\t \", stop=\"+stop);\r\n return this.data.substr(start, count);\r\n }\r\n get sourceName() {\r\n if (!this.name) {\r\n return IntStream_1.IntStream.UNKNOWN_SOURCE_NAME;\r\n }\r\n return this.name;\r\n }\r\n toString() { return this.data; }\r\n}\r\n__decorate([\r\n Decorators_1.Override\r\n], ANTLRInputStream.prototype, \"consume\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ANTLRInputStream.prototype, \"LA\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ANTLRInputStream.prototype, \"index\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ANTLRInputStream.prototype, \"size\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ANTLRInputStream.prototype, \"mark\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ANTLRInputStream.prototype, \"release\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ANTLRInputStream.prototype, \"seek\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ANTLRInputStream.prototype, \"getText\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ANTLRInputStream.prototype, \"sourceName\", null);\r\n__decorate([\r\n Decorators_1.Override\r\n], ANTLRInputStream.prototype, \"toString\", null);\r\nexports.ANTLRInputStream = ANTLRInputStream;\r\n//# sourceMappingURL=ANTLRInputStream.js.map","/*!\r\n * Copyright 2016 The ANTLR Project. All rights reserved.\r\n * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.\r\n */\r\n\"use strict\";\r\nfunction __export(m) {\r\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n// export * from './ANTLRFileStream';\r\n__export(require(\"./ANTLRInputStream\"));\r\n__export(require(\"./BailErrorStrategy\"));\r\n__export(require(\"./BaseErrorListener\"));\r\n__export(require(\"./BufferedTokenStream\"));\r\n__export(require(\"./CommonToken\"));\r\n__export(require(\"./CommonTokenFactory\"));\r\n__export(require(\"./CommonTokenStream\"));\r\n__export(require(\"./ConsoleErrorListener\"));\r\n__export(require(\"./DefaultErrorStrategy\"));\r\n__export(require(\"./Dependents\"));\r\n__export(require(\"./DiagnosticErrorListener\"));\r\n__export(require(\"./FailedPredicateException\"));\r\n__export(require(\"./InputMismatchException\"));\r\n__export(require(\"./InterpreterRuleContext\"));\r\n__export(require(\"./IntStream\"));\r\n__export(require(\"./Lexer\"));\r\n__export(require(\"./LexerInterpreter\"));\r\n__export(require(\"./LexerNoViableAltException\"));\r\n__export(require(\"./ListTokenSource\"));\r\n__export(require(\"./NoViableAltException\"));\r\n__export(require(\"./Parser\"));\r\n__export(require(\"./ParserInterpreter\"));\r\n__export(require(\"./ParserRuleContext\"));\r\n__export(require(\"./ProxyErrorListener\"));\r\n__export(require(\"./ProxyParserErrorListener\"));\r\n__export(require(\"./RecognitionException\"));\r\n__export(require(\"./Recognizer\"));\r\n__export(require(\"./RuleContext\"));\r\n__export(require(\"./RuleContextWithAltNum\"));\r\n__export(require(\"./RuleDependency\"));\r\n__export(require(\"./RuleVersion\"));\r\n__export(require(\"./Token\"));\r\n__export(require(\"./VocabularyImpl\"));\r\n//# sourceMappingURL=index.js.map","import { ANTLRInputStream, CommonTokenStream } from \"antlr4ts\";\nimport {\n Api,\n ArrayType,\n Endpoint,\n Method,\n RouteSubpath,\n StructType,\n SymbolType,\n Type,\n TypeDef,\n TypeName,\n} from \"./defs\";\nimport { ApiDefLexer } from \"./grammar/ApiDefLexer\";\nimport {\n ApiDefParser,\n ArrayContext,\n EndpointContext,\n HeadersContext,\n MethodContext,\n RouteContext,\n StructContext,\n StructfieldContext,\n SubpathContext,\n SymbolContext,\n TypeContext,\n TypedefContext,\n TypenameContext,\n} from \"./grammar/ApiDefParser\";\n\nexport function parse(code: string): Api {\n const inputStream = new ANTLRInputStream(code);\n const lexer = new ApiDefLexer(inputStream);\n const tokenStream = new CommonTokenStream(lexer);\n const parser = new ApiDefParser(tokenStream);\n let error: {\n line: number;\n charPositionInLine: number;\n message: string;\n } | null = null;\n lexer.removeErrorListeners();\n lexer.addErrorListener({\n syntaxError: (\n recognizer,\n offendingSymbol,\n line,\n charPositionInLine,\n message,\n e,\n ) => {\n if (!error) {\n error = { line, charPositionInLine, message };\n }\n },\n });\n parser.removeErrorListeners();\n parser.addErrorListener({\n syntaxError: (\n recognizer,\n offendingSymbol,\n line,\n charPositionInLine,\n message,\n e,\n ) => {\n if (!error) {\n error = { line, charPositionInLine, message };\n }\n },\n });\n const result = parser.api();\n if (error) {\n throw new Error(\n `Syntax error (${error!.line}:${error!.charPositionInLine}): ${\n error!.message\n }.`,\n );\n }\n return {\n endpoints: result.endpoint().map(read_endpoint),\n typeDefs: result.typedef().map(read_typedef),\n };\n}\n\nfunction read_endpoint(endpoint: EndpointContext): Endpoint {\n return {\n name: endpoint.endpointname().text,\n method: read_method(endpoint.method()),\n route: read_route(endpoint.route()),\n headers: read_headers(endpoint.headers()),\n input: read_typename(endpoint.typename()[0]),\n output: read_typename(endpoint.typename()[1]),\n };\n}\n\nfunction read_method(method: MethodContext): Method {\n return method.text as Method;\n}\n\nfunction read_route(route: RouteContext): RouteSubpath[] {\n return route.subpath().map(read_subpath);\n}\n\nfunction read_subpath(subpath: SubpathContext): RouteSubpath {\n return {\n name: subpath.name().text,\n dynamic: !!subpath._dynamic,\n };\n}\n\nfunction read_headers(headers?: HeadersContext) {\n if (headers) {\n return read_typename(headers.typename());\n } else {\n return undefined;\n }\n}\n\nfunction read_typedef(typedef: TypedefContext): TypeDef {\n return {\n name: typedef.typename().text,\n type: read_type(typedef.type()),\n };\n}\n\nfunction read_type(type: TypeContext): Type {\n if (type.array()) {\n return read_array(type.array()!);\n } else if (type.type().length) {\n return {\n kind: \"union\",\n items: flattenUnion(type.type().map(read_type)),\n };\n } else if (type.struct()) {\n return read_struct(type.struct()!);\n } else if (type.symbol()) {\n return read_symbol(type.symbol()!);\n } else if (type.typename()) {\n return read_typename(type.typename()!);\n } else {\n throw new Error();\n }\n}\n\nfunction read_array(array: ArrayContext): ArrayType {\n return {\n kind: \"array\",\n items: read_typename(array.typename()),\n };\n}\n\nfunction flattenUnion(types: Type[]): Type[] {\n return types\n .map((type) => {\n if (typeof type !== \"string\" && type.kind === \"union\") {\n return type.items;\n } else {\n return [type];\n }\n })\n .reduce((acc, curr) => acc.concat(curr), []);\n}\n\nfunction read_struct(struct: StructContext): StructType {\n const items = struct\n .structfield()\n .map(read_structfield)\n .reduce((acc, [fieldName, fieldType]) => {\n return {\n ...acc,\n [fieldName]: fieldType,\n };\n }, {});\n return {\n kind: \"struct\",\n items,\n };\n}\n\nfunction read_structfield(structfield: StructfieldContext): [string, Type] {\n const name = structfield.fieldname().text;\n let type = read_type(structfield.type());\n if (structfield._optional) {\n type = {\n kind: \"optional\",\n type,\n };\n }\n return [name, type];\n}\n\nfunction read_symbol(symbol: SymbolContext): SymbolType {\n return {\n kind: \"symbol\",\n value: symbol.name().text,\n };\n}\n\nfunction read_typename(typename: TypenameContext): TypeName {\n return typename.text;\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nclass TextBuilder {\n constructor() {\n /** List of non-empty parts to concatenate. */\n this._parts = [];\n this._indentLevel = 0;\n }\n append(...text) {\n let incomingTextLength = 0;\n for (let t of text) {\n incomingTextLength += t.length;\n }\n if (incomingTextLength === 0) {\n return;\n }\n if (this._getLastCharacter() === \"\\n\") {\n for (let i = 0; i < this._indentLevel; i++) {\n this._parts.push(\" \");\n }\n }\n for (let t of text) {\n if (t.length === 0) {\n continue;\n }\n this._parts.push(t);\n }\n }\n indented(block) {\n this._indentLevel++;\n this._addLinebreakIfNotBeginning();\n try {\n block();\n }\n finally {\n this._indentLevel--;\n let lastCharacter = this._getLastCharacter();\n if (lastCharacter.length && lastCharacter !== \"\\n\") {\n this._addLinebreakIfNotBeginning();\n }\n }\n }\n linebreak() {\n this._parts.push(\"\\n\");\n }\n build() {\n return this._parts.join(\"\");\n }\n _addLinebreakIfNotBeginning() {\n let lastCharacter = this._getLastCharacter();\n if (lastCharacter.length && lastCharacter !== \"\\n\") {\n this.linebreak();\n }\n }\n _getLastCharacter() {\n if (this._parts.length === 0) {\n return \"\";\n }\n let lastPart = this._parts[this._parts.length - 1];\n return lastPart[lastPart.length - 1];\n }\n}\nexports.default = TextBuilder;\n","import TextBuilder from \"textbuilder\";\nimport { Endpoint, PRIMITIVE_TYPES, PrimitiveType, Type } from \"../defs\";\nimport { EndpointDefinitions, TypeDefinitions } from \"../resolver\";\n\nexport interface GenerateOptions {\n endpoints?:\n | {\n kind: \"client\";\n baseUrl: string;\n }\n | {\n kind: \"server\";\n };\n}\n\nexport function generateTypeScript(\n endpointDefinitions: EndpointDefinitions,\n typeDefinitions: TypeDefinitions,\n options: GenerateOptions = {},\n) {\n const t = new TextBuilder();\n let firstBlock = true;\n if (options.endpoints && options.endpoints.kind === \"client\") {\n if (options.endpoints.baseUrl.endsWith(\"/\")) {\n throw new Error(`Base URL should not end with /.`);\n }\n t.append('import axios from \"axios\";\\n\\n');\n t.append(`const URL = \\\"${options.endpoints.baseUrl}\\\";\\n\\n`);\n for (const endpoint of Object.values(endpointDefinitions)) {\n appendClientEndpoint(endpoint);\n t.append(\"\\n\\n\");\n }\n }\n if (options.endpoints && options.endpoints.kind === \"server\") {\n t.append('import express from \"express\";\\n');\n for (const endpoint of Object.values(endpointDefinitions)) {\n t.append(\n `import { ${endpoint.name} } from './endpoints/${endpoint.name}';\\n`,\n );\n }\n t.append(\"\\n\");\n t.append(\"const PORT = 3010;\\n\\n\");\n t.append(\"const app = express();\\n\\n\");\n for (const endpoint of Object.values(endpointDefinitions)) {\n appendServerEndpoint(endpoint);\n t.append(\"\\n\\n\");\n }\n t.append(\"// tslint:disable-next-line no-console\\n\");\n t.append(\n \"app.listen(PORT, () => console.log(`Listening on port ${PORT}`));\\n\\n\",\n );\n }\n for (const [name, type] of Object.entries(typeDefinitions)) {\n if (!firstBlock) {\n t.append(\"\\n\");\n }\n appendType(type, name);\n firstBlock = false;\n }\n return t.build();\n\n function appendClientEndpoint(endpoint: Endpoint) {\n const endpointArguments: string[] = [];\n if (endpoint.headers) {\n endpointArguments.push(`headers: ${endpoint.headers}`);\n }\n for (const subpath of endpoint.route) {\n if (subpath.dynamic) {\n endpointArguments.push(`${subpath.name}: string`);\n }\n }\n if (endpoint.input !== \"void\") {\n endpointArguments.push(`request: ${endpoint.input}`);\n }\n t.append(\n `export async function ${endpoint.name}(${endpointArguments.join(\n \", \",\n )}): Promise<${endpoint.output}> {`,\n );\n t.indented(() => {\n t.append(`const url = \\`\\${URL}`);\n for (const subpath of endpoint.route) {\n if (subpath.dynamic) {\n t.append(`/\\${${subpath.name}}`);\n } else {\n t.append(`/${subpath.name}`);\n }\n }\n t.append(\"`;\\n\");\n if (endpoint.output !== \"void\") {\n t.append(\"const response = \");\n }\n t.append(`await axios({`);\n t.indented(() => {\n t.append(\"url,\\n\");\n t.append(`method: \"${endpoint.method}\",\\n`);\n if (endpoint.input !== \"void\") {\n t.append(\"data: request,\\n\");\n }\n if (endpoint.headers) {\n t.append(\"headers,\\n\");\n }\n });\n t.append(\"});\\n\");\n if (endpoint.output !== \"void\") {\n t.append(\"return response.data;\\n\");\n }\n });\n t.append(\"}\");\n }\n\n function appendServerEndpoint(endpoint: Endpoint) {\n const path = endpoint.route\n .map((subpath) => {\n if (subpath.dynamic) {\n return \":\" + subpath.name;\n } else {\n return subpath.name;\n }\n })\n .join(\"/\");\n t.append(\n `app.${endpoint.method.toLowerCase()}(\"/${path}\", async (req, res, next) => {`,\n );\n t.indented(() => {\n t.append(\"try {\");\n t.indented(() => {\n const args: string[] = [];\n // TODO: Double check header values.\n if (endpoint.headers) {\n args.push(\"headers\");\n t.append(`const headers: ${endpoint.headers} = {`);\n t.indented(() => {\n const headersType = typeDefinitions[endpoint.headers!];\n if (\n typeof headersType === \"string\" ||\n headersType.kind !== \"struct\"\n ) {\n throw new Error(\n `Headers type ${endpoint.headers} must be a struct.`,\n );\n }\n for (const [fieldName, fieldType] of Object.entries(\n headersType.items,\n )) {\n if (fieldType !== \"string\") {\n throw new Error(`Header ${fieldName} must be a string.`);\n }\n t.append(`${fieldName}: req.header(\"${fieldName}\") || \"\",\\n`);\n }\n });\n t.append(`};\\n`);\n }\n for (const subpath of endpoint.route) {\n if (subpath.dynamic) {\n t.append(\n `const ${subpath.name} = req.params[\"${subpath.name}\"];\\n`,\n );\n args.push(subpath.name);\n }\n }\n // TODO: Double check input structure.\n if (endpoint.input !== \"void\") {\n args.push(\"request\");\n t.append(`const request: ${endpoint.input} = req.body;\\n`);\n }\n if (endpoint.output !== \"void\") {\n t.append(`const response: ${endpoint.output} = `);\n }\n t.append(`await ${endpoint.name}(${args.join(\", \")});\\n`);\n if (endpoint.output !== \"void\") {\n t.append(`res.json(response);\\n`);\n } else {\n t.append(\"res.end();\\n\");\n }\n });\n t.append(\"} catch (err) {\");\n t.indented(() => {\n t.append(\"next(err);\");\n });\n t.append(\"}\");\n });\n t.append(\"});\");\n }\n\n function appendType(type: Type, exported?: string) {\n if (typeof type === \"string\") {\n // TypeName.\n if (exported) {\n t.append(`export type ${exported} = `);\n }\n if (PRIMITIVE_TYPES.has(type)) {\n t.append(primitiveTypeToTypeScript(type as PrimitiveType));\n } else {\n t.append(type);\n }\n if (exported) {\n t.append(\";\\n\");\n }\n } else if (type.kind === \"array\") {\n if (exported) {\n t.append(`export type ${exported} = `);\n }\n appendType(type.items);\n t.append(\"[]\");\n if (exported) {\n t.append(\";\\n\");\n }\n } else if (type.kind === \"union\") {\n if (exported) {\n t.append(`export type ${exported} = `);\n }\n let first = true;\n for (const possibleType of type.items) {\n if (!first) {\n t.append(\" | \");\n }\n appendType(possibleType);\n first = false;\n }\n if (exported) {\n t.append(\";\\n\");\n }\n } else if (type.kind === \"struct\") {\n if (exported) {\n t.append(`export interface ${exported} `);\n }\n t.append(\"{\");\n t.indented(() => {\n for (const [fieldName, fieldType] of Object.entries(type.items)) {\n if (typeof fieldType !== \"string\" && fieldType.kind === \"optional\") {\n t.append(fieldName, \"?: \");\n appendType(fieldType.type);\n } else {\n t.append(fieldName, \": \");\n appendType(fieldType);\n }\n t.append(\";\\n\");\n }\n });\n t.append(\"}\");\n if (exported) {\n t.append(\"\\n\");\n }\n } else if (type.kind === \"symbol\") {\n if (exported) {\n t.append(`export type ${exported} = `);\n }\n t.append(`'${type.value}'`);\n if (exported) {\n t.append(\";\\n\");\n }\n } else {\n throw new Error();\n }\n }\n}\n\nfunction primitiveTypeToTypeScript(typeName: PrimitiveType) {\n if (typeName === \"bool\") {\n return \"boolean\";\n } else if (typeName === \"int\") {\n return \"number\";\n } else if (typeName === \"long\") {\n return \"number\";\n } else if (typeName === \"float\") {\n return \"number\";\n } else if (typeName === \"double\") {\n return \"number\";\n } else if (typeName === \"string\") {\n return \"string\";\n } else if (typeName === \"null\") {\n return \"null\";\n } else {\n throw new Error(`Unknown primary type: ${typeName}.`);\n }\n}\n","module.exports = require(\"path\");","module.exports = require(\"child_process\");","module.exports = require(\"events\");","/**\n * Module dependencies.\n */\n\nvar EventEmitter = require('events').EventEmitter;\nvar spawn = require('child_process').spawn;\nvar path = require('path');\nvar dirname = path.dirname;\nvar basename = path.basename;\nvar fs = require('fs');\n\n/**\n * Inherit `Command` from `EventEmitter.prototype`.\n */\n\nrequire('util').inherits(Command, EventEmitter);\n\n/**\n * Expose the root command.\n */\n\nexports = module.exports = new Command();\n\n/**\n * Expose `Command`.\n */\n\nexports.Command = Command;\n\n/**\n * Expose `Option`.\n */\n\nexports.Option = Option;\n\n/**\n * Initialize a new `Option` with the given `flags` and `description`.\n *\n * @param {String} flags\n * @param {String} description\n * @api public\n */\n\nfunction Option(flags, description) {\n this.flags = flags;\n this.required = ~flags.indexOf('<');\n this.optional = ~flags.indexOf('[');\n this.bool = !~flags.indexOf('-no-');\n flags = flags.split(/[ ,|]+/);\n if (flags.length > 1 && !/^[[<]/.test(flags[1])) this.short = flags.shift();\n this.long = flags.shift();\n this.description = description || '';\n}\n\n/**\n * Return option name.\n *\n * @return {String}\n * @api private\n */\n\nOption.prototype.name = function() {\n return this.long\n .replace('--', '')\n .replace('no-', '');\n};\n\n/**\n * Return option name, in a camelcase format that can be used\n * as a object attribute key.\n *\n * @return {String}\n * @api private\n */\n\nOption.prototype.attributeName = function() {\n return camelcase(this.name());\n};\n\n/**\n * Check if `arg` matches the short or long flag.\n *\n * @param {String} arg\n * @return {Boolean}\n * @api private\n */\n\nOption.prototype.is = function(arg) {\n return this.short === arg || this.long === arg;\n};\n\n/**\n * Initialize a new `Command`.\n *\n * @param {String} name\n * @api public\n */\n\nfunction Command(name) {\n this.commands = [];\n this.options = [];\n this._execs = {};\n this._allowUnknownOption = false;\n this._args = [];\n this._name = name || '';\n}\n\n/**\n * Add command `name`.\n *\n * The `.action()` callback is invoked when the\n * command `name` is specified via __ARGV__,\n * and the remaining arguments are applied to the\n * function for access.\n *\n * When the `name` is \"*\" an un-matched command\n * will be passed as the first arg, followed by\n * the rest of __ARGV__ remaining.\n *\n * Examples:\n *\n * program\n * .version('0.0.1')\n * .option('-C, --chdir <path>', 'change the working directory')\n * .option('-c, --config <path>', 'set config path. defaults to ./deploy.conf')\n * .option('-T, --no-tests', 'ignore test hook')\n *\n * program\n * .command('setup')\n * .description('run remote setup commands')\n * .action(function() {\n * console.log('setup');\n * });\n *\n * program\n * .command('exec <cmd>')\n * .description('run the given remote command')\n * .action(function(cmd) {\n * console.log('exec \"%s\"', cmd);\n * });\n *\n * program\n * .command('teardown <dir> [otherDirs...]')\n * .description('run teardown commands')\n * .action(function(dir, otherDirs) {\n * console.log('dir \"%s\"', dir);\n * if (otherDirs) {\n * otherDirs.forEach(function (oDir) {\n * console.log('dir \"%s\"', oDir);\n * });\n * }\n * });\n *\n * program\n * .command('*')\n * .description('deploy the given env')\n * .action(function(env) {\n * console.log('deploying \"%s\"', env);\n * });\n *\n * program.parse(process.argv);\n *\n * @param {String} name\n * @param {String} [desc] for git-style sub-commands\n * @return {Command} the new command\n * @api public\n */\n\nCommand.prototype.command = function(name, desc, opts) {\n if (typeof desc === 'object' && desc !== null) {\n opts = desc;\n desc = null;\n }\n opts = opts || {};\n var args = name.split(/ +/);\n var cmd = new Command(args.shift());\n\n if (desc) {\n cmd.description(desc);\n this.executables = true;\n this._execs[cmd._name] = true;\n if (opts.isDefault) this.defaultExecutable = cmd._name;\n }\n cmd._noHelp = !!opts.noHelp;\n this.commands.push(cmd);\n cmd.parseExpectedArgs(args);\n cmd.parent = this;\n\n if (desc) return this;\n return cmd;\n};\n\n/**\n * Define argument syntax for the top-level command.\n *\n * @api public\n */\n\nCommand.prototype.arguments = function(desc) {\n return this.parseExpectedArgs(desc.split(/ +/));\n};\n\n/**\n * Add an implicit `help [cmd]` subcommand\n * which invokes `--help` for the given command.\n *\n * @api private\n */\n\nCommand.prototype.addImplicitHelpCommand = function() {\n this.command('help [cmd]', 'display help for [cmd]');\n};\n\n/**\n * Parse expected `args`.\n *\n * For example `[\"[type]\"]` becomes `[{ required: false, name: 'type' }]`.\n *\n * @param {Array} args\n * @return {Command} for chaining\n * @api public\n */\n\nCommand.prototype.parseExpectedArgs = function(args) {\n if (!args.length) return;\n var self = this;\n args.forEach(function(arg) {\n var argDetails = {\n required: false,\n name: '',\n variadic: false\n };\n\n switch (arg[0]) {\n case '<':\n argDetails.required = true;\n argDetails.name = arg.slice(1, -1);\n break;\n case '[':\n argDetails.name = arg.slice(1, -1);\n break;\n }\n\n if (argDetails.name.length > 3 && argDetails.name.slice(-3) === '...') {\n argDetails.variadic = true;\n argDetails.name = argDetails.name.slice(0, -3);\n }\n if (argDetails.name) {\n self._args.push(argDetails);\n }\n });\n return this;\n};\n\n/**\n * Register callback `fn` for the command.\n *\n * Examples:\n *\n * program\n * .command('help')\n * .description('display verbose help')\n * .action(function() {\n * // output help here\n * });\n *\n * @param {Function} fn\n * @return {Command} for chaining\n * @api public\n */\n\nCommand.prototype.action = function(fn) {\n var self = this;\n var listener = function(args, unknown) {\n // Parse any so-far unknown options\n args = args || [];\n unknown = unknown || [];\n\n var parsed = self.parseOptions(unknown);\n\n // Output help if necessary\n outputHelpIfNecessary(self, parsed.unknown);\n\n // If there are still any unknown options, then we simply\n // die, unless someone asked for help, in which case we give it\n // to them, and then we die.\n if (parsed.unknown.length > 0) {\n self.unknownOption(parsed.unknown[0]);\n }\n\n // Leftover arguments need to be pushed back. Fixes issue #56\n if (parsed.args.length) args = parsed.args.concat(args);\n\n self._args.forEach(function(arg, i) {\n if (arg.required && args[i] == null) {\n self.missingArgument(arg.name);\n } else if (arg.variadic) {\n if (i !== self._args.length - 1) {\n self.variadicArgNotLast(arg.name);\n }\n\n args[i] = args.splice(i);\n }\n });\n\n // Always append ourselves to the end of the arguments,\n // to make sure we match the number of arguments the user\n // expects\n if (self._args.length) {\n args[self._args.length] = self;\n } else {\n args.push(self);\n }\n\n fn.apply(self, args);\n };\n var parent = this.parent || this;\n var name = parent === this ? '*' : this._name;\n parent.on('command:' + name, listener);\n if (this._alias) parent.on('command:' + this._alias, listener);\n return this;\n};\n\n/**\n * Define option with `flags`, `description` and optional\n * coercion `fn`.\n *\n * The `flags` string should contain both the short and long flags,\n * separated by comma, a pipe or space. The following are all valid\n * all will output this way when `--help` is used.\n *\n * \"-p, --pepper\"\n * \"-p|--pepper\"\n * \"-p --pepper\"\n *\n * Examples:\n *\n * // simple boolean defaulting to false\n * program.option('-p, --pepper', 'add pepper');\n *\n * --pepper\n * program.pepper\n * // => Boolean\n *\n * // simple boolean defaulting to true\n * program.option('-C, --no-cheese', 'remove cheese');\n *\n * program.cheese\n * // => true\n *\n * --no-cheese\n * program.cheese\n * // => false\n *\n * // required argument\n * program.option('-C, --chdir <path>', 'change the working directory');\n *\n * --chdir /tmp\n * program.chdir\n * // => \"/tmp\"\n *\n * // optional argument\n * program.option('-c, --cheese [type]', 'add cheese [marble]');\n *\n * @param {String} flags\n * @param {String} description\n * @param {Function|*} [fn] or default\n * @param {*} [defaultValue]\n * @return {Command} for chaining\n * @api public\n */\n\nCommand.prototype.option = function(flags, description, fn, defaultValue) {\n var self = this,\n option = new Option(flags, description),\n oname = option.name(),\n name = option.attributeName();\n\n // default as 3rd arg\n if (typeof fn !== 'function') {\n if (fn instanceof RegExp) {\n var regex = fn;\n fn = function(val, def) {\n var m = regex.exec(val);\n return m ? m[0] : def;\n };\n } else {\n defaultValue = fn;\n fn = null;\n }\n }\n\n // preassign default value only for --no-*, [optional], or <required>\n if (!option.bool || option.optional || option.required) {\n // when --no-* we make sure default is true\n if (!option.bool) defaultValue = true;\n // preassign only if we have a default\n if (defaultValue !== undefined) {\n self[name] = defaultValue;\n option.defaultValue = defaultValue;\n }\n }\n\n // register the option\n this.options.push(option);\n\n // when it's passed assign the value\n // and conditionally invoke the callback\n this.on('option:' + oname, function(val) {\n // coercion\n if (val !== null && fn) {\n val = fn(val, self[name] === undefined ? defaultValue : self[name]);\n }\n\n // unassigned or bool\n if (typeof self[name] === 'boolean' || typeof self[name] === 'undefined') {\n // if no value, bool true, and we have a default, then use it!\n if (val == null) {\n self[name] = option.bool\n ? defaultValue || true\n : false;\n } else {\n self[name] = val;\n }\n } else if (val !== null) {\n // reassign\n self[name] = val;\n }\n });\n\n return this;\n};\n\n/**\n * Allow unknown options on the command line.\n *\n * @param {Boolean} arg if `true` or omitted, no error will be thrown\n * for unknown options.\n * @api public\n */\nCommand.prototype.allowUnknownOption = function(arg) {\n this._allowUnknownOption = arguments.length === 0 || arg;\n return this;\n};\n\n/**\n * Parse `argv`, settings options and invoking commands when defined.\n *\n * @param {Array} argv\n * @return {Command} for chaining\n * @api public\n */\n\nCommand.prototype.parse = function(argv) {\n // implicit help\n if (this.executables) this.addImplicitHelpCommand();\n\n // store raw args\n this.rawArgs = argv;\n\n // guess name\n this._name = this._name || basename(argv[1], '.js');\n\n // github-style sub-commands with no sub-command\n if (this.executables && argv.length < 3 && !this.defaultExecutable) {\n // this user needs help\n argv.push('--help');\n }\n\n // process argv\n var parsed = this.parseOptions(this.normalize(argv.slice(2)));\n var args = this.args = parsed.args;\n\n var result = this.parseArgs(this.args, parsed.unknown);\n\n // executable sub-commands\n var name = result.args[0];\n\n var aliasCommand = null;\n // check alias of sub commands\n if (name) {\n aliasCommand = this.commands.filter(function(command) {\n return command.alias() === name;\n })[0];\n }\n\n if (this._execs[name] && typeof this._execs[name] !== 'function') {\n return this.executeSubCommand(argv, args, parsed.unknown);\n } else if (aliasCommand) {\n // is alias of a subCommand\n args[0] = aliasCommand._name;\n return this.executeSubCommand(argv, args, parsed.unknown);\n } else if (this.defaultExecutable) {\n // use the default subcommand\n args.unshift(this.defaultExecutable);\n return this.executeSubCommand(argv, args, parsed.unknown);\n }\n\n return result;\n};\n\n/**\n * Execute a sub-command executable.\n *\n * @param {Array} argv\n * @param {Array} args\n * @param {Array} unknown\n * @api private\n */\n\nCommand.prototype.executeSubCommand = function(argv, args, unknown) {\n args = args.concat(unknown);\n\n if (!args.length) this.help();\n if (args[0] === 'help' && args.length === 1) this.help();\n\n // <cmd> --help\n if (args[0] === 'help') {\n args[0] = args[1];\n args[1] = '--help';\n }\n\n // executable\n var f = argv[1];\n // name of the subcommand, link `pm-install`\n var bin = basename(f, '.js') + '-' + args[0];\n\n // In case of globally installed, get the base dir where executable\n // subcommand file should be located at\n var baseDir,\n link = fs.lstatSync(f).isSymbolicLink() ? fs.readlinkSync(f) : f;\n\n // when symbolink is relative path\n if (link !== f && link.charAt(0) !== '/') {\n link = path.join(dirname(f), link);\n }\n baseDir = dirname(link);\n\n // prefer local `./<bin>` to bin in the $PATH\n var localBin = path.join(baseDir, bin);\n\n // whether bin file is a js script with explicit `.js` extension\n var isExplicitJS = false;\n if (exists(localBin + '.js')) {\n bin = localBin + '.js';\n isExplicitJS = true;\n } else if (exists(localBin)) {\n bin = localBin;\n }\n\n args = args.slice(1);\n\n var proc;\n if (process.platform !== 'win32') {\n if (isExplicitJS) {\n args.unshift(bin);\n // add executable arguments to spawn\n args = (process.execArgv || []).concat(args);\n\n proc = spawn(process.argv[0], args, { stdio: 'inherit', customFds: [0, 1, 2] });\n } else {\n proc = spawn(bin, args, { stdio: 'inherit', customFds: [0, 1, 2] });\n }\n } else {\n args.unshift(bin);\n proc = spawn(process.execPath, args, { stdio: 'inherit' });\n }\n\n var signals = ['SIGUSR1', 'SIGUSR2', 'SIGTERM', 'SIGINT', 'SIGHUP'];\n signals.forEach(function(signal) {\n process.on(signal, function() {\n if (proc.killed === false && proc.exitCode === null) {\n proc.kill(signal);\n }\n });\n });\n proc.on('close', process.exit.bind(process));\n proc.on('error', function(err) {\n if (err.code === 'ENOENT') {\n console.error('\\n %s(1) does not exist, try --help\\n', bin);\n } else if (err.code === 'EACCES') {\n console.error('\\n %s(1) not executable. try chmod or run with root\\n', bin);\n }\n process.exit(1);\n });\n\n // Store the reference to the child process\n this.runningCommand = proc;\n};\n\n/**\n * Normalize `args`, splitting joined short flags. For example\n * the arg \"-abc\" is equivalent to \"-a -b -c\".\n * This also normalizes equal sign and splits \"--abc=def\" into \"--abc def\".\n *\n * @param {Array} args\n * @return {Array}\n * @api private\n */\n\nCommand.prototype.normalize = function(args) {\n var ret = [],\n arg,\n lastOpt,\n index;\n\n for (var i = 0, len = args.length; i < len; ++i) {\n arg = args[i];\n if (i > 0) {\n lastOpt = this.optionFor(args[i - 1]);\n }\n\n if (arg === '--') {\n // Honor option terminator\n ret = ret.concat(args.slice(i));\n break;\n } else if (lastOpt && lastOpt.required) {\n ret.push(arg);\n } else if (arg.length > 1 && arg[0] === '-' && arg[1] !== '-') {\n arg.slice(1).split('').forEach(function(c) {\n ret.push('-' + c);\n });\n } else if (/^--/.test(arg) && ~(index = arg.indexOf('='))) {\n ret.push(arg.slice(0, index), arg.slice(index + 1));\n } else {\n ret.push(arg);\n }\n }\n\n return ret;\n};\n\n/**\n * Parse command `args`.\n *\n * When listener(s) are available those\n * callbacks are invoked, otherwise the \"*\"\n * event is emitted and those actions are invoked.\n *\n * @param {Array} args\n * @return {Command} for chaining\n * @api private\n */\n\nCommand.prototype.parseArgs = function(args, unknown) {\n var name;\n\n if (args.length) {\n name = args[0];\n if (this.listeners('command:' + name).length) {\n this.emit('command:' + args.shift(), args, unknown);\n } else {\n this.emit('command:*', args);\n }\n } else {\n outputHelpIfNecessary(this, unknown);\n\n // If there were no args and we have unknown options,\n // then they are extraneous and we need to error.\n if (unknown.length > 0) {\n this.unknownOption(unknown[0]);\n }\n }\n\n return this;\n};\n\n/**\n * Return an option matching `arg` if any.\n *\n * @param {String} arg\n * @return {Option}\n * @api private\n */\n\nCommand.prototype.optionFor = function(arg) {\n for (var i = 0, len = this.options.length; i < len; ++i) {\n if (this.options[i].is(arg)) {\n return this.options[i];\n }\n }\n};\n\n/**\n * Parse options from `argv` returning `argv`\n * void of these options.\n *\n * @param {Array} argv\n * @return {Array}\n * @api public\n */\n\nCommand.prototype.parseOptions = function(argv) {\n var args = [],\n len = argv.length,\n literal,\n option,\n arg;\n\n var unknownOptions = [];\n\n // parse options\n for (var i = 0; i < len; ++i) {\n arg = argv[i];\n\n // literal args after --\n if (literal) {\n args.push(arg);\n continue;\n }\n\n if (arg === '--') {\n literal = true;\n continue;\n }\n\n // find matching Option\n option = this.optionFor(arg);\n\n // option is defined\n if (option) {\n // requires arg\n if (option.required) {\n arg = argv[++i];\n if (arg == null) return this.optionMissingArgument(option);\n this.emit('option:' + option.name(), arg);\n // optional arg\n } else if (option.optional) {\n arg = argv[i + 1];\n if (arg == null || (arg[0] === '-' && arg !== '-')) {\n arg = null;\n } else {\n ++i;\n }\n this.emit('option:' + option.name(), arg);\n // bool\n } else {\n this.emit('option:' + option.name());\n }\n continue;\n }\n\n // looks like an option\n if (arg.length > 1 && arg[0] === '-') {\n unknownOptions.push(arg);\n\n // If the next argument looks like it might be\n // an argument for this option, we pass it on.\n // If it isn't, then it'll simply be ignored\n if ((i + 1) < argv.length && argv[i + 1][0] !== '-') {\n unknownOptions.push(argv[++i]);\n }\n continue;\n }\n\n // arg\n args.push(arg);\n }\n\n return { args: args, unknown: unknownOptions };\n};\n\n/**\n * Return an object containing options as key-value pairs\n *\n * @return {Object}\n * @api public\n */\nCommand.prototype.opts = function() {\n var result = {},\n len = this.options.length;\n\n for (var i = 0; i < len; i++) {\n var key = this.options[i].attributeName();\n result[key] = key === this._versionOptionName ? this._version : this[key];\n }\n return result;\n};\n\n/**\n * Argument `name` is missing.\n *\n * @param {String} name\n * @api private\n */\n\nCommand.prototype.missingArgument = function(name) {\n console.error();\n console.error(\" error: missing required argument `%s'\", name);\n console.error();\n process.exit(1);\n};\n\n/**\n * `Option` is missing an argument, but received `flag` or nothing.\n *\n * @param {String} option\n * @param {String} flag\n * @api private\n */\n\nCommand.prototype.optionMissingArgument = function(option, flag) {\n console.error();\n if (flag) {\n console.error(\" error: option `%s' argument missing, got `%s'\", option.flags, flag);\n } else {\n console.error(\" error: option `%s' argument missing\", option.flags);\n }\n console.error();\n process.exit(1);\n};\n\n/**\n * Unknown option `flag`.\n *\n * @param {String} flag\n * @api private\n */\n\nCommand.prototype.unknownOption = function(flag) {\n if (this._allowUnknownOption) return;\n console.error();\n console.error(\" error: unknown option `%s'\", flag);\n console.error();\n process.exit(1);\n};\n\n/**\n * Variadic argument with `name` is not the last argument as required.\n *\n * @param {String} name\n * @api private\n */\n\nCommand.prototype.variadicArgNotLast = function(name) {\n console.error();\n console.error(\" error: variadic arguments must be last `%s'\", name);\n console.error();\n process.exit(1);\n};\n\n/**\n * Set the program version to `str`.\n *\n * This method auto-registers the \"-V, --version\" flag\n * which will print the version number when passed.\n *\n * @param {String} str\n * @param {String} [flags]\n * @return {Command} for chaining\n * @api public\n */\n\nCommand.prototype.version = function(str, flags) {\n if (arguments.length === 0) return this._version;\n this._version = str;\n flags = flags || '-V, --version';\n var versionOption = new Option(flags, 'output the version number');\n this._versionOptionName = versionOption.long.substr(2) || 'version';\n this.options.push(versionOption);\n this.on('option:' + this._versionOptionName, function() {\n process.stdout.write(str + '\\n');\n process.exit(0);\n });\n return this;\n};\n\n/**\n * Set the description to `str`.\n *\n * @param {String} str\n * @param {Object} argsDescription\n * @return {String|Command}\n * @api public\n */\n\nCommand.prototype.description = function(str, argsDescription) {\n if (arguments.length === 0) return this._description;\n this._description = str;\n this._argsDescription = argsDescription;\n return this;\n};\n\n/**\n * Set an alias for the command\n *\n * @param {String} alias\n * @return {String|Command}\n * @api public\n */\n\nCommand.prototype.alias = function(alias) {\n var command = this;\n if (this.commands.length !== 0) {\n command = this.commands[this.commands.length - 1];\n }\n\n if (arguments.length === 0) return command._alias;\n\n if (alias === command._name) throw new Error('Command alias can\\'t be the same as its name');\n\n command._alias = alias;\n return this;\n};\n\n/**\n * Set / get the command usage `str`.\n *\n * @param {String} str\n * @return {String|Command}\n * @api public\n */\n\nCommand.prototype.usage = function(str) {\n var args = this._args.map(function(arg) {\n return humanReadableArgName(arg);\n });\n\n var usage = '[options]' +\n (this.commands.length ? ' [command]' : '') +\n (this._args.length ? ' ' + args.join(' ') : '');\n\n if (arguments.length === 0) return this._usage || usage;\n this._usage = str;\n\n return this;\n};\n\n/**\n * Get or set the name of the command\n *\n * @param {String} str\n * @return {String|Command}\n * @api public\n */\n\nCommand.prototype.name = function(str) {\n if (arguments.length === 0) return this._name;\n this._name = str;\n return this;\n};\n\n/**\n * Return prepared commands.\n *\n * @return {Array}\n * @api private\n */\n\nCommand.prototype.prepareCommands = function() {\n return this.commands.filter(function(cmd) {\n return !cmd._noHelp;\n }).map(function(cmd) {\n var args = cmd._args.map(function(arg) {\n return humanReadableArgName(arg);\n }).join(' ');\n\n return [\n cmd._name +\n (cmd._alias ? '|' + cmd._alias : '') +\n (cmd.options.length ? ' [options]' : '') +\n (args ? ' ' + args : ''),\n cmd._description\n ];\n });\n};\n\n/**\n * Return the largest command length.\n *\n * @return {Number}\n * @api private\n */\n\nCommand.prototype.largestCommandLength = function() {\n var commands = this.prepareCommands();\n return commands.reduce(function(max, command) {\n return Math.max(max, command[0].length);\n }, 0);\n};\n\n/**\n * Return the largest option length.\n *\n * @return {Number}\n * @api private\n */\n\nCommand.prototype.largestOptionLength = function() {\n var options = [].slice.call(this.options);\n options.push({\n flags: '-h, --help'\n });\n return options.reduce(function(max, option) {\n return Math.max(max, option.flags.length);\n }, 0);\n};\n\n/**\n * Return the largest arg length.\n *\n * @return {Number}\n * @api private\n */\n\nCommand.prototype.largestArgLength = function() {\n return this._args.reduce(function(max, arg) {\n return Math.max(max, arg.name.length);\n }, 0);\n};\n\n/**\n * Return the pad width.\n *\n * @return {Number}\n * @api private\n */\n\nCommand.prototype.padWidth = function() {\n var width = this.largestOptionLength();\n if (this._argsDescription && this._args.length) {\n if (this.largestArgLength() > width) {\n width = this.largestArgLength();\n }\n }\n\n if (this.commands && this.commands.length) {\n if (this.largestCommandLength() > width) {\n width = this.largestCommandLength();\n }\n }\n\n return width;\n};\n\n/**\n * Return help for options.\n *\n * @return {String}\n * @api private\n */\n\nCommand.prototype.optionHelp = function() {\n var width = this.padWidth();\n\n // Append the help information\n return this.options.map(function(option) {\n return pad(option.flags, width) + ' ' + option.description +\n ((option.bool && option.defaultValue !== undefined) ? ' (default: ' + option.defaultValue + ')' : '');\n }).concat([pad('-h, --help', width) + ' ' + 'output usage information'])\n .join('\\n');\n};\n\n/**\n * Return command help documentation.\n *\n * @return {String}\n * @api private\n */\n\nCommand.prototype.commandHelp = function() {\n if (!this.commands.length) return '';\n\n var commands = this.prepareCommands();\n var width = this.padWidth();\n\n return [\n ' Commands:',\n '',\n commands.map(function(cmd) {\n var desc = cmd[1] ? ' ' + cmd[1] : '';\n return (desc ? pad(cmd[0], width) : cmd[0]) + desc;\n }).join('\\n').replace(/^/gm, ' '),\n ''\n ].join('\\n');\n};\n\n/**\n * Return program help documentation.\n *\n * @return {String}\n * @api private\n */\n\nCommand.prototype.helpInformation = function() {\n var desc = [];\n if (this._description) {\n desc = [\n ' ' + this._description,\n ''\n ];\n\n var argsDescription = this._argsDescription;\n if (argsDescription && this._args.length) {\n var width = this.padWidth();\n desc.push(' Arguments:');\n desc.push('');\n this._args.forEach(function(arg) {\n desc.push(' ' + pad(arg.name, width) + ' ' + argsDescription[arg.name]);\n });\n desc.push('');\n }\n }\n\n var cmdName = this._name;\n if (this._alias) {\n cmdName = cmdName + '|' + this._alias;\n }\n var usage = [\n '',\n ' Usage: ' + cmdName + ' ' + this.usage(),\n ''\n ];\n\n var cmds = [];\n var commandHelp = this.commandHelp();\n if (commandHelp) cmds = [commandHelp];\n\n var options = [\n ' Options:',\n '',\n '' + this.optionHelp().replace(/^/gm, ' '),\n ''\n ];\n\n return usage\n .concat(desc)\n .concat(options)\n .concat(cmds)\n .join('\\n');\n};\n\n/**\n * Output help information for this command\n *\n * @api public\n */\n\nCommand.prototype.outputHelp = function(cb) {\n if (!cb) {\n cb = function(passthru) {\n return passthru;\n };\n }\n process.stdout.write(cb(this.helpInformation()));\n this.emit('--help');\n};\n\n/**\n * Output help information and exit.\n *\n * @api public\n */\n\nCommand.prototype.help = function(cb) {\n this.outputHelp(cb);\n process.exit();\n};\n\n/**\n * Camel-case the given `flag`\n *\n * @param {String} flag\n * @return {String}\n * @api private\n */\n\nfunction camelcase(flag) {\n return flag.split('-').reduce(function(str, word) {\n return str + word[0].toUpperCase() + word.slice(1);\n });\n}\n\n/**\n * Pad `str` to `width`.\n *\n * @param {String} str\n * @param {Number} width\n * @return {String}\n * @api private\n */\n\nfunction pad(str, width) {\n var len = Math.max(0, width - str.length);\n return str + Array(len + 1).join(' ');\n}\n\n/**\n * Output help information if necessary\n *\n * @param {Command} command to output help for\n * @param {Array} array of options to search for -h or --help\n * @api private\n */\n\nfunction outputHelpIfNecessary(cmd, options) {\n options = options || [];\n for (var i = 0; i < options.length; i++) {\n if (options[i] === '--help' || options[i] === '-h') {\n cmd.outputHelp();\n process.exit(0);\n }\n }\n}\n\n/**\n * Takes an argument an returns its human readable equivalent for help usage.\n *\n * @param {Object} arg\n * @return {String}\n * @api private\n */\n\nfunction humanReadableArgName(arg) {\n var nameOutput = arg.name + (arg.variadic === true ? '...' : '');\n\n return arg.required\n ? '<' + nameOutput + '>'\n : '[' + nameOutput + ']';\n}\n\n// for versions before node v0.8 when there weren't `fs.existsSync`\nfunction exists(file) {\n try {\n if (fs.statSync(file).isFile()) {\n return true;\n }\n } catch (e) {\n return false;\n }\n}\n","module.exports = function(module) {\r\n\tif (!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif (!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n","import program from \"commander\";\nimport * as fs from \"fs\";\nimport { GenerateOptions, generateTypeScript } from \"./generators/typescript\";\nimport { parse } from \"./parser\";\nimport { resolve } from \"./resolver\";\n\nexport interface Environment {\n argv: string[];\n info(out: any): void;\n warn(out: any): void;\n error(out: any, e?: Error): void;\n}\n\nexport function cli(env: Environment) {\n program\n .command(\"generate <target> <source>\")\n .option(\"-c, --client <base-url>\")\n .option(\"-s, --server\")\n .action(\n (\n target: string,\n source: string,\n options: {\n client?: string;\n server?: true;\n },\n ) => {\n try {\n if (!fs.existsSync(source)) {\n env.error(`No such file: ${source}.`);\n return;\n }\n const input = fs.readFileSync(source, \"utf8\");\n const api = parse(input);\n switch (target) {\n case \"typescript\":\n const result = resolve(api);\n if (result.kind === \"failure\") {\n env.error(result.errors.join(\"\\n\"));\n break;\n }\n const generateOptions: GenerateOptions = {};\n if (options.client) {\n generateOptions.endpoints = {\n kind: \"client\",\n baseUrl: options.client,\n };\n } else if (options.server) {\n generateOptions.endpoints = {\n kind: \"server\",\n };\n }\n const generated = generateTypeScript(\n result.definedEndpoints,\n result.definedTypes,\n generateOptions,\n );\n env.info(generated);\n break;\n default:\n env.error(`Unknown target: ${target}.`);\n }\n } catch (e) {\n env.error(e);\n }\n },\n );\n\n program.command(\"*\").action((command) => {\n env.error(`Unknown command: ${command}.`);\n });\n\n // Evaluate CLI arguments.\n program.parse(env.argv);\n}\n\nif (require.main === module) {\n cli({\n argv: process.argv,\n info: console.log,\n warn: console.warn,\n error: (out: any, e?: Error) => {\n if (e) {\n // tslint:disable-next-line no-console\n console.error(out, e);\n } else {\n // tslint:disable-next-line no-console\n console.error(out);\n }\n process.exitCode = 1;\n },\n });\n}\n"],"sourceRoot":""} |