1 line
1.3 MiB
1 line
1.3 MiB
{"version":3,"mappings":"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","names":["objectProto","hasOwnProperty","assign","createAssigner","object","source","isPrototype","isArrayLike","copyObject","keys","key","assignValue","baseSlice","array","start","end","index","length","result","compact","resIndex","value","arrayAggregator","setter","iteratee","accumulator","baseAggregator","collection","baseEach","createAggregator","initializer","func","isArray","baseIteratee","LARGE_ARRAY_SIZE","baseDifference","values","comparator","includes","arrayIncludes","isCommon","valuesLength","cacheHas","SetCache","outer","computed","valuesIndex","difference","baseRest","isArrayLikeObject","baseFlatten","drop","n","guard","toInteger","dropRight","arrayEvery","predicate","baseEvery","every","head","flatMap","map","groupBy","baseAssignValue","stringTag","isString","isObjectLike","baseGetTag","nativeMax","fromIndex","baseIndexOf","indexOf","regexpTag","baseIsRegExp","nodeIsRegExp","nodeUtil","isRegExp","baseUnary","FUNC_ERROR_TEXT","negate","args","pickBy","props","arrayMap","getAllKeysIn","prop","basePickBy","path","reject","arrayFilter","baseFilter","baseSome","some","arraySome","uniq","baseUniq","uniqBy","isAstNode","obj","isReference","isAstNodeDescription","isLinkingError","AbstractAstReflection","node","type","subtype","supertype","nested","existing","allTypes","types","possibleSubType","isCompositeCstNode","isLeafCstNode","isRootCstNode","StreamImpl","startFn","nextFn","iterator","count","next","keyFn","valueFn","entryStream","element","other","state","DONE_RESULT","separator","addSeparator","toString","searchElement","callbackfn","done","initialValue","previousValue","mapped","isIterable","depth","stream","skipCount","i","maxSize","by","otherKeySet","item","e","ownKey","EMPTY_STREAM","collections","TreeStreamImpl","root","children","options","Reduction","sum","b","product","min","max","streamCst","isChildNode","child","parent","tokenToRange","token","toDocumentSegment","offset","range","RangeComparison","compareRange","to","startInside","endInside","inRange","DefaultNameRegexp","findCommentNode","cstNode","commentNames","previous","getPreviousNode","isCommentNode","endIndex","hidden","ErrorWithLocation","message","assertUnreachable","_","AbstractRule","AbstractType","Condition","TypeDefinition","ValueLiteral","AbstractElement","isAbstractElement","reflection","ArrayLiteral","ArrayType","BooleanLiteral","isBooleanLiteral","Conjunction","isConjunction","Disjunction","isDisjunction","Grammar","GrammarImport","InferredType","isInferredType","Interface","isInterface","NamedArgument","Negation","isNegation","NumberLiteral","Parameter","ParameterReference","isParameterReference","ParserRule","isParserRule","ReferenceType","ReturnType","isReturnType","SimpleType","isSimpleType","StringLiteral","TerminalRule","isTerminalRule","Type","isType","TypeAttribute","UnionType","Action","isAction","Alternatives","isAlternatives","Assignment","isAssignment","CharacterRange","isCharacterRange","CrossReference","isCrossReference","EndOfFile","isEndOfFile","Group","isGroup","Keyword","isKeyword","NegatedToken","isNegatedToken","RegexToken","isRegexToken","RuleCall","isRuleCall","TerminalAlternatives","isTerminalAlternatives","TerminalGroup","isTerminalGroup","TerminalRuleCall","isTerminalRuleCall","UnorderedGroup","isUnorderedGroup","UntilToken","isUntilToken","Wildcard","isWildcard","LangiumGrammarAstReflection","refInfo","referenceId","linkContentToContainer","name","getContainerOfType","typePredicate","getDocument","findRootNode","streamContents","property","isAstNodeInRange","streamAllContents","streamAst","astNode","_a","nodeRange","streamReferences","assignMandatoryProperties","typeMetaData","genericNode","copyDefaultValue","propertyType","cc","char","insertToSet","set","subItem","addFlag","flagObj","flagKey","ASSERT_EXISTS","ASSERT_NEVER_REACH_HERE","isCharacter","digitsCharCodes","wordCharCodes","whitespaceCodes","hexDigitPattern","decimalPattern","decimalPatternNoZero","RegExpParser","newState","input","flags","alts","begin","terms","disjunction","isBacktracking","atLeast","atMost","atom","complement","escapeCode","letter","escapedChar","nextChar","from","capturing","groupAst","number","howMuch","prevState","howMany","hexString","hexChar","BaseRegExpVisitor","subChild","NEWLINE_REGEXP","regexpParser","TerminalRegExpVisitor","regex","escapeRegExp","visitor","isMultilineComment","regexp","whitespaceCharacters","isWhitespace","ws","getCaseInsensitivePattern","keyword","partialMatches","partial","partialRegExp","match","re","process","tmp","appendRaw","nbChars","appendOptional","getEntryRule","grammar","ast.isParserRule","getHiddenRules","ast.isTerminalRule","getAllReachableRules","allTerminals","ruleNames","entryRule","topMostRules","rule","ruleDfs","rules","visitedSet","ast.isRuleCall","refRule","getCrossReferenceTerminal","crossRef","findNameAssignment","isCommentTerminal","terminalRule","terminalRegex","findNodesForProperty","findNodesForPropertyInternal","findNodeForProperty","nodes","first","nodeFeature","ast.isAssignment","findNodeForKeyword","findNodesForKeywordInternal","ast.isKeyword","treeIterator","keywordNodes","childNode","findAssignment","assignment","startNode","ast.isInferredType","ast.isAction","findNameAssignmentInternal","cache","go","refType","childAssignment","ast.isSimpleType","isDataTypeRule","isDataTypeRuleInternal","visited","getExplicitRuleType","ast.isInterface","ast.isType","getTypeName","ast.isReturnType","actionType","getActionType","action","getRuleType","_b","_c","abstractElementToRegex","flagText","WILDCARD","ast.isTerminalAlternatives","terminalAlternativesToRegex","ast.isTerminalGroup","terminalGroupToRegex","ast.isCharacterRange","characterRangeToRegex","ast.isTerminalRuleCall","withCardinality","ast.isNegatedToken","negateTokenToRegex","ast.isUntilToken","untilTokenToRegex","ast.isRegexToken","lastSlash","regexFlags","ast.isWildcard","alternatives","group","until","keywordToRegex","createGrammarConfig","services","PRINT_ERROR","msg","PRINT_WARNING","timer","val","toFastProperties","toBecomeFast","FakeConstructor","fakeInstance","fakeAccess","tokenLabel","tokType","hasTokenLabel","AbstractProduction","_definition","forEach","prod","NonTerminal","v","definition","Rule","Alternative","RepetitionMandatory","RepetitionMandatoryWithSeparator","Repetition","RepetitionWithSeparator","Alternation","Terminal","serializeGrammar","topRules","serializeProduction","convertDefinition","serializedNonTerminal","Option","serializedTerminal","pattern","GAstVisitor","nodeAny","isSequenceProd","isOptionalProd","alreadyVisited","subProd","isBranchingProd","getProductionDslName","RestWalker","prevRest","currRest","terminal","refProd","flatProd","fullOrRest","optionProd","atLeastOneProd","fullAtLeastOneRest","atLeastOneSepProd","fullAtLeastOneSepRest","restForRepetitionWithSeparator","manyProd","fullManyRest","manySepProd","fullManySepRest","orProd","alt","prodWrapper","repSepProd","firstForTerminal","firstForSequence","firstForBranching","firstSet","seq","nextSubProdIdx","hasInnerProdsRemaining","currSubProd","isLastInnerProdOptional","allAlternativesFirsts","innerProd","flatten","IN","ResyncFollowsWalker","topProd","followName","buildBetweenProdsFollowPrefix","fullRest","restProd","t_in_topProd_follows","computeAllProdsFollows","topProductions","reSyncFollows","currRefsFollow","inner","occurenceInParent","regExpAstCache","regExpParser","getRegExpAst","regExp","regExpStr","regExpAst","clearRegExpParserCache","complementErrorMessage","failedOptimizationPrefixMsg","getOptimizedStartCodesIndices","ensureOptimizations","ast","firstCharOptimizedIndices","msgSuffix","ignoreCase","term","addOptimizedIdxToResult","code","rangeCode","minOptimizationVal","minUnOptVal","maxUnOptVal","minOptIdx","charCodeToOptimizedIndex","maxOptIdx","currOptIdx","isOptionalQuantifier","isWholeOptional","optimizedCharIdx","handleIgnoreCase","upperChar","lowerChar","findCode","setNode","targetCharCodes","find","codeOrRange","targetCode","quantifier","CharCodeFinder","canMatchCharCode","charCodes","charCodeFinder","PATTERN","DEFAULT_MODE","MODES","SUPPORT_STICKY","analyzeTokenTypes","tokenTypes","defaults","tracer","initCharCodeToOptimizedIndexMap","onlyRelevantTypes","currType","Lexer","hasCustom","allTransformedPatterns","currPattern","regExpSource","addStickyFlag","addStartOfInput","isFunction","escapedRegExpString","wrappedRegExp","patternIdxToType","patternIdxToGroup","patternIdxToLongerAltIdxArr","patternIdxToPushMode","patternIdxToPopMode","clazz","groupName","isUndefined","longerAltType","has","patternIdxToCanLineTerminator","lineTerminatorCharCodes","getCharCodes","checkLineBreaksIssues","patternIdxToIsCustom","patternIdxToShort","emptyGroups","patternIdxToConfig","isCustomPattern","isShortPattern","reduce","acc","x","idx","canBeOptimized","charCodeToPatternIdxToConfig","currTokType","charCode","optimizedIdx","addToMapOfArrays","lastOptimizedIdx","charOrInt","currOptimizedIdx","optimizedCodes","isEmpty","validatePatterns","validModesNames","errors","missingResult","findMissingPatterns","invalidResult","findInvalidPatterns","validTokenTypes","validateRegExpPattern","findInvalidGroupType","findModesThatDoNotExist","findUnreachablePatterns","withRegExpPatterns","filter","findEndOfInputAnchor","findStartOfInputAnchor","findUnsupportedFlags","findDuplicatePatterns","findEmptyMatchRegExps","tokenTypesWithMissingPattern","LexerDefinitionErrorType","valid","tokenTypesWithInvalidPattern","end_of_input","EndAnchorFinder","invalidRegex","regexpAst","endAnchorVisitor","matchesEmptyString","start_of_input","StartAnchorFinder","startAnchorVisitor","invalidFlags","found","identicalPatterns","outerType","innerType","duplicatePatterns","currIdenticalSet","setOfIdentical","tokenTypeNames","invalidTypes","validModes","invalidModes","canBeTested","noMetaChar","testIdx","str","tokenType","testTokenType","regExpArray","performRuntimeChecks","lexerDefinition","trackLines","lineTerminatorCharacters","currModeValue","currModeName","currIdx","longerAlt","currLongerAlt","performWarningRuntimeChecks","warnings","hasAnyLineBreak","allTokenTypes","concreteTokenTypes","terminatorCharCodes","currIssue","warningDescriptor","buildLineBreakIssueMessage","cloneEmptyGroups","clonedResult","groupKeys","currKey","currGroupValue","LineTerminatorOptimizedTester","text","len","c","details","charsOrCodes","numOrString","charCodeToOptimizedIdxMap","tokenStructuredMatcher","tokInstance","tokConstructor","instanceType","tokenStructuredMatcherNoCategories","tokenShortNameIdx","tokenIdxToClass","augmentTokenTypes","tokenTypesAndParents","expandCategories","assignTokenDefaultProps","assignCategoriesMapProp","assignCategoriesTokensProp","clone","categories","searching","newCategories","hasShortKeyProperty","hasCategoriesProperty","hasExtendingTokensTypesProperty","hasExtendingTokensTypesMapProperty","singleAssignCategoriesToksMap","nextNode","pathNode","nextCategory","newPath","isTokenType","defaultLexerErrorProvider","fullText","startOffset","line","column","DEFAULT_LEXER_CONFIG","config","phaseDesc","phaseImpl","indent","time","traceMethod","traceInitVal","actualDefinition","hasOnlySingleMode","allModeNames","currModDef","currModName","currAnalyzeResult","allErrMessagesString","error","identity","noop","unOptimizedModes","cannotBeOptimized","modeName","initialMode","j","k","matchAltImage","matchedImage","payload","altPayload","imageLength","newToken","errLength","orgText","orgLength","matchedTokensIndex","guessedNumberOfTokens","matchedTokens","groups","lineTerminatorPattern","currModePatternsLength","currCharCodeToPatternIdxToConfig","modeStack","emptyArray","getPossiblePatterns","getPossiblePatternsSlow","getPossiblePatternsOptimized","possiblePatterns","pop_mode","popToken","newMode","last","modeCanBeOptimized","push_mode","currConfig","recoveryEnabled","nextCharCode","chosenPatternIdxToConfig","chosenPatternsLength","singleCharCode","longerAltLength","longerAltConfig","longerAltPattern","numOfLTsInMatch","foundTerminator","lastLTEndOffset","errorStartOffset","errorLine","errorColumn","foundResyncPoint","pushMode","newLastIndex","lastLTIdx","lastCharIsLT","fixForEndingInLT","oldColumn","image","tokenTypeIdx","startLine","startColumn","tokenVector","tokenToAdd","PARENT","CATEGORIES","LABEL","GROUP","PUSH_MODE","POP_MODE","LONGER_ALT","LINE_BREAKS","START_CHARS_HINT","createToken","createTokenInternal","EOF","createTokenInstance","endOffset","endLine","endColumn","tokenMatcher","defaultParserErrorProvider","expected","actual","ruleName","firstRedundant","expectedPathsPerAlt","customUserDescription","errPrefix","errSuffix","allLookAheadPaths","currAltPaths","nextValidTokenSequences","currPath","currTokenType","calculatedDescription","itemMsg","expectedIterationPaths","defaultGrammarResolverErrorProvider","topLevelRule","undefinedRule","defaultGrammarValidatorErrorProvider","duplicateProds","getExtraProductionArgument","topLevelName","duplicateProd","dslName","extraArgument","hasExplicitIndex","pathMsg","currTok","occurrence","currtok","currMessage","pathNames","currRule","leftRecursivePath","resolveGrammar","topLevels","errMsgProvider","refResolver","GastRefResolverVisitor","nameToTopRule","ref","ParserDefinitionErrorType","AbstractNextPossibleTokensWalker","NextAfterTokenWalker","AbstractNextTerminalAfterProductionWalker","topRule","NextTerminalAfterManyWalker","firstAfterMany","_first","NextTerminalAfterManySepWalker","firstAfterManySep","NextTerminalAfterAtLeastOneWalker","firstAfterAtLeastOne","NextTerminalAfterAtLeastOneSepWalker","atleastOneSepProd","firstAfterfirstAfterAtLeastOneSep","possiblePathsFrom","targetDef","maxLength","remainingPathWith","nextDef","getAlternativesForProd","newDef","currAlt","nextPossibleTokensAfter","initialDef","tokMatcher","maxLookAhead","EXIT_NON_TERMINAL","EXIT_NON_TERMINAL_ARR","EXIT_ALTERNATIVE","foundCompletePath","tokenVectorLength","minimalAlternativesIndex","possiblePaths","currDef","currRuleStack","currOccurrenceStack","nextPath","nextIdx","actualToken","newRuleStack","newOccurrenceStack","nextPathWithout","nextPathWith","secondIteration","separatorGast","nthRepetition","currAltPath","expandTopLevelRule","newCurrOccurrenceStack","PROD_TYPE","getProdType","getLookaheadPaths","prodType","maxLookahead","getLookaheadPathsForOr","getLookaheadPathsForOptionalProd","buildLookaheadFuncForOr","ruleGrammar","hasPredicates","dynamicTokensEnabled","laFuncBuilder","lookAheadPaths","areTokenCategoriesNotUsed","buildLookaheadFuncForOptionalProd","lookaheadBuilder","buildAlternativesLookAheadFunc","numOfAlts","areAllOneTokenLookahead","orAlts","predicates","t","currNumOfPaths","currPredicate","currPathLength","nextToken","singleTokenAlts","choiceToAlt","currExtendingType","buildSingleAlternativeLookaheadFunction","numOfPaths","singleTokensTypes","expectedTokenUniqueKey","RestDefinitionFinderWalker","targetOccurrence","targetProdType","expectedProdType","InsideDefinitionFinderVisitor","targetRef","expectedProdName","initializeArrayOfArrays","size","pathToHashKeys","longerKeys","currShorterKey","categoriesKeySuffix","isUniquePrefixHash","altKnownPathsKeys","searchPathKeys","currAltIdx","otherAltKnownPathsKeys","searchIdx","searchKey","lookAheadSequenceFromAlternatives","altsDefs","partialAlts","finalResult","altsHashes","dict","newData","pathLength","currDataset","altIdx","currAltPathsAndSuffixes","currPathIdx","currPathPrefix","suffixDef","prefixKeys","currAltResult","containsPath","newPartialPathsAndSuffixes","insideDefVisitor","insideDef","afterDef","insideFlat","AlternativeGAST","afterFlat","alternative","searchPath","compareOtherPath","otherPath","searchTok","otherTok","isStrictPrefixOfPath","prefix","otherTokType","singleAltPaths","singlePath","validateLookahead","lookaheadValidationErrorMessages","errorMessage","validateGrammar","grammarName","duplicateErrors","currTopLevel","validateDuplicateProductions","termsNamespaceConflictErrors","checkTerminalAndNoneTerminalsNameSpace","tooManyAltsErrors","curRule","validateTooManyAlts","duplicateRulesError","validateRuleDoesNotAlreadyExist","collectorVisitor","OccurrenceValidationCollector","allRuleProductions","productionGroups","identifyProductionForDuplicates","duplicates","currGroup","currDuplicates","firstProd","defError","param","subrule","option","manySep","atLeastOne","atLeastOneSep","many","or","allRules","className","errMsg","validateRuleIsOverridden","definedRulesNames","validateNoLeftRecursion","nextNonTerminals","getFirstNoneTerminal","validNextSteps","errorsFromNextSteps","currRefRule","currSubDef","isFirstOptional","hasMore","rest","OrCollector","validateEmptyOrAlternative","orCollector","ors","currOr","exceptLast","currAlternative","possibleFirstInAlt","validateAmbiguousAlternationAlternatives","globalMaxLookahead","currOccurrence","actualMaxLookahead","altsAmbiguityErrors","checkAlternativesAmbiguities","altsPrefixAmbiguityErrors","checkPrefixAlternativesAmbiguities","RepetitionCollector","validateSomeNonEmptyLookaheadPath","topLevelRules","currTopRule","currProd","pathsInsideProduction","alternation","foundAmbiguousPaths","identicalAmbiguities","altsCurrPathAppearsIn","currOtherAlt","currOtherAltIdx","currAmbDescriptor","ambgIndices","pathsAndIndices","currPathsAndIdx","currPathAndIdx","targetIdx","targetPath","prefixAmbiguitiesPathsAndIndices","searchPathAndIdx","currAmbPathAndIdx","tokenNames","currToken","currRuleName","actualOptions","topRulesTable","orgResolveGrammar","orgValidateGrammar","MISMATCHED_TOKEN_EXCEPTION","NO_VIABLE_ALT_EXCEPTION","EARLY_EXIT_EXCEPTION","NOT_ALL_INPUT_PARSED_EXCEPTION","RECOGNITION_EXCEPTION_NAMES","isRecognitionException","RecognitionException","MismatchedTokenException","previousToken","NoViableAltException","NotAllInputParsedException","EarlyExitException","EOF_FOLLOW_KEY","IN_RULE_RECOVERY_EXCEPTION","InRuleRecoveryException","Recoverable","DEFAULT_PARSER_CONFIG","attemptInRepetitionRecovery","tokToInsert","grammarRule","grammarRuleArgs","lookAheadFunc","expectedTokType","reSyncTokType","savedLexerState","resyncedTokens","passedResyncPoint","nextTokenWithoutResync","generateErrorMessage","expectTokAfterLastMatch","nextTokIdx","notStuck","tokIdxInRule","grammarPath","follows","nextTok","expectedToken","mismatchedTok","possibleFollowsTokType","followKey","currentRuleReSyncSet","allPossibleReSyncTokTypes","foundMatch","resyncTokType","currRuleShortName","currRuleIdx","prevRuleShortName","explicitRuleStack","explicitOccurrenceStack","followStack","resyncTokens","prodFunc","lookaheadFunc","dslMethodIdx","prodOccurrence","nextToksWalker","pathRuleStack","pathOccurrenceStack","currShortName","firstAfterRepInfo","isEndOfRule","BITS_FOR_METHOD_TYPE","BITS_FOR_OCCURRENCE_IDX","OR_IDX","OPTION_IDX","MANY_IDX","AT_LEAST_ONE_IDX","MANY_SEP_IDX","AT_LEAST_ONE_SEP_IDX","getKeyForAutomaticLookahead","ruleIdx","LLkLookaheadStrategy","leftRecursionErrors","emptyAltErrors","ambiguousAltsErrors","emptyRepetitionErrors","LooksAhead","repetition","repetitionMandatory","repetitionMandatoryWithSeparator","repetitionWithSeparator","collectMethods","prodIdx","laFunc","prodKey","prodMaxLookahead","dslMethodName","DslMethodsCollectorVisitor","dslMethods","setNodeLocationOnlyOffset","currNodeLocation","newLocationInfo","setNodeLocationFull","addTerminalToCst","tokenTypeName","addNoneTerminalToCst","ruleResult","NAME","defineNameProp","nameValue","defaultVisit","ctx","childrenNames","childrenNamesLength","currChildName","currChildArray","currChildArrayLength","currChild","createBaseSemanticVisitorConstructor","derivedConstructor","semanticProto","semanticDefinitionErrors","validateVisitor","errorMessages","currDefError","createBaseVisitorConstructorWithDefaults","baseConstructor","withDefaultsProto","CstVisitorDefinitionError","visitorInstance","validateMissingCstMethods","missingRuleNames","TreeBuilder","fullRuleName","ruleCstNode","prevToken","loc","consumedToken","rootCst","ruleCstResult","preCstNode","newBaseCstVisitorConstructor","newConstructor","ruleStack","occurrenceStack","LexerAdapter","newInput","END_OF_FILE","soughtIdx","RecognizerApi","impl","ruleToCall","actionORMethodDef","altsOrOpts","implementation","DEFAULT_RULE_CONFIG","ruleImplementation","ruleErrors","orgState","RecognizerEngine","tokenVocabulary","uniqueTokens","isObject","noTokenCategoriesUsed","tokenConstructor","resyncEnabled","recoveryValueFunc","shortName","invokeRuleWithTry","cst","resyncEnabledConfig","isFirstInvokedRule","reSyncEnabled","recogError","partialCstResult","orgLookaheadFunction","laKey","separatorLookAheadFunc","lookaheadFunction","nextTerminalAfterWalker","beforeIteration","altIdxToTake","firstRedundantTok","eFromConsumption","eFromInRuleRecovery","savedErrors","savedRuleStack","fullName","idxInCallingRule","ErrorHandler","newErrors","userDefinedErrMsg","insideProdPaths","actualTokens","errMsgTypes","lookAheadPathsPerAlternative","ContentAssist","startRuleName","precedingInput","startRuleGast","topRuleName","topProduction","RECORDING_NULL_OBJECT","HANDLE_SEPARATOR","MAX_METHOD_IDX","RFT","RECORDING_PHASE_TOKEN","RECORDING_PHASE_CSTNODE","GastRecorder","arg1","arg2","that","def","newTopLevelRule","originalError","recordProd","recordOrProd","assertMethodIdxIsValid","getIdxSuffix","prevProd","peek","newNoneTerminal","prodConstructor","mainProdArg","handleSep","grammarAction","newProd","hasOptions","newOrProd","currAltFlat","PerformanceTracer","userTraceInitPerf","traceIsNumber","applyMixins","derivedCtor","baseCtors","baseCtor","baseProto","propName","basePropDescriptor","EMPTY_ALT","Parser","parserInstance","defErrorsMsgs","originalGrammarAction","recordedRuleGast","resolverErrors","validationErrors","lookaheadValidationErrors","allFollows","EmbeddedActionsParser","configClone","buildATNKey","ATN_BASIC","ATN_RULE_START","ATN_PLUS_BLOCK_START","ATN_STAR_BLOCK_START","ATN_RULE_STOP","ATN_BLOCK_END","ATN_STAR_LOOP_BACK","ATN_STAR_LOOP_ENTRY","ATN_PLUS_LOOP_BACK","ATN_LOOP_END","AbstractTransition","target","AtomTransition","EpsilonTransition","RuleTransition","ruleStart","followState","createATN","atn","createRuleStartAndStopATNStates","ruleLength","ruleBlock","block","buildRuleHandle","stop","production","tokenRef","ruleRef","repetitionSep","repetitionMandatorySep","starState","defineDecisionState","handle","makeAlts","star","sep","plusState","plus","optional","handles","makeBlock","blkStart","blkEnd","loop","epsilon","entry","loopEnd","altsLength","transition","isRuleTransition","ruleTransition","removeState","left","right","addTransition","currentRule","nonTerminal","call","a","DFA_ERROR","ATNConfigSet","getATNConfigKey","createDFACache","startState","decision","predicateSet","PredicateSet","EMPTY_PREDICATES","LLStarLookaheadStrategy","initATNSimulator","dfas","logging","decisionIndex","isLL1Sequence","prediction","gate","adaptivePredict","g","sequences","allowEmpty","fullSet","altSet","indices","decisionLength","decisionToDFA","dfaCaches","dfa","closure","computeStartState","addDFAState","newDFAState","performLookahead","s0","previousD","d","getExistingTargetState","computeLookaheadTarget","buildAdaptivePredictError","lookahead","reach","computeReachSet","addDFAEdge","predictedAlt","getUniqueAlt","hasConflictTerminatingPrediction","reportLookaheadAmbiguity","ambiguityIndices","prefixPath","atnState","buildAmbiguityError","current","nextTransitions","nextTokenTypes","configs","intermediate","skippedStopStates","transitionLength","getReachableTarget","hasConfigInRuleStopState","mapKey","numberOfTransitions","p","atnStack","followConfig","getEpsilonTarget","stack","allConfigsInRuleStopStates","altSets","getConflictingAltSets","hasConflictingAltSet","hasStateAssociatedWithOneAlt","configToAlts","DocumentUri","is","URI","integer","uinteger","Position","create","character","candidate","Is","Range","one","two","three","four","Location","uri","LocationLink","targetUri","targetRange","targetSelectionRange","originSelectionRange","Color","red","green","blue","alpha","ColorInformation","color","ColorPresentation","label","textEdit","additionalTextEdits","TextEdit","FoldingRangeKind","FoldingRange","startCharacter","endCharacter","kind","collapsedText","DiagnosticRelatedInformation","location","DiagnosticSeverity","DiagnosticTag","CodeDescription","Diagnostic","severity","relatedInformation","Command","title","command","replace","newText","insert","position","del","ChangeAnnotation","needsConfirmation","description","ChangeAnnotationIdentifier","AnnotatedTextEdit","annotation","TextDocumentEdit","textDocument","edits","OptionalVersionedTextDocumentIdentifier","CreateFile","RenameFile","oldUri","newUri","DeleteFile","WorkspaceEdit","change","TextDocumentIdentifier","VersionedTextDocumentIdentifier","version","TextDocumentItem","languageId","MarkupKind","MarkupContent","CompletionItemKind","InsertTextFormat","CompletionItemTag","InsertReplaceEdit","InsertTextMode","CompletionItemLabelDetails","CompletionItem","CompletionList","items","isIncomplete","MarkedString","fromPlainText","plainText","Hover","ParameterInformation","documentation","SignatureInformation","parameters","DocumentHighlightKind","DocumentHighlight","SymbolKind","SymbolTag","SymbolInformation","containerName","WorkspaceSymbol","DocumentSymbol","detail","selectionRange","CodeActionKind","CodeActionTriggerKind","CodeActionContext","diagnostics","only","triggerKind","CodeAction","kindOrCommandOrEdit","checkKind","CodeLens","data","FormattingOptions","tabSize","insertSpaces","DocumentLink","SelectionRange","SemanticTokenTypes","SemanticTokenModifiers","SemanticTokens","InlineValueText","InlineValueVariableLookup","variableName","caseSensitiveLookup","InlineValueEvaluatableExpression","expression","InlineValueContext","frameId","stoppedLocation","InlayHintKind","InlayHintLabelPart","InlayHint","StringValue","createSnippet","InlineCompletionItem","insertText","filterText","InlineCompletionList","InlineCompletionTriggerKind","SelectedCompletionInfo","InlineCompletionContext","selectedCompletionInfo","WorkspaceFolder","TextDocument","content","FullTextDocument","applyEdits","document","sortedEdits","mergeSort","diff","lastModifiedOffset","compare","leftIdx","rightIdx","FullTextDocument$1","event","lineOffsets","isLineStart","ch","low","high","mid","lineOffset","nextLineOffset","defined","undefined","boolean","string","numberRange","objectLiteral","typedArray","check","CstNodeBuilder","RootCstNodeImpl","feature","compositeNode","CompositeCstNodeImpl","leafNode","LeafCstNodeImpl","tokens","added","AbstractCstNode","CstNodeContainer","firstNode","lastNode","firstRange","lastRange","DatatypeSymbol","isDataTypeNode","ruleSuffix","withRuleSuffix","AbstractLangiumParser","ChevrotainWrapper","choices","callback","LangiumParser","ruleMethod","lexerResult","$type","createNode","hiddenTokens","isCrossRef","convertedValue","fragment","subruleResult","newItem","operator","existingValue","newValue","targetCstNode","AbstractParserErrorMessageProvider","LangiumParserErrorMessageProvider","LangiumCompletionParser","defaultConfig","useDefaultLookahead","createParser","parser","buildRules","parserContext","reachable","parserRules","buildElement","ignoreGuard","method","buildKeyword","buildAction","buildCrossReference","buildRuleCall","buildAlternatives","buildUnorderedGroup","buildGroup","wrap","getGuardCondition","ruleCall","buildRuleCallPredicate","getRule","getToken","namedArgs","buildPredicate","ruleArgs","ruleTarget","condition","methods","predicatedMethod","orIdx","idFunc","groupIdx","lParser","stackId","groupState","wrapped","assignTerminal","cardinality","getRuleName","createCompletionParser","lexer","createLangiumParser","prepareLangiumParser","DefaultTokenBuilder","reachableRules","terminalTokens","terminalToken","stickyRegex","caseInsensitive","keywordPattern","longerAlts","DefaultValueConverter","ValueConverter","convertString","c1","convertEscapeCharacter","convertID","convertInt","convertBigint","convertDate","convertNumber","convertBoolean","ral","_ral","RAL","install","stringArray","elem","events","ral_1","require$$0","Event","_disposable","CallbackList","context","bucket","foundCallbackWithDifferentContext","ret","callbacks","contexts","Emitter","_options","listener","thisArgs","disposables","cancellation","require$$1","events_1","require$$2","CancellationToken","shortcutEvent","MutableToken","CancellationTokenSource","delayNextTick","resolve","lastTick","globalInterruptionPeriod","startCancelableOperation","OperationCancelled","isOperationCancelled","err","interruptAndCheck","Deferred","arg","changes","getWellformedRange","addedLineOffsets","computeLineOffsets","isEOL","update","getWellformedEdit","spans","isAtLineStart","textOffset","LIB","r","o","s","h","f","u","l","P","m","C","y","A","w","Utils","UriUtils","equals","relative","fromPath","toPath","fromParts","toParts","backPart","toPart","normalize","DocumentState","DefaultLangiumDocumentFactory","cancellationToken","model","parseResult","cancelToken","textDocumentGetter","oldText","serviceRegistry","textDoc","DefaultLangiumDocuments","uriString","langiumDoc","ref_resolving","DefaultLinker","linkedNode","refNode","refText","linker","reference","refData","nodeDescription","doc","targetDescription","referenceType","isNamed","DefaultNameProvider","DefaultReferences","sourceCstNode","nodeElem","nameNode","targetNode","refs","indexReferences","MultiMap","elements","BiMap","DefaultScopeComputation","parentNode","exports","rootNode","scopes","container","StreamScope","outerScope","local","MapScope","localName","elementStream","DisposableCache","disposable","SimpleCache","provider","ContextCache","converter","contextKey","contextCache","documentCache","WorkspaceCache","sharedServices","_changed","deleted","DefaultScopeProvider","precomputed","currentNode","allDescriptions","desc","_context","isAstNodeWithComment","isIntermediateReference","DefaultJsonSerializer","serializeOptions","specificReplacer","defaultReplacer","replacer","deserializeOptions","sourceText","textRegions","comments","uriConverter","_d","refValue","$refText","targetDocument","comment","createDocumentSegment","textRegion","assignments","propertyAssignments","containerProperty","containerIndex","propertyName","mutable","fragmentIndex","documentUri","DefaultServiceRegistry","language","ext","diagnosticData","ValidationCategory","ValidationRegistry","checksRecord","thisObj","category","accept","functionality","messageContext","messageDetails","checks","checkBefore","checkAfter","DefaultDocumentValidator","DocumentValidator","lexerDiagnostics","lexerDiagnostic","diagnostic","toDiagnosticSeverity","toDiagnosticData","parserError","linkingError","info","validationItems","acceptor","checksBefore","checksAfter","getDiagnosticRange","DefaultAstNodeDescriptionProvider","nameNodeSegment","nameSegmentGetter","DefaultReferenceDescriptionProvider","descr","targetNodeDescr","refCstNode","docUri","DefaultAstNodeLocator","containerPath","newSegment","$containerProperty","$containerIndex","currentValue","propertyIndex","arrayIndex","DefaultConfigurationProvider","params","languages","lang","configToUpdate","conf","section","configuration","sectionName","Disposable","DefaultDocumentBuilder","documents","buildState","previousCategories","changed","deletedUri","changedUri","newDocument","allChangedUris","rebuildDocuments","changedUris","scopeComputation","toBeValidated","targetState","filtered","targetStateDocs","uriOrToken","buildDisposable","cancelDisposable","listenersCopy","validator","validationSetting","DefaultIndexManager","astNodePath","targetDocUri","docRefs","refDescr","nodeType","uris","documentUris","indexData","references","DefaultWorkspaceManager","_params","folders","fileExtensions","collector","wf","_folders","_collector","workspaceFolder","folderPath","_workspaceFolder","extname","DefaultLexerErrorMessageProvider","DEFAULT_TOKENIZE_OPTIONS","DefaultLexer","lexerTokens","isTokenTypeDictionary","ChevrotainLexer","chevrotainResult","buildTokens","isIMultiModeLexerDefinition","res","isTokenTypeArray","parseJSDoc","opts","lines","getLines","normalizedOptions","normalizeOptions","tokenize","parseJSDocComment","isJSDoc","firstRegex","lastRegex","tagRegex","inlineTagRegex","currentLine","currentCharacter","lastCharacter","skipWhitespace","tagMatch","fullMatch","inlineTagMatches","buildInlineTokens","tags","lineIndex","characterIndex","lastIndex","matchIndex","startContent","tagName","endContent","nonWhitespaceRegex","whitespaceEndRegex","startPosition","JSDocCommentImpl","parseJSDocElement","parseJSDocTag","parseJSDocText","appendEmptyLine","JSDocLineImpl","firstToken","lastToken","parseJSDocInline","JSDocTextImpl","parseJSDocLine","inline","tagToken","docLine","JSDocTagImpl","normalizeOption","escaped","fillNewlines","rendered","renderInlineTag","marker","tag","display","displayStart","renderLinkDefault","JSDocDocumentationProvider","link","_node","_tag","DefaultCommentProvider","DefaultAsyncParser","_cancelToken","DefaultWorkspaceLock","tokenSource","queue","deferred","entries","DefaultHydrator","lexerReport","astNodes","cstNodes","arr","num","cstNodeObj","hydrated","id","createDefaultCoreModule","createDefaultSharedCoreModule","Module","m1","m2","_merge","inject","module1","module2","module3","module4","module5","module6","module7","module8","module9","module","_inject","isProxy","injector","proxy","_resolve","__requested__","value2","value1","EmptyFileSystemProvider","EmptyFileSystem","minimalGrammarModule","minimalSharedGrammarModule","ast.LangiumGrammarAstReflection","createMinimalGrammarServices","shared","loadGrammarFromJson","json","__defProp","__name","Statement","Architecture","isArchitecture","Axis","Branch","isBranch","Checkout","CherryPicking","ClassDefStatement","Commit","isCommit","Curve","Edge","Entry","GitGraph","isGitGraph","Info","isInfo","Item","Junction","Merge","isMerge","Packet","isPacket","PacketBlock","isPacketBlock","Pie","isPie","PieSection","isPieSection","Radar","Service","Treemap","isTreemap","TreemapRow","Direction","Leaf","Section","MermaidAstReflection","loadedInfoGrammar","InfoGrammar","loadedPacketGrammar","PacketGrammar","loadedPieGrammar","PieGrammar","loadedArchitectureGrammar","ArchitectureGrammar","loadedGitGraphGrammar","GitGraphGrammar","loadedRadarGrammar","RadarGrammar","loadedTreemapGrammar","TreemapGrammar","InfoLanguageMetaData","PacketLanguageMetaData","PieLanguageMetaData","ArchitectureLanguageMetaData","GitGraphLanguageMetaData","RadarLanguageMetaData","TreemapLanguageMetaData","MermaidGeneratedSharedModule","InfoGeneratedModule","PacketGeneratedModule","PieGeneratedModule","ArchitectureGeneratedModule","GitGraphGeneratedModule","RadarGeneratedModule","TreemapGeneratedModule","accessibilityDescrRegex","accessibilityTitleRegex","titleRegex","rulesRegexes","AbstractMermaidValueConverter","_cstNode","CommonValueConverter","_rule","_input","AbstractMermaidTokenBuilder","keywords","GitGraphTokenBuilder","GitGraphModule","createGitGraphServices","InfoTokenBuilder","InfoModule","createInfoServices","PacketTokenBuilder","PacketModule","createPacketServices","PieTokenBuilder","PieValueConverter","PieModule","createPieServices","ArchitectureTokenBuilder","ArchitectureValueConverter","ArchitectureModule","createArchitectureServices","RadarTokenBuilder","RadarModule","createRadarServices","TreemapTokenBuilder","classDefRegex","TreemapValueConverter","registerValidationChecks","registry","TreemapValidator","rootNodeIndentation","row","TreemapModule","createTreemapServices","parsers","initializers","createInfoServices2","__vitePreload","infoNVLQJR56","createPacketServices2","packetBFZMPI3H","createPieServices2","pie7BOR55EZ","createArchitectureServices2","architectureU656AL7Q","createGitGraphServices2","gitGraphF6HP7TQM","createRadarServices2","radarNHE76QYJ","createTreemapServices2","treemapKMMF4GRG","parse","diagramType","MermaidParseError","lexerErrors","parserErrors"],"ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140],"sources":["../node_modules/lodash-es/assign.js","../node_modules/lodash-es/_baseSlice.js","../node_modules/lodash-es/compact.js","../node_modules/lodash-es/_arrayAggregator.js","../node_modules/lodash-es/_baseAggregator.js","../node_modules/lodash-es/_createAggregator.js","../node_modules/lodash-es/_baseDifference.js","../node_modules/lodash-es/difference.js","../node_modules/lodash-es/drop.js","../node_modules/lodash-es/dropRight.js","../node_modules/lodash-es/_arrayEvery.js","../node_modules/lodash-es/_baseEvery.js","../node_modules/lodash-es/every.js","../node_modules/lodash-es/head.js","../node_modules/lodash-es/flatMap.js","../node_modules/lodash-es/groupBy.js","../node_modules/lodash-es/isString.js","../node_modules/lodash-es/includes.js","../node_modules/lodash-es/indexOf.js","../node_modules/lodash-es/_baseIsRegExp.js","../node_modules/lodash-es/isRegExp.js","../node_modules/lodash-es/negate.js","../node_modules/lodash-es/pickBy.js","../node_modules/lodash-es/reject.js","../node_modules/lodash-es/_baseSome.js","../node_modules/lodash-es/some.js","../node_modules/lodash-es/uniq.js","../node_modules/lodash-es/uniqBy.js","../node_modules/langium/lib/syntax-tree.js","../node_modules/langium/lib/utils/stream.js","../node_modules/langium/lib/utils/cst-utils.js","../node_modules/langium/lib/utils/errors.js","../node_modules/langium/lib/languages/generated/ast.js","../node_modules/langium/lib/utils/ast-utils.js","../node_modules/@chevrotain/regexp-to-ast/lib/src/utils.js","../node_modules/@chevrotain/regexp-to-ast/lib/src/character-classes.js","../node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.js","../node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js","../node_modules/langium/lib/utils/regexp-utils.js","../node_modules/langium/lib/utils/grammar-utils.js","../node_modules/langium/lib/languages/grammar-config.js","../node_modules/@chevrotain/utils/lib/src/print.js","../node_modules/@chevrotain/utils/lib/src/timer.js","../node_modules/@chevrotain/utils/lib/src/to-fast-properties.js","../node_modules/@chevrotain/gast/lib/src/model.js","../node_modules/@chevrotain/gast/lib/src/visitor.js","../node_modules/@chevrotain/gast/lib/src/helpers.js","../node_modules/chevrotain/lib/src/parse/grammar/rest.js","../node_modules/chevrotain/lib/src/parse/grammar/first.js","../node_modules/chevrotain/lib/src/parse/constants.js","../node_modules/chevrotain/lib/src/parse/grammar/follow.js","../node_modules/chevrotain/lib/src/scan/reg_exp_parser.js","../node_modules/chevrotain/lib/src/scan/reg_exp.js","../node_modules/chevrotain/lib/src/scan/lexer.js","../node_modules/chevrotain/lib/src/scan/tokens.js","../node_modules/chevrotain/lib/src/scan/lexer_errors_public.js","../node_modules/chevrotain/lib/src/scan/lexer_public.js","../node_modules/chevrotain/lib/src/scan/tokens_public.js","../node_modules/chevrotain/lib/src/parse/errors_public.js","../node_modules/chevrotain/lib/src/parse/grammar/resolver.js","../node_modules/chevrotain/lib/src/parse/grammar/interpreter.js","../node_modules/chevrotain/lib/src/parse/grammar/lookahead.js","../node_modules/chevrotain/lib/src/parse/grammar/checks.js","../node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.js","../node_modules/chevrotain/lib/src/parse/exceptions_public.js","../node_modules/chevrotain/lib/src/parse/parser/traits/recoverable.js","../node_modules/chevrotain/lib/src/parse/grammar/keys.js","../node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.js","../node_modules/chevrotain/lib/src/parse/parser/traits/looksahead.js","../node_modules/chevrotain/lib/src/parse/cst/cst.js","../node_modules/chevrotain/lib/src/lang/lang_extensions.js","../node_modules/chevrotain/lib/src/parse/cst/cst_visitor.js","../node_modules/chevrotain/lib/src/parse/parser/traits/tree_builder.js","../node_modules/chevrotain/lib/src/parse/parser/traits/lexer_adapter.js","../node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_api.js","../node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_engine.js","../node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js","../node_modules/chevrotain/lib/src/parse/parser/traits/context_assist.js","../node_modules/chevrotain/lib/src/parse/parser/traits/gast_recorder.js","../node_modules/chevrotain/lib/src/parse/parser/traits/perf_tracer.js","../node_modules/chevrotain/lib/src/parse/parser/utils/apply_mixins.js","../node_modules/chevrotain/lib/src/parse/parser/parser.js","../node_modules/chevrotain-allstar/lib/atn.js","../node_modules/chevrotain-allstar/lib/dfa.js","../node_modules/chevrotain-allstar/lib/all-star-lookahead.js","../node_modules/vscode-languageserver-types/lib/esm/main.js","../node_modules/langium/lib/parser/cst-node-builder.js","../node_modules/langium/lib/parser/langium-parser.js","../node_modules/langium/lib/parser/parser-builder-base.js","../node_modules/langium/lib/parser/completion-parser-builder.js","../node_modules/langium/lib/parser/langium-parser-builder.js","../node_modules/langium/lib/parser/token-builder.js","../node_modules/langium/lib/parser/value-converter.js","../node_modules/vscode-jsonrpc/lib/common/ral.js","../node_modules/vscode-jsonrpc/lib/common/is.js","../node_modules/vscode-jsonrpc/lib/common/events.js","../node_modules/vscode-jsonrpc/lib/common/cancellation.js","../node_modules/langium/lib/utils/promise-utils.js","../node_modules/vscode-languageserver-textdocument/lib/esm/main.js","../node_modules/vscode-uri/lib/esm/index.mjs","../node_modules/langium/lib/utils/uri-utils.js","../node_modules/langium/lib/workspace/documents.js","../node_modules/langium/lib/references/linker.js","../node_modules/langium/lib/references/name-provider.js","../node_modules/langium/lib/references/references.js","../node_modules/langium/lib/utils/collections.js","../node_modules/langium/lib/references/scope-computation.js","../node_modules/langium/lib/references/scope.js","../node_modules/langium/lib/utils/caching.js","../node_modules/langium/lib/references/scope-provider.js","../node_modules/langium/lib/serializer/json-serializer.js","../node_modules/langium/lib/service-registry.js","../node_modules/langium/lib/validation/validation-registry.js","../node_modules/langium/lib/validation/document-validator.js","../node_modules/langium/lib/workspace/ast-descriptions.js","../node_modules/langium/lib/workspace/ast-node-locator.js","../node_modules/langium/lib/workspace/configuration.js","../node_modules/langium/lib/utils/disposable.js","../node_modules/langium/lib/workspace/document-builder.js","../node_modules/langium/lib/workspace/index-manager.js","../node_modules/langium/lib/workspace/workspace-manager.js","../node_modules/langium/lib/parser/lexer.js","../node_modules/langium/lib/documentation/jsdoc.js","../node_modules/langium/lib/documentation/documentation-provider.js","../node_modules/langium/lib/documentation/comment-provider.js","../node_modules/langium/lib/parser/async-parser.js","../node_modules/langium/lib/workspace/workspace-lock.js","../node_modules/langium/lib/serializer/hydrator.js","../node_modules/langium/lib/default-module.js","../node_modules/langium/lib/dependency-injection.js","../node_modules/langium/lib/workspace/file-system-provider.js","../node_modules/langium/lib/utils/grammar-loader.js","../node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-FPAJGGOC.mjs","../node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-S6J4BHB3.mjs","../node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-LBM3YZW2.mjs","../node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-76Q3JFCE.mjs","../node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-T53DSG4Q.mjs","../node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-O7ZBX7Z2.mjs","../node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-LHMN2FUI.mjs","../node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-FWNWRKHM.mjs","../node_modules/@mermaid-js/parser/dist/mermaid-parser.core.mjs"],"sourcesContent":["import assignValue from './_assignValue.js';\nimport copyObject from './_copyObject.js';\nimport createAssigner from './_createAssigner.js';\nimport isArrayLike from './isArrayLike.js';\nimport isPrototype from './_isPrototype.js';\nimport keys from './keys.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns own enumerable string keyed properties of source objects to the\n * destination object. Source objects are applied from left to right.\n * Subsequent sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object` and is loosely based on\n * [`Object.assign`](https://mdn.io/Object/assign).\n *\n * @static\n * @memberOf _\n * @since 0.10.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.assignIn\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * function Bar() {\n * this.c = 3;\n * }\n *\n * Foo.prototype.b = 2;\n * Bar.prototype.d = 4;\n *\n * _.assign({ 'a': 0 }, new Foo, new Bar);\n * // => { 'a': 1, 'c': 3 }\n */\nvar assign = createAssigner(function(object, source) {\n if (isPrototype(source) || isArrayLike(source)) {\n copyObject(source, keys(source), object);\n return;\n }\n for (var key in source) {\n if (hasOwnProperty.call(source, key)) {\n assignValue(object, key, source[key]);\n }\n }\n});\n\nexport default assign;\n","/**\n * The base implementation of `_.slice` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\nfunction baseSlice(array, start, end) {\n var index = -1,\n length = array.length;\n\n if (start < 0) {\n start = -start > length ? 0 : (length + start);\n }\n end = end > length ? length : end;\n if (end < 0) {\n end += length;\n }\n length = start > end ? 0 : ((end - start) >>> 0);\n start >>>= 0;\n\n var result = Array(length);\n while (++index < length) {\n result[index] = array[index + start];\n }\n return result;\n}\n\nexport default baseSlice;\n","/**\n * Creates an array with all falsey values removed. The values `false`, `null`,\n * `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to compact.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * _.compact([0, 1, false, 2, '', 3]);\n * // => [1, 2, 3]\n */\nfunction compact(array) {\n var index = -1,\n length = array == null ? 0 : array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index];\n if (value) {\n result[resIndex++] = value;\n }\n }\n return result;\n}\n\nexport default compact;\n","/**\n * A specialized version of `baseAggregator` for arrays.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform keys.\n * @param {Object} accumulator The initial aggregated object.\n * @returns {Function} Returns `accumulator`.\n */\nfunction arrayAggregator(array, setter, iteratee, accumulator) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n var value = array[index];\n setter(accumulator, value, iteratee(value), array);\n }\n return accumulator;\n}\n\nexport default arrayAggregator;\n","import baseEach from './_baseEach.js';\n\n/**\n * Aggregates elements of `collection` on `accumulator` with keys transformed\n * by `iteratee` and values set by `setter`.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform keys.\n * @param {Object} accumulator The initial aggregated object.\n * @returns {Function} Returns `accumulator`.\n */\nfunction baseAggregator(collection, setter, iteratee, accumulator) {\n baseEach(collection, function(value, key, collection) {\n setter(accumulator, value, iteratee(value), collection);\n });\n return accumulator;\n}\n\nexport default baseAggregator;\n","import arrayAggregator from './_arrayAggregator.js';\nimport baseAggregator from './_baseAggregator.js';\nimport baseIteratee from './_baseIteratee.js';\nimport isArray from './isArray.js';\n\n/**\n * Creates a function like `_.groupBy`.\n *\n * @private\n * @param {Function} setter The function to set accumulator values.\n * @param {Function} [initializer] The accumulator object initializer.\n * @returns {Function} Returns the new aggregator function.\n */\nfunction createAggregator(setter, initializer) {\n return function(collection, iteratee) {\n var func = isArray(collection) ? arrayAggregator : baseAggregator,\n accumulator = initializer ? initializer() : {};\n\n return func(collection, setter, baseIteratee(iteratee, 2), accumulator);\n };\n}\n\nexport default createAggregator;\n","import SetCache from './_SetCache.js';\nimport arrayIncludes from './_arrayIncludes.js';\nimport arrayIncludesWith from './_arrayIncludesWith.js';\nimport arrayMap from './_arrayMap.js';\nimport baseUnary from './_baseUnary.js';\nimport cacheHas from './_cacheHas.js';\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * The base implementation of methods like `_.difference` without support\n * for excluding multiple arrays or iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Array} values The values to exclude.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n */\nfunction baseDifference(array, values, iteratee, comparator) {\n var index = -1,\n includes = arrayIncludes,\n isCommon = true,\n length = array.length,\n result = [],\n valuesLength = values.length;\n\n if (!length) {\n return result;\n }\n if (iteratee) {\n values = arrayMap(values, baseUnary(iteratee));\n }\n if (comparator) {\n includes = arrayIncludesWith;\n isCommon = false;\n }\n else if (values.length >= LARGE_ARRAY_SIZE) {\n includes = cacheHas;\n isCommon = false;\n values = new SetCache(values);\n }\n outer:\n while (++index < length) {\n var value = array[index],\n computed = iteratee == null ? value : iteratee(value);\n\n value = (comparator || value !== 0) ? value : 0;\n if (isCommon && computed === computed) {\n var valuesIndex = valuesLength;\n while (valuesIndex--) {\n if (values[valuesIndex] === computed) {\n continue outer;\n }\n }\n result.push(value);\n }\n else if (!includes(values, computed, comparator)) {\n result.push(value);\n }\n }\n return result;\n}\n\nexport default baseDifference;\n","import baseDifference from './_baseDifference.js';\nimport baseFlatten from './_baseFlatten.js';\nimport baseRest from './_baseRest.js';\nimport isArrayLikeObject from './isArrayLikeObject.js';\n\n/**\n * Creates an array of `array` values not included in the other given arrays\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons. The order and references of result values are\n * determined by the first array.\n *\n * **Note:** Unlike `_.pullAll`, this method returns a new array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {...Array} [values] The values to exclude.\n * @returns {Array} Returns the new array of filtered values.\n * @see _.without, _.xor\n * @example\n *\n * _.difference([2, 1], [2, 3]);\n * // => [1]\n */\nvar difference = baseRest(function(array, values) {\n return isArrayLikeObject(array)\n ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))\n : [];\n});\n\nexport default difference;\n","import baseSlice from './_baseSlice.js';\nimport toInteger from './toInteger.js';\n\n/**\n * Creates a slice of `array` with `n` elements dropped from the beginning.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=1] The number of elements to drop.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.drop([1, 2, 3]);\n * // => [2, 3]\n *\n * _.drop([1, 2, 3], 2);\n * // => [3]\n *\n * _.drop([1, 2, 3], 5);\n * // => []\n *\n * _.drop([1, 2, 3], 0);\n * // => [1, 2, 3]\n */\nfunction drop(array, n, guard) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n n = (guard || n === undefined) ? 1 : toInteger(n);\n return baseSlice(array, n < 0 ? 0 : n, length);\n}\n\nexport default drop;\n","import baseSlice from './_baseSlice.js';\nimport toInteger from './toInteger.js';\n\n/**\n * Creates a slice of `array` with `n` elements dropped from the end.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=1] The number of elements to drop.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.dropRight([1, 2, 3]);\n * // => [1, 2]\n *\n * _.dropRight([1, 2, 3], 2);\n * // => [1]\n *\n * _.dropRight([1, 2, 3], 5);\n * // => []\n *\n * _.dropRight([1, 2, 3], 0);\n * // => [1, 2, 3]\n */\nfunction dropRight(array, n, guard) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n n = (guard || n === undefined) ? 1 : toInteger(n);\n n = length - n;\n return baseSlice(array, 0, n < 0 ? 0 : n);\n}\n\nexport default dropRight;\n","/**\n * A specialized version of `_.every` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if all elements pass the predicate check,\n * else `false`.\n */\nfunction arrayEvery(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (!predicate(array[index], index, array)) {\n return false;\n }\n }\n return true;\n}\n\nexport default arrayEvery;\n","import baseEach from './_baseEach.js';\n\n/**\n * The base implementation of `_.every` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if all elements pass the predicate check,\n * else `false`\n */\nfunction baseEvery(collection, predicate) {\n var result = true;\n baseEach(collection, function(value, index, collection) {\n result = !!predicate(value, index, collection);\n return result;\n });\n return result;\n}\n\nexport default baseEvery;\n","import arrayEvery from './_arrayEvery.js';\nimport baseEvery from './_baseEvery.js';\nimport baseIteratee from './_baseIteratee.js';\nimport isArray from './isArray.js';\nimport isIterateeCall from './_isIterateeCall.js';\n\n/**\n * Checks if `predicate` returns truthy for **all** elements of `collection`.\n * Iteration is stopped once `predicate` returns falsey. The predicate is\n * invoked with three arguments: (value, index|key, collection).\n *\n * **Note:** This method returns `true` for\n * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because\n * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of\n * elements of empty collections.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {boolean} Returns `true` if all elements pass the predicate check,\n * else `false`.\n * @example\n *\n * _.every([true, 1, null, 'yes'], Boolean);\n * // => false\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': false },\n * { 'user': 'fred', 'age': 40, 'active': false }\n * ];\n *\n * // The `_.matches` iteratee shorthand.\n * _.every(users, { 'user': 'barney', 'active': false });\n * // => false\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.every(users, ['active', false]);\n * // => true\n *\n * // The `_.property` iteratee shorthand.\n * _.every(users, 'active');\n * // => false\n */\nfunction every(collection, predicate, guard) {\n var func = isArray(collection) ? arrayEvery : baseEvery;\n if (guard && isIterateeCall(collection, predicate, guard)) {\n predicate = undefined;\n }\n return func(collection, baseIteratee(predicate, 3));\n}\n\nexport default every;\n","/**\n * Gets the first element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @alias first\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the first element of `array`.\n * @example\n *\n * _.head([1, 2, 3]);\n * // => 1\n *\n * _.head([]);\n * // => undefined\n */\nfunction head(array) {\n return (array && array.length) ? array[0] : undefined;\n}\n\nexport default head;\n","import baseFlatten from './_baseFlatten.js';\nimport map from './map.js';\n\n/**\n * Creates a flattened array of values by running each element in `collection`\n * thru `iteratee` and flattening the mapped results. The iteratee is invoked\n * with three arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * function duplicate(n) {\n * return [n, n];\n * }\n *\n * _.flatMap([1, 2], duplicate);\n * // => [1, 1, 2, 2]\n */\nfunction flatMap(collection, iteratee) {\n return baseFlatten(map(collection, iteratee), 1);\n}\n\nexport default flatMap;\n","import baseAssignValue from './_baseAssignValue.js';\nimport createAggregator from './_createAggregator.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an object composed of keys generated from the results of running\n * each element of `collection` thru `iteratee`. The order of grouped values\n * is determined by the order they occur in `collection`. The corresponding\n * value of each key is an array of elements responsible for generating the\n * key. The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n * @returns {Object} Returns the composed aggregate object.\n * @example\n *\n * _.groupBy([6.1, 4.2, 6.3], Math.floor);\n * // => { '4': [4.2], '6': [6.1, 6.3] }\n *\n * // The `_.property` iteratee shorthand.\n * _.groupBy(['one', 'two', 'three'], 'length');\n * // => { '3': ['one', 'two'], '5': ['three'] }\n */\nvar groupBy = createAggregator(function(result, value, key) {\n if (hasOwnProperty.call(result, key)) {\n result[key].push(value);\n } else {\n baseAssignValue(result, key, [value]);\n }\n});\n\nexport default groupBy;\n","import baseGetTag from './_baseGetTag.js';\nimport isArray from './isArray.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar stringTag = '[object String]';\n\n/**\n * Checks if `value` is classified as a `String` primitive or object.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n * @example\n *\n * _.isString('abc');\n * // => true\n *\n * _.isString(1);\n * // => false\n */\nfunction isString(value) {\n return typeof value == 'string' ||\n (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n}\n\nexport default isString;\n","import baseIndexOf from './_baseIndexOf.js';\nimport isArrayLike from './isArrayLike.js';\nimport isString from './isString.js';\nimport toInteger from './toInteger.js';\nimport values from './values.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * Checks if `value` is in `collection`. If `collection` is a string, it's\n * checked for a substring of `value`, otherwise\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * is used for equality comparisons. If `fromIndex` is negative, it's used as\n * the offset from the end of `collection`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object|string} collection The collection to inspect.\n * @param {*} value The value to search for.\n * @param {number} [fromIndex=0] The index to search from.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n * @returns {boolean} Returns `true` if `value` is found, else `false`.\n * @example\n *\n * _.includes([1, 2, 3], 1);\n * // => true\n *\n * _.includes([1, 2, 3], 1, 2);\n * // => false\n *\n * _.includes({ 'a': 1, 'b': 2 }, 1);\n * // => true\n *\n * _.includes('abcd', 'bc');\n * // => true\n */\nfunction includes(collection, value, fromIndex, guard) {\n collection = isArrayLike(collection) ? collection : values(collection);\n fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;\n\n var length = collection.length;\n if (fromIndex < 0) {\n fromIndex = nativeMax(length + fromIndex, 0);\n }\n return isString(collection)\n ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)\n : (!!length && baseIndexOf(collection, value, fromIndex) > -1);\n}\n\nexport default includes;\n","import baseIndexOf from './_baseIndexOf.js';\nimport toInteger from './toInteger.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * Gets the index at which the first occurrence of `value` is found in `array`\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons. If `fromIndex` is negative, it's used as the\n * offset from the end of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n * @example\n *\n * _.indexOf([1, 2, 1, 2], 2);\n * // => 1\n *\n * // Search from the `fromIndex`.\n * _.indexOf([1, 2, 1, 2], 2, 2);\n * // => 3\n */\nfunction indexOf(array, value, fromIndex) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return -1;\n }\n var index = fromIndex == null ? 0 : toInteger(fromIndex);\n if (index < 0) {\n index = nativeMax(length + index, 0);\n }\n return baseIndexOf(array, value, index);\n}\n\nexport default indexOf;\n","import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar regexpTag = '[object RegExp]';\n\n/**\n * The base implementation of `_.isRegExp` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n */\nfunction baseIsRegExp(value) {\n return isObjectLike(value) && baseGetTag(value) == regexpTag;\n}\n\nexport default baseIsRegExp;\n","import baseIsRegExp from './_baseIsRegExp.js';\nimport baseUnary from './_baseUnary.js';\nimport nodeUtil from './_nodeUtil.js';\n\n/* Node.js helper references. */\nvar nodeIsRegExp = nodeUtil && nodeUtil.isRegExp;\n\n/**\n * Checks if `value` is classified as a `RegExp` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n * @example\n *\n * _.isRegExp(/abc/);\n * // => true\n *\n * _.isRegExp('/abc/');\n * // => false\n */\nvar isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;\n\nexport default isRegExp;\n","/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that negates the result of the predicate `func`. The\n * `func` predicate is invoked with the `this` binding and arguments of the\n * created function.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {Function} predicate The predicate to negate.\n * @returns {Function} Returns the new negated function.\n * @example\n *\n * function isEven(n) {\n * return n % 2 == 0;\n * }\n *\n * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));\n * // => [1, 3, 5]\n */\nfunction negate(predicate) {\n if (typeof predicate != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n return function() {\n var args = arguments;\n switch (args.length) {\n case 0: return !predicate.call(this);\n case 1: return !predicate.call(this, args[0]);\n case 2: return !predicate.call(this, args[0], args[1]);\n case 3: return !predicate.call(this, args[0], args[1], args[2]);\n }\n return !predicate.apply(this, args);\n };\n}\n\nexport default negate;\n","import arrayMap from './_arrayMap.js';\nimport baseIteratee from './_baseIteratee.js';\nimport basePickBy from './_basePickBy.js';\nimport getAllKeysIn from './_getAllKeysIn.js';\n\n/**\n * Creates an object composed of the `object` properties `predicate` returns\n * truthy for. The predicate is invoked with two arguments: (value, key).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The source object.\n * @param {Function} [predicate=_.identity] The function invoked per property.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pickBy(object, _.isNumber);\n * // => { 'a': 1, 'c': 3 }\n */\nfunction pickBy(object, predicate) {\n if (object == null) {\n return {};\n }\n var props = arrayMap(getAllKeysIn(object), function(prop) {\n return [prop];\n });\n predicate = baseIteratee(predicate);\n return basePickBy(object, props, function(value, path) {\n return predicate(value, path[0]);\n });\n}\n\nexport default pickBy;\n","import arrayFilter from './_arrayFilter.js';\nimport baseFilter from './_baseFilter.js';\nimport baseIteratee from './_baseIteratee.js';\nimport isArray from './isArray.js';\nimport negate from './negate.js';\n\n/**\n * The opposite of `_.filter`; this method returns the elements of `collection`\n * that `predicate` does **not** return truthy for.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n * @see _.filter\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': false },\n * { 'user': 'fred', 'age': 40, 'active': true }\n * ];\n *\n * _.reject(users, function(o) { return !o.active; });\n * // => objects for ['fred']\n *\n * // The `_.matches` iteratee shorthand.\n * _.reject(users, { 'age': 40, 'active': true });\n * // => objects for ['barney']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.reject(users, ['active', false]);\n * // => objects for ['fred']\n *\n * // The `_.property` iteratee shorthand.\n * _.reject(users, 'active');\n * // => objects for ['barney']\n */\nfunction reject(collection, predicate) {\n var func = isArray(collection) ? arrayFilter : baseFilter;\n return func(collection, negate(baseIteratee(predicate, 3)));\n}\n\nexport default reject;\n","import baseEach from './_baseEach.js';\n\n/**\n * The base implementation of `_.some` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n * else `false`.\n */\nfunction baseSome(collection, predicate) {\n var result;\n\n baseEach(collection, function(value, index, collection) {\n result = predicate(value, index, collection);\n return !result;\n });\n return !!result;\n}\n\nexport default baseSome;\n","import arraySome from './_arraySome.js';\nimport baseIteratee from './_baseIteratee.js';\nimport baseSome from './_baseSome.js';\nimport isArray from './isArray.js';\nimport isIterateeCall from './_isIterateeCall.js';\n\n/**\n * Checks if `predicate` returns truthy for **any** element of `collection`.\n * Iteration is stopped once `predicate` returns truthy. The predicate is\n * invoked with three arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n * else `false`.\n * @example\n *\n * _.some([null, 0, 'yes', false], Boolean);\n * // => true\n *\n * var users = [\n * { 'user': 'barney', 'active': true },\n * { 'user': 'fred', 'active': false }\n * ];\n *\n * // The `_.matches` iteratee shorthand.\n * _.some(users, { 'user': 'barney', 'active': false });\n * // => false\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.some(users, ['active', false]);\n * // => true\n *\n * // The `_.property` iteratee shorthand.\n * _.some(users, 'active');\n * // => true\n */\nfunction some(collection, predicate, guard) {\n var func = isArray(collection) ? arraySome : baseSome;\n if (guard && isIterateeCall(collection, predicate, guard)) {\n predicate = undefined;\n }\n return func(collection, baseIteratee(predicate, 3));\n}\n\nexport default some;\n","import baseUniq from './_baseUniq.js';\n\n/**\n * Creates a duplicate-free version of an array, using\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons, in which only the first occurrence of each element\n * is kept. The order of result values is determined by the order they occur\n * in the array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.uniq([2, 1, 2]);\n * // => [2, 1]\n */\nfunction uniq(array) {\n return (array && array.length) ? baseUniq(array) : [];\n}\n\nexport default uniq;\n","import baseIteratee from './_baseIteratee.js';\nimport baseUniq from './_baseUniq.js';\n\n/**\n * This method is like `_.uniq` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the criterion by which\n * uniqueness is computed. The order of result values is determined by the\n * order they occur in the array. The iteratee is invoked with one argument:\n * (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.uniqBy([2.1, 1.2, 2.3], Math.floor);\n * // => [2.1, 1.2]\n *\n * // The `_.property` iteratee shorthand.\n * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n * // => [{ 'x': 1 }, { 'x': 2 }]\n */\nfunction uniqBy(array, iteratee) {\n return (array && array.length) ? baseUniq(array, baseIteratee(iteratee, 2)) : [];\n}\n\nexport default uniqBy;\n","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport function isAstNode(obj) {\n return typeof obj === 'object' && obj !== null && typeof obj.$type === 'string';\n}\nexport function isReference(obj) {\n return typeof obj === 'object' && obj !== null && typeof obj.$refText === 'string';\n}\nexport function isAstNodeDescription(obj) {\n return typeof obj === 'object' && obj !== null\n && typeof obj.name === 'string'\n && typeof obj.type === 'string'\n && typeof obj.path === 'string';\n}\nexport function isLinkingError(obj) {\n return typeof obj === 'object' && obj !== null\n && isAstNode(obj.container)\n && isReference(obj.reference)\n && typeof obj.message === 'string';\n}\n/**\n * An abstract implementation of the {@link AstReflection} interface.\n * Serves to cache subtype computation results to improve performance throughout different parts of Langium.\n */\nexport class AbstractAstReflection {\n constructor() {\n this.subtypes = {};\n this.allSubtypes = {};\n }\n isInstance(node, type) {\n return isAstNode(node) && this.isSubtype(node.$type, type);\n }\n isSubtype(subtype, supertype) {\n if (subtype === supertype) {\n return true;\n }\n let nested = this.subtypes[subtype];\n if (!nested) {\n nested = this.subtypes[subtype] = {};\n }\n const existing = nested[supertype];\n if (existing !== undefined) {\n return existing;\n }\n else {\n const result = this.computeIsSubtype(subtype, supertype);\n nested[supertype] = result;\n return result;\n }\n }\n getAllSubTypes(type) {\n const existing = this.allSubtypes[type];\n if (existing) {\n return existing;\n }\n else {\n const allTypes = this.getAllTypes();\n const types = [];\n for (const possibleSubType of allTypes) {\n if (this.isSubtype(possibleSubType, type)) {\n types.push(possibleSubType);\n }\n }\n this.allSubtypes[type] = types;\n return types;\n }\n }\n}\nexport function isCompositeCstNode(node) {\n return typeof node === 'object' && node !== null && Array.isArray(node.content);\n}\nexport function isLeafCstNode(node) {\n return typeof node === 'object' && node !== null && typeof node.tokenType === 'object';\n}\nexport function isRootCstNode(node) {\n return isCompositeCstNode(node) && typeof node.fullText === 'string';\n}\n//# sourceMappingURL=syntax-tree.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\n/**\n * The default implementation of `Stream` works with two input functions:\n * - The first function creates the initial state of an iteration.\n * - The second function gets the current state as argument and returns an `IteratorResult`.\n */\nexport class StreamImpl {\n constructor(startFn, nextFn) {\n this.startFn = startFn;\n this.nextFn = nextFn;\n }\n iterator() {\n const iterator = {\n state: this.startFn(),\n next: () => this.nextFn(iterator.state),\n [Symbol.iterator]: () => iterator\n };\n return iterator;\n }\n [Symbol.iterator]() {\n return this.iterator();\n }\n isEmpty() {\n const iterator = this.iterator();\n return Boolean(iterator.next().done);\n }\n count() {\n const iterator = this.iterator();\n let count = 0;\n let next = iterator.next();\n while (!next.done) {\n count++;\n next = iterator.next();\n }\n return count;\n }\n toArray() {\n const result = [];\n const iterator = this.iterator();\n let next;\n do {\n next = iterator.next();\n if (next.value !== undefined) {\n result.push(next.value);\n }\n } while (!next.done);\n return result;\n }\n toSet() {\n return new Set(this);\n }\n toMap(keyFn, valueFn) {\n const entryStream = this.map(element => [\n keyFn ? keyFn(element) : element,\n valueFn ? valueFn(element) : element\n ]);\n return new Map(entryStream);\n }\n toString() {\n return this.join();\n }\n concat(other) {\n return new StreamImpl(() => ({ first: this.startFn(), firstDone: false, iterator: other[Symbol.iterator]() }), state => {\n let result;\n if (!state.firstDone) {\n do {\n result = this.nextFn(state.first);\n if (!result.done) {\n return result;\n }\n } while (!result.done);\n state.firstDone = true;\n }\n do {\n result = state.iterator.next();\n if (!result.done) {\n return result;\n }\n } while (!result.done);\n return DONE_RESULT;\n });\n }\n join(separator = ',') {\n const iterator = this.iterator();\n let value = '';\n let result;\n let addSeparator = false;\n do {\n result = iterator.next();\n if (!result.done) {\n if (addSeparator) {\n value += separator;\n }\n value += toString(result.value);\n }\n addSeparator = true;\n } while (!result.done);\n return value;\n }\n indexOf(searchElement, fromIndex = 0) {\n const iterator = this.iterator();\n let index = 0;\n let next = iterator.next();\n while (!next.done) {\n if (index >= fromIndex && next.value === searchElement) {\n return index;\n }\n next = iterator.next();\n index++;\n }\n return -1;\n }\n every(predicate) {\n const iterator = this.iterator();\n let next = iterator.next();\n while (!next.done) {\n if (!predicate(next.value)) {\n return false;\n }\n next = iterator.next();\n }\n return true;\n }\n some(predicate) {\n const iterator = this.iterator();\n let next = iterator.next();\n while (!next.done) {\n if (predicate(next.value)) {\n return true;\n }\n next = iterator.next();\n }\n return false;\n }\n forEach(callbackfn) {\n const iterator = this.iterator();\n let index = 0;\n let next = iterator.next();\n while (!next.done) {\n callbackfn(next.value, index);\n next = iterator.next();\n index++;\n }\n }\n map(callbackfn) {\n return new StreamImpl(this.startFn, (state) => {\n const { done, value } = this.nextFn(state);\n if (done) {\n return DONE_RESULT;\n }\n else {\n return { done: false, value: callbackfn(value) };\n }\n });\n }\n filter(predicate) {\n return new StreamImpl(this.startFn, state => {\n let result;\n do {\n result = this.nextFn(state);\n if (!result.done && predicate(result.value)) {\n return result;\n }\n } while (!result.done);\n return DONE_RESULT;\n });\n }\n nonNullable() {\n return this.filter(e => e !== undefined && e !== null);\n }\n reduce(callbackfn, initialValue) {\n const iterator = this.iterator();\n let previousValue = initialValue;\n let next = iterator.next();\n while (!next.done) {\n if (previousValue === undefined) {\n previousValue = next.value;\n }\n else {\n previousValue = callbackfn(previousValue, next.value);\n }\n next = iterator.next();\n }\n return previousValue;\n }\n reduceRight(callbackfn, initialValue) {\n return this.recursiveReduce(this.iterator(), callbackfn, initialValue);\n }\n recursiveReduce(iterator, callbackfn, initialValue) {\n const next = iterator.next();\n if (next.done) {\n return initialValue;\n }\n const previousValue = this.recursiveReduce(iterator, callbackfn, initialValue);\n if (previousValue === undefined) {\n return next.value;\n }\n return callbackfn(previousValue, next.value);\n }\n find(predicate) {\n const iterator = this.iterator();\n let next = iterator.next();\n while (!next.done) {\n if (predicate(next.value)) {\n return next.value;\n }\n next = iterator.next();\n }\n return undefined;\n }\n findIndex(predicate) {\n const iterator = this.iterator();\n let index = 0;\n let next = iterator.next();\n while (!next.done) {\n if (predicate(next.value)) {\n return index;\n }\n next = iterator.next();\n index++;\n }\n return -1;\n }\n includes(searchElement) {\n const iterator = this.iterator();\n let next = iterator.next();\n while (!next.done) {\n if (next.value === searchElement) {\n return true;\n }\n next = iterator.next();\n }\n return false;\n }\n flatMap(callbackfn) {\n return new StreamImpl(() => ({ this: this.startFn() }), (state) => {\n do {\n if (state.iterator) {\n const next = state.iterator.next();\n if (next.done) {\n state.iterator = undefined;\n }\n else {\n return next;\n }\n }\n const { done, value } = this.nextFn(state.this);\n if (!done) {\n const mapped = callbackfn(value);\n if (isIterable(mapped)) {\n state.iterator = mapped[Symbol.iterator]();\n }\n else {\n return { done: false, value: mapped };\n }\n }\n } while (state.iterator);\n return DONE_RESULT;\n });\n }\n flat(depth) {\n if (depth === undefined) {\n depth = 1;\n }\n if (depth <= 0) {\n return this;\n }\n const stream = depth > 1 ? this.flat(depth - 1) : this;\n return new StreamImpl(() => ({ this: stream.startFn() }), (state) => {\n do {\n if (state.iterator) {\n const next = state.iterator.next();\n if (next.done) {\n state.iterator = undefined;\n }\n else {\n return next;\n }\n }\n const { done, value } = stream.nextFn(state.this);\n if (!done) {\n if (isIterable(value)) {\n state.iterator = value[Symbol.iterator]();\n }\n else {\n return { done: false, value: value };\n }\n }\n } while (state.iterator);\n return DONE_RESULT;\n });\n }\n head() {\n const iterator = this.iterator();\n const result = iterator.next();\n if (result.done) {\n return undefined;\n }\n return result.value;\n }\n tail(skipCount = 1) {\n return new StreamImpl(() => {\n const state = this.startFn();\n for (let i = 0; i < skipCount; i++) {\n const next = this.nextFn(state);\n if (next.done) {\n return state;\n }\n }\n return state;\n }, this.nextFn);\n }\n limit(maxSize) {\n return new StreamImpl(() => ({ size: 0, state: this.startFn() }), state => {\n state.size++;\n if (state.size > maxSize) {\n return DONE_RESULT;\n }\n return this.nextFn(state.state);\n });\n }\n distinct(by) {\n return new StreamImpl(() => ({ set: new Set(), internalState: this.startFn() }), state => {\n let result;\n do {\n result = this.nextFn(state.internalState);\n if (!result.done) {\n const value = by ? by(result.value) : result.value;\n if (!state.set.has(value)) {\n state.set.add(value);\n return result;\n }\n }\n } while (!result.done);\n return DONE_RESULT;\n });\n }\n exclude(other, key) {\n const otherKeySet = new Set();\n for (const item of other) {\n const value = key ? key(item) : item;\n otherKeySet.add(value);\n }\n return this.filter(e => {\n const ownKey = key ? key(e) : e;\n return !otherKeySet.has(ownKey);\n });\n }\n}\nfunction toString(item) {\n if (typeof item === 'string') {\n return item;\n }\n if (typeof item === 'undefined') {\n return 'undefined';\n }\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n if (typeof item.toString === 'function') {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n return item.toString();\n }\n return Object.prototype.toString.call(item);\n}\nfunction isIterable(obj) {\n return !!obj && typeof obj[Symbol.iterator] === 'function';\n}\n/**\n * An empty stream of any type.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const EMPTY_STREAM = new StreamImpl(() => undefined, () => DONE_RESULT);\n/**\n * Use this `IteratorResult` when implementing a `StreamImpl` to indicate that there are no more elements in the stream.\n */\nexport const DONE_RESULT = Object.freeze({ done: true, value: undefined });\n/**\n * Create a stream from one or more iterables or array-likes.\n */\nexport function stream(...collections) {\n if (collections.length === 1) {\n const collection = collections[0];\n if (collection instanceof StreamImpl) {\n return collection;\n }\n if (isIterable(collection)) {\n return new StreamImpl(() => collection[Symbol.iterator](), (iterator) => iterator.next());\n }\n if (typeof collection.length === 'number') {\n return new StreamImpl(() => ({ index: 0 }), (state) => {\n if (state.index < collection.length) {\n return { done: false, value: collection[state.index++] };\n }\n else {\n return DONE_RESULT;\n }\n });\n }\n }\n if (collections.length > 1) {\n return new StreamImpl(() => ({ collIndex: 0, arrIndex: 0 }), (state) => {\n do {\n if (state.iterator) {\n const next = state.iterator.next();\n if (!next.done) {\n return next;\n }\n state.iterator = undefined;\n }\n if (state.array) {\n if (state.arrIndex < state.array.length) {\n return { done: false, value: state.array[state.arrIndex++] };\n }\n state.array = undefined;\n state.arrIndex = 0;\n }\n if (state.collIndex < collections.length) {\n const collection = collections[state.collIndex++];\n if (isIterable(collection)) {\n state.iterator = collection[Symbol.iterator]();\n }\n else if (collection && typeof collection.length === 'number') {\n state.array = collection;\n }\n }\n } while (state.iterator || state.array || state.collIndex < collections.length);\n return DONE_RESULT;\n });\n }\n return EMPTY_STREAM;\n}\n/**\n * The default implementation of `TreeStream` takes a root element and a function that computes the\n * children of its argument. Whether the root node included in the stream is controlled with the\n * `includeRoot` option, which defaults to `false`.\n */\nexport class TreeStreamImpl extends StreamImpl {\n constructor(root, children, options) {\n super(() => ({\n iterators: (options === null || options === void 0 ? void 0 : options.includeRoot) ? [[root][Symbol.iterator]()] : [children(root)[Symbol.iterator]()],\n pruned: false\n }), state => {\n if (state.pruned) {\n state.iterators.pop();\n state.pruned = false;\n }\n while (state.iterators.length > 0) {\n const iterator = state.iterators[state.iterators.length - 1];\n const next = iterator.next();\n if (next.done) {\n state.iterators.pop();\n }\n else {\n state.iterators.push(children(next.value)[Symbol.iterator]());\n return next;\n }\n }\n return DONE_RESULT;\n });\n }\n iterator() {\n const iterator = {\n state: this.startFn(),\n next: () => this.nextFn(iterator.state),\n prune: () => {\n iterator.state.pruned = true;\n },\n [Symbol.iterator]: () => iterator\n };\n return iterator;\n }\n}\n/**\n * A set of utility functions that reduce a stream to a single value.\n */\nexport var Reduction;\n(function (Reduction) {\n /**\n * Compute the sum of a number stream.\n */\n function sum(stream) {\n return stream.reduce((a, b) => a + b, 0);\n }\n Reduction.sum = sum;\n /**\n * Compute the product of a number stream.\n */\n function product(stream) {\n return stream.reduce((a, b) => a * b, 0);\n }\n Reduction.product = product;\n /**\n * Compute the minimum of a number stream. Returns `undefined` if the stream is empty.\n */\n function min(stream) {\n return stream.reduce((a, b) => Math.min(a, b));\n }\n Reduction.min = min;\n /**\n * Compute the maximum of a number stream. Returns `undefined` if the stream is empty.\n */\n function max(stream) {\n return stream.reduce((a, b) => Math.max(a, b));\n }\n Reduction.max = max;\n})(Reduction || (Reduction = {}));\n//# sourceMappingURL=stream.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { isCompositeCstNode, isLeafCstNode, isRootCstNode } from '../syntax-tree.js';\nimport { TreeStreamImpl } from './stream.js';\n/**\n * Create a stream of all CST nodes that are directly and indirectly contained in the given root node,\n * including the root node itself.\n */\nexport function streamCst(node) {\n return new TreeStreamImpl(node, element => {\n if (isCompositeCstNode(element)) {\n return element.content;\n }\n else {\n return [];\n }\n }, { includeRoot: true });\n}\n/**\n * Create a stream of all leaf nodes that are directly and indirectly contained in the given root node.\n */\nexport function flattenCst(node) {\n return streamCst(node).filter(isLeafCstNode);\n}\n/**\n * Determines whether the specified cst node is a child of the specified parent node.\n */\nexport function isChildNode(child, parent) {\n while (child.container) {\n child = child.container;\n if (child === parent) {\n return true;\n }\n }\n return false;\n}\nexport function tokenToRange(token) {\n // Chevrotain uses 1-based indices everywhere\n // So we subtract 1 from every value to align with the LSP\n return {\n start: {\n character: token.startColumn - 1,\n line: token.startLine - 1\n },\n end: {\n character: token.endColumn, // endColumn uses the correct index\n line: token.endLine - 1\n }\n };\n}\nexport function toDocumentSegment(node) {\n if (!node) {\n return undefined;\n }\n const { offset, end, range } = node;\n return {\n range,\n offset,\n end,\n length: end - offset\n };\n}\nexport var RangeComparison;\n(function (RangeComparison) {\n RangeComparison[RangeComparison[\"Before\"] = 0] = \"Before\";\n RangeComparison[RangeComparison[\"After\"] = 1] = \"After\";\n RangeComparison[RangeComparison[\"OverlapFront\"] = 2] = \"OverlapFront\";\n RangeComparison[RangeComparison[\"OverlapBack\"] = 3] = \"OverlapBack\";\n RangeComparison[RangeComparison[\"Inside\"] = 4] = \"Inside\";\n RangeComparison[RangeComparison[\"Outside\"] = 5] = \"Outside\";\n})(RangeComparison || (RangeComparison = {}));\nexport function compareRange(range, to) {\n if (range.end.line < to.start.line || (range.end.line === to.start.line && range.end.character <= to.start.character)) {\n return RangeComparison.Before;\n }\n else if (range.start.line > to.end.line || (range.start.line === to.end.line && range.start.character >= to.end.character)) {\n return RangeComparison.After;\n }\n const startInside = range.start.line > to.start.line || (range.start.line === to.start.line && range.start.character >= to.start.character);\n const endInside = range.end.line < to.end.line || (range.end.line === to.end.line && range.end.character <= to.end.character);\n if (startInside && endInside) {\n return RangeComparison.Inside;\n }\n else if (startInside) {\n return RangeComparison.OverlapBack;\n }\n else if (endInside) {\n return RangeComparison.OverlapFront;\n }\n else {\n return RangeComparison.Outside;\n }\n}\nexport function inRange(range, to) {\n const comparison = compareRange(range, to);\n return comparison > RangeComparison.After;\n}\n// The \\p{L} regex matches any unicode letter character, i.e. characters from non-english alphabets\n// Together with \\w it matches any kind of character which can commonly appear in IDs\nexport const DefaultNameRegexp = /^[\\w\\p{L}]$/u;\n/**\n * Performs `findLeafNodeAtOffset` with a minor difference: When encountering a character that matches the `nameRegexp` argument,\n * it will instead return the leaf node at the `offset - 1` position.\n *\n * For LSP services, users expect that the declaration of an element is available if the cursor is directly after the element.\n */\nexport function findDeclarationNodeAtOffset(cstNode, offset, nameRegexp = DefaultNameRegexp) {\n if (cstNode) {\n if (offset > 0) {\n const localOffset = offset - cstNode.offset;\n const textAtOffset = cstNode.text.charAt(localOffset);\n if (!nameRegexp.test(textAtOffset)) {\n offset--;\n }\n }\n return findLeafNodeAtOffset(cstNode, offset);\n }\n return undefined;\n}\nexport function findCommentNode(cstNode, commentNames) {\n if (cstNode) {\n const previous = getPreviousNode(cstNode, true);\n if (previous && isCommentNode(previous, commentNames)) {\n return previous;\n }\n if (isRootCstNode(cstNode)) {\n // Go from the first non-hidden node through all nodes in reverse order\n // We do this to find the comment node which directly precedes the root node\n const endIndex = cstNode.content.findIndex(e => !e.hidden);\n for (let i = endIndex - 1; i >= 0; i--) {\n const child = cstNode.content[i];\n if (isCommentNode(child, commentNames)) {\n return child;\n }\n }\n }\n }\n return undefined;\n}\nexport function isCommentNode(cstNode, commentNames) {\n return isLeafCstNode(cstNode) && commentNames.includes(cstNode.tokenType.name);\n}\n/**\n * Finds the leaf CST node at the specified 0-based string offset.\n * Note that the given offset will be within the range of the returned leaf node.\n *\n * If the offset does not point to a CST node (but just white space), this method will return `undefined`.\n *\n * @param node The CST node to search through.\n * @param offset The specified offset.\n * @returns The CST node at the specified offset.\n */\nexport function findLeafNodeAtOffset(node, offset) {\n if (isLeafCstNode(node)) {\n return node;\n }\n else if (isCompositeCstNode(node)) {\n const searchResult = binarySearch(node, offset, false);\n if (searchResult) {\n return findLeafNodeAtOffset(searchResult, offset);\n }\n }\n return undefined;\n}\n/**\n * Finds the leaf CST node at the specified 0-based string offset.\n * If no CST node exists at the specified position, it will return the leaf node before it.\n *\n * If there is no leaf node before the specified offset, this method will return `undefined`.\n *\n * @param node The CST node to search through.\n * @param offset The specified offset.\n * @returns The CST node closest to the specified offset.\n */\nexport function findLeafNodeBeforeOffset(node, offset) {\n if (isLeafCstNode(node)) {\n return node;\n }\n else if (isCompositeCstNode(node)) {\n const searchResult = binarySearch(node, offset, true);\n if (searchResult) {\n return findLeafNodeBeforeOffset(searchResult, offset);\n }\n }\n return undefined;\n}\nfunction binarySearch(node, offset, closest) {\n let left = 0;\n let right = node.content.length - 1;\n let closestNode = undefined;\n while (left <= right) {\n const middle = Math.floor((left + right) / 2);\n const middleNode = node.content[middle];\n if (middleNode.offset <= offset && middleNode.end > offset) {\n // Found an exact match\n return middleNode;\n }\n if (middleNode.end <= offset) {\n // Update the closest node (less than offset) and move to the right half\n closestNode = closest ? middleNode : undefined;\n left = middle + 1;\n }\n else {\n // Move to the left half\n right = middle - 1;\n }\n }\n return closestNode;\n}\nexport function getPreviousNode(node, hidden = true) {\n while (node.container) {\n const parent = node.container;\n let index = parent.content.indexOf(node);\n while (index > 0) {\n index--;\n const previous = parent.content[index];\n if (hidden || !previous.hidden) {\n return previous;\n }\n }\n node = parent;\n }\n return undefined;\n}\nexport function getNextNode(node, hidden = true) {\n while (node.container) {\n const parent = node.container;\n let index = parent.content.indexOf(node);\n const last = parent.content.length - 1;\n while (index < last) {\n index++;\n const next = parent.content[index];\n if (hidden || !next.hidden) {\n return next;\n }\n }\n node = parent;\n }\n return undefined;\n}\nexport function getStartlineNode(node) {\n if (node.range.start.character === 0) {\n return node;\n }\n const line = node.range.start.line;\n let last = node;\n let index;\n while (node.container) {\n const parent = node.container;\n const selfIndex = index !== null && index !== void 0 ? index : parent.content.indexOf(node);\n if (selfIndex === 0) {\n node = parent;\n index = undefined;\n }\n else {\n index = selfIndex - 1;\n node = parent.content[index];\n }\n if (node.range.start.line !== line) {\n break;\n }\n last = node;\n }\n return last;\n}\nexport function getInteriorNodes(start, end) {\n const commonParent = getCommonParent(start, end);\n if (!commonParent) {\n return [];\n }\n return commonParent.parent.content.slice(commonParent.a + 1, commonParent.b);\n}\nfunction getCommonParent(a, b) {\n const aParents = getParentChain(a);\n const bParents = getParentChain(b);\n let current;\n for (let i = 0; i < aParents.length && i < bParents.length; i++) {\n const aParent = aParents[i];\n const bParent = bParents[i];\n if (aParent.parent === bParent.parent) {\n current = {\n parent: aParent.parent,\n a: aParent.index,\n b: bParent.index\n };\n }\n else {\n break;\n }\n }\n return current;\n}\nfunction getParentChain(node) {\n const chain = [];\n while (node.container) {\n const parent = node.container;\n const index = parent.content.indexOf(node);\n chain.push({\n parent,\n index\n });\n node = parent;\n }\n return chain.reverse();\n}\n//# sourceMappingURL=cst-utils.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport class ErrorWithLocation extends Error {\n constructor(node, message) {\n super(node ? `${message} at ${node.range.start.line}:${node.range.start.character}` : message);\n }\n}\nexport function assertUnreachable(_) {\n throw new Error('Error! The input value was not handled.');\n}\n//# sourceMappingURL=errors.js.map","/******************************************************************************\n * This file was generated by langium-cli 3.3.0.\n * DO NOT EDIT MANUALLY!\n ******************************************************************************/\nimport { AbstractAstReflection } from '../../syntax-tree.js';\nexport const LangiumGrammarTerminals = {\n ID: /\\^?[_a-zA-Z][\\w_]*/,\n STRING: /\"(\\\\.|[^\"\\\\])*\"|'(\\\\.|[^'\\\\])*'/,\n NUMBER: /NaN|-?((\\d*\\.\\d+|\\d+)([Ee][+-]?\\d+)?|Infinity)/,\n RegexLiteral: /\\/(?![*+?])(?:[^\\r\\n\\[/\\\\]|\\\\.|\\[(?:[^\\r\\n\\]\\\\]|\\\\.)*\\])+\\/[a-z]*/,\n WS: /\\s+/,\n ML_COMMENT: /\\/\\*[\\s\\S]*?\\*\\//,\n SL_COMMENT: /\\/\\/[^\\n\\r]*/,\n};\nexport const AbstractRule = 'AbstractRule';\nexport function isAbstractRule(item) {\n return reflection.isInstance(item, AbstractRule);\n}\nexport const AbstractType = 'AbstractType';\nexport function isAbstractType(item) {\n return reflection.isInstance(item, AbstractType);\n}\nexport const Condition = 'Condition';\nexport function isCondition(item) {\n return reflection.isInstance(item, Condition);\n}\nexport function isFeatureName(item) {\n return isPrimitiveType(item) || item === 'current' || item === 'entry' || item === 'extends' || item === 'false' || item === 'fragment' || item === 'grammar' || item === 'hidden' || item === 'import' || item === 'interface' || item === 'returns' || item === 'terminal' || item === 'true' || item === 'type' || item === 'infer' || item === 'infers' || item === 'with' || (typeof item === 'string' && (/\\^?[_a-zA-Z][\\w_]*/.test(item)));\n}\nexport function isPrimitiveType(item) {\n return item === 'string' || item === 'number' || item === 'boolean' || item === 'Date' || item === 'bigint';\n}\nexport const TypeDefinition = 'TypeDefinition';\nexport function isTypeDefinition(item) {\n return reflection.isInstance(item, TypeDefinition);\n}\nexport const ValueLiteral = 'ValueLiteral';\nexport function isValueLiteral(item) {\n return reflection.isInstance(item, ValueLiteral);\n}\nexport const AbstractElement = 'AbstractElement';\nexport function isAbstractElement(item) {\n return reflection.isInstance(item, AbstractElement);\n}\nexport const ArrayLiteral = 'ArrayLiteral';\nexport function isArrayLiteral(item) {\n return reflection.isInstance(item, ArrayLiteral);\n}\nexport const ArrayType = 'ArrayType';\nexport function isArrayType(item) {\n return reflection.isInstance(item, ArrayType);\n}\nexport const BooleanLiteral = 'BooleanLiteral';\nexport function isBooleanLiteral(item) {\n return reflection.isInstance(item, BooleanLiteral);\n}\nexport const Conjunction = 'Conjunction';\nexport function isConjunction(item) {\n return reflection.isInstance(item, Conjunction);\n}\nexport const Disjunction = 'Disjunction';\nexport function isDisjunction(item) {\n return reflection.isInstance(item, Disjunction);\n}\nexport const Grammar = 'Grammar';\nexport function isGrammar(item) {\n return reflection.isInstance(item, Grammar);\n}\nexport const GrammarImport = 'GrammarImport';\nexport function isGrammarImport(item) {\n return reflection.isInstance(item, GrammarImport);\n}\nexport const InferredType = 'InferredType';\nexport function isInferredType(item) {\n return reflection.isInstance(item, InferredType);\n}\nexport const Interface = 'Interface';\nexport function isInterface(item) {\n return reflection.isInstance(item, Interface);\n}\nexport const NamedArgument = 'NamedArgument';\nexport function isNamedArgument(item) {\n return reflection.isInstance(item, NamedArgument);\n}\nexport const Negation = 'Negation';\nexport function isNegation(item) {\n return reflection.isInstance(item, Negation);\n}\nexport const NumberLiteral = 'NumberLiteral';\nexport function isNumberLiteral(item) {\n return reflection.isInstance(item, NumberLiteral);\n}\nexport const Parameter = 'Parameter';\nexport function isParameter(item) {\n return reflection.isInstance(item, Parameter);\n}\nexport const ParameterReference = 'ParameterReference';\nexport function isParameterReference(item) {\n return reflection.isInstance(item, ParameterReference);\n}\nexport const ParserRule = 'ParserRule';\nexport function isParserRule(item) {\n return reflection.isInstance(item, ParserRule);\n}\nexport const ReferenceType = 'ReferenceType';\nexport function isReferenceType(item) {\n return reflection.isInstance(item, ReferenceType);\n}\nexport const ReturnType = 'ReturnType';\nexport function isReturnType(item) {\n return reflection.isInstance(item, ReturnType);\n}\nexport const SimpleType = 'SimpleType';\nexport function isSimpleType(item) {\n return reflection.isInstance(item, SimpleType);\n}\nexport const StringLiteral = 'StringLiteral';\nexport function isStringLiteral(item) {\n return reflection.isInstance(item, StringLiteral);\n}\nexport const TerminalRule = 'TerminalRule';\nexport function isTerminalRule(item) {\n return reflection.isInstance(item, TerminalRule);\n}\nexport const Type = 'Type';\nexport function isType(item) {\n return reflection.isInstance(item, Type);\n}\nexport const TypeAttribute = 'TypeAttribute';\nexport function isTypeAttribute(item) {\n return reflection.isInstance(item, TypeAttribute);\n}\nexport const UnionType = 'UnionType';\nexport function isUnionType(item) {\n return reflection.isInstance(item, UnionType);\n}\nexport const Action = 'Action';\nexport function isAction(item) {\n return reflection.isInstance(item, Action);\n}\nexport const Alternatives = 'Alternatives';\nexport function isAlternatives(item) {\n return reflection.isInstance(item, Alternatives);\n}\nexport const Assignment = 'Assignment';\nexport function isAssignment(item) {\n return reflection.isInstance(item, Assignment);\n}\nexport const CharacterRange = 'CharacterRange';\nexport function isCharacterRange(item) {\n return reflection.isInstance(item, CharacterRange);\n}\nexport const CrossReference = 'CrossReference';\nexport function isCrossReference(item) {\n return reflection.isInstance(item, CrossReference);\n}\nexport const EndOfFile = 'EndOfFile';\nexport function isEndOfFile(item) {\n return reflection.isInstance(item, EndOfFile);\n}\nexport const Group = 'Group';\nexport function isGroup(item) {\n return reflection.isInstance(item, Group);\n}\nexport const Keyword = 'Keyword';\nexport function isKeyword(item) {\n return reflection.isInstance(item, Keyword);\n}\nexport const NegatedToken = 'NegatedToken';\nexport function isNegatedToken(item) {\n return reflection.isInstance(item, NegatedToken);\n}\nexport const RegexToken = 'RegexToken';\nexport function isRegexToken(item) {\n return reflection.isInstance(item, RegexToken);\n}\nexport const RuleCall = 'RuleCall';\nexport function isRuleCall(item) {\n return reflection.isInstance(item, RuleCall);\n}\nexport const TerminalAlternatives = 'TerminalAlternatives';\nexport function isTerminalAlternatives(item) {\n return reflection.isInstance(item, TerminalAlternatives);\n}\nexport const TerminalGroup = 'TerminalGroup';\nexport function isTerminalGroup(item) {\n return reflection.isInstance(item, TerminalGroup);\n}\nexport const TerminalRuleCall = 'TerminalRuleCall';\nexport function isTerminalRuleCall(item) {\n return reflection.isInstance(item, TerminalRuleCall);\n}\nexport const UnorderedGroup = 'UnorderedGroup';\nexport function isUnorderedGroup(item) {\n return reflection.isInstance(item, UnorderedGroup);\n}\nexport const UntilToken = 'UntilToken';\nexport function isUntilToken(item) {\n return reflection.isInstance(item, UntilToken);\n}\nexport const Wildcard = 'Wildcard';\nexport function isWildcard(item) {\n return reflection.isInstance(item, Wildcard);\n}\nexport class LangiumGrammarAstReflection extends AbstractAstReflection {\n getAllTypes() {\n return [AbstractElement, AbstractRule, AbstractType, Action, Alternatives, ArrayLiteral, ArrayType, Assignment, BooleanLiteral, CharacterRange, Condition, Conjunction, CrossReference, Disjunction, EndOfFile, Grammar, GrammarImport, Group, InferredType, Interface, Keyword, NamedArgument, NegatedToken, Negation, NumberLiteral, Parameter, ParameterReference, ParserRule, ReferenceType, RegexToken, ReturnType, RuleCall, SimpleType, StringLiteral, TerminalAlternatives, TerminalGroup, TerminalRule, TerminalRuleCall, Type, TypeAttribute, TypeDefinition, UnionType, UnorderedGroup, UntilToken, ValueLiteral, Wildcard];\n }\n computeIsSubtype(subtype, supertype) {\n switch (subtype) {\n case Action:\n case Alternatives:\n case Assignment:\n case CharacterRange:\n case CrossReference:\n case EndOfFile:\n case Group:\n case Keyword:\n case NegatedToken:\n case RegexToken:\n case RuleCall:\n case TerminalAlternatives:\n case TerminalGroup:\n case TerminalRuleCall:\n case UnorderedGroup:\n case UntilToken:\n case Wildcard: {\n return this.isSubtype(AbstractElement, supertype);\n }\n case ArrayLiteral:\n case NumberLiteral:\n case StringLiteral: {\n return this.isSubtype(ValueLiteral, supertype);\n }\n case ArrayType:\n case ReferenceType:\n case SimpleType:\n case UnionType: {\n return this.isSubtype(TypeDefinition, supertype);\n }\n case BooleanLiteral: {\n return this.isSubtype(Condition, supertype) || this.isSubtype(ValueLiteral, supertype);\n }\n case Conjunction:\n case Disjunction:\n case Negation:\n case ParameterReference: {\n return this.isSubtype(Condition, supertype);\n }\n case InferredType:\n case Interface:\n case Type: {\n return this.isSubtype(AbstractType, supertype);\n }\n case ParserRule: {\n return this.isSubtype(AbstractRule, supertype) || this.isSubtype(AbstractType, supertype);\n }\n case TerminalRule: {\n return this.isSubtype(AbstractRule, supertype);\n }\n default: {\n return false;\n }\n }\n }\n getReferenceType(refInfo) {\n const referenceId = `${refInfo.container.$type}:${refInfo.property}`;\n switch (referenceId) {\n case 'Action:type':\n case 'CrossReference:type':\n case 'Interface:superTypes':\n case 'ParserRule:returnType':\n case 'SimpleType:typeRef': {\n return AbstractType;\n }\n case 'Grammar:hiddenTokens':\n case 'ParserRule:hiddenTokens':\n case 'RuleCall:rule': {\n return AbstractRule;\n }\n case 'Grammar:usedGrammars': {\n return Grammar;\n }\n case 'NamedArgument:parameter':\n case 'ParameterReference:parameter': {\n return Parameter;\n }\n case 'TerminalRuleCall:rule': {\n return TerminalRule;\n }\n default: {\n throw new Error(`${referenceId} is not a valid reference id.`);\n }\n }\n }\n getTypeMetaData(type) {\n switch (type) {\n case AbstractElement: {\n return {\n name: AbstractElement,\n properties: [\n { name: 'cardinality' },\n { name: 'lookahead' }\n ]\n };\n }\n case ArrayLiteral: {\n return {\n name: ArrayLiteral,\n properties: [\n { name: 'elements', defaultValue: [] }\n ]\n };\n }\n case ArrayType: {\n return {\n name: ArrayType,\n properties: [\n { name: 'elementType' }\n ]\n };\n }\n case BooleanLiteral: {\n return {\n name: BooleanLiteral,\n properties: [\n { name: 'true', defaultValue: false }\n ]\n };\n }\n case Conjunction: {\n return {\n name: Conjunction,\n properties: [\n { name: 'left' },\n { name: 'right' }\n ]\n };\n }\n case Disjunction: {\n return {\n name: Disjunction,\n properties: [\n { name: 'left' },\n { name: 'right' }\n ]\n };\n }\n case Grammar: {\n return {\n name: Grammar,\n properties: [\n { name: 'definesHiddenTokens', defaultValue: false },\n { name: 'hiddenTokens', defaultValue: [] },\n { name: 'imports', defaultValue: [] },\n { name: 'interfaces', defaultValue: [] },\n { name: 'isDeclared', defaultValue: false },\n { name: 'name' },\n { name: 'rules', defaultValue: [] },\n { name: 'types', defaultValue: [] },\n { name: 'usedGrammars', defaultValue: [] }\n ]\n };\n }\n case GrammarImport: {\n return {\n name: GrammarImport,\n properties: [\n { name: 'path' }\n ]\n };\n }\n case InferredType: {\n return {\n name: InferredType,\n properties: [\n { name: 'name' }\n ]\n };\n }\n case Interface: {\n return {\n name: Interface,\n properties: [\n { name: 'attributes', defaultValue: [] },\n { name: 'name' },\n { name: 'superTypes', defaultValue: [] }\n ]\n };\n }\n case NamedArgument: {\n return {\n name: NamedArgument,\n properties: [\n { name: 'calledByName', defaultValue: false },\n { name: 'parameter' },\n { name: 'value' }\n ]\n };\n }\n case Negation: {\n return {\n name: Negation,\n properties: [\n { name: 'value' }\n ]\n };\n }\n case NumberLiteral: {\n return {\n name: NumberLiteral,\n properties: [\n { name: 'value' }\n ]\n };\n }\n case Parameter: {\n return {\n name: Parameter,\n properties: [\n { name: 'name' }\n ]\n };\n }\n case ParameterReference: {\n return {\n name: ParameterReference,\n properties: [\n { name: 'parameter' }\n ]\n };\n }\n case ParserRule: {\n return {\n name: ParserRule,\n properties: [\n { name: 'dataType' },\n { name: 'definesHiddenTokens', defaultValue: false },\n { name: 'definition' },\n { name: 'entry', defaultValue: false },\n { name: 'fragment', defaultValue: false },\n { name: 'hiddenTokens', defaultValue: [] },\n { name: 'inferredType' },\n { name: 'name' },\n { name: 'parameters', defaultValue: [] },\n { name: 'returnType' },\n { name: 'wildcard', defaultValue: false }\n ]\n };\n }\n case ReferenceType: {\n return {\n name: ReferenceType,\n properties: [\n { name: 'referenceType' }\n ]\n };\n }\n case ReturnType: {\n return {\n name: ReturnType,\n properties: [\n { name: 'name' }\n ]\n };\n }\n case SimpleType: {\n return {\n name: SimpleType,\n properties: [\n { name: 'primitiveType' },\n { name: 'stringType' },\n { name: 'typeRef' }\n ]\n };\n }\n case StringLiteral: {\n return {\n name: StringLiteral,\n properties: [\n { name: 'value' }\n ]\n };\n }\n case TerminalRule: {\n return {\n name: TerminalRule,\n properties: [\n { name: 'definition' },\n { name: 'fragment', defaultValue: false },\n { name: 'hidden', defaultValue: false },\n { name: 'name' },\n { name: 'type' }\n ]\n };\n }\n case Type: {\n return {\n name: Type,\n properties: [\n { name: 'name' },\n { name: 'type' }\n ]\n };\n }\n case TypeAttribute: {\n return {\n name: TypeAttribute,\n properties: [\n { name: 'defaultValue' },\n { name: 'isOptional', defaultValue: false },\n { name: 'name' },\n { name: 'type' }\n ]\n };\n }\n case UnionType: {\n return {\n name: UnionType,\n properties: [\n { name: 'types', defaultValue: [] }\n ]\n };\n }\n case Action: {\n return {\n name: Action,\n properties: [\n { name: 'cardinality' },\n { name: 'feature' },\n { name: 'inferredType' },\n { name: 'lookahead' },\n { name: 'operator' },\n { name: 'type' }\n ]\n };\n }\n case Alternatives: {\n return {\n name: Alternatives,\n properties: [\n { name: 'cardinality' },\n { name: 'elements', defaultValue: [] },\n { name: 'lookahead' }\n ]\n };\n }\n case Assignment: {\n return {\n name: Assignment,\n properties: [\n { name: 'cardinality' },\n { name: 'feature' },\n { name: 'lookahead' },\n { name: 'operator' },\n { name: 'terminal' }\n ]\n };\n }\n case CharacterRange: {\n return {\n name: CharacterRange,\n properties: [\n { name: 'cardinality' },\n { name: 'left' },\n { name: 'lookahead' },\n { name: 'right' }\n ]\n };\n }\n case CrossReference: {\n return {\n name: CrossReference,\n properties: [\n { name: 'cardinality' },\n { name: 'deprecatedSyntax', defaultValue: false },\n { name: 'lookahead' },\n { name: 'terminal' },\n { name: 'type' }\n ]\n };\n }\n case EndOfFile: {\n return {\n name: EndOfFile,\n properties: [\n { name: 'cardinality' },\n { name: 'lookahead' }\n ]\n };\n }\n case Group: {\n return {\n name: Group,\n properties: [\n { name: 'cardinality' },\n { name: 'elements', defaultValue: [] },\n { name: 'guardCondition' },\n { name: 'lookahead' }\n ]\n };\n }\n case Keyword: {\n return {\n name: Keyword,\n properties: [\n { name: 'cardinality' },\n { name: 'lookahead' },\n { name: 'value' }\n ]\n };\n }\n case NegatedToken: {\n return {\n name: NegatedToken,\n properties: [\n { name: 'cardinality' },\n { name: 'lookahead' },\n { name: 'terminal' }\n ]\n };\n }\n case RegexToken: {\n return {\n name: RegexToken,\n properties: [\n { name: 'cardinality' },\n { name: 'lookahead' },\n { name: 'regex' }\n ]\n };\n }\n case RuleCall: {\n return {\n name: RuleCall,\n properties: [\n { name: 'arguments', defaultValue: [] },\n { name: 'cardinality' },\n { name: 'lookahead' },\n { name: 'rule' }\n ]\n };\n }\n case TerminalAlternatives: {\n return {\n name: TerminalAlternatives,\n properties: [\n { name: 'cardinality' },\n { name: 'elements', defaultValue: [] },\n { name: 'lookahead' }\n ]\n };\n }\n case TerminalGroup: {\n return {\n name: TerminalGroup,\n properties: [\n { name: 'cardinality' },\n { name: 'elements', defaultValue: [] },\n { name: 'lookahead' }\n ]\n };\n }\n case TerminalRuleCall: {\n return {\n name: TerminalRuleCall,\n properties: [\n { name: 'cardinality' },\n { name: 'lookahead' },\n { name: 'rule' }\n ]\n };\n }\n case UnorderedGroup: {\n return {\n name: UnorderedGroup,\n properties: [\n { name: 'cardinality' },\n { name: 'elements', defaultValue: [] },\n { name: 'lookahead' }\n ]\n };\n }\n case UntilToken: {\n return {\n name: UntilToken,\n properties: [\n { name: 'cardinality' },\n { name: 'lookahead' },\n { name: 'terminal' }\n ]\n };\n }\n case Wildcard: {\n return {\n name: Wildcard,\n properties: [\n { name: 'cardinality' },\n { name: 'lookahead' }\n ]\n };\n }\n default: {\n return {\n name: type,\n properties: []\n };\n }\n }\n }\n}\nexport const reflection = new LangiumGrammarAstReflection();\n//# sourceMappingURL=ast.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { isAstNode, isReference } from '../syntax-tree.js';\nimport { DONE_RESULT, stream, StreamImpl, TreeStreamImpl } from './stream.js';\nimport { inRange } from './cst-utils.js';\n/**\n * Link the `$container` and other related properties of every AST node that is directly contained\n * in the given `node`.\n */\nexport function linkContentToContainer(node) {\n for (const [name, value] of Object.entries(node)) {\n if (!name.startsWith('$')) {\n if (Array.isArray(value)) {\n value.forEach((item, index) => {\n if (isAstNode(item)) {\n item.$container = node;\n item.$containerProperty = name;\n item.$containerIndex = index;\n }\n });\n }\n else if (isAstNode(value)) {\n value.$container = node;\n value.$containerProperty = name;\n }\n }\n }\n}\n/**\n * Walk along the hierarchy of containers from the given AST node to the root and return the first\n * node that matches the type predicate. If the start node itself matches, it is returned.\n * If no container matches, `undefined` is returned.\n */\nexport function getContainerOfType(node, typePredicate) {\n let item = node;\n while (item) {\n if (typePredicate(item)) {\n return item;\n }\n item = item.$container;\n }\n return undefined;\n}\n/**\n * Walk along the hierarchy of containers from the given AST node to the root and check for existence\n * of a container that matches the given predicate. The start node is included in the checks.\n */\nexport function hasContainerOfType(node, predicate) {\n let item = node;\n while (item) {\n if (predicate(item)) {\n return true;\n }\n item = item.$container;\n }\n return false;\n}\n/**\n * Retrieve the document in which the given AST node is contained. A reference to the document is\n * usually held by the root node of the AST.\n *\n * @throws an error if the node is not contained in a document.\n */\nexport function getDocument(node) {\n const rootNode = findRootNode(node);\n const result = rootNode.$document;\n if (!result) {\n throw new Error('AST node has no document.');\n }\n return result;\n}\n/**\n * Returns the root node of the given AST node by following the `$container` references.\n */\nexport function findRootNode(node) {\n while (node.$container) {\n node = node.$container;\n }\n return node;\n}\n/**\n * Create a stream of all AST nodes that are directly contained in the given node. This includes\n * single-valued as well as multi-valued (array) properties.\n */\nexport function streamContents(node, options) {\n if (!node) {\n throw new Error('Node must be an AstNode.');\n }\n const range = options === null || options === void 0 ? void 0 : options.range;\n return new StreamImpl(() => ({\n keys: Object.keys(node),\n keyIndex: 0,\n arrayIndex: 0\n }), state => {\n while (state.keyIndex < state.keys.length) {\n const property = state.keys[state.keyIndex];\n if (!property.startsWith('$')) {\n const value = node[property];\n if (isAstNode(value)) {\n state.keyIndex++;\n if (isAstNodeInRange(value, range)) {\n return { done: false, value };\n }\n }\n else if (Array.isArray(value)) {\n while (state.arrayIndex < value.length) {\n const index = state.arrayIndex++;\n const element = value[index];\n if (isAstNode(element) && isAstNodeInRange(element, range)) {\n return { done: false, value: element };\n }\n }\n state.arrayIndex = 0;\n }\n }\n state.keyIndex++;\n }\n return DONE_RESULT;\n });\n}\n/**\n * Create a stream of all AST nodes that are directly and indirectly contained in the given root node.\n * This does not include the root node itself.\n */\nexport function streamAllContents(root, options) {\n if (!root) {\n throw new Error('Root node must be an AstNode.');\n }\n return new TreeStreamImpl(root, node => streamContents(node, options));\n}\n/**\n * Create a stream of all AST nodes that are directly and indirectly contained in the given root node,\n * including the root node itself.\n */\nexport function streamAst(root, options) {\n if (!root) {\n throw new Error('Root node must be an AstNode.');\n }\n else if ((options === null || options === void 0 ? void 0 : options.range) && !isAstNodeInRange(root, options.range)) {\n // Return an empty stream if the root node isn't in range\n return new TreeStreamImpl(root, () => []);\n }\n return new TreeStreamImpl(root, node => streamContents(node, options), { includeRoot: true });\n}\nfunction isAstNodeInRange(astNode, range) {\n var _a;\n if (!range) {\n return true;\n }\n const nodeRange = (_a = astNode.$cstNode) === null || _a === void 0 ? void 0 : _a.range;\n if (!nodeRange) {\n return false;\n }\n return inRange(nodeRange, range);\n}\n/**\n * Create a stream of all cross-references that are held by the given AST node. This includes\n * single-valued as well as multi-valued (array) properties.\n */\nexport function streamReferences(node) {\n return new StreamImpl(() => ({\n keys: Object.keys(node),\n keyIndex: 0,\n arrayIndex: 0\n }), state => {\n while (state.keyIndex < state.keys.length) {\n const property = state.keys[state.keyIndex];\n if (!property.startsWith('$')) {\n const value = node[property];\n if (isReference(value)) {\n state.keyIndex++;\n return { done: false, value: { reference: value, container: node, property } };\n }\n else if (Array.isArray(value)) {\n while (state.arrayIndex < value.length) {\n const index = state.arrayIndex++;\n const element = value[index];\n if (isReference(element)) {\n return { done: false, value: { reference: element, container: node, property, index } };\n }\n }\n state.arrayIndex = 0;\n }\n }\n state.keyIndex++;\n }\n return DONE_RESULT;\n });\n}\n/**\n * Returns a Stream of references to the target node from the AstNode tree\n *\n * @param targetNode AstNode we are looking for\n * @param lookup AstNode where we search for references. If not provided, the root node of the document is used as the default value\n */\nexport function findLocalReferences(targetNode, lookup = getDocument(targetNode).parseResult.value) {\n const refs = [];\n streamAst(lookup).forEach(node => {\n streamReferences(node).forEach(refInfo => {\n if (refInfo.reference.ref === targetNode) {\n refs.push(refInfo.reference);\n }\n });\n });\n return stream(refs);\n}\n/**\n * Assigns all mandatory AST properties to the specified node.\n *\n * @param reflection Reflection object used to gather mandatory properties for the node.\n * @param node Specified node is modified in place and properties are directly assigned.\n */\nexport function assignMandatoryProperties(reflection, node) {\n const typeMetaData = reflection.getTypeMetaData(node.$type);\n const genericNode = node;\n for (const property of typeMetaData.properties) {\n // Only set the value if the property is not already set and if it has a default value\n if (property.defaultValue !== undefined && genericNode[property.name] === undefined) {\n genericNode[property.name] = copyDefaultValue(property.defaultValue);\n }\n }\n}\nfunction copyDefaultValue(propertyType) {\n if (Array.isArray(propertyType)) {\n return [...propertyType.map(copyDefaultValue)];\n }\n else {\n return propertyType;\n }\n}\n/**\n * Creates a deep copy of the specified AST node.\n * The resulting copy will only contain semantically relevant information, such as the `$type` property and AST properties.\n *\n * References are copied without resolved cross reference. The specified function is used to rebuild them.\n */\nexport function copyAstNode(node, buildReference) {\n const copy = { $type: node.$type };\n for (const [name, value] of Object.entries(node)) {\n if (!name.startsWith('$')) {\n if (isAstNode(value)) {\n copy[name] = copyAstNode(value, buildReference);\n }\n else if (isReference(value)) {\n copy[name] = buildReference(copy, name, value.$refNode, value.$refText);\n }\n else if (Array.isArray(value)) {\n const copiedArray = [];\n for (const element of value) {\n if (isAstNode(element)) {\n copiedArray.push(copyAstNode(element, buildReference));\n }\n else if (isReference(element)) {\n copiedArray.push(buildReference(copy, name, element.$refNode, element.$refText));\n }\n else {\n copiedArray.push(element);\n }\n }\n copy[name] = copiedArray;\n }\n else {\n copy[name] = value;\n }\n }\n }\n linkContentToContainer(copy);\n return copy;\n}\n//# sourceMappingURL=ast-utils.js.map","export function cc(char) {\n return char.charCodeAt(0);\n}\nexport function insertToSet(item, set) {\n if (Array.isArray(item)) {\n item.forEach(function (subItem) {\n set.push(subItem);\n });\n }\n else {\n set.push(item);\n }\n}\nexport function addFlag(flagObj, flagKey) {\n if (flagObj[flagKey] === true) {\n throw \"duplicate flag \" + flagKey;\n }\n const x = flagObj[flagKey];\n flagObj[flagKey] = true;\n}\nexport function ASSERT_EXISTS(obj) {\n // istanbul ignore next\n if (obj === undefined) {\n throw Error(\"Internal Error - Should never get here!\");\n }\n return true;\n}\n// istanbul ignore next\nexport function ASSERT_NEVER_REACH_HERE() {\n throw Error(\"Internal Error - Should never get here!\");\n}\nexport function isCharacter(obj) {\n return obj[\"type\"] === \"Character\";\n}\n//# sourceMappingURL=utils.js.map","import { cc } from \"./utils.js\";\nexport const digitsCharCodes = [];\nfor (let i = cc(\"0\"); i <= cc(\"9\"); i++) {\n digitsCharCodes.push(i);\n}\nexport const wordCharCodes = [cc(\"_\")].concat(digitsCharCodes);\nfor (let i = cc(\"a\"); i <= cc(\"z\"); i++) {\n wordCharCodes.push(i);\n}\nfor (let i = cc(\"A\"); i <= cc(\"Z\"); i++) {\n wordCharCodes.push(i);\n}\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#character-classes\nexport const whitespaceCodes = [\n cc(\" \"),\n cc(\"\\f\"),\n cc(\"\\n\"),\n cc(\"\\r\"),\n cc(\"\\t\"),\n cc(\"\\v\"),\n cc(\"\\t\"),\n cc(\"\\u00a0\"),\n cc(\"\\u1680\"),\n cc(\"\\u2000\"),\n cc(\"\\u2001\"),\n cc(\"\\u2002\"),\n cc(\"\\u2003\"),\n cc(\"\\u2004\"),\n cc(\"\\u2005\"),\n cc(\"\\u2006\"),\n cc(\"\\u2007\"),\n cc(\"\\u2008\"),\n cc(\"\\u2009\"),\n cc(\"\\u200a\"),\n cc(\"\\u2028\"),\n cc(\"\\u2029\"),\n cc(\"\\u202f\"),\n cc(\"\\u205f\"),\n cc(\"\\u3000\"),\n cc(\"\\ufeff\"),\n];\n//# sourceMappingURL=character-classes.js.map","import { addFlag, ASSERT_EXISTS, ASSERT_NEVER_REACH_HERE, cc, insertToSet, isCharacter, } from \"./utils.js\";\nimport { digitsCharCodes, whitespaceCodes, wordCharCodes, } from \"./character-classes.js\";\n// consts and utilities\nconst hexDigitPattern = /[0-9a-fA-F]/;\nconst decimalPattern = /[0-9]/;\nconst decimalPatternNoZero = /[1-9]/;\n// https://hackernoon.com/the-madness-of-parsing-real-world-javascript-regexps-d9ee336df983\n// https://www.ecma-international.org/ecma-262/8.0/index.html#prod-Pattern\nexport class RegExpParser {\n constructor() {\n this.idx = 0;\n this.input = \"\";\n this.groupIdx = 0;\n }\n saveState() {\n return {\n idx: this.idx,\n input: this.input,\n groupIdx: this.groupIdx,\n };\n }\n restoreState(newState) {\n this.idx = newState.idx;\n this.input = newState.input;\n this.groupIdx = newState.groupIdx;\n }\n pattern(input) {\n // parser state\n this.idx = 0;\n this.input = input;\n this.groupIdx = 0;\n this.consumeChar(\"/\");\n const value = this.disjunction();\n this.consumeChar(\"/\");\n const flags = {\n type: \"Flags\",\n loc: { begin: this.idx, end: input.length },\n global: false,\n ignoreCase: false,\n multiLine: false,\n unicode: false,\n sticky: false,\n };\n while (this.isRegExpFlag()) {\n switch (this.popChar()) {\n case \"g\":\n addFlag(flags, \"global\");\n break;\n case \"i\":\n addFlag(flags, \"ignoreCase\");\n break;\n case \"m\":\n addFlag(flags, \"multiLine\");\n break;\n case \"u\":\n addFlag(flags, \"unicode\");\n break;\n case \"y\":\n addFlag(flags, \"sticky\");\n break;\n }\n }\n if (this.idx !== this.input.length) {\n throw Error(\"Redundant input: \" + this.input.substring(this.idx));\n }\n return {\n type: \"Pattern\",\n flags: flags,\n value: value,\n loc: this.loc(0),\n };\n }\n disjunction() {\n const alts = [];\n const begin = this.idx;\n alts.push(this.alternative());\n while (this.peekChar() === \"|\") {\n this.consumeChar(\"|\");\n alts.push(this.alternative());\n }\n return { type: \"Disjunction\", value: alts, loc: this.loc(begin) };\n }\n alternative() {\n const terms = [];\n const begin = this.idx;\n while (this.isTerm()) {\n terms.push(this.term());\n }\n return { type: \"Alternative\", value: terms, loc: this.loc(begin) };\n }\n term() {\n if (this.isAssertion()) {\n return this.assertion();\n }\n else {\n return this.atom();\n }\n }\n assertion() {\n const begin = this.idx;\n switch (this.popChar()) {\n case \"^\":\n return {\n type: \"StartAnchor\",\n loc: this.loc(begin),\n };\n case \"$\":\n return { type: \"EndAnchor\", loc: this.loc(begin) };\n // '\\b' or '\\B'\n case \"\\\\\":\n switch (this.popChar()) {\n case \"b\":\n return {\n type: \"WordBoundary\",\n loc: this.loc(begin),\n };\n case \"B\":\n return {\n type: \"NonWordBoundary\",\n loc: this.loc(begin),\n };\n }\n // istanbul ignore next\n throw Error(\"Invalid Assertion Escape\");\n // '(?=' or '(?!'\n case \"(\":\n this.consumeChar(\"?\");\n let type;\n switch (this.popChar()) {\n case \"=\":\n type = \"Lookahead\";\n break;\n case \"!\":\n type = \"NegativeLookahead\";\n break;\n }\n ASSERT_EXISTS(type);\n const disjunction = this.disjunction();\n this.consumeChar(\")\");\n return {\n type: type,\n value: disjunction,\n loc: this.loc(begin),\n };\n }\n // istanbul ignore next\n return ASSERT_NEVER_REACH_HERE();\n }\n quantifier(isBacktracking = false) {\n let range = undefined;\n const begin = this.idx;\n switch (this.popChar()) {\n case \"*\":\n range = {\n atLeast: 0,\n atMost: Infinity,\n };\n break;\n case \"+\":\n range = {\n atLeast: 1,\n atMost: Infinity,\n };\n break;\n case \"?\":\n range = {\n atLeast: 0,\n atMost: 1,\n };\n break;\n case \"{\":\n const atLeast = this.integerIncludingZero();\n switch (this.popChar()) {\n case \"}\":\n range = {\n atLeast: atLeast,\n atMost: atLeast,\n };\n break;\n case \",\":\n let atMost;\n if (this.isDigit()) {\n atMost = this.integerIncludingZero();\n range = {\n atLeast: atLeast,\n atMost: atMost,\n };\n }\n else {\n range = {\n atLeast: atLeast,\n atMost: Infinity,\n };\n }\n this.consumeChar(\"}\");\n break;\n }\n // throwing exceptions from \"ASSERT_EXISTS\" during backtracking\n // causes severe performance degradations\n if (isBacktracking === true && range === undefined) {\n return undefined;\n }\n ASSERT_EXISTS(range);\n break;\n }\n // throwing exceptions from \"ASSERT_EXISTS\" during backtracking\n // causes severe performance degradations\n if (isBacktracking === true && range === undefined) {\n return undefined;\n }\n // istanbul ignore else\n if (ASSERT_EXISTS(range)) {\n if (this.peekChar(0) === \"?\") {\n this.consumeChar(\"?\");\n range.greedy = false;\n }\n else {\n range.greedy = true;\n }\n range.type = \"Quantifier\";\n range.loc = this.loc(begin);\n return range;\n }\n }\n atom() {\n let atom;\n const begin = this.idx;\n switch (this.peekChar()) {\n case \".\":\n atom = this.dotAll();\n break;\n case \"\\\\\":\n atom = this.atomEscape();\n break;\n case \"[\":\n atom = this.characterClass();\n break;\n case \"(\":\n atom = this.group();\n break;\n }\n if (atom === undefined && this.isPatternCharacter()) {\n atom = this.patternCharacter();\n }\n // istanbul ignore else\n if (ASSERT_EXISTS(atom)) {\n atom.loc = this.loc(begin);\n if (this.isQuantifier()) {\n atom.quantifier = this.quantifier();\n }\n return atom;\n }\n // istanbul ignore next\n return ASSERT_NEVER_REACH_HERE();\n }\n dotAll() {\n this.consumeChar(\".\");\n return {\n type: \"Set\",\n complement: true,\n value: [cc(\"\\n\"), cc(\"\\r\"), cc(\"\\u2028\"), cc(\"\\u2029\")],\n };\n }\n atomEscape() {\n this.consumeChar(\"\\\\\");\n switch (this.peekChar()) {\n case \"1\":\n case \"2\":\n case \"3\":\n case \"4\":\n case \"5\":\n case \"6\":\n case \"7\":\n case \"8\":\n case \"9\":\n return this.decimalEscapeAtom();\n case \"d\":\n case \"D\":\n case \"s\":\n case \"S\":\n case \"w\":\n case \"W\":\n return this.characterClassEscape();\n case \"f\":\n case \"n\":\n case \"r\":\n case \"t\":\n case \"v\":\n return this.controlEscapeAtom();\n case \"c\":\n return this.controlLetterEscapeAtom();\n case \"0\":\n return this.nulCharacterAtom();\n case \"x\":\n return this.hexEscapeSequenceAtom();\n case \"u\":\n return this.regExpUnicodeEscapeSequenceAtom();\n default:\n return this.identityEscapeAtom();\n }\n }\n decimalEscapeAtom() {\n const value = this.positiveInteger();\n return { type: \"GroupBackReference\", value: value };\n }\n characterClassEscape() {\n let set;\n let complement = false;\n switch (this.popChar()) {\n case \"d\":\n set = digitsCharCodes;\n break;\n case \"D\":\n set = digitsCharCodes;\n complement = true;\n break;\n case \"s\":\n set = whitespaceCodes;\n break;\n case \"S\":\n set = whitespaceCodes;\n complement = true;\n break;\n case \"w\":\n set = wordCharCodes;\n break;\n case \"W\":\n set = wordCharCodes;\n complement = true;\n break;\n }\n // istanbul ignore else\n if (ASSERT_EXISTS(set)) {\n return { type: \"Set\", value: set, complement: complement };\n }\n // istanbul ignore next\n return ASSERT_NEVER_REACH_HERE();\n }\n controlEscapeAtom() {\n let escapeCode;\n switch (this.popChar()) {\n case \"f\":\n escapeCode = cc(\"\\f\");\n break;\n case \"n\":\n escapeCode = cc(\"\\n\");\n break;\n case \"r\":\n escapeCode = cc(\"\\r\");\n break;\n case \"t\":\n escapeCode = cc(\"\\t\");\n break;\n case \"v\":\n escapeCode = cc(\"\\v\");\n break;\n }\n // istanbul ignore else\n if (ASSERT_EXISTS(escapeCode)) {\n return { type: \"Character\", value: escapeCode };\n }\n // istanbul ignore next\n return ASSERT_NEVER_REACH_HERE();\n }\n controlLetterEscapeAtom() {\n this.consumeChar(\"c\");\n const letter = this.popChar();\n if (/[a-zA-Z]/.test(letter) === false) {\n throw Error(\"Invalid \");\n }\n const letterCode = letter.toUpperCase().charCodeAt(0) - 64;\n return { type: \"Character\", value: letterCode };\n }\n nulCharacterAtom() {\n // TODO implement '[lookahead ∉ DecimalDigit]'\n // TODO: for the deprecated octal escape sequence\n this.consumeChar(\"0\");\n return { type: \"Character\", value: cc(\"\\0\") };\n }\n hexEscapeSequenceAtom() {\n this.consumeChar(\"x\");\n return this.parseHexDigits(2);\n }\n regExpUnicodeEscapeSequenceAtom() {\n this.consumeChar(\"u\");\n return this.parseHexDigits(4);\n }\n identityEscapeAtom() {\n // TODO: implement \"SourceCharacter but not UnicodeIDContinue\"\n // // http://unicode.org/reports/tr31/#Specific_Character_Adjustments\n const escapedChar = this.popChar();\n return { type: \"Character\", value: cc(escapedChar) };\n }\n classPatternCharacterAtom() {\n switch (this.peekChar()) {\n // istanbul ignore next\n case \"\\n\":\n // istanbul ignore next\n case \"\\r\":\n // istanbul ignore next\n case \"\\u2028\":\n // istanbul ignore next\n case \"\\u2029\":\n // istanbul ignore next\n case \"\\\\\":\n // istanbul ignore next\n case \"]\":\n throw Error(\"TBD\");\n default:\n const nextChar = this.popChar();\n return { type: \"Character\", value: cc(nextChar) };\n }\n }\n characterClass() {\n const set = [];\n let complement = false;\n this.consumeChar(\"[\");\n if (this.peekChar(0) === \"^\") {\n this.consumeChar(\"^\");\n complement = true;\n }\n while (this.isClassAtom()) {\n const from = this.classAtom();\n const isFromSingleChar = from.type === \"Character\";\n if (isCharacter(from) && this.isRangeDash()) {\n this.consumeChar(\"-\");\n const to = this.classAtom();\n const isToSingleChar = to.type === \"Character\";\n // a range can only be used when both sides are single characters\n if (isCharacter(to)) {\n if (to.value < from.value) {\n throw Error(\"Range out of order in character class\");\n }\n set.push({ from: from.value, to: to.value });\n }\n else {\n // literal dash\n insertToSet(from.value, set);\n set.push(cc(\"-\"));\n insertToSet(to.value, set);\n }\n }\n else {\n insertToSet(from.value, set);\n }\n }\n this.consumeChar(\"]\");\n return { type: \"Set\", complement: complement, value: set };\n }\n classAtom() {\n switch (this.peekChar()) {\n // istanbul ignore next\n case \"]\":\n // istanbul ignore next\n case \"\\n\":\n // istanbul ignore next\n case \"\\r\":\n // istanbul ignore next\n case \"\\u2028\":\n // istanbul ignore next\n case \"\\u2029\":\n throw Error(\"TBD\");\n case \"\\\\\":\n return this.classEscape();\n default:\n return this.classPatternCharacterAtom();\n }\n }\n classEscape() {\n this.consumeChar(\"\\\\\");\n switch (this.peekChar()) {\n // Matches a backspace.\n // (Not to be confused with \\b word boundary outside characterClass)\n case \"b\":\n this.consumeChar(\"b\");\n return { type: \"Character\", value: cc(\"\\u0008\") };\n case \"d\":\n case \"D\":\n case \"s\":\n case \"S\":\n case \"w\":\n case \"W\":\n return this.characterClassEscape();\n case \"f\":\n case \"n\":\n case \"r\":\n case \"t\":\n case \"v\":\n return this.controlEscapeAtom();\n case \"c\":\n return this.controlLetterEscapeAtom();\n case \"0\":\n return this.nulCharacterAtom();\n case \"x\":\n return this.hexEscapeSequenceAtom();\n case \"u\":\n return this.regExpUnicodeEscapeSequenceAtom();\n default:\n return this.identityEscapeAtom();\n }\n }\n group() {\n let capturing = true;\n this.consumeChar(\"(\");\n switch (this.peekChar(0)) {\n case \"?\":\n this.consumeChar(\"?\");\n this.consumeChar(\":\");\n capturing = false;\n break;\n default:\n this.groupIdx++;\n break;\n }\n const value = this.disjunction();\n this.consumeChar(\")\");\n const groupAst = {\n type: \"Group\",\n capturing: capturing,\n value: value,\n };\n if (capturing) {\n groupAst[\"idx\"] = this.groupIdx;\n }\n return groupAst;\n }\n positiveInteger() {\n let number = this.popChar();\n // istanbul ignore next - can't ever get here due to previous lookahead checks\n // still implementing this error checking in case this ever changes.\n if (decimalPatternNoZero.test(number) === false) {\n throw Error(\"Expecting a positive integer\");\n }\n while (decimalPattern.test(this.peekChar(0))) {\n number += this.popChar();\n }\n return parseInt(number, 10);\n }\n integerIncludingZero() {\n let number = this.popChar();\n if (decimalPattern.test(number) === false) {\n throw Error(\"Expecting an integer\");\n }\n while (decimalPattern.test(this.peekChar(0))) {\n number += this.popChar();\n }\n return parseInt(number, 10);\n }\n patternCharacter() {\n const nextChar = this.popChar();\n switch (nextChar) {\n // istanbul ignore next\n case \"\\n\":\n // istanbul ignore next\n case \"\\r\":\n // istanbul ignore next\n case \"\\u2028\":\n // istanbul ignore next\n case \"\\u2029\":\n // istanbul ignore next\n case \"^\":\n // istanbul ignore next\n case \"$\":\n // istanbul ignore next\n case \"\\\\\":\n // istanbul ignore next\n case \".\":\n // istanbul ignore next\n case \"*\":\n // istanbul ignore next\n case \"+\":\n // istanbul ignore next\n case \"?\":\n // istanbul ignore next\n case \"(\":\n // istanbul ignore next\n case \")\":\n // istanbul ignore next\n case \"[\":\n // istanbul ignore next\n case \"|\":\n // istanbul ignore next\n throw Error(\"TBD\");\n default:\n return { type: \"Character\", value: cc(nextChar) };\n }\n }\n isRegExpFlag() {\n switch (this.peekChar(0)) {\n case \"g\":\n case \"i\":\n case \"m\":\n case \"u\":\n case \"y\":\n return true;\n default:\n return false;\n }\n }\n isRangeDash() {\n return this.peekChar() === \"-\" && this.isClassAtom(1);\n }\n isDigit() {\n return decimalPattern.test(this.peekChar(0));\n }\n isClassAtom(howMuch = 0) {\n switch (this.peekChar(howMuch)) {\n case \"]\":\n case \"\\n\":\n case \"\\r\":\n case \"\\u2028\":\n case \"\\u2029\":\n return false;\n default:\n return true;\n }\n }\n isTerm() {\n return this.isAtom() || this.isAssertion();\n }\n isAtom() {\n if (this.isPatternCharacter()) {\n return true;\n }\n switch (this.peekChar(0)) {\n case \".\":\n case \"\\\\\": // atomEscape\n case \"[\": // characterClass\n // TODO: isAtom must be called before isAssertion - disambiguate\n case \"(\": // group\n return true;\n default:\n return false;\n }\n }\n isAssertion() {\n switch (this.peekChar(0)) {\n case \"^\":\n case \"$\":\n return true;\n // '\\b' or '\\B'\n case \"\\\\\":\n switch (this.peekChar(1)) {\n case \"b\":\n case \"B\":\n return true;\n default:\n return false;\n }\n // '(?=' or '(?!'\n case \"(\":\n return (this.peekChar(1) === \"?\" &&\n (this.peekChar(2) === \"=\" || this.peekChar(2) === \"!\"));\n default:\n return false;\n }\n }\n isQuantifier() {\n const prevState = this.saveState();\n try {\n return this.quantifier(true) !== undefined;\n }\n catch (e) {\n return false;\n }\n finally {\n this.restoreState(prevState);\n }\n }\n isPatternCharacter() {\n switch (this.peekChar()) {\n case \"^\":\n case \"$\":\n case \"\\\\\":\n case \".\":\n case \"*\":\n case \"+\":\n case \"?\":\n case \"(\":\n case \")\":\n case \"[\":\n case \"|\":\n case \"/\":\n case \"\\n\":\n case \"\\r\":\n case \"\\u2028\":\n case \"\\u2029\":\n return false;\n default:\n return true;\n }\n }\n parseHexDigits(howMany) {\n let hexString = \"\";\n for (let i = 0; i < howMany; i++) {\n const hexChar = this.popChar();\n if (hexDigitPattern.test(hexChar) === false) {\n throw Error(\"Expecting a HexDecimal digits\");\n }\n hexString += hexChar;\n }\n const charCode = parseInt(hexString, 16);\n return { type: \"Character\", value: charCode };\n }\n peekChar(howMuch = 0) {\n return this.input[this.idx + howMuch];\n }\n popChar() {\n const nextChar = this.peekChar(0);\n this.consumeChar(undefined);\n return nextChar;\n }\n consumeChar(char) {\n if (char !== undefined && this.input[this.idx] !== char) {\n throw Error(\"Expected: '\" +\n char +\n \"' but found: '\" +\n this.input[this.idx] +\n \"' at offset: \" +\n this.idx);\n }\n if (this.idx >= this.input.length) {\n throw Error(\"Unexpected end of input\");\n }\n this.idx++;\n }\n loc(begin) {\n return { begin: begin, end: this.idx };\n }\n}\n//# sourceMappingURL=regexp-parser.js.map","export class BaseRegExpVisitor {\n visitChildren(node) {\n for (const key in node) {\n const child = node[key];\n /* istanbul ignore else */\n if (node.hasOwnProperty(key)) {\n if (child.type !== undefined) {\n this.visit(child);\n }\n else if (Array.isArray(child)) {\n child.forEach((subChild) => {\n this.visit(subChild);\n }, this);\n }\n }\n }\n }\n visit(node) {\n switch (node.type) {\n case \"Pattern\":\n this.visitPattern(node);\n break;\n case \"Flags\":\n this.visitFlags(node);\n break;\n case \"Disjunction\":\n this.visitDisjunction(node);\n break;\n case \"Alternative\":\n this.visitAlternative(node);\n break;\n case \"StartAnchor\":\n this.visitStartAnchor(node);\n break;\n case \"EndAnchor\":\n this.visitEndAnchor(node);\n break;\n case \"WordBoundary\":\n this.visitWordBoundary(node);\n break;\n case \"NonWordBoundary\":\n this.visitNonWordBoundary(node);\n break;\n case \"Lookahead\":\n this.visitLookahead(node);\n break;\n case \"NegativeLookahead\":\n this.visitNegativeLookahead(node);\n break;\n case \"Character\":\n this.visitCharacter(node);\n break;\n case \"Set\":\n this.visitSet(node);\n break;\n case \"Group\":\n this.visitGroup(node);\n break;\n case \"GroupBackReference\":\n this.visitGroupBackReference(node);\n break;\n case \"Quantifier\":\n this.visitQuantifier(node);\n break;\n }\n this.visitChildren(node);\n }\n visitPattern(node) { }\n visitFlags(node) { }\n visitDisjunction(node) { }\n visitAlternative(node) { }\n // Assertion\n visitStartAnchor(node) { }\n visitEndAnchor(node) { }\n visitWordBoundary(node) { }\n visitNonWordBoundary(node) { }\n visitLookahead(node) { }\n visitNegativeLookahead(node) { }\n // atoms\n visitCharacter(node) { }\n visitSet(node) { }\n visitGroup(node) { }\n visitGroupBackReference(node) { }\n visitQuantifier(node) { }\n}\n//# sourceMappingURL=base-regexp-visitor.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { RegExpParser, BaseRegExpVisitor } from '@chevrotain/regexp-to-ast';\nexport const NEWLINE_REGEXP = /\\r?\\n/gm;\nconst regexpParser = new RegExpParser();\n/**\n * This class is in charge of heuristically identifying start/end tokens of terminals.\n *\n * The way this works is by doing the following:\n * 1. Traverse the regular expression in the \"start state\"\n * 2. Add any encountered sets/single characters to the \"start regexp\"\n * 3. Once we encounter any variable-length content (i.e. with quantifiers such as +/?/*), we enter the \"end state\"\n * 4. In the end state, any sets/single characters are added to an \"end stack\".\n * 5. If we re-encounter any variable-length content we reset the end stack\n * 6. We continue visiting the regex until the end, reseting the end stack and rebuilding it as necessary\n *\n * After traversing a regular expression the `startRegexp/endRegexp` properties allow access to the stored start/end of the terminal\n */\nclass TerminalRegExpVisitor extends BaseRegExpVisitor {\n constructor() {\n super(...arguments);\n this.isStarting = true;\n this.endRegexpStack = [];\n this.multiline = false;\n }\n get endRegex() {\n return this.endRegexpStack.join('');\n }\n reset(regex) {\n this.multiline = false;\n this.regex = regex;\n this.startRegexp = '';\n this.isStarting = true;\n this.endRegexpStack = [];\n }\n visitGroup(node) {\n if (node.quantifier) {\n this.isStarting = false;\n this.endRegexpStack = [];\n }\n }\n visitCharacter(node) {\n const char = String.fromCharCode(node.value);\n if (!this.multiline && char === '\\n') {\n this.multiline = true;\n }\n if (node.quantifier) {\n this.isStarting = false;\n this.endRegexpStack = [];\n }\n else {\n const escapedChar = escapeRegExp(char);\n this.endRegexpStack.push(escapedChar);\n if (this.isStarting) {\n this.startRegexp += escapedChar;\n }\n }\n }\n visitSet(node) {\n if (!this.multiline) {\n const set = this.regex.substring(node.loc.begin, node.loc.end);\n const regex = new RegExp(set);\n this.multiline = Boolean('\\n'.match(regex));\n }\n if (node.quantifier) {\n this.isStarting = false;\n this.endRegexpStack = [];\n }\n else {\n const set = this.regex.substring(node.loc.begin, node.loc.end);\n this.endRegexpStack.push(set);\n if (this.isStarting) {\n this.startRegexp += set;\n }\n }\n }\n visitChildren(node) {\n if (node.type === 'Group') {\n // Ignore children of groups with quantifier (+/*/?)\n // These groups are unrelated to start/end tokens of terminals\n const group = node;\n if (group.quantifier) {\n return;\n }\n }\n super.visitChildren(node);\n }\n}\nconst visitor = new TerminalRegExpVisitor();\nexport function getTerminalParts(regexp) {\n try {\n if (typeof regexp !== 'string') {\n regexp = regexp.source;\n }\n regexp = `/${regexp}/`;\n const pattern = regexpParser.pattern(regexp);\n const parts = [];\n for (const alternative of pattern.value.value) {\n visitor.reset(regexp);\n visitor.visit(alternative);\n parts.push({\n start: visitor.startRegexp,\n end: visitor.endRegex\n });\n }\n return parts;\n }\n catch (_a) {\n return [];\n }\n}\nexport function isMultilineComment(regexp) {\n try {\n if (typeof regexp === 'string') {\n regexp = new RegExp(regexp);\n }\n regexp = regexp.toString();\n visitor.reset(regexp);\n // Parsing the pattern might fail (since it's user code)\n visitor.visit(regexpParser.pattern(regexp));\n return visitor.multiline;\n }\n catch (_a) {\n return false;\n }\n}\n/**\n * A set of all characters that are considered whitespace by the '\\s' RegExp character class.\n * Taken from [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions/Character_classes).\n */\nexport const whitespaceCharacters = ('\\f\\n\\r\\t\\v\\u0020\\u00a0\\u1680\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007' +\n '\\u2008\\u2009\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff').split('');\nexport function isWhitespace(value) {\n const regexp = typeof value === 'string' ? new RegExp(value) : value;\n return whitespaceCharacters.some((ws) => regexp.test(ws));\n}\nexport function escapeRegExp(value) {\n return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\nexport function getCaseInsensitivePattern(keyword) {\n return Array.prototype.map.call(keyword, letter => /\\w/.test(letter) ? `[${letter.toLowerCase()}${letter.toUpperCase()}]` : escapeRegExp(letter)).join('');\n}\n/**\n * Determines whether the given input has a partial match with the specified regex.\n * @param regex The regex to partially match against\n * @param input The input string\n * @returns Whether any match exists.\n */\nexport function partialMatches(regex, input) {\n const partial = partialRegExp(regex);\n const match = input.match(partial);\n return !!match && match[0].length > 0;\n}\n/**\n * Builds a partial regex from the input regex. A partial regex is able to match incomplete input strings. E.g.\n * a partial regex constructed from `/ab/` is able to match the string `a` without needing a following `b` character. However it won't match `b` alone.\n * @param regex The input regex to be converted.\n * @returns A partial regex constructed from the input regex.\n */\nexport function partialRegExp(regex) {\n if (typeof regex === 'string') {\n regex = new RegExp(regex);\n }\n const re = regex, source = regex.source;\n let i = 0;\n function process() {\n let result = '', tmp;\n function appendRaw(nbChars) {\n result += source.substr(i, nbChars);\n i += nbChars;\n }\n function appendOptional(nbChars) {\n result += '(?:' + source.substr(i, nbChars) + '|$)';\n i += nbChars;\n }\n while (i < source.length) {\n switch (source[i]) {\n case '\\\\':\n switch (source[i + 1]) {\n case 'c':\n appendOptional(3);\n break;\n case 'x':\n appendOptional(4);\n break;\n case 'u':\n if (re.unicode) {\n if (source[i + 2] === '{') {\n appendOptional(source.indexOf('}', i) - i + 1);\n }\n else {\n appendOptional(6);\n }\n }\n else {\n appendOptional(2);\n }\n break;\n case 'p':\n case 'P':\n if (re.unicode) {\n appendOptional(source.indexOf('}', i) - i + 1);\n }\n else {\n appendOptional(2);\n }\n break;\n case 'k':\n appendOptional(source.indexOf('>', i) - i + 1);\n break;\n default:\n appendOptional(2);\n break;\n }\n break;\n case '[':\n tmp = /\\[(?:\\\\.|.)*?\\]/g;\n tmp.lastIndex = i;\n tmp = tmp.exec(source) || [];\n appendOptional(tmp[0].length);\n break;\n case '|':\n case '^':\n case '$':\n case '*':\n case '+':\n case '?':\n appendRaw(1);\n break;\n case '{':\n tmp = /\\{\\d+,?\\d*\\}/g;\n tmp.lastIndex = i;\n tmp = tmp.exec(source);\n if (tmp) {\n appendRaw(tmp[0].length);\n }\n else {\n appendOptional(1);\n }\n break;\n case '(':\n if (source[i + 1] === '?') {\n switch (source[i + 2]) {\n case ':':\n result += '(?:';\n i += 3;\n result += process() + '|$)';\n break;\n case '=':\n result += '(?=';\n i += 3;\n result += process() + ')';\n break;\n case '!':\n tmp = i;\n i += 3;\n process();\n result += source.substr(tmp, i - tmp);\n break;\n case '<':\n switch (source[i + 3]) {\n case '=':\n case '!':\n tmp = i;\n i += 4;\n process();\n result += source.substr(tmp, i - tmp);\n break;\n default:\n appendRaw(source.indexOf('>', i) - i + 1);\n result += process() + '|$)';\n break;\n }\n break;\n }\n }\n else {\n appendRaw(1);\n result += process() + '|$)';\n }\n break;\n case ')':\n ++i;\n return result;\n default:\n appendOptional(1);\n break;\n }\n }\n return result;\n }\n return new RegExp(process(), regex.flags);\n}\n//# sourceMappingURL=regexp-utils.js.map","/******************************************************************************\n * Copyright 2021-2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { assertUnreachable } from '../utils/errors.js';\nimport * as ast from '../languages/generated/ast.js';\nimport { isCompositeCstNode } from '../syntax-tree.js';\nimport { getContainerOfType, streamAllContents } from './ast-utils.js';\nimport { streamCst } from './cst-utils.js';\nimport { escapeRegExp, isWhitespace } from './regexp-utils.js';\n/**\n * Returns the entry rule of the given grammar, if any. If the grammar file does not contain an entry rule,\n * the result is `undefined`.\n */\nexport function getEntryRule(grammar) {\n return grammar.rules.find(e => ast.isParserRule(e) && e.entry);\n}\n/**\n * Returns all hidden terminal rules of the given grammar, if any.\n */\nexport function getHiddenRules(grammar) {\n return grammar.rules.filter((e) => ast.isTerminalRule(e) && e.hidden);\n}\n/**\n * Returns all rules that can be reached from the topmost rules of the specified grammar (entry and hidden terminal rules).\n *\n * @param grammar The grammar that contains all rules\n * @param allTerminals Whether or not to include terminals that are referenced only by other terminals\n * @returns A list of referenced parser and terminal rules. If the grammar contains no entry rule,\n * this function returns all rules of the specified grammar.\n */\nexport function getAllReachableRules(grammar, allTerminals) {\n const ruleNames = new Set();\n const entryRule = getEntryRule(grammar);\n if (!entryRule) {\n return new Set(grammar.rules);\n }\n const topMostRules = [entryRule].concat(getHiddenRules(grammar));\n for (const rule of topMostRules) {\n ruleDfs(rule, ruleNames, allTerminals);\n }\n const rules = new Set();\n for (const rule of grammar.rules) {\n if (ruleNames.has(rule.name) || (ast.isTerminalRule(rule) && rule.hidden)) {\n rules.add(rule);\n }\n }\n return rules;\n}\nfunction ruleDfs(rule, visitedSet, allTerminals) {\n visitedSet.add(rule.name);\n streamAllContents(rule).forEach(node => {\n if (ast.isRuleCall(node) || (allTerminals && ast.isTerminalRuleCall(node))) {\n const refRule = node.rule.ref;\n if (refRule && !visitedSet.has(refRule.name)) {\n ruleDfs(refRule, visitedSet, allTerminals);\n }\n }\n });\n}\n/**\n * Determines the grammar expression used to parse a cross-reference (usually a reference to a terminal rule).\n * A cross-reference can declare this expression explicitly in the form `[Type : Terminal]`, but if `Terminal`\n * is omitted, this function attempts to infer it from the name of the referenced `Type` (using `findNameAssignment`).\n *\n * Returns the grammar expression used to parse the given cross-reference, or `undefined` if it is not declared\n * and cannot be inferred.\n */\nexport function getCrossReferenceTerminal(crossRef) {\n if (crossRef.terminal) {\n return crossRef.terminal;\n }\n else if (crossRef.type.ref) {\n const nameAssigment = findNameAssignment(crossRef.type.ref);\n return nameAssigment === null || nameAssigment === void 0 ? void 0 : nameAssigment.terminal;\n }\n return undefined;\n}\n/**\n * Determines whether the given terminal rule represents a comment. This is true if the rule is marked\n * as `hidden` and it does not match white space. This means every hidden token (i.e. excluded from the AST)\n * that contains visible characters is considered a comment.\n */\nexport function isCommentTerminal(terminalRule) {\n return terminalRule.hidden && !isWhitespace(terminalRegex(terminalRule));\n}\n/**\n * Find all CST nodes within the given node that contribute to the specified property.\n *\n * @param node A CST node in which to look for property assignments. If this is undefined, the result is an empty array.\n * @param property A property name of the constructed AST node. If this is undefined, the result is an empty array.\n */\nexport function findNodesForProperty(node, property) {\n if (!node || !property) {\n return [];\n }\n return findNodesForPropertyInternal(node, property, node.astNode, true);\n}\n/**\n * Find a single CST node within the given node that contributes to the specified property.\n *\n * @param node A CST node in which to look for property assignments. If this is undefined, the result is `undefined`.\n * @param property A property name of the constructed AST node. If this is undefined, the result is `undefined`.\n * @param index If no index is specified or the index is less than zero, the first found node is returned. If the\n * specified index exceeds the number of assignments to the property, the last found node is returned. Otherwise,\n * the node with the specified index is returned.\n */\nexport function findNodeForProperty(node, property, index) {\n if (!node || !property) {\n return undefined;\n }\n const nodes = findNodesForPropertyInternal(node, property, node.astNode, true);\n if (nodes.length === 0) {\n return undefined;\n }\n if (index !== undefined) {\n index = Math.max(0, Math.min(index, nodes.length - 1));\n }\n else {\n index = 0;\n }\n return nodes[index];\n}\nfunction findNodesForPropertyInternal(node, property, element, first) {\n if (!first) {\n const nodeFeature = getContainerOfType(node.grammarSource, ast.isAssignment);\n if (nodeFeature && nodeFeature.feature === property) {\n return [node];\n }\n }\n if (isCompositeCstNode(node) && node.astNode === element) {\n return node.content.flatMap(e => findNodesForPropertyInternal(e, property, element, false));\n }\n return [];\n}\n/**\n * Find all CST nodes within the given node that correspond to the specified keyword.\n *\n * @param node A CST node in which to look for keywords. If this is undefined, the result is an empty array.\n * @param keyword A keyword as specified in the grammar.\n */\nexport function findNodesForKeyword(node, keyword) {\n if (!node) {\n return [];\n }\n return findNodesForKeywordInternal(node, keyword, node === null || node === void 0 ? void 0 : node.astNode);\n}\n/**\n * Find a single CST node within the given node that corresponds to the specified keyword.\n *\n * @param node A CST node in which to look for keywords. If this is undefined, the result is `undefined`.\n * @param keyword A keyword as specified in the grammar.\n * @param index If no index is specified or the index is less than zero, the first found node is returned. If the\n * specified index exceeds the number of keyword occurrences, the last found node is returned. Otherwise,\n * the node with the specified index is returned.\n */\nexport function findNodeForKeyword(node, keyword, index) {\n if (!node) {\n return undefined;\n }\n const nodes = findNodesForKeywordInternal(node, keyword, node === null || node === void 0 ? void 0 : node.astNode);\n if (nodes.length === 0) {\n return undefined;\n }\n if (index !== undefined) {\n index = Math.max(0, Math.min(index, nodes.length - 1));\n }\n else {\n index = 0;\n }\n return nodes[index];\n}\nexport function findNodesForKeywordInternal(node, keyword, element) {\n if (node.astNode !== element) {\n return [];\n }\n if (ast.isKeyword(node.grammarSource) && node.grammarSource.value === keyword) {\n return [node];\n }\n const treeIterator = streamCst(node).iterator();\n let result;\n const keywordNodes = [];\n do {\n result = treeIterator.next();\n if (!result.done) {\n const childNode = result.value;\n if (childNode.astNode === element) {\n if (ast.isKeyword(childNode.grammarSource) && childNode.grammarSource.value === keyword) {\n keywordNodes.push(childNode);\n }\n }\n else {\n treeIterator.prune();\n }\n }\n } while (!result.done);\n return keywordNodes;\n}\n/**\n * If the given CST node was parsed in the context of a property assignment, the respective `Assignment` grammar\n * node is returned. If no assignment is found, the result is `undefined`.\n *\n * @param cstNode A CST node for which to find a property assignment.\n */\nexport function findAssignment(cstNode) {\n var _a;\n const astNode = cstNode.astNode;\n // Only search until the ast node of the parent cst node is no longer the original ast node\n // This would make us jump to a preceding rule call, which contains only unrelated assignments\n while (astNode === ((_a = cstNode.container) === null || _a === void 0 ? void 0 : _a.astNode)) {\n const assignment = getContainerOfType(cstNode.grammarSource, ast.isAssignment);\n if (assignment) {\n return assignment;\n }\n cstNode = cstNode.container;\n }\n return undefined;\n}\n/**\n * Find an assignment to the `name` property for the given grammar type. This requires the `type` to be inferred\n * from a parser rule, and that rule must contain an assignment to the `name` property. In all other cases,\n * this function returns `undefined`.\n */\nexport function findNameAssignment(type) {\n let startNode = type;\n if (ast.isInferredType(startNode)) {\n // for inferred types, the location to start searching for the name-assignment is different\n if (ast.isAction(startNode.$container)) {\n // a type which is explicitly inferred by an action: investigate the sibbling of the Action node, i.e. start searching at the Action's parent\n startNode = startNode.$container.$container;\n }\n else if (ast.isParserRule(startNode.$container)) {\n // investigate the parser rule with the explicitly inferred type\n startNode = startNode.$container;\n }\n else {\n assertUnreachable(startNode.$container);\n }\n }\n return findNameAssignmentInternal(type, startNode, new Map());\n}\nfunction findNameAssignmentInternal(type, startNode, cache) {\n var _a;\n // the cache is only required to prevent infinite loops\n function go(node, refType) {\n let childAssignment = undefined;\n const parentAssignment = getContainerOfType(node, ast.isAssignment);\n // No parent assignment implies unassigned rule call\n if (!parentAssignment) {\n childAssignment = findNameAssignmentInternal(refType, refType, cache);\n }\n cache.set(type, childAssignment);\n return childAssignment;\n }\n if (cache.has(type)) {\n return cache.get(type);\n }\n cache.set(type, undefined);\n for (const node of streamAllContents(startNode)) {\n if (ast.isAssignment(node) && node.feature.toLowerCase() === 'name') {\n cache.set(type, node);\n return node;\n }\n else if (ast.isRuleCall(node) && ast.isParserRule(node.rule.ref)) {\n return go(node, node.rule.ref);\n }\n else if (ast.isSimpleType(node) && ((_a = node.typeRef) === null || _a === void 0 ? void 0 : _a.ref)) {\n return go(node, node.typeRef.ref);\n }\n }\n return undefined;\n}\nexport function getActionAtElement(element) {\n const parent = element.$container;\n if (ast.isGroup(parent)) {\n const elements = parent.elements;\n const index = elements.indexOf(element);\n for (let i = index - 1; i >= 0; i--) {\n const item = elements[i];\n if (ast.isAction(item)) {\n return item;\n }\n else {\n const action = streamAllContents(elements[i]).find(ast.isAction);\n if (action) {\n return action;\n }\n }\n }\n }\n if (ast.isAbstractElement(parent)) {\n return getActionAtElement(parent);\n }\n else {\n return undefined;\n }\n}\nexport function isOptionalCardinality(cardinality, element) {\n return cardinality === '?' || cardinality === '*' || (ast.isGroup(element) && Boolean(element.guardCondition));\n}\nexport function isArrayCardinality(cardinality) {\n return cardinality === '*' || cardinality === '+';\n}\nexport function isArrayOperator(operator) {\n return operator === '+=';\n}\n/**\n * Determines whether the given parser rule is a _data type rule_, meaning that it has a\n * primitive return type like `number`, `boolean`, etc.\n */\nexport function isDataTypeRule(rule) {\n return isDataTypeRuleInternal(rule, new Set());\n}\nfunction isDataTypeRuleInternal(rule, visited) {\n if (visited.has(rule)) {\n return true;\n }\n else {\n visited.add(rule);\n }\n for (const node of streamAllContents(rule)) {\n if (ast.isRuleCall(node)) {\n if (!node.rule.ref) {\n // RuleCall to unresolved rule. Don't assume `rule` is a DataType rule.\n return false;\n }\n if (ast.isParserRule(node.rule.ref) && !isDataTypeRuleInternal(node.rule.ref, visited)) {\n return false;\n }\n }\n else if (ast.isAssignment(node)) {\n return false;\n }\n else if (ast.isAction(node)) {\n return false;\n }\n }\n return Boolean(rule.definition);\n}\nexport function isDataType(type) {\n return isDataTypeInternal(type.type, new Set());\n}\nfunction isDataTypeInternal(type, visited) {\n if (visited.has(type)) {\n return true;\n }\n else {\n visited.add(type);\n }\n if (ast.isArrayType(type)) {\n return false;\n }\n else if (ast.isReferenceType(type)) {\n return false;\n }\n else if (ast.isUnionType(type)) {\n return type.types.every(e => isDataTypeInternal(e, visited));\n }\n else if (ast.isSimpleType(type)) {\n if (type.primitiveType !== undefined) {\n return true;\n }\n else if (type.stringType !== undefined) {\n return true;\n }\n else if (type.typeRef !== undefined) {\n const ref = type.typeRef.ref;\n if (ast.isType(ref)) {\n return isDataTypeInternal(ref.type, visited);\n }\n else {\n return false;\n }\n }\n else {\n return false;\n }\n }\n else {\n return false;\n }\n}\nexport function getExplicitRuleType(rule) {\n if (rule.inferredType) {\n return rule.inferredType.name;\n }\n else if (rule.dataType) {\n return rule.dataType;\n }\n else if (rule.returnType) {\n const refType = rule.returnType.ref;\n if (refType) {\n // check if we need to check Action as return type\n if (ast.isParserRule(refType)) {\n return refType.name;\n }\n else if (ast.isInterface(refType) || ast.isType(refType)) {\n return refType.name;\n }\n }\n }\n return undefined;\n}\nexport function getTypeName(type) {\n var _a;\n if (ast.isParserRule(type)) {\n return isDataTypeRule(type) ? type.name : (_a = getExplicitRuleType(type)) !== null && _a !== void 0 ? _a : type.name;\n }\n else if (ast.isInterface(type) || ast.isType(type) || ast.isReturnType(type)) {\n return type.name;\n }\n else if (ast.isAction(type)) {\n const actionType = getActionType(type);\n if (actionType) {\n return actionType;\n }\n }\n else if (ast.isInferredType(type)) {\n return type.name;\n }\n throw new Error('Cannot get name of Unknown Type');\n}\nexport function getActionType(action) {\n var _a;\n if (action.inferredType) {\n return action.inferredType.name;\n }\n else if ((_a = action.type) === null || _a === void 0 ? void 0 : _a.ref) {\n return getTypeName(action.type.ref);\n }\n return undefined; // not inferring and not referencing a valid type\n}\n/**\n * This function is used at development time (for code generation and the internal type system) to get the type of the AST node produced by the given rule.\n * For data type rules, the name of the rule is returned,\n * e.g. \"INT_value returns number: MY_INT;\" returns \"INT_value\".\n * @param rule the given rule\n * @returns the name of the AST node type of the rule\n */\nexport function getRuleTypeName(rule) {\n var _a, _b, _c;\n if (ast.isTerminalRule(rule)) {\n return (_b = (_a = rule.type) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'string';\n }\n else {\n return isDataTypeRule(rule) ? rule.name : (_c = getExplicitRuleType(rule)) !== null && _c !== void 0 ? _c : rule.name;\n }\n}\n/**\n * This function is used at runtime to get the actual type of the values produced by the given rule at runtime.\n * For data type rules, the name of the declared return type of the rule is returned (if any),\n * e.g. \"INT_value returns number: MY_INT;\" returns \"number\".\n * @param rule the given rule\n * @returns the name of the type of the produced values of the rule at runtime\n */\nexport function getRuleType(rule) {\n var _a, _b, _c;\n if (ast.isTerminalRule(rule)) {\n return (_b = (_a = rule.type) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'string';\n }\n else {\n return (_c = getExplicitRuleType(rule)) !== null && _c !== void 0 ? _c : rule.name;\n }\n}\nexport function terminalRegex(terminalRule) {\n const flags = {\n s: false,\n i: false,\n u: false\n };\n const source = abstractElementToRegex(terminalRule.definition, flags);\n const flagText = Object.entries(flags).filter(([, value]) => value).map(([name]) => name).join('');\n return new RegExp(source, flagText);\n}\n// Using [\\s\\S]* allows to match everything, compared to . which doesn't match line terminators\nconst WILDCARD = /[\\s\\S]/.source;\nfunction abstractElementToRegex(element, flags) {\n if (ast.isTerminalAlternatives(element)) {\n return terminalAlternativesToRegex(element);\n }\n else if (ast.isTerminalGroup(element)) {\n return terminalGroupToRegex(element);\n }\n else if (ast.isCharacterRange(element)) {\n return characterRangeToRegex(element);\n }\n else if (ast.isTerminalRuleCall(element)) {\n const rule = element.rule.ref;\n if (!rule) {\n throw new Error('Missing rule reference.');\n }\n return withCardinality(abstractElementToRegex(rule.definition), {\n cardinality: element.cardinality,\n lookahead: element.lookahead\n });\n }\n else if (ast.isNegatedToken(element)) {\n return negateTokenToRegex(element);\n }\n else if (ast.isUntilToken(element)) {\n return untilTokenToRegex(element);\n }\n else if (ast.isRegexToken(element)) {\n const lastSlash = element.regex.lastIndexOf('/');\n const source = element.regex.substring(1, lastSlash);\n const regexFlags = element.regex.substring(lastSlash + 1);\n if (flags) {\n flags.i = regexFlags.includes('i');\n flags.s = regexFlags.includes('s');\n flags.u = regexFlags.includes('u');\n }\n return withCardinality(source, {\n cardinality: element.cardinality,\n lookahead: element.lookahead,\n wrap: false\n });\n }\n else if (ast.isWildcard(element)) {\n return withCardinality(WILDCARD, {\n cardinality: element.cardinality,\n lookahead: element.lookahead\n });\n }\n else {\n throw new Error(`Invalid terminal element: ${element === null || element === void 0 ? void 0 : element.$type}`);\n }\n}\nfunction terminalAlternativesToRegex(alternatives) {\n return withCardinality(alternatives.elements.map(e => abstractElementToRegex(e)).join('|'), {\n cardinality: alternatives.cardinality,\n lookahead: alternatives.lookahead\n });\n}\nfunction terminalGroupToRegex(group) {\n return withCardinality(group.elements.map(e => abstractElementToRegex(e)).join(''), {\n cardinality: group.cardinality,\n lookahead: group.lookahead\n });\n}\nfunction untilTokenToRegex(until) {\n return withCardinality(`${WILDCARD}*?${abstractElementToRegex(until.terminal)}`, {\n cardinality: until.cardinality,\n lookahead: until.lookahead\n });\n}\nfunction negateTokenToRegex(negate) {\n return withCardinality(`(?!${abstractElementToRegex(negate.terminal)})${WILDCARD}*?`, {\n cardinality: negate.cardinality,\n lookahead: negate.lookahead\n });\n}\nfunction characterRangeToRegex(range) {\n if (range.right) {\n return withCardinality(`[${keywordToRegex(range.left)}-${keywordToRegex(range.right)}]`, {\n cardinality: range.cardinality,\n lookahead: range.lookahead,\n wrap: false\n });\n }\n return withCardinality(keywordToRegex(range.left), {\n cardinality: range.cardinality,\n lookahead: range.lookahead,\n wrap: false\n });\n}\nfunction keywordToRegex(keyword) {\n return escapeRegExp(keyword.value);\n}\nfunction withCardinality(regex, options) {\n var _a;\n if (options.wrap !== false || options.lookahead) {\n regex = `(${(_a = options.lookahead) !== null && _a !== void 0 ? _a : ''}${regex})`;\n }\n if (options.cardinality) {\n return `${regex}${options.cardinality}`;\n }\n return regex;\n}\n//# sourceMappingURL=grammar-utils.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { DefaultNameRegexp } from '../utils/cst-utils.js';\nimport { isCommentTerminal, terminalRegex } from '../utils/grammar-utils.js';\nimport { isMultilineComment } from '../utils/regexp-utils.js';\nimport { isTerminalRule } from './generated/ast.js';\n/**\n * Create the default grammar configuration (used by `createDefaultModule`). This can be overridden in a\n * language-specific module.\n */\nexport function createGrammarConfig(services) {\n const rules = [];\n const grammar = services.Grammar;\n for (const rule of grammar.rules) {\n if (isTerminalRule(rule) && isCommentTerminal(rule) && isMultilineComment(terminalRegex(rule))) {\n rules.push(rule.name);\n }\n }\n return {\n multilineCommentRules: rules,\n nameRegexp: DefaultNameRegexp\n };\n}\n//# sourceMappingURL=grammar-config.js.map","export function PRINT_ERROR(msg) {\n /* istanbul ignore else - can't override global.console in node.js */\n if (console && console.error) {\n console.error(`Error: ${msg}`);\n }\n}\nexport function PRINT_WARNING(msg) {\n /* istanbul ignore else - can't override global.console in node.js*/\n if (console && console.warn) {\n // TODO: modify docs accordingly\n console.warn(`Warning: ${msg}`);\n }\n}\n//# sourceMappingURL=print.js.map","export function timer(func) {\n const start = new Date().getTime();\n const val = func();\n const end = new Date().getTime();\n const total = end - start;\n return { time: total, value: val };\n}\n//# sourceMappingURL=timer.js.map","// based on: https://github.com/petkaantonov/bluebird/blob/b97c0d2d487e8c5076e8bd897e0dcd4622d31846/src/util.js#L201-L216\nexport function toFastProperties(toBecomeFast) {\n function FakeConstructor() { }\n // If our object is used as a constructor, it would receive\n FakeConstructor.prototype = toBecomeFast;\n const fakeInstance = new FakeConstructor();\n function fakeAccess() {\n return typeof fakeInstance.bar;\n }\n // help V8 understand this is a \"real\" prototype by actually using\n // the fake instance.\n fakeAccess();\n fakeAccess();\n // Always true condition to suppress the Firefox warning of unreachable\n // code after a return statement.\n if (1)\n return toBecomeFast;\n // Eval prevents optimization of this method (even though this is dead code)\n // - https://esbuild.github.io/content-types/#direct-eval\n /* istanbul ignore next */\n // tslint:disable-next-line\n (0, eval)(toBecomeFast);\n}\n//# sourceMappingURL=to-fast-properties.js.map","import { assign, forEach, isRegExp, isString, map, pickBy } from \"lodash-es\";\n// TODO: duplicated code to avoid extracting another sub-package -- how to avoid?\nfunction tokenLabel(tokType) {\n if (hasTokenLabel(tokType)) {\n return tokType.LABEL;\n }\n else {\n return tokType.name;\n }\n}\n// TODO: duplicated code to avoid extracting another sub-package -- how to avoid?\nfunction hasTokenLabel(obj) {\n return isString(obj.LABEL) && obj.LABEL !== \"\";\n}\nexport class AbstractProduction {\n get definition() {\n return this._definition;\n }\n set definition(value) {\n this._definition = value;\n }\n constructor(_definition) {\n this._definition = _definition;\n }\n accept(visitor) {\n visitor.visit(this);\n forEach(this.definition, (prod) => {\n prod.accept(visitor);\n });\n }\n}\nexport class NonTerminal extends AbstractProduction {\n constructor(options) {\n super([]);\n this.idx = 1;\n assign(this, pickBy(options, (v) => v !== undefined));\n }\n set definition(definition) {\n // immutable\n }\n get definition() {\n if (this.referencedRule !== undefined) {\n return this.referencedRule.definition;\n }\n return [];\n }\n accept(visitor) {\n visitor.visit(this);\n // don't visit children of a reference, we will get cyclic infinite loops if we do so\n }\n}\nexport class Rule extends AbstractProduction {\n constructor(options) {\n super(options.definition);\n this.orgText = \"\";\n assign(this, pickBy(options, (v) => v !== undefined));\n }\n}\nexport class Alternative extends AbstractProduction {\n constructor(options) {\n super(options.definition);\n this.ignoreAmbiguities = false;\n assign(this, pickBy(options, (v) => v !== undefined));\n }\n}\nexport class Option extends AbstractProduction {\n constructor(options) {\n super(options.definition);\n this.idx = 1;\n assign(this, pickBy(options, (v) => v !== undefined));\n }\n}\nexport class RepetitionMandatory extends AbstractProduction {\n constructor(options) {\n super(options.definition);\n this.idx = 1;\n assign(this, pickBy(options, (v) => v !== undefined));\n }\n}\nexport class RepetitionMandatoryWithSeparator extends AbstractProduction {\n constructor(options) {\n super(options.definition);\n this.idx = 1;\n assign(this, pickBy(options, (v) => v !== undefined));\n }\n}\nexport class Repetition extends AbstractProduction {\n constructor(options) {\n super(options.definition);\n this.idx = 1;\n assign(this, pickBy(options, (v) => v !== undefined));\n }\n}\nexport class RepetitionWithSeparator extends AbstractProduction {\n constructor(options) {\n super(options.definition);\n this.idx = 1;\n assign(this, pickBy(options, (v) => v !== undefined));\n }\n}\nexport class Alternation extends AbstractProduction {\n get definition() {\n return this._definition;\n }\n set definition(value) {\n this._definition = value;\n }\n constructor(options) {\n super(options.definition);\n this.idx = 1;\n this.ignoreAmbiguities = false;\n this.hasPredicates = false;\n assign(this, pickBy(options, (v) => v !== undefined));\n }\n}\nexport class Terminal {\n constructor(options) {\n this.idx = 1;\n assign(this, pickBy(options, (v) => v !== undefined));\n }\n accept(visitor) {\n visitor.visit(this);\n }\n}\nexport function serializeGrammar(topRules) {\n return map(topRules, serializeProduction);\n}\nexport function serializeProduction(node) {\n function convertDefinition(definition) {\n return map(definition, serializeProduction);\n }\n /* istanbul ignore else */\n if (node instanceof NonTerminal) {\n const serializedNonTerminal = {\n type: \"NonTerminal\",\n name: node.nonTerminalName,\n idx: node.idx,\n };\n if (isString(node.label)) {\n serializedNonTerminal.label = node.label;\n }\n return serializedNonTerminal;\n }\n else if (node instanceof Alternative) {\n return {\n type: \"Alternative\",\n definition: convertDefinition(node.definition),\n };\n }\n else if (node instanceof Option) {\n return {\n type: \"Option\",\n idx: node.idx,\n definition: convertDefinition(node.definition),\n };\n }\n else if (node instanceof RepetitionMandatory) {\n return {\n type: \"RepetitionMandatory\",\n idx: node.idx,\n definition: convertDefinition(node.definition),\n };\n }\n else if (node instanceof RepetitionMandatoryWithSeparator) {\n return {\n type: \"RepetitionMandatoryWithSeparator\",\n idx: node.idx,\n separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),\n definition: convertDefinition(node.definition),\n };\n }\n else if (node instanceof RepetitionWithSeparator) {\n return {\n type: \"RepetitionWithSeparator\",\n idx: node.idx,\n separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),\n definition: convertDefinition(node.definition),\n };\n }\n else if (node instanceof Repetition) {\n return {\n type: \"Repetition\",\n idx: node.idx,\n definition: convertDefinition(node.definition),\n };\n }\n else if (node instanceof Alternation) {\n return {\n type: \"Alternation\",\n idx: node.idx,\n definition: convertDefinition(node.definition),\n };\n }\n else if (node instanceof Terminal) {\n const serializedTerminal = {\n type: \"Terminal\",\n name: node.terminalType.name,\n label: tokenLabel(node.terminalType),\n idx: node.idx,\n };\n if (isString(node.label)) {\n serializedTerminal.terminalLabel = node.label;\n }\n const pattern = node.terminalType.PATTERN;\n if (node.terminalType.PATTERN) {\n serializedTerminal.pattern = isRegExp(pattern)\n ? pattern.source\n : pattern;\n }\n return serializedTerminal;\n }\n else if (node instanceof Rule) {\n return {\n type: \"Rule\",\n name: node.name,\n orgText: node.orgText,\n definition: convertDefinition(node.definition),\n };\n /* c8 ignore next 3 */\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n}\n//# sourceMappingURL=model.js.map","import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, } from \"./model.js\";\nexport class GAstVisitor {\n visit(node) {\n const nodeAny = node;\n switch (nodeAny.constructor) {\n case NonTerminal:\n return this.visitNonTerminal(nodeAny);\n case Alternative:\n return this.visitAlternative(nodeAny);\n case Option:\n return this.visitOption(nodeAny);\n case RepetitionMandatory:\n return this.visitRepetitionMandatory(nodeAny);\n case RepetitionMandatoryWithSeparator:\n return this.visitRepetitionMandatoryWithSeparator(nodeAny);\n case RepetitionWithSeparator:\n return this.visitRepetitionWithSeparator(nodeAny);\n case Repetition:\n return this.visitRepetition(nodeAny);\n case Alternation:\n return this.visitAlternation(nodeAny);\n case Terminal:\n return this.visitTerminal(nodeAny);\n case Rule:\n return this.visitRule(nodeAny);\n /* c8 ignore next 2 */\n default:\n throw Error(\"non exhaustive match\");\n }\n }\n /* c8 ignore next */\n visitNonTerminal(node) { }\n /* c8 ignore next */\n visitAlternative(node) { }\n /* c8 ignore next */\n visitOption(node) { }\n /* c8 ignore next */\n visitRepetition(node) { }\n /* c8 ignore next */\n visitRepetitionMandatory(node) { }\n /* c8 ignore next 3 */\n visitRepetitionMandatoryWithSeparator(node) { }\n /* c8 ignore next */\n visitRepetitionWithSeparator(node) { }\n /* c8 ignore next */\n visitAlternation(node) { }\n /* c8 ignore next */\n visitTerminal(node) { }\n /* c8 ignore next */\n visitRule(node) { }\n}\n//# sourceMappingURL=visitor.js.map","import { every, includes, some } from \"lodash-es\";\nimport { AbstractProduction, Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, } from \"./model.js\";\nexport function isSequenceProd(prod) {\n return (prod instanceof Alternative ||\n prod instanceof Option ||\n prod instanceof Repetition ||\n prod instanceof RepetitionMandatory ||\n prod instanceof RepetitionMandatoryWithSeparator ||\n prod instanceof RepetitionWithSeparator ||\n prod instanceof Terminal ||\n prod instanceof Rule);\n}\nexport function isOptionalProd(prod, alreadyVisited = []) {\n const isDirectlyOptional = prod instanceof Option ||\n prod instanceof Repetition ||\n prod instanceof RepetitionWithSeparator;\n if (isDirectlyOptional) {\n return true;\n }\n // note that this can cause infinite loop if one optional empty TOP production has a cyclic dependency with another\n // empty optional top rule\n // may be indirectly optional ((A?B?C?) | (D?E?F?))\n if (prod instanceof Alternation) {\n // for OR its enough for just one of the alternatives to be optional\n return some(prod.definition, (subProd) => {\n return isOptionalProd(subProd, alreadyVisited);\n });\n }\n else if (prod instanceof NonTerminal && includes(alreadyVisited, prod)) {\n // avoiding stack overflow due to infinite recursion\n return false;\n }\n else if (prod instanceof AbstractProduction) {\n if (prod instanceof NonTerminal) {\n alreadyVisited.push(prod);\n }\n return every(prod.definition, (subProd) => {\n return isOptionalProd(subProd, alreadyVisited);\n });\n }\n else {\n return false;\n }\n}\nexport function isBranchingProd(prod) {\n return prod instanceof Alternation;\n}\nexport function getProductionDslName(prod) {\n /* istanbul ignore else */\n if (prod instanceof NonTerminal) {\n return \"SUBRULE\";\n }\n else if (prod instanceof Option) {\n return \"OPTION\";\n }\n else if (prod instanceof Alternation) {\n return \"OR\";\n }\n else if (prod instanceof RepetitionMandatory) {\n return \"AT_LEAST_ONE\";\n }\n else if (prod instanceof RepetitionMandatoryWithSeparator) {\n return \"AT_LEAST_ONE_SEP\";\n }\n else if (prod instanceof RepetitionWithSeparator) {\n return \"MANY_SEP\";\n }\n else if (prod instanceof Repetition) {\n return \"MANY\";\n }\n else if (prod instanceof Terminal) {\n return \"CONSUME\";\n /* c8 ignore next 3 */\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n}\n//# sourceMappingURL=helpers.js.map","import { drop, forEach } from \"lodash-es\";\nimport { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Terminal, } from \"@chevrotain/gast\";\n/**\n * A Grammar Walker that computes the \"remaining\" grammar \"after\" a productions in the grammar.\n */\nexport class RestWalker {\n walk(prod, prevRest = []) {\n forEach(prod.definition, (subProd, index) => {\n const currRest = drop(prod.definition, index + 1);\n /* istanbul ignore else */\n if (subProd instanceof NonTerminal) {\n this.walkProdRef(subProd, currRest, prevRest);\n }\n else if (subProd instanceof Terminal) {\n this.walkTerminal(subProd, currRest, prevRest);\n }\n else if (subProd instanceof Alternative) {\n this.walkFlat(subProd, currRest, prevRest);\n }\n else if (subProd instanceof Option) {\n this.walkOption(subProd, currRest, prevRest);\n }\n else if (subProd instanceof RepetitionMandatory) {\n this.walkAtLeastOne(subProd, currRest, prevRest);\n }\n else if (subProd instanceof RepetitionMandatoryWithSeparator) {\n this.walkAtLeastOneSep(subProd, currRest, prevRest);\n }\n else if (subProd instanceof RepetitionWithSeparator) {\n this.walkManySep(subProd, currRest, prevRest);\n }\n else if (subProd instanceof Repetition) {\n this.walkMany(subProd, currRest, prevRest);\n }\n else if (subProd instanceof Alternation) {\n this.walkOr(subProd, currRest, prevRest);\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n });\n }\n walkTerminal(terminal, currRest, prevRest) { }\n walkProdRef(refProd, currRest, prevRest) { }\n walkFlat(flatProd, currRest, prevRest) {\n // ABCDEF => after the D the rest is EF\n const fullOrRest = currRest.concat(prevRest);\n this.walk(flatProd, fullOrRest);\n }\n walkOption(optionProd, currRest, prevRest) {\n // ABC(DE)?F => after the (DE)? the rest is F\n const fullOrRest = currRest.concat(prevRest);\n this.walk(optionProd, fullOrRest);\n }\n walkAtLeastOne(atLeastOneProd, currRest, prevRest) {\n // ABC(DE)+F => after the (DE)+ the rest is (DE)?F\n const fullAtLeastOneRest = [\n new Option({ definition: atLeastOneProd.definition }),\n ].concat(currRest, prevRest);\n this.walk(atLeastOneProd, fullAtLeastOneRest);\n }\n walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {\n // ABC DE(,DE)* F => after the (,DE)+ the rest is (,DE)?F\n const fullAtLeastOneSepRest = restForRepetitionWithSeparator(atLeastOneSepProd, currRest, prevRest);\n this.walk(atLeastOneSepProd, fullAtLeastOneSepRest);\n }\n walkMany(manyProd, currRest, prevRest) {\n // ABC(DE)*F => after the (DE)* the rest is (DE)?F\n const fullManyRest = [\n new Option({ definition: manyProd.definition }),\n ].concat(currRest, prevRest);\n this.walk(manyProd, fullManyRest);\n }\n walkManySep(manySepProd, currRest, prevRest) {\n // ABC (DE(,DE)*)? F => after the (,DE)* the rest is (,DE)?F\n const fullManySepRest = restForRepetitionWithSeparator(manySepProd, currRest, prevRest);\n this.walk(manySepProd, fullManySepRest);\n }\n walkOr(orProd, currRest, prevRest) {\n // ABC(D|E|F)G => when finding the (D|E|F) the rest is G\n const fullOrRest = currRest.concat(prevRest);\n // walk all different alternatives\n forEach(orProd.definition, (alt) => {\n // wrapping each alternative in a single definition wrapper\n // to avoid errors in computing the rest of that alternative in the invocation to computeInProdFollows\n // (otherwise for OR([alt1,alt2]) alt2 will be considered in 'rest' of alt1\n const prodWrapper = new Alternative({ definition: [alt] });\n this.walk(prodWrapper, fullOrRest);\n });\n }\n}\nfunction restForRepetitionWithSeparator(repSepProd, currRest, prevRest) {\n const repSepRest = [\n new Option({\n definition: [\n new Terminal({ terminalType: repSepProd.separator }),\n ].concat(repSepProd.definition),\n }),\n ];\n const fullRepSepRest = repSepRest.concat(currRest, prevRest);\n return fullRepSepRest;\n}\n//# sourceMappingURL=rest.js.map","import { flatten, map, uniq } from \"lodash-es\";\nimport { isBranchingProd, isOptionalProd, isSequenceProd, NonTerminal, Terminal, } from \"@chevrotain/gast\";\nexport function first(prod) {\n /* istanbul ignore else */\n if (prod instanceof NonTerminal) {\n // this could in theory cause infinite loops if\n // (1) prod A refs prod B.\n // (2) prod B refs prod A\n // (3) AB can match the empty set\n // in other words a cycle where everything is optional so the first will keep\n // looking ahead for the next optional part and will never exit\n // currently there is no safeguard for this unique edge case because\n // (1) not sure a grammar in which this can happen is useful for anything (productive)\n return first(prod.referencedRule);\n }\n else if (prod instanceof Terminal) {\n return firstForTerminal(prod);\n }\n else if (isSequenceProd(prod)) {\n return firstForSequence(prod);\n }\n else if (isBranchingProd(prod)) {\n return firstForBranching(prod);\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n}\nexport function firstForSequence(prod) {\n let firstSet = [];\n const seq = prod.definition;\n let nextSubProdIdx = 0;\n let hasInnerProdsRemaining = seq.length > nextSubProdIdx;\n let currSubProd;\n // so we enter the loop at least once (if the definition is not empty\n let isLastInnerProdOptional = true;\n // scan a sequence until it's end or until we have found a NONE optional production in it\n while (hasInnerProdsRemaining && isLastInnerProdOptional) {\n currSubProd = seq[nextSubProdIdx];\n isLastInnerProdOptional = isOptionalProd(currSubProd);\n firstSet = firstSet.concat(first(currSubProd));\n nextSubProdIdx = nextSubProdIdx + 1;\n hasInnerProdsRemaining = seq.length > nextSubProdIdx;\n }\n return uniq(firstSet);\n}\nexport function firstForBranching(prod) {\n const allAlternativesFirsts = map(prod.definition, (innerProd) => {\n return first(innerProd);\n });\n return uniq(flatten(allAlternativesFirsts));\n}\nexport function firstForTerminal(terminal) {\n return [terminal.terminalType];\n}\n//# sourceMappingURL=first.js.map","// TODO: can this be removed? where is it used?\nexport const IN = \"_~IN~_\";\n//# sourceMappingURL=constants.js.map","import { RestWalker } from \"./rest.js\";\nimport { first } from \"./first.js\";\nimport { assign, forEach } from \"lodash-es\";\nimport { IN } from \"../constants.js\";\nimport { Alternative } from \"@chevrotain/gast\";\n// This ResyncFollowsWalker computes all of the follows required for RESYNC\n// (skipping reference production).\nexport class ResyncFollowsWalker extends RestWalker {\n constructor(topProd) {\n super();\n this.topProd = topProd;\n this.follows = {};\n }\n startWalking() {\n this.walk(this.topProd);\n return this.follows;\n }\n walkTerminal(terminal, currRest, prevRest) {\n // do nothing! just like in the public sector after 13:00\n }\n walkProdRef(refProd, currRest, prevRest) {\n const followName = buildBetweenProdsFollowPrefix(refProd.referencedRule, refProd.idx) +\n this.topProd.name;\n const fullRest = currRest.concat(prevRest);\n const restProd = new Alternative({ definition: fullRest });\n const t_in_topProd_follows = first(restProd);\n this.follows[followName] = t_in_topProd_follows;\n }\n}\nexport function computeAllProdsFollows(topProductions) {\n const reSyncFollows = {};\n forEach(topProductions, (topProd) => {\n const currRefsFollow = new ResyncFollowsWalker(topProd).startWalking();\n assign(reSyncFollows, currRefsFollow);\n });\n return reSyncFollows;\n}\nexport function buildBetweenProdsFollowPrefix(inner, occurenceInParent) {\n return inner.name + occurenceInParent + IN;\n}\nexport function buildInProdFollowPrefix(terminal) {\n const terminalName = terminal.terminalType.name;\n return terminalName + terminal.idx + IN;\n}\n//# sourceMappingURL=follow.js.map","import { RegExpParser, } from \"@chevrotain/regexp-to-ast\";\nlet regExpAstCache = {};\nconst regExpParser = new RegExpParser();\nexport function getRegExpAst(regExp) {\n const regExpStr = regExp.toString();\n if (regExpAstCache.hasOwnProperty(regExpStr)) {\n return regExpAstCache[regExpStr];\n }\n else {\n const regExpAst = regExpParser.pattern(regExpStr);\n regExpAstCache[regExpStr] = regExpAst;\n return regExpAst;\n }\n}\nexport function clearRegExpParserCache() {\n regExpAstCache = {};\n}\n//# sourceMappingURL=reg_exp_parser.js.map","import { BaseRegExpVisitor, } from \"@chevrotain/regexp-to-ast\";\nimport { every, find, forEach, includes, isArray, values } from \"lodash-es\";\nimport { PRINT_ERROR, PRINT_WARNING } from \"@chevrotain/utils\";\nimport { getRegExpAst } from \"./reg_exp_parser.js\";\nimport { charCodeToOptimizedIndex, minOptimizationVal } from \"./lexer.js\";\nconst complementErrorMessage = \"Complement Sets are not supported for first char optimization\";\nexport const failedOptimizationPrefixMsg = 'Unable to use \"first char\" lexer optimizations:\\n';\nexport function getOptimizedStartCodesIndices(regExp, ensureOptimizations = false) {\n try {\n const ast = getRegExpAst(regExp);\n const firstChars = firstCharOptimizedIndices(ast.value, {}, ast.flags.ignoreCase);\n return firstChars;\n }\n catch (e) {\n /* istanbul ignore next */\n // Testing this relies on the regexp-to-ast library having a bug... */\n // TODO: only the else branch needs to be ignored, try to fix with newer prettier / tsc\n if (e.message === complementErrorMessage) {\n if (ensureOptimizations) {\n PRINT_WARNING(`${failedOptimizationPrefixMsg}` +\n `\\tUnable to optimize: < ${regExp.toString()} >\\n` +\n \"\\tComplement Sets cannot be automatically optimized.\\n\" +\n \"\\tThis will disable the lexer's first char optimizations.\\n\" +\n \"\\tSee: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#COMPLEMENT for details.\");\n }\n }\n else {\n let msgSuffix = \"\";\n if (ensureOptimizations) {\n msgSuffix =\n \"\\n\\tThis will disable the lexer's first char optimizations.\\n\" +\n \"\\tSee: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#REGEXP_PARSING for details.\";\n }\n PRINT_ERROR(`${failedOptimizationPrefixMsg}\\n` +\n `\\tFailed parsing: < ${regExp.toString()} >\\n` +\n `\\tUsing the @chevrotain/regexp-to-ast library\\n` +\n \"\\tPlease open an issue at: https://github.com/chevrotain/chevrotain/issues\" +\n msgSuffix);\n }\n }\n return [];\n}\nexport function firstCharOptimizedIndices(ast, result, ignoreCase) {\n switch (ast.type) {\n case \"Disjunction\":\n for (let i = 0; i < ast.value.length; i++) {\n firstCharOptimizedIndices(ast.value[i], result, ignoreCase);\n }\n break;\n case \"Alternative\":\n const terms = ast.value;\n for (let i = 0; i < terms.length; i++) {\n const term = terms[i];\n // skip terms that cannot effect the first char results\n switch (term.type) {\n case \"EndAnchor\":\n // A group back reference cannot affect potential starting char.\n // because if a back reference is the first production than automatically\n // the group being referenced has had to come BEFORE so its codes have already been added\n case \"GroupBackReference\":\n // assertions do not affect potential starting codes\n case \"Lookahead\":\n case \"NegativeLookahead\":\n case \"StartAnchor\":\n case \"WordBoundary\":\n case \"NonWordBoundary\":\n continue;\n }\n const atom = term;\n switch (atom.type) {\n case \"Character\":\n addOptimizedIdxToResult(atom.value, result, ignoreCase);\n break;\n case \"Set\":\n if (atom.complement === true) {\n throw Error(complementErrorMessage);\n }\n forEach(atom.value, (code) => {\n if (typeof code === \"number\") {\n addOptimizedIdxToResult(code, result, ignoreCase);\n }\n else {\n // range\n const range = code;\n // cannot optimize when ignoreCase is\n if (ignoreCase === true) {\n for (let rangeCode = range.from; rangeCode <= range.to; rangeCode++) {\n addOptimizedIdxToResult(rangeCode, result, ignoreCase);\n }\n }\n // Optimization (2 orders of magnitude less work for very large ranges)\n else {\n // handle unoptimized values\n for (let rangeCode = range.from; rangeCode <= range.to && rangeCode < minOptimizationVal; rangeCode++) {\n addOptimizedIdxToResult(rangeCode, result, ignoreCase);\n }\n // Less common charCode where we optimize for faster init time, by using larger \"buckets\"\n if (range.to >= minOptimizationVal) {\n const minUnOptVal = range.from >= minOptimizationVal\n ? range.from\n : minOptimizationVal;\n const maxUnOptVal = range.to;\n const minOptIdx = charCodeToOptimizedIndex(minUnOptVal);\n const maxOptIdx = charCodeToOptimizedIndex(maxUnOptVal);\n for (let currOptIdx = minOptIdx; currOptIdx <= maxOptIdx; currOptIdx++) {\n result[currOptIdx] = currOptIdx;\n }\n }\n }\n }\n });\n break;\n case \"Group\":\n firstCharOptimizedIndices(atom.value, result, ignoreCase);\n break;\n /* istanbul ignore next */\n default:\n throw Error(\"Non Exhaustive Match\");\n }\n // reached a mandatory production, no more **start** codes can be found on this alternative\n const isOptionalQuantifier = atom.quantifier !== undefined && atom.quantifier.atLeast === 0;\n if (\n // A group may be optional due to empty contents /(?:)/\n // or if everything inside it is optional /((a)?)/\n (atom.type === \"Group\" && isWholeOptional(atom) === false) ||\n // If this term is not a group it may only be optional if it has an optional quantifier\n (atom.type !== \"Group\" && isOptionalQuantifier === false)) {\n break;\n }\n }\n break;\n /* istanbul ignore next */\n default:\n throw Error(\"non exhaustive match!\");\n }\n // console.log(Object.keys(result).length)\n return values(result);\n}\nfunction addOptimizedIdxToResult(code, result, ignoreCase) {\n const optimizedCharIdx = charCodeToOptimizedIndex(code);\n result[optimizedCharIdx] = optimizedCharIdx;\n if (ignoreCase === true) {\n handleIgnoreCase(code, result);\n }\n}\nfunction handleIgnoreCase(code, result) {\n const char = String.fromCharCode(code);\n const upperChar = char.toUpperCase();\n /* istanbul ignore else */\n if (upperChar !== char) {\n const optimizedCharIdx = charCodeToOptimizedIndex(upperChar.charCodeAt(0));\n result[optimizedCharIdx] = optimizedCharIdx;\n }\n else {\n const lowerChar = char.toLowerCase();\n if (lowerChar !== char) {\n const optimizedCharIdx = charCodeToOptimizedIndex(lowerChar.charCodeAt(0));\n result[optimizedCharIdx] = optimizedCharIdx;\n }\n }\n}\nfunction findCode(setNode, targetCharCodes) {\n return find(setNode.value, (codeOrRange) => {\n if (typeof codeOrRange === \"number\") {\n return includes(targetCharCodes, codeOrRange);\n }\n else {\n // range\n const range = codeOrRange;\n return (find(targetCharCodes, (targetCode) => range.from <= targetCode && targetCode <= range.to) !== undefined);\n }\n });\n}\nfunction isWholeOptional(ast) {\n const quantifier = ast.quantifier;\n if (quantifier && quantifier.atLeast === 0) {\n return true;\n }\n if (!ast.value) {\n return false;\n }\n return isArray(ast.value)\n ? every(ast.value, isWholeOptional)\n : isWholeOptional(ast.value);\n}\nclass CharCodeFinder extends BaseRegExpVisitor {\n constructor(targetCharCodes) {\n super();\n this.targetCharCodes = targetCharCodes;\n this.found = false;\n }\n visitChildren(node) {\n // No need to keep looking...\n if (this.found === true) {\n return;\n }\n // switch lookaheads as they do not actually consume any characters thus\n // finding a charCode at lookahead context does not mean that regexp can actually contain it in a match.\n switch (node.type) {\n case \"Lookahead\":\n this.visitLookahead(node);\n return;\n case \"NegativeLookahead\":\n this.visitNegativeLookahead(node);\n return;\n }\n super.visitChildren(node);\n }\n visitCharacter(node) {\n if (includes(this.targetCharCodes, node.value)) {\n this.found = true;\n }\n }\n visitSet(node) {\n if (node.complement) {\n if (findCode(node, this.targetCharCodes) === undefined) {\n this.found = true;\n }\n }\n else {\n if (findCode(node, this.targetCharCodes) !== undefined) {\n this.found = true;\n }\n }\n }\n}\nexport function canMatchCharCode(charCodes, pattern) {\n if (pattern instanceof RegExp) {\n const ast = getRegExpAst(pattern);\n const charCodeFinder = new CharCodeFinder(charCodes);\n charCodeFinder.visit(ast);\n return charCodeFinder.found;\n }\n else {\n return (find(pattern, (char) => {\n return includes(charCodes, char.charCodeAt(0));\n }) !== undefined);\n }\n}\n//# sourceMappingURL=reg_exp.js.map","import { BaseRegExpVisitor } from \"@chevrotain/regexp-to-ast\";\nimport { Lexer, LexerDefinitionErrorType, } from \"./lexer_public.js\";\nimport { compact, defaults, difference, filter, find, first, flatten, forEach, has, includes, indexOf, isArray, isEmpty, isFunction, isRegExp, isString, isUndefined, keys, map, reduce, reject, values, } from \"lodash-es\";\nimport { PRINT_ERROR } from \"@chevrotain/utils\";\nimport { canMatchCharCode, failedOptimizationPrefixMsg, getOptimizedStartCodesIndices, } from \"./reg_exp.js\";\nimport { getRegExpAst } from \"./reg_exp_parser.js\";\nconst PATTERN = \"PATTERN\";\nexport const DEFAULT_MODE = \"defaultMode\";\nexport const MODES = \"modes\";\nexport let SUPPORT_STICKY = typeof new RegExp(\"(?:)\").sticky === \"boolean\";\nexport function disableSticky() {\n SUPPORT_STICKY = false;\n}\nexport function enableSticky() {\n SUPPORT_STICKY = true;\n}\nexport function analyzeTokenTypes(tokenTypes, options) {\n options = defaults(options, {\n useSticky: SUPPORT_STICKY,\n debug: false,\n safeMode: false,\n positionTracking: \"full\",\n lineTerminatorCharacters: [\"\\r\", \"\\n\"],\n tracer: (msg, action) => action(),\n });\n const tracer = options.tracer;\n tracer(\"initCharCodeToOptimizedIndexMap\", () => {\n initCharCodeToOptimizedIndexMap();\n });\n let onlyRelevantTypes;\n tracer(\"Reject Lexer.NA\", () => {\n onlyRelevantTypes = reject(tokenTypes, (currType) => {\n return currType[PATTERN] === Lexer.NA;\n });\n });\n let hasCustom = false;\n let allTransformedPatterns;\n tracer(\"Transform Patterns\", () => {\n hasCustom = false;\n allTransformedPatterns = map(onlyRelevantTypes, (currType) => {\n const currPattern = currType[PATTERN];\n /* istanbul ignore else */\n if (isRegExp(currPattern)) {\n const regExpSource = currPattern.source;\n if (regExpSource.length === 1 &&\n // only these regExp meta characters which can appear in a length one regExp\n regExpSource !== \"^\" &&\n regExpSource !== \"$\" &&\n regExpSource !== \".\" &&\n !currPattern.ignoreCase) {\n return regExpSource;\n }\n else if (regExpSource.length === 2 &&\n regExpSource[0] === \"\\\\\" &&\n // not a meta character\n !includes([\n \"d\",\n \"D\",\n \"s\",\n \"S\",\n \"t\",\n \"r\",\n \"n\",\n \"t\",\n \"0\",\n \"c\",\n \"b\",\n \"B\",\n \"f\",\n \"v\",\n \"w\",\n \"W\",\n ], regExpSource[1])) {\n // escaped meta Characters: /\\+/ /\\[/\n // or redundant escaping: /\\a/\n // without the escaping \"\\\"\n return regExpSource[1];\n }\n else {\n return options.useSticky\n ? addStickyFlag(currPattern)\n : addStartOfInput(currPattern);\n }\n }\n else if (isFunction(currPattern)) {\n hasCustom = true;\n // CustomPatternMatcherFunc - custom patterns do not require any transformations, only wrapping in a RegExp Like object\n return { exec: currPattern };\n }\n else if (typeof currPattern === \"object\") {\n hasCustom = true;\n // ICustomPattern\n return currPattern;\n }\n else if (typeof currPattern === \"string\") {\n if (currPattern.length === 1) {\n return currPattern;\n }\n else {\n const escapedRegExpString = currPattern.replace(/[\\\\^$.*+?()[\\]{}|]/g, \"\\\\$&\");\n const wrappedRegExp = new RegExp(escapedRegExpString);\n return options.useSticky\n ? addStickyFlag(wrappedRegExp)\n : addStartOfInput(wrappedRegExp);\n }\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n });\n });\n let patternIdxToType;\n let patternIdxToGroup;\n let patternIdxToLongerAltIdxArr;\n let patternIdxToPushMode;\n let patternIdxToPopMode;\n tracer(\"misc mapping\", () => {\n patternIdxToType = map(onlyRelevantTypes, (currType) => currType.tokenTypeIdx);\n patternIdxToGroup = map(onlyRelevantTypes, (clazz) => {\n const groupName = clazz.GROUP;\n /* istanbul ignore next */\n if (groupName === Lexer.SKIPPED) {\n return undefined;\n }\n else if (isString(groupName)) {\n return groupName;\n }\n else if (isUndefined(groupName)) {\n return false;\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n });\n patternIdxToLongerAltIdxArr = map(onlyRelevantTypes, (clazz) => {\n const longerAltType = clazz.LONGER_ALT;\n if (longerAltType) {\n const longerAltIdxArr = isArray(longerAltType)\n ? map(longerAltType, (type) => indexOf(onlyRelevantTypes, type))\n : [indexOf(onlyRelevantTypes, longerAltType)];\n return longerAltIdxArr;\n }\n });\n patternIdxToPushMode = map(onlyRelevantTypes, (clazz) => clazz.PUSH_MODE);\n patternIdxToPopMode = map(onlyRelevantTypes, (clazz) => has(clazz, \"POP_MODE\"));\n });\n let patternIdxToCanLineTerminator;\n tracer(\"Line Terminator Handling\", () => {\n const lineTerminatorCharCodes = getCharCodes(options.lineTerminatorCharacters);\n patternIdxToCanLineTerminator = map(onlyRelevantTypes, (tokType) => false);\n if (options.positionTracking !== \"onlyOffset\") {\n patternIdxToCanLineTerminator = map(onlyRelevantTypes, (tokType) => {\n if (has(tokType, \"LINE_BREAKS\")) {\n return !!tokType.LINE_BREAKS;\n }\n else {\n return (checkLineBreaksIssues(tokType, lineTerminatorCharCodes) === false &&\n canMatchCharCode(lineTerminatorCharCodes, tokType.PATTERN));\n }\n });\n }\n });\n let patternIdxToIsCustom;\n let patternIdxToShort;\n let emptyGroups;\n let patternIdxToConfig;\n tracer(\"Misc Mapping #2\", () => {\n patternIdxToIsCustom = map(onlyRelevantTypes, isCustomPattern);\n patternIdxToShort = map(allTransformedPatterns, isShortPattern);\n emptyGroups = reduce(onlyRelevantTypes, (acc, clazz) => {\n const groupName = clazz.GROUP;\n if (isString(groupName) && !(groupName === Lexer.SKIPPED)) {\n acc[groupName] = [];\n }\n return acc;\n }, {});\n patternIdxToConfig = map(allTransformedPatterns, (x, idx) => {\n return {\n pattern: allTransformedPatterns[idx],\n longerAlt: patternIdxToLongerAltIdxArr[idx],\n canLineTerminator: patternIdxToCanLineTerminator[idx],\n isCustom: patternIdxToIsCustom[idx],\n short: patternIdxToShort[idx],\n group: patternIdxToGroup[idx],\n push: patternIdxToPushMode[idx],\n pop: patternIdxToPopMode[idx],\n tokenTypeIdx: patternIdxToType[idx],\n tokenType: onlyRelevantTypes[idx],\n };\n });\n });\n let canBeOptimized = true;\n let charCodeToPatternIdxToConfig = [];\n if (!options.safeMode) {\n tracer(\"First Char Optimization\", () => {\n charCodeToPatternIdxToConfig = reduce(onlyRelevantTypes, (result, currTokType, idx) => {\n if (typeof currTokType.PATTERN === \"string\") {\n const charCode = currTokType.PATTERN.charCodeAt(0);\n const optimizedIdx = charCodeToOptimizedIndex(charCode);\n addToMapOfArrays(result, optimizedIdx, patternIdxToConfig[idx]);\n }\n else if (isArray(currTokType.START_CHARS_HINT)) {\n let lastOptimizedIdx;\n forEach(currTokType.START_CHARS_HINT, (charOrInt) => {\n const charCode = typeof charOrInt === \"string\"\n ? charOrInt.charCodeAt(0)\n : charOrInt;\n const currOptimizedIdx = charCodeToOptimizedIndex(charCode);\n // Avoid adding the config multiple times\n /* istanbul ignore else */\n // - Difficult to check this scenario effects as it is only a performance\n // optimization that does not change correctness\n if (lastOptimizedIdx !== currOptimizedIdx) {\n lastOptimizedIdx = currOptimizedIdx;\n addToMapOfArrays(result, currOptimizedIdx, patternIdxToConfig[idx]);\n }\n });\n }\n else if (isRegExp(currTokType.PATTERN)) {\n if (currTokType.PATTERN.unicode) {\n canBeOptimized = false;\n if (options.ensureOptimizations) {\n PRINT_ERROR(`${failedOptimizationPrefixMsg}` +\n `\\tUnable to analyze < ${currTokType.PATTERN.toString()} > pattern.\\n` +\n \"\\tThe regexp unicode flag is not currently supported by the regexp-to-ast library.\\n\" +\n \"\\tThis will disable the lexer's first char optimizations.\\n\" +\n \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNICODE_OPTIMIZE\");\n }\n }\n else {\n const optimizedCodes = getOptimizedStartCodesIndices(currTokType.PATTERN, options.ensureOptimizations);\n /* istanbul ignore if */\n // start code will only be empty given an empty regExp or failure of regexp-to-ast library\n // the first should be a different validation and the second cannot be tested.\n if (isEmpty(optimizedCodes)) {\n // we cannot understand what codes may start possible matches\n // The optimization correctness requires knowing start codes for ALL patterns.\n // Not actually sure this is an error, no debug message\n canBeOptimized = false;\n }\n forEach(optimizedCodes, (code) => {\n addToMapOfArrays(result, code, patternIdxToConfig[idx]);\n });\n }\n }\n else {\n if (options.ensureOptimizations) {\n PRINT_ERROR(`${failedOptimizationPrefixMsg}` +\n `\\tTokenType: <${currTokType.name}> is using a custom token pattern without providing <start_chars_hint> parameter.\\n` +\n \"\\tThis will disable the lexer's first char optimizations.\\n\" +\n \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_OPTIMIZE\");\n }\n canBeOptimized = false;\n }\n return result;\n }, []);\n });\n }\n return {\n emptyGroups: emptyGroups,\n patternIdxToConfig: patternIdxToConfig,\n charCodeToPatternIdxToConfig: charCodeToPatternIdxToConfig,\n hasCustom: hasCustom,\n canBeOptimized: canBeOptimized,\n };\n}\nexport function validatePatterns(tokenTypes, validModesNames) {\n let errors = [];\n const missingResult = findMissingPatterns(tokenTypes);\n errors = errors.concat(missingResult.errors);\n const invalidResult = findInvalidPatterns(missingResult.valid);\n const validTokenTypes = invalidResult.valid;\n errors = errors.concat(invalidResult.errors);\n errors = errors.concat(validateRegExpPattern(validTokenTypes));\n errors = errors.concat(findInvalidGroupType(validTokenTypes));\n errors = errors.concat(findModesThatDoNotExist(validTokenTypes, validModesNames));\n errors = errors.concat(findUnreachablePatterns(validTokenTypes));\n return errors;\n}\nfunction validateRegExpPattern(tokenTypes) {\n let errors = [];\n const withRegExpPatterns = filter(tokenTypes, (currTokType) => isRegExp(currTokType[PATTERN]));\n errors = errors.concat(findEndOfInputAnchor(withRegExpPatterns));\n errors = errors.concat(findStartOfInputAnchor(withRegExpPatterns));\n errors = errors.concat(findUnsupportedFlags(withRegExpPatterns));\n errors = errors.concat(findDuplicatePatterns(withRegExpPatterns));\n errors = errors.concat(findEmptyMatchRegExps(withRegExpPatterns));\n return errors;\n}\nexport function findMissingPatterns(tokenTypes) {\n const tokenTypesWithMissingPattern = filter(tokenTypes, (currType) => {\n return !has(currType, PATTERN);\n });\n const errors = map(tokenTypesWithMissingPattern, (currType) => {\n return {\n message: \"Token Type: ->\" +\n currType.name +\n \"<- missing static 'PATTERN' property\",\n type: LexerDefinitionErrorType.MISSING_PATTERN,\n tokenTypes: [currType],\n };\n });\n const valid = difference(tokenTypes, tokenTypesWithMissingPattern);\n return { errors, valid };\n}\nexport function findInvalidPatterns(tokenTypes) {\n const tokenTypesWithInvalidPattern = filter(tokenTypes, (currType) => {\n const pattern = currType[PATTERN];\n return (!isRegExp(pattern) &&\n !isFunction(pattern) &&\n !has(pattern, \"exec\") &&\n !isString(pattern));\n });\n const errors = map(tokenTypesWithInvalidPattern, (currType) => {\n return {\n message: \"Token Type: ->\" +\n currType.name +\n \"<- static 'PATTERN' can only be a RegExp, a\" +\n \" Function matching the {CustomPatternMatcherFunc} type or an Object matching the {ICustomPattern} interface.\",\n type: LexerDefinitionErrorType.INVALID_PATTERN,\n tokenTypes: [currType],\n };\n });\n const valid = difference(tokenTypes, tokenTypesWithInvalidPattern);\n return { errors, valid };\n}\nconst end_of_input = /[^\\\\][$]/;\nexport function findEndOfInputAnchor(tokenTypes) {\n class EndAnchorFinder extends BaseRegExpVisitor {\n constructor() {\n super(...arguments);\n this.found = false;\n }\n visitEndAnchor(node) {\n this.found = true;\n }\n }\n const invalidRegex = filter(tokenTypes, (currType) => {\n const pattern = currType.PATTERN;\n try {\n const regexpAst = getRegExpAst(pattern);\n const endAnchorVisitor = new EndAnchorFinder();\n endAnchorVisitor.visit(regexpAst);\n return endAnchorVisitor.found;\n }\n catch (e) {\n // old behavior in case of runtime exceptions with regexp-to-ast.\n /* istanbul ignore next - cannot ensure an error in regexp-to-ast*/\n return end_of_input.test(pattern.source);\n }\n });\n const errors = map(invalidRegex, (currType) => {\n return {\n message: \"Unexpected RegExp Anchor Error:\\n\" +\n \"\\tToken Type: ->\" +\n currType.name +\n \"<- static 'PATTERN' cannot contain end of input anchor '$'\\n\" +\n \"\\tSee chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS\" +\n \"\\tfor details.\",\n type: LexerDefinitionErrorType.EOI_ANCHOR_FOUND,\n tokenTypes: [currType],\n };\n });\n return errors;\n}\nexport function findEmptyMatchRegExps(tokenTypes) {\n const matchesEmptyString = filter(tokenTypes, (currType) => {\n const pattern = currType.PATTERN;\n return pattern.test(\"\");\n });\n const errors = map(matchesEmptyString, (currType) => {\n return {\n message: \"Token Type: ->\" +\n currType.name +\n \"<- static 'PATTERN' must not match an empty string\",\n type: LexerDefinitionErrorType.EMPTY_MATCH_PATTERN,\n tokenTypes: [currType],\n };\n });\n return errors;\n}\nconst start_of_input = /[^\\\\[][\\^]|^\\^/;\nexport function findStartOfInputAnchor(tokenTypes) {\n class StartAnchorFinder extends BaseRegExpVisitor {\n constructor() {\n super(...arguments);\n this.found = false;\n }\n visitStartAnchor(node) {\n this.found = true;\n }\n }\n const invalidRegex = filter(tokenTypes, (currType) => {\n const pattern = currType.PATTERN;\n try {\n const regexpAst = getRegExpAst(pattern);\n const startAnchorVisitor = new StartAnchorFinder();\n startAnchorVisitor.visit(regexpAst);\n return startAnchorVisitor.found;\n }\n catch (e) {\n // old behavior in case of runtime exceptions with regexp-to-ast.\n /* istanbul ignore next - cannot ensure an error in regexp-to-ast*/\n return start_of_input.test(pattern.source);\n }\n });\n const errors = map(invalidRegex, (currType) => {\n return {\n message: \"Unexpected RegExp Anchor Error:\\n\" +\n \"\\tToken Type: ->\" +\n currType.name +\n \"<- static 'PATTERN' cannot contain start of input anchor '^'\\n\" +\n \"\\tSee https://chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS\" +\n \"\\tfor details.\",\n type: LexerDefinitionErrorType.SOI_ANCHOR_FOUND,\n tokenTypes: [currType],\n };\n });\n return errors;\n}\nexport function findUnsupportedFlags(tokenTypes) {\n const invalidFlags = filter(tokenTypes, (currType) => {\n const pattern = currType[PATTERN];\n return pattern instanceof RegExp && (pattern.multiline || pattern.global);\n });\n const errors = map(invalidFlags, (currType) => {\n return {\n message: \"Token Type: ->\" +\n currType.name +\n \"<- static 'PATTERN' may NOT contain global('g') or multiline('m')\",\n type: LexerDefinitionErrorType.UNSUPPORTED_FLAGS_FOUND,\n tokenTypes: [currType],\n };\n });\n return errors;\n}\n// This can only test for identical duplicate RegExps, not semantically equivalent ones.\nexport function findDuplicatePatterns(tokenTypes) {\n const found = [];\n let identicalPatterns = map(tokenTypes, (outerType) => {\n return reduce(tokenTypes, (result, innerType) => {\n if (outerType.PATTERN.source === innerType.PATTERN.source &&\n !includes(found, innerType) &&\n innerType.PATTERN !== Lexer.NA) {\n // this avoids duplicates in the result, each Token Type may only appear in one \"set\"\n // in essence we are creating Equivalence classes on equality relation.\n found.push(innerType);\n result.push(innerType);\n return result;\n }\n return result;\n }, []);\n });\n identicalPatterns = compact(identicalPatterns);\n const duplicatePatterns = filter(identicalPatterns, (currIdenticalSet) => {\n return currIdenticalSet.length > 1;\n });\n const errors = map(duplicatePatterns, (setOfIdentical) => {\n const tokenTypeNames = map(setOfIdentical, (currType) => {\n return currType.name;\n });\n const dupPatternSrc = first(setOfIdentical).PATTERN;\n return {\n message: `The same RegExp pattern ->${dupPatternSrc}<-` +\n `has been used in all of the following Token Types: ${tokenTypeNames.join(\", \")} <-`,\n type: LexerDefinitionErrorType.DUPLICATE_PATTERNS_FOUND,\n tokenTypes: setOfIdentical,\n };\n });\n return errors;\n}\nexport function findInvalidGroupType(tokenTypes) {\n const invalidTypes = filter(tokenTypes, (clazz) => {\n if (!has(clazz, \"GROUP\")) {\n return false;\n }\n const group = clazz.GROUP;\n return group !== Lexer.SKIPPED && group !== Lexer.NA && !isString(group);\n });\n const errors = map(invalidTypes, (currType) => {\n return {\n message: \"Token Type: ->\" +\n currType.name +\n \"<- static 'GROUP' can only be Lexer.SKIPPED/Lexer.NA/A String\",\n type: LexerDefinitionErrorType.INVALID_GROUP_TYPE_FOUND,\n tokenTypes: [currType],\n };\n });\n return errors;\n}\nexport function findModesThatDoNotExist(tokenTypes, validModes) {\n const invalidModes = filter(tokenTypes, (clazz) => {\n return (clazz.PUSH_MODE !== undefined && !includes(validModes, clazz.PUSH_MODE));\n });\n const errors = map(invalidModes, (tokType) => {\n const msg = `Token Type: ->${tokType.name}<- static 'PUSH_MODE' value cannot refer to a Lexer Mode ->${tokType.PUSH_MODE}<-` +\n `which does not exist`;\n return {\n message: msg,\n type: LexerDefinitionErrorType.PUSH_MODE_DOES_NOT_EXIST,\n tokenTypes: [tokType],\n };\n });\n return errors;\n}\nexport function findUnreachablePatterns(tokenTypes) {\n const errors = [];\n const canBeTested = reduce(tokenTypes, (result, tokType, idx) => {\n const pattern = tokType.PATTERN;\n if (pattern === Lexer.NA) {\n return result;\n }\n // a more comprehensive validation for all forms of regExps would require\n // deeper regExp analysis capabilities\n if (isString(pattern)) {\n result.push({ str: pattern, idx, tokenType: tokType });\n }\n else if (isRegExp(pattern) && noMetaChar(pattern)) {\n result.push({ str: pattern.source, idx, tokenType: tokType });\n }\n return result;\n }, []);\n forEach(tokenTypes, (tokType, testIdx) => {\n forEach(canBeTested, ({ str, idx, tokenType }) => {\n if (testIdx < idx && testTokenType(str, tokType.PATTERN)) {\n const msg = `Token: ->${tokenType.name}<- can never be matched.\\n` +\n `Because it appears AFTER the Token Type ->${tokType.name}<-` +\n `in the lexer's definition.\\n` +\n `See https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNREACHABLE`;\n errors.push({\n message: msg,\n type: LexerDefinitionErrorType.UNREACHABLE_PATTERN,\n tokenTypes: [tokType, tokenType],\n });\n }\n });\n });\n return errors;\n}\nfunction testTokenType(str, pattern) {\n /* istanbul ignore else */\n if (isRegExp(pattern)) {\n const regExpArray = pattern.exec(str);\n return regExpArray !== null && regExpArray.index === 0;\n }\n else if (isFunction(pattern)) {\n // maintain the API of custom patterns\n return pattern(str, 0, [], {});\n }\n else if (has(pattern, \"exec\")) {\n // maintain the API of custom patterns\n return pattern.exec(str, 0, [], {});\n }\n else if (typeof pattern === \"string\") {\n return pattern === str;\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n}\nfunction noMetaChar(regExp) {\n //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp\n const metaChars = [\n \".\",\n \"\\\\\",\n \"[\",\n \"]\",\n \"|\",\n \"^\",\n \"$\",\n \"(\",\n \")\",\n \"?\",\n \"*\",\n \"+\",\n \"{\",\n ];\n return (find(metaChars, (char) => regExp.source.indexOf(char) !== -1) === undefined);\n}\nexport function addStartOfInput(pattern) {\n const flags = pattern.ignoreCase ? \"i\" : \"\";\n // always wrapping in a none capturing group preceded by '^' to make sure matching can only work on start of input.\n // duplicate/redundant start of input markers have no meaning (/^^^^A/ === /^A/)\n return new RegExp(`^(?:${pattern.source})`, flags);\n}\nexport function addStickyFlag(pattern) {\n const flags = pattern.ignoreCase ? \"iy\" : \"y\";\n // always wrapping in a none capturing group preceded by '^' to make sure matching can only work on start of input.\n // duplicate/redundant start of input markers have no meaning (/^^^^A/ === /^A/)\n return new RegExp(`${pattern.source}`, flags);\n}\nexport function performRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharacters) {\n const errors = [];\n // some run time checks to help the end users.\n if (!has(lexerDefinition, DEFAULT_MODE)) {\n errors.push({\n message: \"A MultiMode Lexer cannot be initialized without a <\" +\n DEFAULT_MODE +\n \"> property in its definition\\n\",\n type: LexerDefinitionErrorType.MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE,\n });\n }\n if (!has(lexerDefinition, MODES)) {\n errors.push({\n message: \"A MultiMode Lexer cannot be initialized without a <\" +\n MODES +\n \"> property in its definition\\n\",\n type: LexerDefinitionErrorType.MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY,\n });\n }\n if (has(lexerDefinition, MODES) &&\n has(lexerDefinition, DEFAULT_MODE) &&\n !has(lexerDefinition.modes, lexerDefinition.defaultMode)) {\n errors.push({\n message: `A MultiMode Lexer cannot be initialized with a ${DEFAULT_MODE}: <${lexerDefinition.defaultMode}>` +\n `which does not exist\\n`,\n type: LexerDefinitionErrorType.MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST,\n });\n }\n if (has(lexerDefinition, MODES)) {\n forEach(lexerDefinition.modes, (currModeValue, currModeName) => {\n forEach(currModeValue, (currTokType, currIdx) => {\n if (isUndefined(currTokType)) {\n errors.push({\n message: `A Lexer cannot be initialized using an undefined Token Type. Mode:` +\n `<${currModeName}> at index: <${currIdx}>\\n`,\n type: LexerDefinitionErrorType.LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED,\n });\n }\n else if (has(currTokType, \"LONGER_ALT\")) {\n const longerAlt = isArray(currTokType.LONGER_ALT)\n ? currTokType.LONGER_ALT\n : [currTokType.LONGER_ALT];\n forEach(longerAlt, (currLongerAlt) => {\n if (!isUndefined(currLongerAlt) &&\n !includes(currModeValue, currLongerAlt)) {\n errors.push({\n message: `A MultiMode Lexer cannot be initialized with a longer_alt <${currLongerAlt.name}> on token <${currTokType.name}> outside of mode <${currModeName}>\\n`,\n type: LexerDefinitionErrorType.MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE,\n });\n }\n });\n }\n });\n });\n }\n return errors;\n}\nexport function performWarningRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharacters) {\n const warnings = [];\n let hasAnyLineBreak = false;\n const allTokenTypes = compact(flatten(values(lexerDefinition.modes)));\n const concreteTokenTypes = reject(allTokenTypes, (currType) => currType[PATTERN] === Lexer.NA);\n const terminatorCharCodes = getCharCodes(lineTerminatorCharacters);\n if (trackLines) {\n forEach(concreteTokenTypes, (tokType) => {\n const currIssue = checkLineBreaksIssues(tokType, terminatorCharCodes);\n if (currIssue !== false) {\n const message = buildLineBreakIssueMessage(tokType, currIssue);\n const warningDescriptor = {\n message,\n type: currIssue.issue,\n tokenType: tokType,\n };\n warnings.push(warningDescriptor);\n }\n else {\n // we don't want to attempt to scan if the user explicitly specified the line_breaks option.\n if (has(tokType, \"LINE_BREAKS\")) {\n if (tokType.LINE_BREAKS === true) {\n hasAnyLineBreak = true;\n }\n }\n else {\n if (canMatchCharCode(terminatorCharCodes, tokType.PATTERN)) {\n hasAnyLineBreak = true;\n }\n }\n }\n });\n }\n if (trackLines && !hasAnyLineBreak) {\n warnings.push({\n message: \"Warning: No LINE_BREAKS Found.\\n\" +\n \"\\tThis Lexer has been defined to track line and column information,\\n\" +\n \"\\tBut none of the Token Types can be identified as matching a line terminator.\\n\" +\n \"\\tSee https://chevrotain.io/docs/guide/resolving_lexer_errors.html#LINE_BREAKS \\n\" +\n \"\\tfor details.\",\n type: LexerDefinitionErrorType.NO_LINE_BREAKS_FLAGS,\n });\n }\n return warnings;\n}\nexport function cloneEmptyGroups(emptyGroups) {\n const clonedResult = {};\n const groupKeys = keys(emptyGroups);\n forEach(groupKeys, (currKey) => {\n const currGroupValue = emptyGroups[currKey];\n /* istanbul ignore else */\n if (isArray(currGroupValue)) {\n clonedResult[currKey] = [];\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n });\n return clonedResult;\n}\n// TODO: refactor to avoid duplication\nexport function isCustomPattern(tokenType) {\n const pattern = tokenType.PATTERN;\n /* istanbul ignore else */\n if (isRegExp(pattern)) {\n return false;\n }\n else if (isFunction(pattern)) {\n // CustomPatternMatcherFunc - custom patterns do not require any transformations, only wrapping in a RegExp Like object\n return true;\n }\n else if (has(pattern, \"exec\")) {\n // ICustomPattern\n return true;\n }\n else if (isString(pattern)) {\n return false;\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n}\nexport function isShortPattern(pattern) {\n if (isString(pattern) && pattern.length === 1) {\n return pattern.charCodeAt(0);\n }\n else {\n return false;\n }\n}\n/**\n * Faster than using a RegExp for default newline detection during lexing.\n */\nexport const LineTerminatorOptimizedTester = {\n // implements /\\n|\\r\\n?/g.test\n test: function (text) {\n const len = text.length;\n for (let i = this.lastIndex; i < len; i++) {\n const c = text.charCodeAt(i);\n if (c === 10) {\n this.lastIndex = i + 1;\n return true;\n }\n else if (c === 13) {\n if (text.charCodeAt(i + 1) === 10) {\n this.lastIndex = i + 2;\n }\n else {\n this.lastIndex = i + 1;\n }\n return true;\n }\n }\n return false;\n },\n lastIndex: 0,\n};\nfunction checkLineBreaksIssues(tokType, lineTerminatorCharCodes) {\n if (has(tokType, \"LINE_BREAKS\")) {\n // if the user explicitly declared the line_breaks option we will respect their choice\n // and assume it is correct.\n return false;\n }\n else {\n /* istanbul ignore else */\n if (isRegExp(tokType.PATTERN)) {\n try {\n // TODO: why is the casting suddenly needed?\n canMatchCharCode(lineTerminatorCharCodes, tokType.PATTERN);\n }\n catch (e) {\n /* istanbul ignore next - to test this we would have to mock <canMatchCharCode> to throw an error */\n return {\n issue: LexerDefinitionErrorType.IDENTIFY_TERMINATOR,\n errMsg: e.message,\n };\n }\n return false;\n }\n else if (isString(tokType.PATTERN)) {\n // string literal patterns can always be analyzed to detect line terminator usage\n return false;\n }\n else if (isCustomPattern(tokType)) {\n // custom token types\n return { issue: LexerDefinitionErrorType.CUSTOM_LINE_BREAK };\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n }\n}\nexport function buildLineBreakIssueMessage(tokType, details) {\n /* istanbul ignore else */\n if (details.issue === LexerDefinitionErrorType.IDENTIFY_TERMINATOR) {\n return (\"Warning: unable to identify line terminator usage in pattern.\\n\" +\n `\\tThe problem is in the <${tokType.name}> Token Type\\n` +\n `\\t Root cause: ${details.errMsg}.\\n` +\n \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#IDENTIFY_TERMINATOR\");\n }\n else if (details.issue === LexerDefinitionErrorType.CUSTOM_LINE_BREAK) {\n return (\"Warning: A Custom Token Pattern should specify the <line_breaks> option.\\n\" +\n `\\tThe problem is in the <${tokType.name}> Token Type\\n` +\n \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_LINE_BREAK\");\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n}\nfunction getCharCodes(charsOrCodes) {\n const charCodes = map(charsOrCodes, (numOrString) => {\n if (isString(numOrString)) {\n return numOrString.charCodeAt(0);\n }\n else {\n return numOrString;\n }\n });\n return charCodes;\n}\nfunction addToMapOfArrays(map, key, value) {\n if (map[key] === undefined) {\n map[key] = [value];\n }\n else {\n map[key].push(value);\n }\n}\nexport const minOptimizationVal = 256;\n/**\n * We are mapping charCode above ASCI (256) into buckets each in the size of 256.\n * This is because ASCI are the most common start chars so each one of those will get its own\n * possible token configs vector.\n *\n * Tokens starting with charCodes \"above\" ASCI are uncommon, so we can \"afford\"\n * to place these into buckets of possible token configs, What we gain from\n * this is avoiding the case of creating an optimization 'charCodeToPatternIdxToConfig'\n * which would contain 10,000+ arrays of small size (e.g unicode Identifiers scenario).\n * Our 'charCodeToPatternIdxToConfig' max size will now be:\n * 256 + (2^16 / 2^8) - 1 === 511\n *\n * note the hack for fast division integer part extraction\n * See: https://stackoverflow.com/a/4228528\n */\nlet charCodeToOptimizedIdxMap = [];\nexport function charCodeToOptimizedIndex(charCode) {\n return charCode < minOptimizationVal\n ? charCode\n : charCodeToOptimizedIdxMap[charCode];\n}\n/**\n * This is a compromise between cold start / hot running performance\n * Creating this array takes ~3ms on a modern machine,\n * But if we perform the computation at runtime as needed the CSS Lexer benchmark\n * performance degrades by ~10%\n *\n * TODO: Perhaps it should be lazy initialized only if a charCode > 255 is used.\n */\nfunction initCharCodeToOptimizedIndexMap() {\n if (isEmpty(charCodeToOptimizedIdxMap)) {\n charCodeToOptimizedIdxMap = new Array(65536);\n for (let i = 0; i < 65536; i++) {\n charCodeToOptimizedIdxMap[i] = i > 255 ? 255 + ~~(i / 255) : i;\n }\n }\n}\n//# sourceMappingURL=lexer.js.map","import { clone, compact, difference, flatten, forEach, has, includes, isArray, isEmpty, map, } from \"lodash-es\";\nexport function tokenStructuredMatcher(tokInstance, tokConstructor) {\n const instanceType = tokInstance.tokenTypeIdx;\n if (instanceType === tokConstructor.tokenTypeIdx) {\n return true;\n }\n else {\n return (tokConstructor.isParent === true &&\n tokConstructor.categoryMatchesMap[instanceType] === true);\n }\n}\n// Optimized tokenMatcher in case our grammar does not use token categories\n// Being so tiny it is much more likely to be in-lined and this avoid the function call overhead\nexport function tokenStructuredMatcherNoCategories(token, tokType) {\n return token.tokenTypeIdx === tokType.tokenTypeIdx;\n}\nexport let tokenShortNameIdx = 1;\nexport const tokenIdxToClass = {};\nexport function augmentTokenTypes(tokenTypes) {\n // collect the parent Token Types as well.\n const tokenTypesAndParents = expandCategories(tokenTypes);\n // add required tokenType and categoryMatches properties\n assignTokenDefaultProps(tokenTypesAndParents);\n // fill up the categoryMatches\n assignCategoriesMapProp(tokenTypesAndParents);\n assignCategoriesTokensProp(tokenTypesAndParents);\n forEach(tokenTypesAndParents, (tokType) => {\n tokType.isParent = tokType.categoryMatches.length > 0;\n });\n}\nexport function expandCategories(tokenTypes) {\n let result = clone(tokenTypes);\n let categories = tokenTypes;\n let searching = true;\n while (searching) {\n categories = compact(flatten(map(categories, (currTokType) => currTokType.CATEGORIES)));\n const newCategories = difference(categories, result);\n result = result.concat(newCategories);\n if (isEmpty(newCategories)) {\n searching = false;\n }\n else {\n categories = newCategories;\n }\n }\n return result;\n}\nexport function assignTokenDefaultProps(tokenTypes) {\n forEach(tokenTypes, (currTokType) => {\n if (!hasShortKeyProperty(currTokType)) {\n tokenIdxToClass[tokenShortNameIdx] = currTokType;\n currTokType.tokenTypeIdx = tokenShortNameIdx++;\n }\n // CATEGORIES? : TokenType | TokenType[]\n if (hasCategoriesProperty(currTokType) &&\n !isArray(currTokType.CATEGORIES)\n // &&\n // !isUndefined(currTokType.CATEGORIES.PATTERN)\n ) {\n currTokType.CATEGORIES = [currTokType.CATEGORIES];\n }\n if (!hasCategoriesProperty(currTokType)) {\n currTokType.CATEGORIES = [];\n }\n if (!hasExtendingTokensTypesProperty(currTokType)) {\n currTokType.categoryMatches = [];\n }\n if (!hasExtendingTokensTypesMapProperty(currTokType)) {\n currTokType.categoryMatchesMap = {};\n }\n });\n}\nexport function assignCategoriesTokensProp(tokenTypes) {\n forEach(tokenTypes, (currTokType) => {\n // avoid duplications\n currTokType.categoryMatches = [];\n forEach(currTokType.categoryMatchesMap, (val, key) => {\n currTokType.categoryMatches.push(tokenIdxToClass[key].tokenTypeIdx);\n });\n });\n}\nexport function assignCategoriesMapProp(tokenTypes) {\n forEach(tokenTypes, (currTokType) => {\n singleAssignCategoriesToksMap([], currTokType);\n });\n}\nexport function singleAssignCategoriesToksMap(path, nextNode) {\n forEach(path, (pathNode) => {\n nextNode.categoryMatchesMap[pathNode.tokenTypeIdx] = true;\n });\n forEach(nextNode.CATEGORIES, (nextCategory) => {\n const newPath = path.concat(nextNode);\n // avoids infinite loops due to cyclic categories.\n if (!includes(newPath, nextCategory)) {\n singleAssignCategoriesToksMap(newPath, nextCategory);\n }\n });\n}\nexport function hasShortKeyProperty(tokType) {\n return has(tokType, \"tokenTypeIdx\");\n}\nexport function hasCategoriesProperty(tokType) {\n return has(tokType, \"CATEGORIES\");\n}\nexport function hasExtendingTokensTypesProperty(tokType) {\n return has(tokType, \"categoryMatches\");\n}\nexport function hasExtendingTokensTypesMapProperty(tokType) {\n return has(tokType, \"categoryMatchesMap\");\n}\nexport function isTokenType(tokType) {\n return has(tokType, \"tokenTypeIdx\");\n}\n//# sourceMappingURL=tokens.js.map","export const defaultLexerErrorProvider = {\n buildUnableToPopLexerModeMessage(token) {\n return `Unable to pop Lexer Mode after encountering Token ->${token.image}<- The Mode Stack is empty`;\n },\n buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column) {\n return (`unexpected character: ->${fullText.charAt(startOffset)}<- at offset: ${startOffset},` + ` skipped ${length} characters.`);\n },\n};\n//# sourceMappingURL=lexer_errors_public.js.map","import { analyzeTokenTypes, charCodeToOptimizedIndex, cloneEmptyGroups, DEFAULT_MODE, LineTerminatorOptimizedTester, performRuntimeChecks, performWarningRuntimeChecks, SUPPORT_STICKY, validatePatterns, } from \"./lexer.js\";\nimport { assign, clone, forEach, identity, isArray, isEmpty, isUndefined, keys, last, map, noop, reduce, reject, } from \"lodash-es\";\nimport { PRINT_WARNING, timer, toFastProperties } from \"@chevrotain/utils\";\nimport { augmentTokenTypes } from \"./tokens.js\";\nimport { defaultLexerErrorProvider } from \"./lexer_errors_public.js\";\nimport { clearRegExpParserCache } from \"./reg_exp_parser.js\";\nexport var LexerDefinitionErrorType;\n(function (LexerDefinitionErrorType) {\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"MISSING_PATTERN\"] = 0] = \"MISSING_PATTERN\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"INVALID_PATTERN\"] = 1] = \"INVALID_PATTERN\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"EOI_ANCHOR_FOUND\"] = 2] = \"EOI_ANCHOR_FOUND\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"UNSUPPORTED_FLAGS_FOUND\"] = 3] = \"UNSUPPORTED_FLAGS_FOUND\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"DUPLICATE_PATTERNS_FOUND\"] = 4] = \"DUPLICATE_PATTERNS_FOUND\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"INVALID_GROUP_TYPE_FOUND\"] = 5] = \"INVALID_GROUP_TYPE_FOUND\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"PUSH_MODE_DOES_NOT_EXIST\"] = 6] = \"PUSH_MODE_DOES_NOT_EXIST\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE\"] = 7] = \"MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY\"] = 8] = \"MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST\"] = 9] = \"MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED\"] = 10] = \"LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"SOI_ANCHOR_FOUND\"] = 11] = \"SOI_ANCHOR_FOUND\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"EMPTY_MATCH_PATTERN\"] = 12] = \"EMPTY_MATCH_PATTERN\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"NO_LINE_BREAKS_FLAGS\"] = 13] = \"NO_LINE_BREAKS_FLAGS\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"UNREACHABLE_PATTERN\"] = 14] = \"UNREACHABLE_PATTERN\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"IDENTIFY_TERMINATOR\"] = 15] = \"IDENTIFY_TERMINATOR\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"CUSTOM_LINE_BREAK\"] = 16] = \"CUSTOM_LINE_BREAK\";\n LexerDefinitionErrorType[LexerDefinitionErrorType[\"MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE\"] = 17] = \"MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE\";\n})(LexerDefinitionErrorType || (LexerDefinitionErrorType = {}));\nconst DEFAULT_LEXER_CONFIG = {\n deferDefinitionErrorsHandling: false,\n positionTracking: \"full\",\n lineTerminatorsPattern: /\\n|\\r\\n?/g,\n lineTerminatorCharacters: [\"\\n\", \"\\r\"],\n ensureOptimizations: false,\n safeMode: false,\n errorMessageProvider: defaultLexerErrorProvider,\n traceInitPerf: false,\n skipValidations: false,\n recoveryEnabled: true,\n};\nObject.freeze(DEFAULT_LEXER_CONFIG);\nexport class Lexer {\n constructor(lexerDefinition, config = DEFAULT_LEXER_CONFIG) {\n this.lexerDefinition = lexerDefinition;\n this.lexerDefinitionErrors = [];\n this.lexerDefinitionWarning = [];\n this.patternIdxToConfig = {};\n this.charCodeToPatternIdxToConfig = {};\n this.modes = [];\n this.emptyGroups = {};\n this.trackStartLines = true;\n this.trackEndLines = true;\n this.hasCustom = false;\n this.canModeBeOptimized = {};\n // Duplicated from the parser's perf trace trait to allow future extraction\n // of the lexer to a separate package.\n this.TRACE_INIT = (phaseDesc, phaseImpl) => {\n // No need to optimize this using NOOP pattern because\n // It is not called in a hot spot...\n if (this.traceInitPerf === true) {\n this.traceInitIndent++;\n const indent = new Array(this.traceInitIndent + 1).join(\"\\t\");\n if (this.traceInitIndent < this.traceInitMaxIdent) {\n console.log(`${indent}--> <${phaseDesc}>`);\n }\n const { time, value } = timer(phaseImpl);\n /* istanbul ignore next - Difficult to reproduce specific performance behavior (>10ms) in tests */\n const traceMethod = time > 10 ? console.warn : console.log;\n if (this.traceInitIndent < this.traceInitMaxIdent) {\n traceMethod(`${indent}<-- <${phaseDesc}> time: ${time}ms`);\n }\n this.traceInitIndent--;\n return value;\n }\n else {\n return phaseImpl();\n }\n };\n if (typeof config === \"boolean\") {\n throw Error(\"The second argument to the Lexer constructor is now an ILexerConfig Object.\\n\" +\n \"a boolean 2nd argument is no longer supported\");\n }\n // todo: defaults func?\n this.config = assign({}, DEFAULT_LEXER_CONFIG, config);\n const traceInitVal = this.config.traceInitPerf;\n if (traceInitVal === true) {\n this.traceInitMaxIdent = Infinity;\n this.traceInitPerf = true;\n }\n else if (typeof traceInitVal === \"number\") {\n this.traceInitMaxIdent = traceInitVal;\n this.traceInitPerf = true;\n }\n this.traceInitIndent = -1;\n this.TRACE_INIT(\"Lexer Constructor\", () => {\n let actualDefinition;\n let hasOnlySingleMode = true;\n this.TRACE_INIT(\"Lexer Config handling\", () => {\n if (this.config.lineTerminatorsPattern ===\n DEFAULT_LEXER_CONFIG.lineTerminatorsPattern) {\n // optimized built-in implementation for the defaults definition of lineTerminators\n this.config.lineTerminatorsPattern = LineTerminatorOptimizedTester;\n }\n else {\n if (this.config.lineTerminatorCharacters ===\n DEFAULT_LEXER_CONFIG.lineTerminatorCharacters) {\n throw Error(\"Error: Missing <lineTerminatorCharacters> property on the Lexer config.\\n\" +\n \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#MISSING_LINE_TERM_CHARS\");\n }\n }\n if (config.safeMode && config.ensureOptimizations) {\n throw Error('\"safeMode\" and \"ensureOptimizations\" flags are mutually exclusive.');\n }\n this.trackStartLines = /full|onlyStart/i.test(this.config.positionTracking);\n this.trackEndLines = /full/i.test(this.config.positionTracking);\n // Convert SingleModeLexerDefinition into a IMultiModeLexerDefinition.\n if (isArray(lexerDefinition)) {\n actualDefinition = {\n modes: { defaultMode: clone(lexerDefinition) },\n defaultMode: DEFAULT_MODE,\n };\n }\n else {\n // no conversion needed, input should already be a IMultiModeLexerDefinition\n hasOnlySingleMode = false;\n actualDefinition = clone(lexerDefinition);\n }\n });\n if (this.config.skipValidations === false) {\n this.TRACE_INIT(\"performRuntimeChecks\", () => {\n this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(performRuntimeChecks(actualDefinition, this.trackStartLines, this.config.lineTerminatorCharacters));\n });\n this.TRACE_INIT(\"performWarningRuntimeChecks\", () => {\n this.lexerDefinitionWarning = this.lexerDefinitionWarning.concat(performWarningRuntimeChecks(actualDefinition, this.trackStartLines, this.config.lineTerminatorCharacters));\n });\n }\n // for extra robustness to avoid throwing an none informative error message\n actualDefinition.modes = actualDefinition.modes\n ? actualDefinition.modes\n : {};\n // an error of undefined TokenTypes will be detected in \"performRuntimeChecks\" above.\n // this transformation is to increase robustness in the case of partially invalid lexer definition.\n forEach(actualDefinition.modes, (currModeValue, currModeName) => {\n actualDefinition.modes[currModeName] = reject(currModeValue, (currTokType) => isUndefined(currTokType));\n });\n const allModeNames = keys(actualDefinition.modes);\n forEach(actualDefinition.modes, (currModDef, currModName) => {\n this.TRACE_INIT(`Mode: <${currModName}> processing`, () => {\n this.modes.push(currModName);\n if (this.config.skipValidations === false) {\n this.TRACE_INIT(`validatePatterns`, () => {\n this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(validatePatterns(currModDef, allModeNames));\n });\n }\n // If definition errors were encountered, the analysis phase may fail unexpectedly/\n // Considering a lexer with definition errors may never be used, there is no point\n // to performing the analysis anyhow...\n if (isEmpty(this.lexerDefinitionErrors)) {\n augmentTokenTypes(currModDef);\n let currAnalyzeResult;\n this.TRACE_INIT(`analyzeTokenTypes`, () => {\n currAnalyzeResult = analyzeTokenTypes(currModDef, {\n lineTerminatorCharacters: this.config.lineTerminatorCharacters,\n positionTracking: config.positionTracking,\n ensureOptimizations: config.ensureOptimizations,\n safeMode: config.safeMode,\n tracer: this.TRACE_INIT,\n });\n });\n this.patternIdxToConfig[currModName] =\n currAnalyzeResult.patternIdxToConfig;\n this.charCodeToPatternIdxToConfig[currModName] =\n currAnalyzeResult.charCodeToPatternIdxToConfig;\n this.emptyGroups = assign({}, this.emptyGroups, currAnalyzeResult.emptyGroups);\n this.hasCustom = currAnalyzeResult.hasCustom || this.hasCustom;\n this.canModeBeOptimized[currModName] =\n currAnalyzeResult.canBeOptimized;\n }\n });\n });\n this.defaultMode = actualDefinition.defaultMode;\n if (!isEmpty(this.lexerDefinitionErrors) &&\n !this.config.deferDefinitionErrorsHandling) {\n const allErrMessages = map(this.lexerDefinitionErrors, (error) => {\n return error.message;\n });\n const allErrMessagesString = allErrMessages.join(\"-----------------------\\n\");\n throw new Error(\"Errors detected in definition of Lexer:\\n\" + allErrMessagesString);\n }\n // Only print warning if there are no errors, This will avoid pl\n forEach(this.lexerDefinitionWarning, (warningDescriptor) => {\n PRINT_WARNING(warningDescriptor.message);\n });\n this.TRACE_INIT(\"Choosing sub-methods implementations\", () => {\n // Choose the relevant internal implementations for this specific parser.\n // These implementations should be in-lined by the JavaScript engine\n // to provide optimal performance in each scenario.\n if (SUPPORT_STICKY) {\n this.chopInput = identity;\n this.match = this.matchWithTest;\n }\n else {\n this.updateLastIndex = noop;\n this.match = this.matchWithExec;\n }\n if (hasOnlySingleMode) {\n this.handleModes = noop;\n }\n if (this.trackStartLines === false) {\n this.computeNewColumn = identity;\n }\n if (this.trackEndLines === false) {\n this.updateTokenEndLineColumnLocation = noop;\n }\n if (/full/i.test(this.config.positionTracking)) {\n this.createTokenInstance = this.createFullToken;\n }\n else if (/onlyStart/i.test(this.config.positionTracking)) {\n this.createTokenInstance = this.createStartOnlyToken;\n }\n else if (/onlyOffset/i.test(this.config.positionTracking)) {\n this.createTokenInstance = this.createOffsetOnlyToken;\n }\n else {\n throw Error(`Invalid <positionTracking> config option: \"${this.config.positionTracking}\"`);\n }\n if (this.hasCustom) {\n this.addToken = this.addTokenUsingPush;\n this.handlePayload = this.handlePayloadWithCustom;\n }\n else {\n this.addToken = this.addTokenUsingMemberAccess;\n this.handlePayload = this.handlePayloadNoCustom;\n }\n });\n this.TRACE_INIT(\"Failed Optimization Warnings\", () => {\n const unOptimizedModes = reduce(this.canModeBeOptimized, (cannotBeOptimized, canBeOptimized, modeName) => {\n if (canBeOptimized === false) {\n cannotBeOptimized.push(modeName);\n }\n return cannotBeOptimized;\n }, []);\n if (config.ensureOptimizations && !isEmpty(unOptimizedModes)) {\n throw Error(`Lexer Modes: < ${unOptimizedModes.join(\", \")} > cannot be optimized.\\n` +\n '\\t Disable the \"ensureOptimizations\" lexer config flag to silently ignore this and run the lexer in an un-optimized mode.\\n' +\n \"\\t Or inspect the console log for details on how to resolve these issues.\");\n }\n });\n this.TRACE_INIT(\"clearRegExpParserCache\", () => {\n clearRegExpParserCache();\n });\n this.TRACE_INIT(\"toFastProperties\", () => {\n toFastProperties(this);\n });\n });\n }\n tokenize(text, initialMode = this.defaultMode) {\n if (!isEmpty(this.lexerDefinitionErrors)) {\n const allErrMessages = map(this.lexerDefinitionErrors, (error) => {\n return error.message;\n });\n const allErrMessagesString = allErrMessages.join(\"-----------------------\\n\");\n throw new Error(\"Unable to Tokenize because Errors detected in definition of Lexer:\\n\" +\n allErrMessagesString);\n }\n return this.tokenizeInternal(text, initialMode);\n }\n // There is quite a bit of duplication between this and \"tokenizeInternalLazy\"\n // This is intentional due to performance considerations.\n // this method also used quite a bit of `!` none null assertions because it is too optimized\n // for `tsc` to always understand it is \"safe\"\n tokenizeInternal(text, initialMode) {\n let i, j, k, matchAltImage, longerAlt, matchedImage, payload, altPayload, imageLength, group, tokType, newToken, errLength, droppedChar, msg, match;\n const orgText = text;\n const orgLength = orgText.length;\n let offset = 0;\n let matchedTokensIndex = 0;\n // initializing the tokensArray to the \"guessed\" size.\n // guessing too little will still reduce the number of array re-sizes on pushes.\n // guessing too large (Tested by guessing x4 too large) may cost a bit more of memory\n // but would still have a faster runtime by avoiding (All but one) array resizing.\n const guessedNumberOfTokens = this.hasCustom\n ? 0 // will break custom token pattern APIs the matchedTokens array will contain undefined elements.\n : Math.floor(text.length / 10);\n const matchedTokens = new Array(guessedNumberOfTokens);\n const errors = [];\n let line = this.trackStartLines ? 1 : undefined;\n let column = this.trackStartLines ? 1 : undefined;\n const groups = cloneEmptyGroups(this.emptyGroups);\n const trackLines = this.trackStartLines;\n const lineTerminatorPattern = this.config.lineTerminatorsPattern;\n let currModePatternsLength = 0;\n let patternIdxToConfig = [];\n let currCharCodeToPatternIdxToConfig = [];\n const modeStack = [];\n const emptyArray = [];\n Object.freeze(emptyArray);\n let getPossiblePatterns;\n function getPossiblePatternsSlow() {\n return patternIdxToConfig;\n }\n function getPossiblePatternsOptimized(charCode) {\n const optimizedCharIdx = charCodeToOptimizedIndex(charCode);\n const possiblePatterns = currCharCodeToPatternIdxToConfig[optimizedCharIdx];\n if (possiblePatterns === undefined) {\n return emptyArray;\n }\n else {\n return possiblePatterns;\n }\n }\n const pop_mode = (popToken) => {\n // TODO: perhaps avoid this error in the edge case there is no more input?\n if (modeStack.length === 1 &&\n // if we have both a POP_MODE and a PUSH_MODE this is in-fact a \"transition\"\n // So no error should occur.\n popToken.tokenType.PUSH_MODE === undefined) {\n // if we try to pop the last mode there lexer will no longer have ANY mode.\n // thus the pop is ignored, an error will be created and the lexer will continue parsing in the previous mode.\n const msg = this.config.errorMessageProvider.buildUnableToPopLexerModeMessage(popToken);\n errors.push({\n offset: popToken.startOffset,\n line: popToken.startLine,\n column: popToken.startColumn,\n length: popToken.image.length,\n message: msg,\n });\n }\n else {\n modeStack.pop();\n const newMode = last(modeStack);\n patternIdxToConfig = this.patternIdxToConfig[newMode];\n currCharCodeToPatternIdxToConfig =\n this.charCodeToPatternIdxToConfig[newMode];\n currModePatternsLength = patternIdxToConfig.length;\n const modeCanBeOptimized = this.canModeBeOptimized[newMode] && this.config.safeMode === false;\n if (currCharCodeToPatternIdxToConfig && modeCanBeOptimized) {\n getPossiblePatterns = getPossiblePatternsOptimized;\n }\n else {\n getPossiblePatterns = getPossiblePatternsSlow;\n }\n }\n };\n function push_mode(newMode) {\n modeStack.push(newMode);\n currCharCodeToPatternIdxToConfig =\n this.charCodeToPatternIdxToConfig[newMode];\n patternIdxToConfig = this.patternIdxToConfig[newMode];\n currModePatternsLength = patternIdxToConfig.length;\n currModePatternsLength = patternIdxToConfig.length;\n const modeCanBeOptimized = this.canModeBeOptimized[newMode] && this.config.safeMode === false;\n if (currCharCodeToPatternIdxToConfig && modeCanBeOptimized) {\n getPossiblePatterns = getPossiblePatternsOptimized;\n }\n else {\n getPossiblePatterns = getPossiblePatternsSlow;\n }\n }\n // this pattern seems to avoid a V8 de-optimization, although that de-optimization does not\n // seem to matter performance wise.\n push_mode.call(this, initialMode);\n let currConfig;\n const recoveryEnabled = this.config.recoveryEnabled;\n while (offset < orgLength) {\n matchedImage = null;\n const nextCharCode = orgText.charCodeAt(offset);\n const chosenPatternIdxToConfig = getPossiblePatterns(nextCharCode);\n const chosenPatternsLength = chosenPatternIdxToConfig.length;\n for (i = 0; i < chosenPatternsLength; i++) {\n currConfig = chosenPatternIdxToConfig[i];\n const currPattern = currConfig.pattern;\n payload = null;\n // manually in-lined because > 600 chars won't be in-lined in V8\n const singleCharCode = currConfig.short;\n if (singleCharCode !== false) {\n if (nextCharCode === singleCharCode) {\n // single character string\n matchedImage = currPattern;\n }\n }\n else if (currConfig.isCustom === true) {\n match = currPattern.exec(orgText, offset, matchedTokens, groups);\n if (match !== null) {\n matchedImage = match[0];\n if (match.payload !== undefined) {\n payload = match.payload;\n }\n }\n else {\n matchedImage = null;\n }\n }\n else {\n this.updateLastIndex(currPattern, offset);\n matchedImage = this.match(currPattern, text, offset);\n }\n if (matchedImage !== null) {\n // even though this pattern matched we must try a another longer alternative.\n // this can be used to prioritize keywords over identifiers\n longerAlt = currConfig.longerAlt;\n if (longerAlt !== undefined) {\n // TODO: micro optimize, avoid extra prop access\n // by saving/linking longerAlt on the original config?\n const longerAltLength = longerAlt.length;\n for (k = 0; k < longerAltLength; k++) {\n const longerAltConfig = patternIdxToConfig[longerAlt[k]];\n const longerAltPattern = longerAltConfig.pattern;\n altPayload = null;\n // single Char can never be a longer alt so no need to test it.\n // manually in-lined because > 600 chars won't be in-lined in V8\n if (longerAltConfig.isCustom === true) {\n match = longerAltPattern.exec(orgText, offset, matchedTokens, groups);\n if (match !== null) {\n matchAltImage = match[0];\n if (match.payload !== undefined) {\n altPayload = match.payload;\n }\n }\n else {\n matchAltImage = null;\n }\n }\n else {\n this.updateLastIndex(longerAltPattern, offset);\n matchAltImage = this.match(longerAltPattern, text, offset);\n }\n if (matchAltImage && matchAltImage.length > matchedImage.length) {\n matchedImage = matchAltImage;\n payload = altPayload;\n currConfig = longerAltConfig;\n // Exit the loop early after matching one of the longer alternatives\n // The first matched alternative takes precedence\n break;\n }\n }\n }\n break;\n }\n }\n // successful match\n if (matchedImage !== null) {\n imageLength = matchedImage.length;\n group = currConfig.group;\n if (group !== undefined) {\n tokType = currConfig.tokenTypeIdx;\n // TODO: \"offset + imageLength\" and the new column may be computed twice in case of \"full\" location information inside\n // createFullToken method\n newToken = this.createTokenInstance(matchedImage, offset, tokType, currConfig.tokenType, line, column, imageLength);\n this.handlePayload(newToken, payload);\n // TODO: optimize NOOP in case there are no special groups?\n if (group === false) {\n matchedTokensIndex = this.addToken(matchedTokens, matchedTokensIndex, newToken);\n }\n else {\n groups[group].push(newToken);\n }\n }\n text = this.chopInput(text, imageLength);\n offset = offset + imageLength;\n // TODO: with newlines the column may be assigned twice\n column = this.computeNewColumn(column, imageLength);\n if (trackLines === true && currConfig.canLineTerminator === true) {\n let numOfLTsInMatch = 0;\n let foundTerminator;\n let lastLTEndOffset;\n lineTerminatorPattern.lastIndex = 0;\n do {\n foundTerminator = lineTerminatorPattern.test(matchedImage);\n if (foundTerminator === true) {\n lastLTEndOffset = lineTerminatorPattern.lastIndex - 1;\n numOfLTsInMatch++;\n }\n } while (foundTerminator === true);\n if (numOfLTsInMatch !== 0) {\n line = line + numOfLTsInMatch;\n column = imageLength - lastLTEndOffset;\n this.updateTokenEndLineColumnLocation(newToken, group, lastLTEndOffset, numOfLTsInMatch, line, column, imageLength);\n }\n }\n // will be NOOP if no modes present\n this.handleModes(currConfig, pop_mode, push_mode, newToken);\n }\n else {\n // error recovery, drop characters until we identify a valid token's start point\n const errorStartOffset = offset;\n const errorLine = line;\n const errorColumn = column;\n let foundResyncPoint = recoveryEnabled === false;\n while (foundResyncPoint === false && offset < orgLength) {\n // Identity Func (when sticky flag is enabled)\n text = this.chopInput(text, 1);\n offset++;\n for (j = 0; j < currModePatternsLength; j++) {\n const currConfig = patternIdxToConfig[j];\n const currPattern = currConfig.pattern;\n // manually in-lined because > 600 chars won't be in-lined in V8\n const singleCharCode = currConfig.short;\n if (singleCharCode !== false) {\n if (orgText.charCodeAt(offset) === singleCharCode) {\n // single character string\n foundResyncPoint = true;\n }\n }\n else if (currConfig.isCustom === true) {\n foundResyncPoint =\n currPattern.exec(orgText, offset, matchedTokens, groups) !== null;\n }\n else {\n this.updateLastIndex(currPattern, offset);\n foundResyncPoint = currPattern.exec(text) !== null;\n }\n if (foundResyncPoint === true) {\n break;\n }\n }\n }\n errLength = offset - errorStartOffset;\n column = this.computeNewColumn(column, errLength);\n // at this point we either re-synced or reached the end of the input text\n msg = this.config.errorMessageProvider.buildUnexpectedCharactersMessage(orgText, errorStartOffset, errLength, errorLine, errorColumn);\n errors.push({\n offset: errorStartOffset,\n line: errorLine,\n column: errorColumn,\n length: errLength,\n message: msg,\n });\n if (recoveryEnabled === false) {\n break;\n }\n }\n }\n // if we do have custom patterns which push directly into the\n // TODO: custom tokens should not push directly??\n if (!this.hasCustom) {\n // if we guessed a too large size for the tokens array this will shrink it to the right size.\n matchedTokens.length = matchedTokensIndex;\n }\n return {\n tokens: matchedTokens,\n groups: groups,\n errors: errors,\n };\n }\n handleModes(config, pop_mode, push_mode, newToken) {\n if (config.pop === true) {\n // need to save the PUSH_MODE property as if the mode is popped\n // patternIdxToPopMode is updated to reflect the new mode after popping the stack\n const pushMode = config.push;\n pop_mode(newToken);\n if (pushMode !== undefined) {\n push_mode.call(this, pushMode);\n }\n }\n else if (config.push !== undefined) {\n push_mode.call(this, config.push);\n }\n }\n chopInput(text, length) {\n return text.substring(length);\n }\n updateLastIndex(regExp, newLastIndex) {\n regExp.lastIndex = newLastIndex;\n }\n // TODO: decrease this under 600 characters? inspect stripping comments option in TSC compiler\n updateTokenEndLineColumnLocation(newToken, group, lastLTIdx, numOfLTsInMatch, line, column, imageLength) {\n let lastCharIsLT, fixForEndingInLT;\n if (group !== undefined) {\n // a none skipped multi line Token, need to update endLine/endColumn\n lastCharIsLT = lastLTIdx === imageLength - 1;\n fixForEndingInLT = lastCharIsLT ? -1 : 0;\n if (!(numOfLTsInMatch === 1 && lastCharIsLT === true)) {\n // if a token ends in a LT that last LT only affects the line numbering of following Tokens\n newToken.endLine = line + fixForEndingInLT;\n // the last LT in a token does not affect the endColumn either as the [columnStart ... columnEnd)\n // inclusive to exclusive range.\n newToken.endColumn = column - 1 + -fixForEndingInLT;\n }\n // else single LT in the last character of a token, no need to modify the endLine/EndColumn\n }\n }\n computeNewColumn(oldColumn, imageLength) {\n return oldColumn + imageLength;\n }\n createOffsetOnlyToken(image, startOffset, tokenTypeIdx, tokenType) {\n return {\n image,\n startOffset,\n tokenTypeIdx,\n tokenType,\n };\n }\n createStartOnlyToken(image, startOffset, tokenTypeIdx, tokenType, startLine, startColumn) {\n return {\n image,\n startOffset,\n startLine,\n startColumn,\n tokenTypeIdx,\n tokenType,\n };\n }\n createFullToken(image, startOffset, tokenTypeIdx, tokenType, startLine, startColumn, imageLength) {\n return {\n image,\n startOffset,\n endOffset: startOffset + imageLength - 1,\n startLine,\n endLine: startLine,\n startColumn,\n endColumn: startColumn + imageLength - 1,\n tokenTypeIdx,\n tokenType,\n };\n }\n addTokenUsingPush(tokenVector, index, tokenToAdd) {\n tokenVector.push(tokenToAdd);\n return index;\n }\n addTokenUsingMemberAccess(tokenVector, index, tokenToAdd) {\n tokenVector[index] = tokenToAdd;\n index++;\n return index;\n }\n handlePayloadNoCustom(token, payload) { }\n handlePayloadWithCustom(token, payload) {\n if (payload !== null) {\n token.payload = payload;\n }\n }\n matchWithTest(pattern, text, offset) {\n const found = pattern.test(text);\n if (found === true) {\n return text.substring(offset, pattern.lastIndex);\n }\n return null;\n }\n matchWithExec(pattern, text) {\n const regExpArray = pattern.exec(text);\n return regExpArray !== null ? regExpArray[0] : null;\n }\n}\nLexer.SKIPPED = \"This marks a skipped Token pattern, this means each token identified by it will\" +\n \"be consumed and then thrown into oblivion, this can be used to for example to completely ignore whitespace.\";\nLexer.NA = /NOT_APPLICABLE/;\n//# sourceMappingURL=lexer_public.js.map","import { has, isString, isUndefined } from \"lodash-es\";\nimport { Lexer } from \"./lexer_public.js\";\nimport { augmentTokenTypes, tokenStructuredMatcher } from \"./tokens.js\";\nexport function tokenLabel(tokType) {\n if (hasTokenLabel(tokType)) {\n return tokType.LABEL;\n }\n else {\n return tokType.name;\n }\n}\nexport function tokenName(tokType) {\n return tokType.name;\n}\nexport function hasTokenLabel(obj) {\n return isString(obj.LABEL) && obj.LABEL !== \"\";\n}\nconst PARENT = \"parent\";\nconst CATEGORIES = \"categories\";\nconst LABEL = \"label\";\nconst GROUP = \"group\";\nconst PUSH_MODE = \"push_mode\";\nconst POP_MODE = \"pop_mode\";\nconst LONGER_ALT = \"longer_alt\";\nconst LINE_BREAKS = \"line_breaks\";\nconst START_CHARS_HINT = \"start_chars_hint\";\nexport function createToken(config) {\n return createTokenInternal(config);\n}\nfunction createTokenInternal(config) {\n const pattern = config.pattern;\n const tokenType = {};\n tokenType.name = config.name;\n if (!isUndefined(pattern)) {\n tokenType.PATTERN = pattern;\n }\n if (has(config, PARENT)) {\n throw (\"The parent property is no longer supported.\\n\" +\n \"See: https://github.com/chevrotain/chevrotain/issues/564#issuecomment-349062346 for details.\");\n }\n if (has(config, CATEGORIES)) {\n // casting to ANY as this will be fixed inside `augmentTokenTypes``\n tokenType.CATEGORIES = config[CATEGORIES];\n }\n augmentTokenTypes([tokenType]);\n if (has(config, LABEL)) {\n tokenType.LABEL = config[LABEL];\n }\n if (has(config, GROUP)) {\n tokenType.GROUP = config[GROUP];\n }\n if (has(config, POP_MODE)) {\n tokenType.POP_MODE = config[POP_MODE];\n }\n if (has(config, PUSH_MODE)) {\n tokenType.PUSH_MODE = config[PUSH_MODE];\n }\n if (has(config, LONGER_ALT)) {\n tokenType.LONGER_ALT = config[LONGER_ALT];\n }\n if (has(config, LINE_BREAKS)) {\n tokenType.LINE_BREAKS = config[LINE_BREAKS];\n }\n if (has(config, START_CHARS_HINT)) {\n tokenType.START_CHARS_HINT = config[START_CHARS_HINT];\n }\n return tokenType;\n}\nexport const EOF = createToken({ name: \"EOF\", pattern: Lexer.NA });\naugmentTokenTypes([EOF]);\nexport function createTokenInstance(tokType, image, startOffset, endOffset, startLine, endLine, startColumn, endColumn) {\n return {\n image,\n startOffset,\n endOffset,\n startLine,\n endLine,\n startColumn,\n endColumn,\n tokenTypeIdx: tokType.tokenTypeIdx,\n tokenType: tokType,\n };\n}\nexport function tokenMatcher(token, tokType) {\n return tokenStructuredMatcher(token, tokType);\n}\n//# sourceMappingURL=tokens_public.js.map","import { hasTokenLabel, tokenLabel } from \"../scan/tokens_public.js\";\nimport { first, map, reduce } from \"lodash-es\";\nimport { getProductionDslName, NonTerminal, Rule, Terminal, } from \"@chevrotain/gast\";\nexport const defaultParserErrorProvider = {\n buildMismatchTokenMessage({ expected, actual, previous, ruleName }) {\n const hasLabel = hasTokenLabel(expected);\n const expectedMsg = hasLabel\n ? `--> ${tokenLabel(expected)} <--`\n : `token of type --> ${expected.name} <--`;\n const msg = `Expecting ${expectedMsg} but found --> '${actual.image}' <--`;\n return msg;\n },\n buildNotAllInputParsedMessage({ firstRedundant, ruleName }) {\n return \"Redundant input, expecting EOF but found: \" + firstRedundant.image;\n },\n buildNoViableAltMessage({ expectedPathsPerAlt, actual, previous, customUserDescription, ruleName, }) {\n const errPrefix = \"Expecting: \";\n // TODO: issue: No Viable Alternative Error may have incomplete details. #502\n const actualText = first(actual).image;\n const errSuffix = \"\\nbut found: '\" + actualText + \"'\";\n if (customUserDescription) {\n return errPrefix + customUserDescription + errSuffix;\n }\n else {\n const allLookAheadPaths = reduce(expectedPathsPerAlt, (result, currAltPaths) => result.concat(currAltPaths), []);\n const nextValidTokenSequences = map(allLookAheadPaths, (currPath) => `[${map(currPath, (currTokenType) => tokenLabel(currTokenType)).join(\", \")}]`);\n const nextValidSequenceItems = map(nextValidTokenSequences, (itemMsg, idx) => ` ${idx + 1}. ${itemMsg}`);\n const calculatedDescription = `one of these possible Token sequences:\\n${nextValidSequenceItems.join(\"\\n\")}`;\n return errPrefix + calculatedDescription + errSuffix;\n }\n },\n buildEarlyExitMessage({ expectedIterationPaths, actual, customUserDescription, ruleName, }) {\n const errPrefix = \"Expecting: \";\n // TODO: issue: No Viable Alternative Error may have incomplete details. #502\n const actualText = first(actual).image;\n const errSuffix = \"\\nbut found: '\" + actualText + \"'\";\n if (customUserDescription) {\n return errPrefix + customUserDescription + errSuffix;\n }\n else {\n const nextValidTokenSequences = map(expectedIterationPaths, (currPath) => `[${map(currPath, (currTokenType) => tokenLabel(currTokenType)).join(\",\")}]`);\n const calculatedDescription = `expecting at least one iteration which starts with one of these possible Token sequences::\\n ` +\n `<${nextValidTokenSequences.join(\" ,\")}>`;\n return errPrefix + calculatedDescription + errSuffix;\n }\n },\n};\nObject.freeze(defaultParserErrorProvider);\nexport const defaultGrammarResolverErrorProvider = {\n buildRuleNotFoundError(topLevelRule, undefinedRule) {\n const msg = \"Invalid grammar, reference to a rule which is not defined: ->\" +\n undefinedRule.nonTerminalName +\n \"<-\\n\" +\n \"inside top level rule: ->\" +\n topLevelRule.name +\n \"<-\";\n return msg;\n },\n};\nexport const defaultGrammarValidatorErrorProvider = {\n buildDuplicateFoundError(topLevelRule, duplicateProds) {\n function getExtraProductionArgument(prod) {\n if (prod instanceof Terminal) {\n return prod.terminalType.name;\n }\n else if (prod instanceof NonTerminal) {\n return prod.nonTerminalName;\n }\n else {\n return \"\";\n }\n }\n const topLevelName = topLevelRule.name;\n const duplicateProd = first(duplicateProds);\n const index = duplicateProd.idx;\n const dslName = getProductionDslName(duplicateProd);\n const extraArgument = getExtraProductionArgument(duplicateProd);\n const hasExplicitIndex = index > 0;\n let msg = `->${dslName}${hasExplicitIndex ? index : \"\"}<- ${extraArgument ? `with argument: ->${extraArgument}<-` : \"\"}\n appears more than once (${duplicateProds.length} times) in the top level rule: ->${topLevelName}<-. \n For further details see: https://chevrotain.io/docs/FAQ.html#NUMERICAL_SUFFIXES \n `;\n // white space trimming time! better to trim afterwards as it allows to use WELL formatted multi line template strings...\n msg = msg.replace(/[ \\t]+/g, \" \");\n msg = msg.replace(/\\s\\s+/g, \"\\n\");\n return msg;\n },\n buildNamespaceConflictError(rule) {\n const errMsg = `Namespace conflict found in grammar.\\n` +\n `The grammar has both a Terminal(Token) and a Non-Terminal(Rule) named: <${rule.name}>.\\n` +\n `To resolve this make sure each Terminal and Non-Terminal names are unique\\n` +\n `This is easy to accomplish by using the convention that Terminal names start with an uppercase letter\\n` +\n `and Non-Terminal names start with a lower case letter.`;\n return errMsg;\n },\n buildAlternationPrefixAmbiguityError(options) {\n const pathMsg = map(options.prefixPath, (currTok) => tokenLabel(currTok)).join(\", \");\n const occurrence = options.alternation.idx === 0 ? \"\" : options.alternation.idx;\n const errMsg = `Ambiguous alternatives: <${options.ambiguityIndices.join(\" ,\")}> due to common lookahead prefix\\n` +\n `in <OR${occurrence}> inside <${options.topLevelRule.name}> Rule,\\n` +\n `<${pathMsg}> may appears as a prefix path in all these alternatives.\\n` +\n `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#COMMON_PREFIX\\n` +\n `For Further details.`;\n return errMsg;\n },\n buildAlternationAmbiguityError(options) {\n const pathMsg = map(options.prefixPath, (currtok) => tokenLabel(currtok)).join(\", \");\n const occurrence = options.alternation.idx === 0 ? \"\" : options.alternation.idx;\n let currMessage = `Ambiguous Alternatives Detected: <${options.ambiguityIndices.join(\" ,\")}> in <OR${occurrence}>` +\n ` inside <${options.topLevelRule.name}> Rule,\\n` +\n `<${pathMsg}> may appears as a prefix path in all these alternatives.\\n`;\n currMessage =\n currMessage +\n `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES\\n` +\n `For Further details.`;\n return currMessage;\n },\n buildEmptyRepetitionError(options) {\n let dslName = getProductionDslName(options.repetition);\n if (options.repetition.idx !== 0) {\n dslName += options.repetition.idx;\n }\n const errMsg = `The repetition <${dslName}> within Rule <${options.topLevelRule.name}> can never consume any tokens.\\n` +\n `This could lead to an infinite loop.`;\n return errMsg;\n },\n // TODO: remove - `errors_public` from nyc.config.js exclude\n // once this method is fully removed from this file\n buildTokenNameError(options) {\n /* istanbul ignore next */\n return \"deprecated\";\n },\n buildEmptyAlternationError(options) {\n const errMsg = `Ambiguous empty alternative: <${options.emptyChoiceIdx + 1}>` +\n ` in <OR${options.alternation.idx}> inside <${options.topLevelRule.name}> Rule.\\n` +\n `Only the last alternative may be an empty alternative.`;\n return errMsg;\n },\n buildTooManyAlternativesError(options) {\n const errMsg = `An Alternation cannot have more than 256 alternatives:\\n` +\n `<OR${options.alternation.idx}> inside <${options.topLevelRule.name}> Rule.\\n has ${options.alternation.definition.length + 1} alternatives.`;\n return errMsg;\n },\n buildLeftRecursionError(options) {\n const ruleName = options.topLevelRule.name;\n const pathNames = map(options.leftRecursionPath, (currRule) => currRule.name);\n const leftRecursivePath = `${ruleName} --> ${pathNames\n .concat([ruleName])\n .join(\" --> \")}`;\n const errMsg = `Left Recursion found in grammar.\\n` +\n `rule: <${ruleName}> can be invoked from itself (directly or indirectly)\\n` +\n `without consuming any Tokens. The grammar path that causes this is: \\n ${leftRecursivePath}\\n` +\n ` To fix this refactor your grammar to remove the left recursion.\\n` +\n `see: https://en.wikipedia.org/wiki/LL_parser#Left_factoring.`;\n return errMsg;\n },\n // TODO: remove - `errors_public` from nyc.config.js exclude\n // once this method is fully removed from this file\n buildInvalidRuleNameError(options) {\n /* istanbul ignore next */\n return \"deprecated\";\n },\n buildDuplicateRuleNameError(options) {\n let ruleName;\n if (options.topLevelRule instanceof Rule) {\n ruleName = options.topLevelRule.name;\n }\n else {\n ruleName = options.topLevelRule;\n }\n const errMsg = `Duplicate definition, rule: ->${ruleName}<- is already defined in the grammar: ->${options.grammarName}<-`;\n return errMsg;\n },\n};\n//# sourceMappingURL=errors_public.js.map","import { ParserDefinitionErrorType, } from \"../parser/parser.js\";\nimport { forEach, values } from \"lodash-es\";\nimport { GAstVisitor } from \"@chevrotain/gast\";\nexport function resolveGrammar(topLevels, errMsgProvider) {\n const refResolver = new GastRefResolverVisitor(topLevels, errMsgProvider);\n refResolver.resolveRefs();\n return refResolver.errors;\n}\nexport class GastRefResolverVisitor extends GAstVisitor {\n constructor(nameToTopRule, errMsgProvider) {\n super();\n this.nameToTopRule = nameToTopRule;\n this.errMsgProvider = errMsgProvider;\n this.errors = [];\n }\n resolveRefs() {\n forEach(values(this.nameToTopRule), (prod) => {\n this.currTopLevel = prod;\n prod.accept(this);\n });\n }\n visitNonTerminal(node) {\n const ref = this.nameToTopRule[node.nonTerminalName];\n if (!ref) {\n const msg = this.errMsgProvider.buildRuleNotFoundError(this.currTopLevel, node);\n this.errors.push({\n message: msg,\n type: ParserDefinitionErrorType.UNRESOLVED_SUBRULE_REF,\n ruleName: this.currTopLevel.name,\n unresolvedRefName: node.nonTerminalName,\n });\n }\n else {\n node.referencedRule = ref;\n }\n }\n}\n//# sourceMappingURL=resolver.js.map","import { clone, drop, dropRight, first as _first, forEach, isEmpty, last, } from \"lodash-es\";\nimport { first } from \"./first.js\";\nimport { RestWalker } from \"./rest.js\";\nimport { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, } from \"@chevrotain/gast\";\nexport class AbstractNextPossibleTokensWalker extends RestWalker {\n constructor(topProd, path) {\n super();\n this.topProd = topProd;\n this.path = path;\n this.possibleTokTypes = [];\n this.nextProductionName = \"\";\n this.nextProductionOccurrence = 0;\n this.found = false;\n this.isAtEndOfPath = false;\n }\n startWalking() {\n this.found = false;\n if (this.path.ruleStack[0] !== this.topProd.name) {\n throw Error(\"The path does not start with the walker's top Rule!\");\n }\n // immutable for the win\n this.ruleStack = clone(this.path.ruleStack).reverse(); // intelij bug requires assertion\n this.occurrenceStack = clone(this.path.occurrenceStack).reverse(); // intelij bug requires assertion\n // already verified that the first production is valid, we now seek the 2nd production\n this.ruleStack.pop();\n this.occurrenceStack.pop();\n this.updateExpectedNext();\n this.walk(this.topProd);\n return this.possibleTokTypes;\n }\n walk(prod, prevRest = []) {\n // stop scanning once we found the path\n if (!this.found) {\n super.walk(prod, prevRest);\n }\n }\n walkProdRef(refProd, currRest, prevRest) {\n // found the next production, need to keep walking in it\n if (refProd.referencedRule.name === this.nextProductionName &&\n refProd.idx === this.nextProductionOccurrence) {\n const fullRest = currRest.concat(prevRest);\n this.updateExpectedNext();\n this.walk(refProd.referencedRule, fullRest);\n }\n }\n updateExpectedNext() {\n // need to consume the Terminal\n if (isEmpty(this.ruleStack)) {\n // must reset nextProductionXXX to avoid walking down another Top Level production while what we are\n // really seeking is the last Terminal...\n this.nextProductionName = \"\";\n this.nextProductionOccurrence = 0;\n this.isAtEndOfPath = true;\n }\n else {\n this.nextProductionName = this.ruleStack.pop();\n this.nextProductionOccurrence = this.occurrenceStack.pop();\n }\n }\n}\nexport class NextAfterTokenWalker extends AbstractNextPossibleTokensWalker {\n constructor(topProd, path) {\n super(topProd, path);\n this.path = path;\n this.nextTerminalName = \"\";\n this.nextTerminalOccurrence = 0;\n this.nextTerminalName = this.path.lastTok.name;\n this.nextTerminalOccurrence = this.path.lastTokOccurrence;\n }\n walkTerminal(terminal, currRest, prevRest) {\n if (this.isAtEndOfPath &&\n terminal.terminalType.name === this.nextTerminalName &&\n terminal.idx === this.nextTerminalOccurrence &&\n !this.found) {\n const fullRest = currRest.concat(prevRest);\n const restProd = new Alternative({ definition: fullRest });\n this.possibleTokTypes = first(restProd);\n this.found = true;\n }\n }\n}\n/**\n * This walker only \"walks\" a single \"TOP\" level in the Grammar Ast, this means\n * it never \"follows\" production refs\n */\nexport class AbstractNextTerminalAfterProductionWalker extends RestWalker {\n constructor(topRule, occurrence) {\n super();\n this.topRule = topRule;\n this.occurrence = occurrence;\n this.result = {\n token: undefined,\n occurrence: undefined,\n isEndOfRule: undefined,\n };\n }\n startWalking() {\n this.walk(this.topRule);\n return this.result;\n }\n}\nexport class NextTerminalAfterManyWalker extends AbstractNextTerminalAfterProductionWalker {\n walkMany(manyProd, currRest, prevRest) {\n if (manyProd.idx === this.occurrence) {\n const firstAfterMany = _first(currRest.concat(prevRest));\n this.result.isEndOfRule = firstAfterMany === undefined;\n if (firstAfterMany instanceof Terminal) {\n this.result.token = firstAfterMany.terminalType;\n this.result.occurrence = firstAfterMany.idx;\n }\n }\n else {\n super.walkMany(manyProd, currRest, prevRest);\n }\n }\n}\nexport class NextTerminalAfterManySepWalker extends AbstractNextTerminalAfterProductionWalker {\n walkManySep(manySepProd, currRest, prevRest) {\n if (manySepProd.idx === this.occurrence) {\n const firstAfterManySep = _first(currRest.concat(prevRest));\n this.result.isEndOfRule = firstAfterManySep === undefined;\n if (firstAfterManySep instanceof Terminal) {\n this.result.token = firstAfterManySep.terminalType;\n this.result.occurrence = firstAfterManySep.idx;\n }\n }\n else {\n super.walkManySep(manySepProd, currRest, prevRest);\n }\n }\n}\nexport class NextTerminalAfterAtLeastOneWalker extends AbstractNextTerminalAfterProductionWalker {\n walkAtLeastOne(atLeastOneProd, currRest, prevRest) {\n if (atLeastOneProd.idx === this.occurrence) {\n const firstAfterAtLeastOne = _first(currRest.concat(prevRest));\n this.result.isEndOfRule = firstAfterAtLeastOne === undefined;\n if (firstAfterAtLeastOne instanceof Terminal) {\n this.result.token = firstAfterAtLeastOne.terminalType;\n this.result.occurrence = firstAfterAtLeastOne.idx;\n }\n }\n else {\n super.walkAtLeastOne(atLeastOneProd, currRest, prevRest);\n }\n }\n}\n// TODO: reduce code duplication in the AfterWalkers\nexport class NextTerminalAfterAtLeastOneSepWalker extends AbstractNextTerminalAfterProductionWalker {\n walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest) {\n if (atleastOneSepProd.idx === this.occurrence) {\n const firstAfterfirstAfterAtLeastOneSep = _first(currRest.concat(prevRest));\n this.result.isEndOfRule = firstAfterfirstAfterAtLeastOneSep === undefined;\n if (firstAfterfirstAfterAtLeastOneSep instanceof Terminal) {\n this.result.token = firstAfterfirstAfterAtLeastOneSep.terminalType;\n this.result.occurrence = firstAfterfirstAfterAtLeastOneSep.idx;\n }\n }\n else {\n super.walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest);\n }\n }\n}\nexport function possiblePathsFrom(targetDef, maxLength, currPath = []) {\n // avoid side effects\n currPath = clone(currPath);\n let result = [];\n let i = 0;\n // TODO: avoid inner funcs\n function remainingPathWith(nextDef) {\n return nextDef.concat(drop(targetDef, i + 1));\n }\n // TODO: avoid inner funcs\n function getAlternativesForProd(definition) {\n const alternatives = possiblePathsFrom(remainingPathWith(definition), maxLength, currPath);\n return result.concat(alternatives);\n }\n /**\n * Mandatory productions will halt the loop as the paths computed from their recursive calls will already contain the\n * following (rest) of the targetDef.\n *\n * For optional productions (Option/Repetition/...) the loop will continue to represent the paths that do not include the\n * the optional production.\n */\n while (currPath.length < maxLength && i < targetDef.length) {\n const prod = targetDef[i];\n /* istanbul ignore else */\n if (prod instanceof Alternative) {\n return getAlternativesForProd(prod.definition);\n }\n else if (prod instanceof NonTerminal) {\n return getAlternativesForProd(prod.definition);\n }\n else if (prod instanceof Option) {\n result = getAlternativesForProd(prod.definition);\n }\n else if (prod instanceof RepetitionMandatory) {\n const newDef = prod.definition.concat([\n new Repetition({\n definition: prod.definition,\n }),\n ]);\n return getAlternativesForProd(newDef);\n }\n else if (prod instanceof RepetitionMandatoryWithSeparator) {\n const newDef = [\n new Alternative({ definition: prod.definition }),\n new Repetition({\n definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition),\n }),\n ];\n return getAlternativesForProd(newDef);\n }\n else if (prod instanceof RepetitionWithSeparator) {\n const newDef = prod.definition.concat([\n new Repetition({\n definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition),\n }),\n ]);\n result = getAlternativesForProd(newDef);\n }\n else if (prod instanceof Repetition) {\n const newDef = prod.definition.concat([\n new Repetition({\n definition: prod.definition,\n }),\n ]);\n result = getAlternativesForProd(newDef);\n }\n else if (prod instanceof Alternation) {\n forEach(prod.definition, (currAlt) => {\n // TODO: this is a limited check for empty alternatives\n // It would prevent a common case of infinite loops during parser initialization.\n // However **in-directly** empty alternatives may still cause issues.\n if (isEmpty(currAlt.definition) === false) {\n result = getAlternativesForProd(currAlt.definition);\n }\n });\n return result;\n }\n else if (prod instanceof Terminal) {\n currPath.push(prod.terminalType);\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n i++;\n }\n result.push({\n partialPath: currPath,\n suffixDef: drop(targetDef, i),\n });\n return result;\n}\nexport function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhead) {\n const EXIT_NON_TERMINAL = \"EXIT_NONE_TERMINAL\";\n // to avoid creating a new Array each time.\n const EXIT_NON_TERMINAL_ARR = [EXIT_NON_TERMINAL];\n const EXIT_ALTERNATIVE = \"EXIT_ALTERNATIVE\";\n let foundCompletePath = false;\n const tokenVectorLength = tokenVector.length;\n const minimalAlternativesIndex = tokenVectorLength - maxLookAhead - 1;\n const result = [];\n const possiblePaths = [];\n possiblePaths.push({\n idx: -1,\n def: initialDef,\n ruleStack: [],\n occurrenceStack: [],\n });\n while (!isEmpty(possiblePaths)) {\n const currPath = possiblePaths.pop();\n // skip alternatives if no more results can be found (assuming deterministic grammar with fixed lookahead)\n if (currPath === EXIT_ALTERNATIVE) {\n if (foundCompletePath &&\n last(possiblePaths).idx <= minimalAlternativesIndex) {\n // remove irrelevant alternative\n possiblePaths.pop();\n }\n continue;\n }\n const currDef = currPath.def;\n const currIdx = currPath.idx;\n const currRuleStack = currPath.ruleStack;\n const currOccurrenceStack = currPath.occurrenceStack;\n // For Example: an empty path could exist in a valid grammar in the case of an EMPTY_ALT\n if (isEmpty(currDef)) {\n continue;\n }\n const prod = currDef[0];\n /* istanbul ignore else */\n if (prod === EXIT_NON_TERMINAL) {\n const nextPath = {\n idx: currIdx,\n def: drop(currDef),\n ruleStack: dropRight(currRuleStack),\n occurrenceStack: dropRight(currOccurrenceStack),\n };\n possiblePaths.push(nextPath);\n }\n else if (prod instanceof Terminal) {\n /* istanbul ignore else */\n if (currIdx < tokenVectorLength - 1) {\n const nextIdx = currIdx + 1;\n const actualToken = tokenVector[nextIdx];\n if (tokMatcher(actualToken, prod.terminalType)) {\n const nextPath = {\n idx: nextIdx,\n def: drop(currDef),\n ruleStack: currRuleStack,\n occurrenceStack: currOccurrenceStack,\n };\n possiblePaths.push(nextPath);\n }\n // end of the line\n }\n else if (currIdx === tokenVectorLength - 1) {\n // IGNORE ABOVE ELSE\n result.push({\n nextTokenType: prod.terminalType,\n nextTokenOccurrence: prod.idx,\n ruleStack: currRuleStack,\n occurrenceStack: currOccurrenceStack,\n });\n foundCompletePath = true;\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n }\n else if (prod instanceof NonTerminal) {\n const newRuleStack = clone(currRuleStack);\n newRuleStack.push(prod.nonTerminalName);\n const newOccurrenceStack = clone(currOccurrenceStack);\n newOccurrenceStack.push(prod.idx);\n const nextPath = {\n idx: currIdx,\n def: prod.definition.concat(EXIT_NON_TERMINAL_ARR, drop(currDef)),\n ruleStack: newRuleStack,\n occurrenceStack: newOccurrenceStack,\n };\n possiblePaths.push(nextPath);\n }\n else if (prod instanceof Option) {\n // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n const nextPathWithout = {\n idx: currIdx,\n def: drop(currDef),\n ruleStack: currRuleStack,\n occurrenceStack: currOccurrenceStack,\n };\n possiblePaths.push(nextPathWithout);\n // required marker to avoid backtracking paths whose higher priority alternatives already matched\n possiblePaths.push(EXIT_ALTERNATIVE);\n const nextPathWith = {\n idx: currIdx,\n def: prod.definition.concat(drop(currDef)),\n ruleStack: currRuleStack,\n occurrenceStack: currOccurrenceStack,\n };\n possiblePaths.push(nextPathWith);\n }\n else if (prod instanceof RepetitionMandatory) {\n // TODO:(THE NEW operators here take a while...) (convert once?)\n const secondIteration = new Repetition({\n definition: prod.definition,\n idx: prod.idx,\n });\n const nextDef = prod.definition.concat([secondIteration], drop(currDef));\n const nextPath = {\n idx: currIdx,\n def: nextDef,\n ruleStack: currRuleStack,\n occurrenceStack: currOccurrenceStack,\n };\n possiblePaths.push(nextPath);\n }\n else if (prod instanceof RepetitionMandatoryWithSeparator) {\n // TODO:(THE NEW operators here take a while...) (convert once?)\n const separatorGast = new Terminal({\n terminalType: prod.separator,\n });\n const secondIteration = new Repetition({\n definition: [separatorGast].concat(prod.definition),\n idx: prod.idx,\n });\n const nextDef = prod.definition.concat([secondIteration], drop(currDef));\n const nextPath = {\n idx: currIdx,\n def: nextDef,\n ruleStack: currRuleStack,\n occurrenceStack: currOccurrenceStack,\n };\n possiblePaths.push(nextPath);\n }\n else if (prod instanceof RepetitionWithSeparator) {\n // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n const nextPathWithout = {\n idx: currIdx,\n def: drop(currDef),\n ruleStack: currRuleStack,\n occurrenceStack: currOccurrenceStack,\n };\n possiblePaths.push(nextPathWithout);\n // required marker to avoid backtracking paths whose higher priority alternatives already matched\n possiblePaths.push(EXIT_ALTERNATIVE);\n const separatorGast = new Terminal({\n terminalType: prod.separator,\n });\n const nthRepetition = new Repetition({\n definition: [separatorGast].concat(prod.definition),\n idx: prod.idx,\n });\n const nextDef = prod.definition.concat([nthRepetition], drop(currDef));\n const nextPathWith = {\n idx: currIdx,\n def: nextDef,\n ruleStack: currRuleStack,\n occurrenceStack: currOccurrenceStack,\n };\n possiblePaths.push(nextPathWith);\n }\n else if (prod instanceof Repetition) {\n // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n const nextPathWithout = {\n idx: currIdx,\n def: drop(currDef),\n ruleStack: currRuleStack,\n occurrenceStack: currOccurrenceStack,\n };\n possiblePaths.push(nextPathWithout);\n // required marker to avoid backtracking paths whose higher priority alternatives already matched\n possiblePaths.push(EXIT_ALTERNATIVE);\n // TODO: an empty repetition will cause infinite loops here, will the parser detect this in selfAnalysis?\n const nthRepetition = new Repetition({\n definition: prod.definition,\n idx: prod.idx,\n });\n const nextDef = prod.definition.concat([nthRepetition], drop(currDef));\n const nextPathWith = {\n idx: currIdx,\n def: nextDef,\n ruleStack: currRuleStack,\n occurrenceStack: currOccurrenceStack,\n };\n possiblePaths.push(nextPathWith);\n }\n else if (prod instanceof Alternation) {\n // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n for (let i = prod.definition.length - 1; i >= 0; i--) {\n const currAlt = prod.definition[i];\n const currAltPath = {\n idx: currIdx,\n def: currAlt.definition.concat(drop(currDef)),\n ruleStack: currRuleStack,\n occurrenceStack: currOccurrenceStack,\n };\n possiblePaths.push(currAltPath);\n possiblePaths.push(EXIT_ALTERNATIVE);\n }\n }\n else if (prod instanceof Alternative) {\n possiblePaths.push({\n idx: currIdx,\n def: prod.definition.concat(drop(currDef)),\n ruleStack: currRuleStack,\n occurrenceStack: currOccurrenceStack,\n });\n }\n else if (prod instanceof Rule) {\n // last because we should only encounter at most a single one of these per invocation.\n possiblePaths.push(expandTopLevelRule(prod, currIdx, currRuleStack, currOccurrenceStack));\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n }\n return result;\n}\nfunction expandTopLevelRule(topRule, currIdx, currRuleStack, currOccurrenceStack) {\n const newRuleStack = clone(currRuleStack);\n newRuleStack.push(topRule.name);\n const newCurrOccurrenceStack = clone(currOccurrenceStack);\n // top rule is always assumed to have been called with occurrence index 1\n newCurrOccurrenceStack.push(1);\n return {\n idx: currIdx,\n def: topRule.definition,\n ruleStack: newRuleStack,\n occurrenceStack: newCurrOccurrenceStack,\n };\n}\n//# sourceMappingURL=interpreter.js.map","import { every, flatten, forEach, has, isEmpty, map, reduce } from \"lodash-es\";\nimport { possiblePathsFrom } from \"./interpreter.js\";\nimport { RestWalker } from \"./rest.js\";\nimport { tokenStructuredMatcher, tokenStructuredMatcherNoCategories, } from \"../../scan/tokens.js\";\nimport { Alternation, Alternative as AlternativeGAST, GAstVisitor, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, } from \"@chevrotain/gast\";\nexport var PROD_TYPE;\n(function (PROD_TYPE) {\n PROD_TYPE[PROD_TYPE[\"OPTION\"] = 0] = \"OPTION\";\n PROD_TYPE[PROD_TYPE[\"REPETITION\"] = 1] = \"REPETITION\";\n PROD_TYPE[PROD_TYPE[\"REPETITION_MANDATORY\"] = 2] = \"REPETITION_MANDATORY\";\n PROD_TYPE[PROD_TYPE[\"REPETITION_MANDATORY_WITH_SEPARATOR\"] = 3] = \"REPETITION_MANDATORY_WITH_SEPARATOR\";\n PROD_TYPE[PROD_TYPE[\"REPETITION_WITH_SEPARATOR\"] = 4] = \"REPETITION_WITH_SEPARATOR\";\n PROD_TYPE[PROD_TYPE[\"ALTERNATION\"] = 5] = \"ALTERNATION\";\n})(PROD_TYPE || (PROD_TYPE = {}));\nexport function getProdType(prod) {\n /* istanbul ignore else */\n if (prod instanceof Option || prod === \"Option\") {\n return PROD_TYPE.OPTION;\n }\n else if (prod instanceof Repetition || prod === \"Repetition\") {\n return PROD_TYPE.REPETITION;\n }\n else if (prod instanceof RepetitionMandatory ||\n prod === \"RepetitionMandatory\") {\n return PROD_TYPE.REPETITION_MANDATORY;\n }\n else if (prod instanceof RepetitionMandatoryWithSeparator ||\n prod === \"RepetitionMandatoryWithSeparator\") {\n return PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR;\n }\n else if (prod instanceof RepetitionWithSeparator ||\n prod === \"RepetitionWithSeparator\") {\n return PROD_TYPE.REPETITION_WITH_SEPARATOR;\n }\n else if (prod instanceof Alternation || prod === \"Alternation\") {\n return PROD_TYPE.ALTERNATION;\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n}\nexport function getLookaheadPaths(options) {\n const { occurrence, rule, prodType, maxLookahead } = options;\n const type = getProdType(prodType);\n if (type === PROD_TYPE.ALTERNATION) {\n return getLookaheadPathsForOr(occurrence, rule, maxLookahead);\n }\n else {\n return getLookaheadPathsForOptionalProd(occurrence, rule, type, maxLookahead);\n }\n}\nexport function buildLookaheadFuncForOr(occurrence, ruleGrammar, maxLookahead, hasPredicates, dynamicTokensEnabled, laFuncBuilder) {\n const lookAheadPaths = getLookaheadPathsForOr(occurrence, ruleGrammar, maxLookahead);\n const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths)\n ? tokenStructuredMatcherNoCategories\n : tokenStructuredMatcher;\n return laFuncBuilder(lookAheadPaths, hasPredicates, tokenMatcher, dynamicTokensEnabled);\n}\n/**\n * When dealing with an Optional production (OPTION/MANY/2nd iteration of AT_LEAST_ONE/...) we need to compare\n * the lookahead \"inside\" the production and the lookahead immediately \"after\" it in the same top level rule (context free).\n *\n * Example: given a production:\n * ABC(DE)?DF\n *\n * The optional '(DE)?' should only be entered if we see 'DE'. a single Token 'D' is not sufficient to distinguish between the two\n * alternatives.\n *\n * @returns A Lookahead function which will return true IFF the parser should parse the Optional production.\n */\nexport function buildLookaheadFuncForOptionalProd(occurrence, ruleGrammar, k, dynamicTokensEnabled, prodType, lookaheadBuilder) {\n const lookAheadPaths = getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k);\n const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths)\n ? tokenStructuredMatcherNoCategories\n : tokenStructuredMatcher;\n return lookaheadBuilder(lookAheadPaths[0], tokenMatcher, dynamicTokensEnabled);\n}\nexport function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher, dynamicTokensEnabled) {\n const numOfAlts = alts.length;\n const areAllOneTokenLookahead = every(alts, (currAlt) => {\n return every(currAlt, (currPath) => {\n return currPath.length === 1;\n });\n });\n // This version takes into account the predicates as well.\n if (hasPredicates) {\n /**\n * @returns {number} - The chosen alternative index\n */\n return function (orAlts) {\n // unfortunately the predicates must be extracted every single time\n // as they cannot be cached due to references to parameters(vars) which are no longer valid.\n // note that in the common case of no predicates, no cpu time will be wasted on this (see else block)\n const predicates = map(orAlts, (currAlt) => currAlt.GATE);\n for (let t = 0; t < numOfAlts; t++) {\n const currAlt = alts[t];\n const currNumOfPaths = currAlt.length;\n const currPredicate = predicates[t];\n if (currPredicate !== undefined && currPredicate.call(this) === false) {\n // if the predicate does not match there is no point in checking the paths\n continue;\n }\n nextPath: for (let j = 0; j < currNumOfPaths; j++) {\n const currPath = currAlt[j];\n const currPathLength = currPath.length;\n for (let i = 0; i < currPathLength; i++) {\n const nextToken = this.LA(i + 1);\n if (tokenMatcher(nextToken, currPath[i]) === false) {\n // mismatch in current path\n // try the next pth\n continue nextPath;\n }\n }\n // found a full path that matches.\n // this will also work for an empty ALT as the loop will be skipped\n return t;\n }\n // none of the paths for the current alternative matched\n // try the next alternative\n }\n // none of the alternatives could be matched\n return undefined;\n };\n }\n else if (areAllOneTokenLookahead && !dynamicTokensEnabled) {\n // optimized (common) case of all the lookaheads paths requiring only\n // a single token lookahead. These Optimizations cannot work if dynamically defined Tokens are used.\n const singleTokenAlts = map(alts, (currAlt) => {\n return flatten(currAlt);\n });\n const choiceToAlt = reduce(singleTokenAlts, (result, currAlt, idx) => {\n forEach(currAlt, (currTokType) => {\n if (!has(result, currTokType.tokenTypeIdx)) {\n result[currTokType.tokenTypeIdx] = idx;\n }\n forEach(currTokType.categoryMatches, (currExtendingType) => {\n if (!has(result, currExtendingType)) {\n result[currExtendingType] = idx;\n }\n });\n });\n return result;\n }, {});\n /**\n * @returns {number} - The chosen alternative index\n */\n return function () {\n const nextToken = this.LA(1);\n return choiceToAlt[nextToken.tokenTypeIdx];\n };\n }\n else {\n // optimized lookahead without needing to check the predicates at all.\n // this causes code duplication which is intentional to improve performance.\n /**\n * @returns {number} - The chosen alternative index\n */\n return function () {\n for (let t = 0; t < numOfAlts; t++) {\n const currAlt = alts[t];\n const currNumOfPaths = currAlt.length;\n nextPath: for (let j = 0; j < currNumOfPaths; j++) {\n const currPath = currAlt[j];\n const currPathLength = currPath.length;\n for (let i = 0; i < currPathLength; i++) {\n const nextToken = this.LA(i + 1);\n if (tokenMatcher(nextToken, currPath[i]) === false) {\n // mismatch in current path\n // try the next pth\n continue nextPath;\n }\n }\n // found a full path that matches.\n // this will also work for an empty ALT as the loop will be skipped\n return t;\n }\n // none of the paths for the current alternative matched\n // try the next alternative\n }\n // none of the alternatives could be matched\n return undefined;\n };\n }\n}\nexport function buildSingleAlternativeLookaheadFunction(alt, tokenMatcher, dynamicTokensEnabled) {\n const areAllOneTokenLookahead = every(alt, (currPath) => {\n return currPath.length === 1;\n });\n const numOfPaths = alt.length;\n // optimized (common) case of all the lookaheads paths requiring only\n // a single token lookahead.\n if (areAllOneTokenLookahead && !dynamicTokensEnabled) {\n const singleTokensTypes = flatten(alt);\n if (singleTokensTypes.length === 1 &&\n isEmpty(singleTokensTypes[0].categoryMatches)) {\n const expectedTokenType = singleTokensTypes[0];\n const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;\n return function () {\n return this.LA(1).tokenTypeIdx === expectedTokenUniqueKey;\n };\n }\n else {\n const choiceToAlt = reduce(singleTokensTypes, (result, currTokType, idx) => {\n result[currTokType.tokenTypeIdx] = true;\n forEach(currTokType.categoryMatches, (currExtendingType) => {\n result[currExtendingType] = true;\n });\n return result;\n }, []);\n return function () {\n const nextToken = this.LA(1);\n return choiceToAlt[nextToken.tokenTypeIdx] === true;\n };\n }\n }\n else {\n return function () {\n nextPath: for (let j = 0; j < numOfPaths; j++) {\n const currPath = alt[j];\n const currPathLength = currPath.length;\n for (let i = 0; i < currPathLength; i++) {\n const nextToken = this.LA(i + 1);\n if (tokenMatcher(nextToken, currPath[i]) === false) {\n // mismatch in current path\n // try the next pth\n continue nextPath;\n }\n }\n // found a full path that matches.\n return true;\n }\n // none of the paths matched\n return false;\n };\n }\n}\nclass RestDefinitionFinderWalker extends RestWalker {\n constructor(topProd, targetOccurrence, targetProdType) {\n super();\n this.topProd = topProd;\n this.targetOccurrence = targetOccurrence;\n this.targetProdType = targetProdType;\n }\n startWalking() {\n this.walk(this.topProd);\n return this.restDef;\n }\n checkIsTarget(node, expectedProdType, currRest, prevRest) {\n if (node.idx === this.targetOccurrence &&\n this.targetProdType === expectedProdType) {\n this.restDef = currRest.concat(prevRest);\n return true;\n }\n // performance optimization, do not iterate over the entire Grammar ast after we have found the target\n return false;\n }\n walkOption(optionProd, currRest, prevRest) {\n if (!this.checkIsTarget(optionProd, PROD_TYPE.OPTION, currRest, prevRest)) {\n super.walkOption(optionProd, currRest, prevRest);\n }\n }\n walkAtLeastOne(atLeastOneProd, currRest, prevRest) {\n if (!this.checkIsTarget(atLeastOneProd, PROD_TYPE.REPETITION_MANDATORY, currRest, prevRest)) {\n super.walkOption(atLeastOneProd, currRest, prevRest);\n }\n }\n walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {\n if (!this.checkIsTarget(atLeastOneSepProd, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, currRest, prevRest)) {\n super.walkOption(atLeastOneSepProd, currRest, prevRest);\n }\n }\n walkMany(manyProd, currRest, prevRest) {\n if (!this.checkIsTarget(manyProd, PROD_TYPE.REPETITION, currRest, prevRest)) {\n super.walkOption(manyProd, currRest, prevRest);\n }\n }\n walkManySep(manySepProd, currRest, prevRest) {\n if (!this.checkIsTarget(manySepProd, PROD_TYPE.REPETITION_WITH_SEPARATOR, currRest, prevRest)) {\n super.walkOption(manySepProd, currRest, prevRest);\n }\n }\n}\n/**\n * Returns the definition of a target production in a top level level rule.\n */\nclass InsideDefinitionFinderVisitor extends GAstVisitor {\n constructor(targetOccurrence, targetProdType, targetRef) {\n super();\n this.targetOccurrence = targetOccurrence;\n this.targetProdType = targetProdType;\n this.targetRef = targetRef;\n this.result = [];\n }\n checkIsTarget(node, expectedProdName) {\n if (node.idx === this.targetOccurrence &&\n this.targetProdType === expectedProdName &&\n (this.targetRef === undefined || node === this.targetRef)) {\n this.result = node.definition;\n }\n }\n visitOption(node) {\n this.checkIsTarget(node, PROD_TYPE.OPTION);\n }\n visitRepetition(node) {\n this.checkIsTarget(node, PROD_TYPE.REPETITION);\n }\n visitRepetitionMandatory(node) {\n this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY);\n }\n visitRepetitionMandatoryWithSeparator(node) {\n this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR);\n }\n visitRepetitionWithSeparator(node) {\n this.checkIsTarget(node, PROD_TYPE.REPETITION_WITH_SEPARATOR);\n }\n visitAlternation(node) {\n this.checkIsTarget(node, PROD_TYPE.ALTERNATION);\n }\n}\nfunction initializeArrayOfArrays(size) {\n const result = new Array(size);\n for (let i = 0; i < size; i++) {\n result[i] = [];\n }\n return result;\n}\n/**\n * A sort of hash function between a Path in the grammar and a string.\n * Note that this returns multiple \"hashes\" to support the scenario of token categories.\n * - A single path with categories may match multiple **actual** paths.\n */\nfunction pathToHashKeys(path) {\n let keys = [\"\"];\n for (let i = 0; i < path.length; i++) {\n const tokType = path[i];\n const longerKeys = [];\n for (let j = 0; j < keys.length; j++) {\n const currShorterKey = keys[j];\n longerKeys.push(currShorterKey + \"_\" + tokType.tokenTypeIdx);\n for (let t = 0; t < tokType.categoryMatches.length; t++) {\n const categoriesKeySuffix = \"_\" + tokType.categoryMatches[t];\n longerKeys.push(currShorterKey + categoriesKeySuffix);\n }\n }\n keys = longerKeys;\n }\n return keys;\n}\n/**\n * Imperative style due to being called from a hot spot\n */\nfunction isUniquePrefixHash(altKnownPathsKeys, searchPathKeys, idx) {\n for (let currAltIdx = 0; currAltIdx < altKnownPathsKeys.length; currAltIdx++) {\n // We only want to test vs the other alternatives\n if (currAltIdx === idx) {\n continue;\n }\n const otherAltKnownPathsKeys = altKnownPathsKeys[currAltIdx];\n for (let searchIdx = 0; searchIdx < searchPathKeys.length; searchIdx++) {\n const searchKey = searchPathKeys[searchIdx];\n if (otherAltKnownPathsKeys[searchKey] === true) {\n return false;\n }\n }\n }\n // None of the SearchPathKeys were found in any of the other alternatives\n return true;\n}\nexport function lookAheadSequenceFromAlternatives(altsDefs, k) {\n const partialAlts = map(altsDefs, (currAlt) => possiblePathsFrom([currAlt], 1));\n const finalResult = initializeArrayOfArrays(partialAlts.length);\n const altsHashes = map(partialAlts, (currAltPaths) => {\n const dict = {};\n forEach(currAltPaths, (item) => {\n const keys = pathToHashKeys(item.partialPath);\n forEach(keys, (currKey) => {\n dict[currKey] = true;\n });\n });\n return dict;\n });\n let newData = partialAlts;\n // maxLookahead loop\n for (let pathLength = 1; pathLength <= k; pathLength++) {\n const currDataset = newData;\n newData = initializeArrayOfArrays(currDataset.length);\n // alternatives loop\n for (let altIdx = 0; altIdx < currDataset.length; altIdx++) {\n const currAltPathsAndSuffixes = currDataset[altIdx];\n // paths in current alternative loop\n for (let currPathIdx = 0; currPathIdx < currAltPathsAndSuffixes.length; currPathIdx++) {\n const currPathPrefix = currAltPathsAndSuffixes[currPathIdx].partialPath;\n const suffixDef = currAltPathsAndSuffixes[currPathIdx].suffixDef;\n const prefixKeys = pathToHashKeys(currPathPrefix);\n const isUnique = isUniquePrefixHash(altsHashes, prefixKeys, altIdx);\n // End of the line for this path.\n if (isUnique || isEmpty(suffixDef) || currPathPrefix.length === k) {\n const currAltResult = finalResult[altIdx];\n // TODO: Can we implement a containsPath using Maps/Dictionaries?\n if (containsPath(currAltResult, currPathPrefix) === false) {\n currAltResult.push(currPathPrefix);\n // Update all new keys for the current path.\n for (let j = 0; j < prefixKeys.length; j++) {\n const currKey = prefixKeys[j];\n altsHashes[altIdx][currKey] = true;\n }\n }\n }\n // Expand longer paths\n else {\n const newPartialPathsAndSuffixes = possiblePathsFrom(suffixDef, pathLength + 1, currPathPrefix);\n newData[altIdx] = newData[altIdx].concat(newPartialPathsAndSuffixes);\n // Update keys for new known paths\n forEach(newPartialPathsAndSuffixes, (item) => {\n const prefixKeys = pathToHashKeys(item.partialPath);\n forEach(prefixKeys, (key) => {\n altsHashes[altIdx][key] = true;\n });\n });\n }\n }\n }\n }\n return finalResult;\n}\nexport function getLookaheadPathsForOr(occurrence, ruleGrammar, k, orProd) {\n const visitor = new InsideDefinitionFinderVisitor(occurrence, PROD_TYPE.ALTERNATION, orProd);\n ruleGrammar.accept(visitor);\n return lookAheadSequenceFromAlternatives(visitor.result, k);\n}\nexport function getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k) {\n const insideDefVisitor = new InsideDefinitionFinderVisitor(occurrence, prodType);\n ruleGrammar.accept(insideDefVisitor);\n const insideDef = insideDefVisitor.result;\n const afterDefWalker = new RestDefinitionFinderWalker(ruleGrammar, occurrence, prodType);\n const afterDef = afterDefWalker.startWalking();\n const insideFlat = new AlternativeGAST({ definition: insideDef });\n const afterFlat = new AlternativeGAST({ definition: afterDef });\n return lookAheadSequenceFromAlternatives([insideFlat, afterFlat], k);\n}\nexport function containsPath(alternative, searchPath) {\n compareOtherPath: for (let i = 0; i < alternative.length; i++) {\n const otherPath = alternative[i];\n if (otherPath.length !== searchPath.length) {\n continue;\n }\n for (let j = 0; j < otherPath.length; j++) {\n const searchTok = searchPath[j];\n const otherTok = otherPath[j];\n const matchingTokens = searchTok === otherTok ||\n otherTok.categoryMatchesMap[searchTok.tokenTypeIdx] !== undefined;\n if (matchingTokens === false) {\n continue compareOtherPath;\n }\n }\n return true;\n }\n return false;\n}\nexport function isStrictPrefixOfPath(prefix, other) {\n return (prefix.length < other.length &&\n every(prefix, (tokType, idx) => {\n const otherTokType = other[idx];\n return (tokType === otherTokType ||\n otherTokType.categoryMatchesMap[tokType.tokenTypeIdx]);\n }));\n}\nexport function areTokenCategoriesNotUsed(lookAheadPaths) {\n return every(lookAheadPaths, (singleAltPaths) => every(singleAltPaths, (singlePath) => every(singlePath, (token) => isEmpty(token.categoryMatches))));\n}\n//# sourceMappingURL=lookahead.js.map","import { clone, compact, difference, drop, dropRight, filter, first, flatMap, flatten, forEach, groupBy, includes, isEmpty, map, pickBy, reduce, reject, values, } from \"lodash-es\";\nimport { ParserDefinitionErrorType, } from \"../parser/parser.js\";\nimport { Alternation, Alternative as AlternativeGAST, GAstVisitor, getProductionDslName, isOptionalProd, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Terminal, } from \"@chevrotain/gast\";\nimport { containsPath, getLookaheadPathsForOptionalProd, getLookaheadPathsForOr, getProdType, isStrictPrefixOfPath, } from \"./lookahead.js\";\nimport { nextPossibleTokensAfter } from \"./interpreter.js\";\nimport { tokenStructuredMatcher } from \"../../scan/tokens.js\";\nexport function validateLookahead(options) {\n const lookaheadValidationErrorMessages = options.lookaheadStrategy.validate({\n rules: options.rules,\n tokenTypes: options.tokenTypes,\n grammarName: options.grammarName,\n });\n return map(lookaheadValidationErrorMessages, (errorMessage) => (Object.assign({ type: ParserDefinitionErrorType.CUSTOM_LOOKAHEAD_VALIDATION }, errorMessage)));\n}\nexport function validateGrammar(topLevels, tokenTypes, errMsgProvider, grammarName) {\n const duplicateErrors = flatMap(topLevels, (currTopLevel) => validateDuplicateProductions(currTopLevel, errMsgProvider));\n const termsNamespaceConflictErrors = checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider);\n const tooManyAltsErrors = flatMap(topLevels, (curRule) => validateTooManyAlts(curRule, errMsgProvider));\n const duplicateRulesError = flatMap(topLevels, (curRule) => validateRuleDoesNotAlreadyExist(curRule, topLevels, grammarName, errMsgProvider));\n return duplicateErrors.concat(termsNamespaceConflictErrors, tooManyAltsErrors, duplicateRulesError);\n}\nfunction validateDuplicateProductions(topLevelRule, errMsgProvider) {\n const collectorVisitor = new OccurrenceValidationCollector();\n topLevelRule.accept(collectorVisitor);\n const allRuleProductions = collectorVisitor.allProductions;\n const productionGroups = groupBy(allRuleProductions, identifyProductionForDuplicates);\n const duplicates = pickBy(productionGroups, (currGroup) => {\n return currGroup.length > 1;\n });\n const errors = map(values(duplicates), (currDuplicates) => {\n const firstProd = first(currDuplicates);\n const msg = errMsgProvider.buildDuplicateFoundError(topLevelRule, currDuplicates);\n const dslName = getProductionDslName(firstProd);\n const defError = {\n message: msg,\n type: ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,\n ruleName: topLevelRule.name,\n dslName: dslName,\n occurrence: firstProd.idx,\n };\n const param = getExtraProductionArgument(firstProd);\n if (param) {\n defError.parameter = param;\n }\n return defError;\n });\n return errors;\n}\nexport function identifyProductionForDuplicates(prod) {\n return `${getProductionDslName(prod)}_#_${prod.idx}_#_${getExtraProductionArgument(prod)}`;\n}\nfunction getExtraProductionArgument(prod) {\n if (prod instanceof Terminal) {\n return prod.terminalType.name;\n }\n else if (prod instanceof NonTerminal) {\n return prod.nonTerminalName;\n }\n else {\n return \"\";\n }\n}\nexport class OccurrenceValidationCollector extends GAstVisitor {\n constructor() {\n super(...arguments);\n this.allProductions = [];\n }\n visitNonTerminal(subrule) {\n this.allProductions.push(subrule);\n }\n visitOption(option) {\n this.allProductions.push(option);\n }\n visitRepetitionWithSeparator(manySep) {\n this.allProductions.push(manySep);\n }\n visitRepetitionMandatory(atLeastOne) {\n this.allProductions.push(atLeastOne);\n }\n visitRepetitionMandatoryWithSeparator(atLeastOneSep) {\n this.allProductions.push(atLeastOneSep);\n }\n visitRepetition(many) {\n this.allProductions.push(many);\n }\n visitAlternation(or) {\n this.allProductions.push(or);\n }\n visitTerminal(terminal) {\n this.allProductions.push(terminal);\n }\n}\nexport function validateRuleDoesNotAlreadyExist(rule, allRules, className, errMsgProvider) {\n const errors = [];\n const occurrences = reduce(allRules, (result, curRule) => {\n if (curRule.name === rule.name) {\n return result + 1;\n }\n return result;\n }, 0);\n if (occurrences > 1) {\n const errMsg = errMsgProvider.buildDuplicateRuleNameError({\n topLevelRule: rule,\n grammarName: className,\n });\n errors.push({\n message: errMsg,\n type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,\n ruleName: rule.name,\n });\n }\n return errors;\n}\n// TODO: is there anyway to get only the rule names of rules inherited from the super grammars?\n// This is not part of the IGrammarErrorProvider because the validation cannot be performed on\n// The grammar structure, only at runtime.\nexport function validateRuleIsOverridden(ruleName, definedRulesNames, className) {\n const errors = [];\n let errMsg;\n if (!includes(definedRulesNames, ruleName)) {\n errMsg =\n `Invalid rule override, rule: ->${ruleName}<- cannot be overridden in the grammar: ->${className}<-` +\n `as it is not defined in any of the super grammars `;\n errors.push({\n message: errMsg,\n type: ParserDefinitionErrorType.INVALID_RULE_OVERRIDE,\n ruleName: ruleName,\n });\n }\n return errors;\n}\nexport function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path = []) {\n const errors = [];\n const nextNonTerminals = getFirstNoneTerminal(currRule.definition);\n if (isEmpty(nextNonTerminals)) {\n return [];\n }\n else {\n const ruleName = topRule.name;\n const foundLeftRecursion = includes(nextNonTerminals, topRule);\n if (foundLeftRecursion) {\n errors.push({\n message: errMsgProvider.buildLeftRecursionError({\n topLevelRule: topRule,\n leftRecursionPath: path,\n }),\n type: ParserDefinitionErrorType.LEFT_RECURSION,\n ruleName: ruleName,\n });\n }\n // we are only looking for cyclic paths leading back to the specific topRule\n // other cyclic paths are ignored, we still need this difference to avoid infinite loops...\n const validNextSteps = difference(nextNonTerminals, path.concat([topRule]));\n const errorsFromNextSteps = flatMap(validNextSteps, (currRefRule) => {\n const newPath = clone(path);\n newPath.push(currRefRule);\n return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);\n });\n return errors.concat(errorsFromNextSteps);\n }\n}\nexport function getFirstNoneTerminal(definition) {\n let result = [];\n if (isEmpty(definition)) {\n return result;\n }\n const firstProd = first(definition);\n /* istanbul ignore else */\n if (firstProd instanceof NonTerminal) {\n result.push(firstProd.referencedRule);\n }\n else if (firstProd instanceof AlternativeGAST ||\n firstProd instanceof Option ||\n firstProd instanceof RepetitionMandatory ||\n firstProd instanceof RepetitionMandatoryWithSeparator ||\n firstProd instanceof RepetitionWithSeparator ||\n firstProd instanceof Repetition) {\n result = result.concat(getFirstNoneTerminal(firstProd.definition));\n }\n else if (firstProd instanceof Alternation) {\n // each sub definition in alternation is a FLAT\n result = flatten(map(firstProd.definition, (currSubDef) => getFirstNoneTerminal(currSubDef.definition)));\n }\n else if (firstProd instanceof Terminal) {\n // nothing to see, move along\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n const isFirstOptional = isOptionalProd(firstProd);\n const hasMore = definition.length > 1;\n if (isFirstOptional && hasMore) {\n const rest = drop(definition);\n return result.concat(getFirstNoneTerminal(rest));\n }\n else {\n return result;\n }\n}\nclass OrCollector extends GAstVisitor {\n constructor() {\n super(...arguments);\n this.alternations = [];\n }\n visitAlternation(node) {\n this.alternations.push(node);\n }\n}\nexport function validateEmptyOrAlternative(topLevelRule, errMsgProvider) {\n const orCollector = new OrCollector();\n topLevelRule.accept(orCollector);\n const ors = orCollector.alternations;\n const errors = flatMap(ors, (currOr) => {\n const exceptLast = dropRight(currOr.definition);\n return flatMap(exceptLast, (currAlternative, currAltIdx) => {\n const possibleFirstInAlt = nextPossibleTokensAfter([currAlternative], [], tokenStructuredMatcher, 1);\n if (isEmpty(possibleFirstInAlt)) {\n return [\n {\n message: errMsgProvider.buildEmptyAlternationError({\n topLevelRule: topLevelRule,\n alternation: currOr,\n emptyChoiceIdx: currAltIdx,\n }),\n type: ParserDefinitionErrorType.NONE_LAST_EMPTY_ALT,\n ruleName: topLevelRule.name,\n occurrence: currOr.idx,\n alternative: currAltIdx + 1,\n },\n ];\n }\n else {\n return [];\n }\n });\n });\n return errors;\n}\nexport function validateAmbiguousAlternationAlternatives(topLevelRule, globalMaxLookahead, errMsgProvider) {\n const orCollector = new OrCollector();\n topLevelRule.accept(orCollector);\n let ors = orCollector.alternations;\n // New Handling of ignoring ambiguities\n // - https://github.com/chevrotain/chevrotain/issues/869\n ors = reject(ors, (currOr) => currOr.ignoreAmbiguities === true);\n const errors = flatMap(ors, (currOr) => {\n const currOccurrence = currOr.idx;\n const actualMaxLookahead = currOr.maxLookahead || globalMaxLookahead;\n const alternatives = getLookaheadPathsForOr(currOccurrence, topLevelRule, actualMaxLookahead, currOr);\n const altsAmbiguityErrors = checkAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);\n const altsPrefixAmbiguityErrors = checkPrefixAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);\n return altsAmbiguityErrors.concat(altsPrefixAmbiguityErrors);\n });\n return errors;\n}\nexport class RepetitionCollector extends GAstVisitor {\n constructor() {\n super(...arguments);\n this.allProductions = [];\n }\n visitRepetitionWithSeparator(manySep) {\n this.allProductions.push(manySep);\n }\n visitRepetitionMandatory(atLeastOne) {\n this.allProductions.push(atLeastOne);\n }\n visitRepetitionMandatoryWithSeparator(atLeastOneSep) {\n this.allProductions.push(atLeastOneSep);\n }\n visitRepetition(many) {\n this.allProductions.push(many);\n }\n}\nexport function validateTooManyAlts(topLevelRule, errMsgProvider) {\n const orCollector = new OrCollector();\n topLevelRule.accept(orCollector);\n const ors = orCollector.alternations;\n const errors = flatMap(ors, (currOr) => {\n if (currOr.definition.length > 255) {\n return [\n {\n message: errMsgProvider.buildTooManyAlternativesError({\n topLevelRule: topLevelRule,\n alternation: currOr,\n }),\n type: ParserDefinitionErrorType.TOO_MANY_ALTS,\n ruleName: topLevelRule.name,\n occurrence: currOr.idx,\n },\n ];\n }\n else {\n return [];\n }\n });\n return errors;\n}\nexport function validateSomeNonEmptyLookaheadPath(topLevelRules, maxLookahead, errMsgProvider) {\n const errors = [];\n forEach(topLevelRules, (currTopRule) => {\n const collectorVisitor = new RepetitionCollector();\n currTopRule.accept(collectorVisitor);\n const allRuleProductions = collectorVisitor.allProductions;\n forEach(allRuleProductions, (currProd) => {\n const prodType = getProdType(currProd);\n const actualMaxLookahead = currProd.maxLookahead || maxLookahead;\n const currOccurrence = currProd.idx;\n const paths = getLookaheadPathsForOptionalProd(currOccurrence, currTopRule, prodType, actualMaxLookahead);\n const pathsInsideProduction = paths[0];\n if (isEmpty(flatten(pathsInsideProduction))) {\n const errMsg = errMsgProvider.buildEmptyRepetitionError({\n topLevelRule: currTopRule,\n repetition: currProd,\n });\n errors.push({\n message: errMsg,\n type: ParserDefinitionErrorType.NO_NON_EMPTY_LOOKAHEAD,\n ruleName: currTopRule.name,\n });\n }\n });\n });\n return errors;\n}\nfunction checkAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {\n const foundAmbiguousPaths = [];\n const identicalAmbiguities = reduce(alternatives, (result, currAlt, currAltIdx) => {\n // ignore (skip) ambiguities with this alternative\n if (alternation.definition[currAltIdx].ignoreAmbiguities === true) {\n return result;\n }\n forEach(currAlt, (currPath) => {\n const altsCurrPathAppearsIn = [currAltIdx];\n forEach(alternatives, (currOtherAlt, currOtherAltIdx) => {\n if (currAltIdx !== currOtherAltIdx &&\n containsPath(currOtherAlt, currPath) &&\n // ignore (skip) ambiguities with this \"other\" alternative\n alternation.definition[currOtherAltIdx].ignoreAmbiguities !== true) {\n altsCurrPathAppearsIn.push(currOtherAltIdx);\n }\n });\n if (altsCurrPathAppearsIn.length > 1 &&\n !containsPath(foundAmbiguousPaths, currPath)) {\n foundAmbiguousPaths.push(currPath);\n result.push({\n alts: altsCurrPathAppearsIn,\n path: currPath,\n });\n }\n });\n return result;\n }, []);\n const currErrors = map(identicalAmbiguities, (currAmbDescriptor) => {\n const ambgIndices = map(currAmbDescriptor.alts, (currAltIdx) => currAltIdx + 1);\n const currMessage = errMsgProvider.buildAlternationAmbiguityError({\n topLevelRule: rule,\n alternation: alternation,\n ambiguityIndices: ambgIndices,\n prefixPath: currAmbDescriptor.path,\n });\n return {\n message: currMessage,\n type: ParserDefinitionErrorType.AMBIGUOUS_ALTS,\n ruleName: rule.name,\n occurrence: alternation.idx,\n alternatives: currAmbDescriptor.alts,\n };\n });\n return currErrors;\n}\nexport function checkPrefixAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {\n // flatten\n const pathsAndIndices = reduce(alternatives, (result, currAlt, idx) => {\n const currPathsAndIdx = map(currAlt, (currPath) => {\n return { idx: idx, path: currPath };\n });\n return result.concat(currPathsAndIdx);\n }, []);\n const errors = compact(flatMap(pathsAndIndices, (currPathAndIdx) => {\n const alternativeGast = alternation.definition[currPathAndIdx.idx];\n // ignore (skip) ambiguities with this alternative\n if (alternativeGast.ignoreAmbiguities === true) {\n return [];\n }\n const targetIdx = currPathAndIdx.idx;\n const targetPath = currPathAndIdx.path;\n const prefixAmbiguitiesPathsAndIndices = filter(pathsAndIndices, (searchPathAndIdx) => {\n // prefix ambiguity can only be created from lower idx (higher priority) path\n return (\n // ignore (skip) ambiguities with this \"other\" alternative\n alternation.definition[searchPathAndIdx.idx].ignoreAmbiguities !==\n true &&\n searchPathAndIdx.idx < targetIdx &&\n // checking for strict prefix because identical lookaheads\n // will be be detected using a different validation.\n isStrictPrefixOfPath(searchPathAndIdx.path, targetPath));\n });\n const currPathPrefixErrors = map(prefixAmbiguitiesPathsAndIndices, (currAmbPathAndIdx) => {\n const ambgIndices = [currAmbPathAndIdx.idx + 1, targetIdx + 1];\n const occurrence = alternation.idx === 0 ? \"\" : alternation.idx;\n const message = errMsgProvider.buildAlternationPrefixAmbiguityError({\n topLevelRule: rule,\n alternation: alternation,\n ambiguityIndices: ambgIndices,\n prefixPath: currAmbPathAndIdx.path,\n });\n return {\n message: message,\n type: ParserDefinitionErrorType.AMBIGUOUS_PREFIX_ALTS,\n ruleName: rule.name,\n occurrence: occurrence,\n alternatives: ambgIndices,\n };\n });\n return currPathPrefixErrors;\n }));\n return errors;\n}\nfunction checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider) {\n const errors = [];\n const tokenNames = map(tokenTypes, (currToken) => currToken.name);\n forEach(topLevels, (currRule) => {\n const currRuleName = currRule.name;\n if (includes(tokenNames, currRuleName)) {\n const errMsg = errMsgProvider.buildNamespaceConflictError(currRule);\n errors.push({\n message: errMsg,\n type: ParserDefinitionErrorType.CONFLICT_TOKENS_RULES_NAMESPACE,\n ruleName: currRuleName,\n });\n }\n });\n return errors;\n}\n//# sourceMappingURL=checks.js.map","import { defaults, forEach } from \"lodash-es\";\nimport { resolveGrammar as orgResolveGrammar } from \"../resolver.js\";\nimport { validateGrammar as orgValidateGrammar } from \"../checks.js\";\nimport { defaultGrammarResolverErrorProvider, defaultGrammarValidatorErrorProvider, } from \"../../errors_public.js\";\nexport function resolveGrammar(options) {\n const actualOptions = defaults(options, {\n errMsgProvider: defaultGrammarResolverErrorProvider,\n });\n const topRulesTable = {};\n forEach(options.rules, (rule) => {\n topRulesTable[rule.name] = rule;\n });\n return orgResolveGrammar(topRulesTable, actualOptions.errMsgProvider);\n}\nexport function validateGrammar(options) {\n options = defaults(options, {\n errMsgProvider: defaultGrammarValidatorErrorProvider,\n });\n return orgValidateGrammar(options.rules, options.tokenTypes, options.errMsgProvider, options.grammarName);\n}\n//# sourceMappingURL=gast_resolver_public.js.map","import { includes } from \"lodash-es\";\nconst MISMATCHED_TOKEN_EXCEPTION = \"MismatchedTokenException\";\nconst NO_VIABLE_ALT_EXCEPTION = \"NoViableAltException\";\nconst EARLY_EXIT_EXCEPTION = \"EarlyExitException\";\nconst NOT_ALL_INPUT_PARSED_EXCEPTION = \"NotAllInputParsedException\";\nconst RECOGNITION_EXCEPTION_NAMES = [\n MISMATCHED_TOKEN_EXCEPTION,\n NO_VIABLE_ALT_EXCEPTION,\n EARLY_EXIT_EXCEPTION,\n NOT_ALL_INPUT_PARSED_EXCEPTION,\n];\nObject.freeze(RECOGNITION_EXCEPTION_NAMES);\n// hacks to bypass no support for custom Errors in javascript/typescript\nexport function isRecognitionException(error) {\n // can't do instanceof on hacked custom js exceptions\n return includes(RECOGNITION_EXCEPTION_NAMES, error.name);\n}\nclass RecognitionException extends Error {\n constructor(message, token) {\n super(message);\n this.token = token;\n this.resyncedTokens = [];\n // fix prototype chain when typescript target is ES5\n Object.setPrototypeOf(this, new.target.prototype);\n /* istanbul ignore next - V8 workaround to remove constructor from stacktrace when typescript target is ES5 */\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, this.constructor);\n }\n }\n}\nexport class MismatchedTokenException extends RecognitionException {\n constructor(message, token, previousToken) {\n super(message, token);\n this.previousToken = previousToken;\n this.name = MISMATCHED_TOKEN_EXCEPTION;\n }\n}\nexport class NoViableAltException extends RecognitionException {\n constructor(message, token, previousToken) {\n super(message, token);\n this.previousToken = previousToken;\n this.name = NO_VIABLE_ALT_EXCEPTION;\n }\n}\nexport class NotAllInputParsedException extends RecognitionException {\n constructor(message, token) {\n super(message, token);\n this.name = NOT_ALL_INPUT_PARSED_EXCEPTION;\n }\n}\nexport class EarlyExitException extends RecognitionException {\n constructor(message, token, previousToken) {\n super(message, token);\n this.previousToken = previousToken;\n this.name = EARLY_EXIT_EXCEPTION;\n }\n}\n//# sourceMappingURL=exceptions_public.js.map","import { createTokenInstance, EOF, tokenMatcher, } from \"../../../scan/tokens_public.js\";\nimport { clone, dropRight, find, flatten, has, includes, isEmpty, map, } from \"lodash-es\";\nimport { MismatchedTokenException } from \"../../exceptions_public.js\";\nimport { IN } from \"../../constants.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\nexport const EOF_FOLLOW_KEY = {};\nexport const IN_RULE_RECOVERY_EXCEPTION = \"InRuleRecoveryException\";\nexport class InRuleRecoveryException extends Error {\n constructor(message) {\n super(message);\n this.name = IN_RULE_RECOVERY_EXCEPTION;\n }\n}\n/**\n * This trait is responsible for the error recovery and fault tolerant logic\n */\nexport class Recoverable {\n initRecoverable(config) {\n this.firstAfterRepMap = {};\n this.resyncFollows = {};\n this.recoveryEnabled = has(config, \"recoveryEnabled\")\n ? config.recoveryEnabled // assumes end user provides the correct config value/type\n : DEFAULT_PARSER_CONFIG.recoveryEnabled;\n // performance optimization, NOOP will be inlined which\n // effectively means that this optional feature does not exist\n // when not used.\n if (this.recoveryEnabled) {\n this.attemptInRepetitionRecovery = attemptInRepetitionRecovery;\n }\n }\n getTokenToInsert(tokType) {\n const tokToInsert = createTokenInstance(tokType, \"\", NaN, NaN, NaN, NaN, NaN, NaN);\n tokToInsert.isInsertedInRecovery = true;\n return tokToInsert;\n }\n canTokenTypeBeInsertedInRecovery(tokType) {\n return true;\n }\n canTokenTypeBeDeletedInRecovery(tokType) {\n return true;\n }\n tryInRepetitionRecovery(grammarRule, grammarRuleArgs, lookAheadFunc, expectedTokType) {\n // TODO: can the resyncTokenType be cached?\n const reSyncTokType = this.findReSyncTokenType();\n const savedLexerState = this.exportLexerState();\n const resyncedTokens = [];\n let passedResyncPoint = false;\n const nextTokenWithoutResync = this.LA(1);\n let currToken = this.LA(1);\n const generateErrorMessage = () => {\n const previousToken = this.LA(0);\n // we are preemptively re-syncing before an error has been detected, therefor we must reproduce\n // the error that would have been thrown\n const msg = this.errorMessageProvider.buildMismatchTokenMessage({\n expected: expectedTokType,\n actual: nextTokenWithoutResync,\n previous: previousToken,\n ruleName: this.getCurrRuleFullName(),\n });\n const error = new MismatchedTokenException(msg, nextTokenWithoutResync, this.LA(0));\n // the first token here will be the original cause of the error, this is not part of the resyncedTokens property.\n error.resyncedTokens = dropRight(resyncedTokens);\n this.SAVE_ERROR(error);\n };\n while (!passedResyncPoint) {\n // re-synced to a point where we can safely exit the repetition/\n if (this.tokenMatcher(currToken, expectedTokType)) {\n generateErrorMessage();\n return; // must return here to avoid reverting the inputIdx\n }\n else if (lookAheadFunc.call(this)) {\n // we skipped enough tokens so we can resync right back into another iteration of the repetition grammar rule\n generateErrorMessage();\n // recursive invocation in other to support multiple re-syncs in the same top level repetition grammar rule\n grammarRule.apply(this, grammarRuleArgs);\n return; // must return here to avoid reverting the inputIdx\n }\n else if (this.tokenMatcher(currToken, reSyncTokType)) {\n passedResyncPoint = true;\n }\n else {\n currToken = this.SKIP_TOKEN();\n this.addToResyncTokens(currToken, resyncedTokens);\n }\n }\n // we were unable to find a CLOSER point to resync inside the Repetition, reset the state.\n // The parsing exception we were trying to prevent will happen in the NEXT parsing step. it may be handled by\n // \"between rules\" resync recovery later in the flow.\n this.importLexerState(savedLexerState);\n }\n shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck) {\n // Edge case of arriving from a MANY repetition which is stuck\n // Attempting recovery in this case could cause an infinite loop\n if (notStuck === false) {\n return false;\n }\n // no need to recover, next token is what we expect...\n if (this.tokenMatcher(this.LA(1), expectTokAfterLastMatch)) {\n return false;\n }\n // error recovery is disabled during backtracking as it can make the parser ignore a valid grammar path\n // and prefer some backtracking path that includes recovered errors.\n if (this.isBackTracking()) {\n return false;\n }\n // if we can perform inRule recovery (single token insertion or deletion) we always prefer that recovery algorithm\n // because if it works, it makes the least amount of changes to the input stream (greedy algorithm)\n //noinspection RedundantIfStatementJS\n if (this.canPerformInRuleRecovery(expectTokAfterLastMatch, this.getFollowsForInRuleRecovery(expectTokAfterLastMatch, nextTokIdx))) {\n return false;\n }\n return true;\n }\n // Error Recovery functionality\n getFollowsForInRuleRecovery(tokType, tokIdxInRule) {\n const grammarPath = this.getCurrentGrammarPath(tokType, tokIdxInRule);\n const follows = this.getNextPossibleTokenTypes(grammarPath);\n return follows;\n }\n tryInRuleRecovery(expectedTokType, follows) {\n if (this.canRecoverWithSingleTokenInsertion(expectedTokType, follows)) {\n const tokToInsert = this.getTokenToInsert(expectedTokType);\n return tokToInsert;\n }\n if (this.canRecoverWithSingleTokenDeletion(expectedTokType)) {\n const nextTok = this.SKIP_TOKEN();\n this.consumeToken();\n return nextTok;\n }\n throw new InRuleRecoveryException(\"sad sad panda\");\n }\n canPerformInRuleRecovery(expectedToken, follows) {\n return (this.canRecoverWithSingleTokenInsertion(expectedToken, follows) ||\n this.canRecoverWithSingleTokenDeletion(expectedToken));\n }\n canRecoverWithSingleTokenInsertion(expectedTokType, follows) {\n if (!this.canTokenTypeBeInsertedInRecovery(expectedTokType)) {\n return false;\n }\n // must know the possible following tokens to perform single token insertion\n if (isEmpty(follows)) {\n return false;\n }\n const mismatchedTok = this.LA(1);\n const isMisMatchedTokInFollows = find(follows, (possibleFollowsTokType) => {\n return this.tokenMatcher(mismatchedTok, possibleFollowsTokType);\n }) !== undefined;\n return isMisMatchedTokInFollows;\n }\n canRecoverWithSingleTokenDeletion(expectedTokType) {\n if (!this.canTokenTypeBeDeletedInRecovery(expectedTokType)) {\n return false;\n }\n const isNextTokenWhatIsExpected = this.tokenMatcher(this.LA(2), expectedTokType);\n return isNextTokenWhatIsExpected;\n }\n isInCurrentRuleReSyncSet(tokenTypeIdx) {\n const followKey = this.getCurrFollowKey();\n const currentRuleReSyncSet = this.getFollowSetFromFollowKey(followKey);\n return includes(currentRuleReSyncSet, tokenTypeIdx);\n }\n findReSyncTokenType() {\n const allPossibleReSyncTokTypes = this.flattenFollowSet();\n // this loop will always terminate as EOF is always in the follow stack and also always (virtually) in the input\n let nextToken = this.LA(1);\n let k = 2;\n while (true) {\n const foundMatch = find(allPossibleReSyncTokTypes, (resyncTokType) => {\n const canMatch = tokenMatcher(nextToken, resyncTokType);\n return canMatch;\n });\n if (foundMatch !== undefined) {\n return foundMatch;\n }\n nextToken = this.LA(k);\n k++;\n }\n }\n getCurrFollowKey() {\n // the length is at least one as we always add the ruleName to the stack before invoking the rule.\n if (this.RULE_STACK.length === 1) {\n return EOF_FOLLOW_KEY;\n }\n const currRuleShortName = this.getLastExplicitRuleShortName();\n const currRuleIdx = this.getLastExplicitRuleOccurrenceIndex();\n const prevRuleShortName = this.getPreviousExplicitRuleShortName();\n return {\n ruleName: this.shortRuleNameToFullName(currRuleShortName),\n idxInCallingRule: currRuleIdx,\n inRule: this.shortRuleNameToFullName(prevRuleShortName),\n };\n }\n buildFullFollowKeyStack() {\n const explicitRuleStack = this.RULE_STACK;\n const explicitOccurrenceStack = this.RULE_OCCURRENCE_STACK;\n return map(explicitRuleStack, (ruleName, idx) => {\n if (idx === 0) {\n return EOF_FOLLOW_KEY;\n }\n return {\n ruleName: this.shortRuleNameToFullName(ruleName),\n idxInCallingRule: explicitOccurrenceStack[idx],\n inRule: this.shortRuleNameToFullName(explicitRuleStack[idx - 1]),\n };\n });\n }\n flattenFollowSet() {\n const followStack = map(this.buildFullFollowKeyStack(), (currKey) => {\n return this.getFollowSetFromFollowKey(currKey);\n });\n return flatten(followStack);\n }\n getFollowSetFromFollowKey(followKey) {\n if (followKey === EOF_FOLLOW_KEY) {\n return [EOF];\n }\n const followName = followKey.ruleName + followKey.idxInCallingRule + IN + followKey.inRule;\n return this.resyncFollows[followName];\n }\n // It does not make any sense to include a virtual EOF token in the list of resynced tokens\n // as EOF does not really exist and thus does not contain any useful information (line/column numbers)\n addToResyncTokens(token, resyncTokens) {\n if (!this.tokenMatcher(token, EOF)) {\n resyncTokens.push(token);\n }\n return resyncTokens;\n }\n reSyncTo(tokType) {\n const resyncedTokens = [];\n let nextTok = this.LA(1);\n while (this.tokenMatcher(nextTok, tokType) === false) {\n nextTok = this.SKIP_TOKEN();\n this.addToResyncTokens(nextTok, resyncedTokens);\n }\n // the last token is not part of the error.\n return dropRight(resyncedTokens);\n }\n attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {\n // by default this is a NO-OP\n // The actual implementation is with the function(not method) below\n }\n getCurrentGrammarPath(tokType, tokIdxInRule) {\n const pathRuleStack = this.getHumanReadableRuleStack();\n const pathOccurrenceStack = clone(this.RULE_OCCURRENCE_STACK);\n const grammarPath = {\n ruleStack: pathRuleStack,\n occurrenceStack: pathOccurrenceStack,\n lastTok: tokType,\n lastTokOccurrence: tokIdxInRule,\n };\n return grammarPath;\n }\n getHumanReadableRuleStack() {\n return map(this.RULE_STACK, (currShortName) => this.shortRuleNameToFullName(currShortName));\n }\n}\nexport function attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {\n const key = this.getKeyForAutomaticLookahead(dslMethodIdx, prodOccurrence);\n let firstAfterRepInfo = this.firstAfterRepMap[key];\n if (firstAfterRepInfo === undefined) {\n const currRuleName = this.getCurrRuleFullName();\n const ruleGrammar = this.getGAstProductions()[currRuleName];\n const walker = new nextToksWalker(ruleGrammar, prodOccurrence);\n firstAfterRepInfo = walker.startWalking();\n this.firstAfterRepMap[key] = firstAfterRepInfo;\n }\n let expectTokAfterLastMatch = firstAfterRepInfo.token;\n let nextTokIdx = firstAfterRepInfo.occurrence;\n const isEndOfRule = firstAfterRepInfo.isEndOfRule;\n // special edge case of a TOP most repetition after which the input should END.\n // this will force an attempt for inRule recovery in that scenario.\n if (this.RULE_STACK.length === 1 &&\n isEndOfRule &&\n expectTokAfterLastMatch === undefined) {\n expectTokAfterLastMatch = EOF;\n nextTokIdx = 1;\n }\n // We don't have anything to re-sync to...\n // this condition was extracted from `shouldInRepetitionRecoveryBeTried` to act as a type-guard\n if (expectTokAfterLastMatch === undefined || nextTokIdx === undefined) {\n return;\n }\n if (this.shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck)) {\n // TODO: performance optimization: instead of passing the original args here, we modify\n // the args param (or create a new one) and make sure the lookahead func is explicitly provided\n // to avoid searching the cache for it once more.\n this.tryInRepetitionRecovery(prodFunc, args, lookaheadFunc, expectTokAfterLastMatch);\n }\n}\n//# sourceMappingURL=recoverable.js.map","// Lookahead keys are 32Bit integers in the form\n// TTTTTTTT-ZZZZZZZZZZZZ-YYYY-XXXXXXXX\n// XXXX -> Occurrence Index bitmap.\n// YYYY -> DSL Method Type bitmap.\n// ZZZZZZZZZZZZZZZ -> Rule short Index bitmap.\n// TTTTTTTTT -> alternation alternative index bitmap\nexport const BITS_FOR_METHOD_TYPE = 4;\nexport const BITS_FOR_OCCURRENCE_IDX = 8;\nexport const BITS_FOR_RULE_IDX = 12;\n// TODO: validation, this means that there may at most 2^8 --> 256 alternatives for an alternation.\nexport const BITS_FOR_ALT_IDX = 8;\n// short string used as part of mapping keys.\n// being short improves the performance when composing KEYS for maps out of these\n// The 5 - 8 bits (16 possible values, are reserved for the DSL method indices)\nexport const OR_IDX = 1 << BITS_FOR_OCCURRENCE_IDX;\nexport const OPTION_IDX = 2 << BITS_FOR_OCCURRENCE_IDX;\nexport const MANY_IDX = 3 << BITS_FOR_OCCURRENCE_IDX;\nexport const AT_LEAST_ONE_IDX = 4 << BITS_FOR_OCCURRENCE_IDX;\nexport const MANY_SEP_IDX = 5 << BITS_FOR_OCCURRENCE_IDX;\nexport const AT_LEAST_ONE_SEP_IDX = 6 << BITS_FOR_OCCURRENCE_IDX;\n// this actually returns a number, but it is always used as a string (object prop key)\nexport function getKeyForAutomaticLookahead(ruleIdx, dslMethodIdx, occurrence) {\n return occurrence | dslMethodIdx | ruleIdx;\n}\nconst BITS_START_FOR_ALT_IDX = 32 - BITS_FOR_ALT_IDX;\n//# sourceMappingURL=keys.js.map","import { flatMap, isEmpty } from \"lodash-es\";\nimport { defaultGrammarValidatorErrorProvider } from \"../errors_public.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser/parser.js\";\nimport { validateAmbiguousAlternationAlternatives, validateEmptyOrAlternative, validateNoLeftRecursion, validateSomeNonEmptyLookaheadPath, } from \"./checks.js\";\nimport { buildAlternativesLookAheadFunc, buildLookaheadFuncForOptionalProd, buildLookaheadFuncForOr, buildSingleAlternativeLookaheadFunction, getProdType, } from \"./lookahead.js\";\nexport class LLkLookaheadStrategy {\n constructor(options) {\n var _a;\n this.maxLookahead =\n (_a = options === null || options === void 0 ? void 0 : options.maxLookahead) !== null && _a !== void 0 ? _a : DEFAULT_PARSER_CONFIG.maxLookahead;\n }\n validate(options) {\n const leftRecursionErrors = this.validateNoLeftRecursion(options.rules);\n if (isEmpty(leftRecursionErrors)) {\n const emptyAltErrors = this.validateEmptyOrAlternatives(options.rules);\n const ambiguousAltsErrors = this.validateAmbiguousAlternationAlternatives(options.rules, this.maxLookahead);\n const emptyRepetitionErrors = this.validateSomeNonEmptyLookaheadPath(options.rules, this.maxLookahead);\n const allErrors = [\n ...leftRecursionErrors,\n ...emptyAltErrors,\n ...ambiguousAltsErrors,\n ...emptyRepetitionErrors,\n ];\n return allErrors;\n }\n return leftRecursionErrors;\n }\n validateNoLeftRecursion(rules) {\n return flatMap(rules, (currTopRule) => validateNoLeftRecursion(currTopRule, currTopRule, defaultGrammarValidatorErrorProvider));\n }\n validateEmptyOrAlternatives(rules) {\n return flatMap(rules, (currTopRule) => validateEmptyOrAlternative(currTopRule, defaultGrammarValidatorErrorProvider));\n }\n validateAmbiguousAlternationAlternatives(rules, maxLookahead) {\n return flatMap(rules, (currTopRule) => validateAmbiguousAlternationAlternatives(currTopRule, maxLookahead, defaultGrammarValidatorErrorProvider));\n }\n validateSomeNonEmptyLookaheadPath(rules, maxLookahead) {\n return validateSomeNonEmptyLookaheadPath(rules, maxLookahead, defaultGrammarValidatorErrorProvider);\n }\n buildLookaheadForAlternation(options) {\n return buildLookaheadFuncForOr(options.prodOccurrence, options.rule, options.maxLookahead, options.hasPredicates, options.dynamicTokensEnabled, buildAlternativesLookAheadFunc);\n }\n buildLookaheadForOptional(options) {\n return buildLookaheadFuncForOptionalProd(options.prodOccurrence, options.rule, options.maxLookahead, options.dynamicTokensEnabled, getProdType(options.prodType), buildSingleAlternativeLookaheadFunction);\n }\n}\n//# sourceMappingURL=llk_lookahead.js.map","import { forEach, has } from \"lodash-es\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\nimport { AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, getKeyForAutomaticLookahead, MANY_IDX, MANY_SEP_IDX, OPTION_IDX, OR_IDX, } from \"../../grammar/keys.js\";\nimport { GAstVisitor, getProductionDslName, } from \"@chevrotain/gast\";\nimport { LLkLookaheadStrategy } from \"../../grammar/llk_lookahead.js\";\n/**\n * Trait responsible for the lookahead related utilities and optimizations.\n */\nexport class LooksAhead {\n initLooksAhead(config) {\n this.dynamicTokensEnabled = has(config, \"dynamicTokensEnabled\")\n ? config.dynamicTokensEnabled // assumes end user provides the correct config value/type\n : DEFAULT_PARSER_CONFIG.dynamicTokensEnabled;\n this.maxLookahead = has(config, \"maxLookahead\")\n ? config.maxLookahead // assumes end user provides the correct config value/type\n : DEFAULT_PARSER_CONFIG.maxLookahead;\n this.lookaheadStrategy = has(config, \"lookaheadStrategy\")\n ? config.lookaheadStrategy // assumes end user provides the correct config value/type\n : new LLkLookaheadStrategy({ maxLookahead: this.maxLookahead });\n this.lookAheadFuncsCache = new Map();\n }\n preComputeLookaheadFunctions(rules) {\n forEach(rules, (currRule) => {\n this.TRACE_INIT(`${currRule.name} Rule Lookahead`, () => {\n const { alternation, repetition, option, repetitionMandatory, repetitionMandatoryWithSeparator, repetitionWithSeparator, } = collectMethods(currRule);\n forEach(alternation, (currProd) => {\n const prodIdx = currProd.idx === 0 ? \"\" : currProd.idx;\n this.TRACE_INIT(`${getProductionDslName(currProd)}${prodIdx}`, () => {\n const laFunc = this.lookaheadStrategy.buildLookaheadForAlternation({\n prodOccurrence: currProd.idx,\n rule: currRule,\n maxLookahead: currProd.maxLookahead || this.maxLookahead,\n hasPredicates: currProd.hasPredicates,\n dynamicTokensEnabled: this.dynamicTokensEnabled,\n });\n const key = getKeyForAutomaticLookahead(this.fullRuleNameToShort[currRule.name], OR_IDX, currProd.idx);\n this.setLaFuncCache(key, laFunc);\n });\n });\n forEach(repetition, (currProd) => {\n this.computeLookaheadFunc(currRule, currProd.idx, MANY_IDX, \"Repetition\", currProd.maxLookahead, getProductionDslName(currProd));\n });\n forEach(option, (currProd) => {\n this.computeLookaheadFunc(currRule, currProd.idx, OPTION_IDX, \"Option\", currProd.maxLookahead, getProductionDslName(currProd));\n });\n forEach(repetitionMandatory, (currProd) => {\n this.computeLookaheadFunc(currRule, currProd.idx, AT_LEAST_ONE_IDX, \"RepetitionMandatory\", currProd.maxLookahead, getProductionDslName(currProd));\n });\n forEach(repetitionMandatoryWithSeparator, (currProd) => {\n this.computeLookaheadFunc(currRule, currProd.idx, AT_LEAST_ONE_SEP_IDX, \"RepetitionMandatoryWithSeparator\", currProd.maxLookahead, getProductionDslName(currProd));\n });\n forEach(repetitionWithSeparator, (currProd) => {\n this.computeLookaheadFunc(currRule, currProd.idx, MANY_SEP_IDX, \"RepetitionWithSeparator\", currProd.maxLookahead, getProductionDslName(currProd));\n });\n });\n });\n }\n computeLookaheadFunc(rule, prodOccurrence, prodKey, prodType, prodMaxLookahead, dslMethodName) {\n this.TRACE_INIT(`${dslMethodName}${prodOccurrence === 0 ? \"\" : prodOccurrence}`, () => {\n const laFunc = this.lookaheadStrategy.buildLookaheadForOptional({\n prodOccurrence,\n rule,\n maxLookahead: prodMaxLookahead || this.maxLookahead,\n dynamicTokensEnabled: this.dynamicTokensEnabled,\n prodType,\n });\n const key = getKeyForAutomaticLookahead(this.fullRuleNameToShort[rule.name], prodKey, prodOccurrence);\n this.setLaFuncCache(key, laFunc);\n });\n }\n // this actually returns a number, but it is always used as a string (object prop key)\n getKeyForAutomaticLookahead(dslMethodIdx, occurrence) {\n const currRuleShortName = this.getLastExplicitRuleShortName();\n return getKeyForAutomaticLookahead(currRuleShortName, dslMethodIdx, occurrence);\n }\n getLaFuncFromCache(key) {\n return this.lookAheadFuncsCache.get(key);\n }\n /* istanbul ignore next */\n setLaFuncCache(key, value) {\n this.lookAheadFuncsCache.set(key, value);\n }\n}\nclass DslMethodsCollectorVisitor extends GAstVisitor {\n constructor() {\n super(...arguments);\n this.dslMethods = {\n option: [],\n alternation: [],\n repetition: [],\n repetitionWithSeparator: [],\n repetitionMandatory: [],\n repetitionMandatoryWithSeparator: [],\n };\n }\n reset() {\n this.dslMethods = {\n option: [],\n alternation: [],\n repetition: [],\n repetitionWithSeparator: [],\n repetitionMandatory: [],\n repetitionMandatoryWithSeparator: [],\n };\n }\n visitOption(option) {\n this.dslMethods.option.push(option);\n }\n visitRepetitionWithSeparator(manySep) {\n this.dslMethods.repetitionWithSeparator.push(manySep);\n }\n visitRepetitionMandatory(atLeastOne) {\n this.dslMethods.repetitionMandatory.push(atLeastOne);\n }\n visitRepetitionMandatoryWithSeparator(atLeastOneSep) {\n this.dslMethods.repetitionMandatoryWithSeparator.push(atLeastOneSep);\n }\n visitRepetition(many) {\n this.dslMethods.repetition.push(many);\n }\n visitAlternation(or) {\n this.dslMethods.alternation.push(or);\n }\n}\nconst collectorVisitor = new DslMethodsCollectorVisitor();\nexport function collectMethods(rule) {\n collectorVisitor.reset();\n rule.accept(collectorVisitor);\n const dslMethods = collectorVisitor.dslMethods;\n // avoid uncleaned references\n collectorVisitor.reset();\n return dslMethods;\n}\n//# sourceMappingURL=looksahead.js.map","/**\n * This nodeLocation tracking is not efficient and should only be used\n * when error recovery is enabled or the Token Vector contains virtual Tokens\n * (e.g, Python Indent/Outdent)\n * As it executes the calculation for every single terminal/nonTerminal\n * and does not rely on the fact the token vector is **sorted**\n */\nexport function setNodeLocationOnlyOffset(currNodeLocation, newLocationInfo) {\n // First (valid) update for this cst node\n if (isNaN(currNodeLocation.startOffset) === true) {\n // assumption1: Token location information is either NaN or a valid number\n // assumption2: Token location information is fully valid if it exist\n // (both start/end offsets exist and are numbers).\n currNodeLocation.startOffset = newLocationInfo.startOffset;\n currNodeLocation.endOffset = newLocationInfo.endOffset;\n }\n // Once the startOffset has been updated with a valid number it should never receive\n // any farther updates as the Token vector is sorted.\n // We still have to check this this condition for every new possible location info\n // because with error recovery enabled we may encounter invalid tokens (NaN location props)\n else if (currNodeLocation.endOffset < newLocationInfo.endOffset === true) {\n currNodeLocation.endOffset = newLocationInfo.endOffset;\n }\n}\n/**\n * This nodeLocation tracking is not efficient and should only be used\n * when error recovery is enabled or the Token Vector contains virtual Tokens\n * (e.g, Python Indent/Outdent)\n * As it executes the calculation for every single terminal/nonTerminal\n * and does not rely on the fact the token vector is **sorted**\n */\nexport function setNodeLocationFull(currNodeLocation, newLocationInfo) {\n // First (valid) update for this cst node\n if (isNaN(currNodeLocation.startOffset) === true) {\n // assumption1: Token location information is either NaN or a valid number\n // assumption2: Token location information is fully valid if it exist\n // (all start/end props exist and are numbers).\n currNodeLocation.startOffset = newLocationInfo.startOffset;\n currNodeLocation.startColumn = newLocationInfo.startColumn;\n currNodeLocation.startLine = newLocationInfo.startLine;\n currNodeLocation.endOffset = newLocationInfo.endOffset;\n currNodeLocation.endColumn = newLocationInfo.endColumn;\n currNodeLocation.endLine = newLocationInfo.endLine;\n }\n // Once the start props has been updated with a valid number it should never receive\n // any farther updates as the Token vector is sorted.\n // We still have to check this this condition for every new possible location info\n // because with error recovery enabled we may encounter invalid tokens (NaN location props)\n else if (currNodeLocation.endOffset < newLocationInfo.endOffset === true) {\n currNodeLocation.endOffset = newLocationInfo.endOffset;\n currNodeLocation.endColumn = newLocationInfo.endColumn;\n currNodeLocation.endLine = newLocationInfo.endLine;\n }\n}\nexport function addTerminalToCst(node, token, tokenTypeName) {\n if (node.children[tokenTypeName] === undefined) {\n node.children[tokenTypeName] = [token];\n }\n else {\n node.children[tokenTypeName].push(token);\n }\n}\nexport function addNoneTerminalToCst(node, ruleName, ruleResult) {\n if (node.children[ruleName] === undefined) {\n node.children[ruleName] = [ruleResult];\n }\n else {\n node.children[ruleName].push(ruleResult);\n }\n}\n//# sourceMappingURL=cst.js.map","const NAME = \"name\";\nexport function defineNameProp(obj, nameValue) {\n Object.defineProperty(obj, NAME, {\n enumerable: false,\n configurable: true,\n writable: false,\n value: nameValue,\n });\n}\n//# sourceMappingURL=lang_extensions.js.map","import { compact, filter, forEach, isArray, isEmpty, isFunction, isUndefined, keys, map, } from \"lodash-es\";\nimport { defineNameProp } from \"../../lang/lang_extensions.js\";\nexport function defaultVisit(ctx, param) {\n const childrenNames = keys(ctx);\n const childrenNamesLength = childrenNames.length;\n for (let i = 0; i < childrenNamesLength; i++) {\n const currChildName = childrenNames[i];\n const currChildArray = ctx[currChildName];\n const currChildArrayLength = currChildArray.length;\n for (let j = 0; j < currChildArrayLength; j++) {\n const currChild = currChildArray[j];\n // distinction between Tokens Children and CstNode children\n if (currChild.tokenTypeIdx === undefined) {\n this[currChild.name](currChild.children, param);\n }\n }\n }\n // defaultVisit does not support generic out param\n}\nexport function createBaseSemanticVisitorConstructor(grammarName, ruleNames) {\n const derivedConstructor = function () { };\n // can be overwritten according to:\n // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/\n // name?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FFunction%2Fname\n defineNameProp(derivedConstructor, grammarName + \"BaseSemantics\");\n const semanticProto = {\n visit: function (cstNode, param) {\n // enables writing more concise visitor methods when CstNode has only a single child\n if (isArray(cstNode)) {\n // A CST Node's children dictionary can never have empty arrays as values\n // If a key is defined there will be at least one element in the corresponding value array.\n cstNode = cstNode[0];\n }\n // enables passing optional CstNodes concisely.\n if (isUndefined(cstNode)) {\n return undefined;\n }\n return this[cstNode.name](cstNode.children, param);\n },\n validateVisitor: function () {\n const semanticDefinitionErrors = validateVisitor(this, ruleNames);\n if (!isEmpty(semanticDefinitionErrors)) {\n const errorMessages = map(semanticDefinitionErrors, (currDefError) => currDefError.msg);\n throw Error(`Errors Detected in CST Visitor <${this.constructor.name}>:\\n\\t` +\n `${errorMessages.join(\"\\n\\n\").replace(/\\n/g, \"\\n\\t\")}`);\n }\n },\n };\n derivedConstructor.prototype = semanticProto;\n derivedConstructor.prototype.constructor = derivedConstructor;\n derivedConstructor._RULE_NAMES = ruleNames;\n return derivedConstructor;\n}\nexport function createBaseVisitorConstructorWithDefaults(grammarName, ruleNames, baseConstructor) {\n const derivedConstructor = function () { };\n // can be overwritten according to:\n // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/\n // name?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FFunction%2Fname\n defineNameProp(derivedConstructor, grammarName + \"BaseSemanticsWithDefaults\");\n const withDefaultsProto = Object.create(baseConstructor.prototype);\n forEach(ruleNames, (ruleName) => {\n withDefaultsProto[ruleName] = defaultVisit;\n });\n derivedConstructor.prototype = withDefaultsProto;\n derivedConstructor.prototype.constructor = derivedConstructor;\n return derivedConstructor;\n}\nexport var CstVisitorDefinitionError;\n(function (CstVisitorDefinitionError) {\n CstVisitorDefinitionError[CstVisitorDefinitionError[\"REDUNDANT_METHOD\"] = 0] = \"REDUNDANT_METHOD\";\n CstVisitorDefinitionError[CstVisitorDefinitionError[\"MISSING_METHOD\"] = 1] = \"MISSING_METHOD\";\n})(CstVisitorDefinitionError || (CstVisitorDefinitionError = {}));\nexport function validateVisitor(visitorInstance, ruleNames) {\n const missingErrors = validateMissingCstMethods(visitorInstance, ruleNames);\n return missingErrors;\n}\nexport function validateMissingCstMethods(visitorInstance, ruleNames) {\n const missingRuleNames = filter(ruleNames, (currRuleName) => {\n return isFunction(visitorInstance[currRuleName]) === false;\n });\n const errors = map(missingRuleNames, (currRuleName) => {\n return {\n msg: `Missing visitor method: <${currRuleName}> on ${(visitorInstance.constructor.name)} CST Visitor.`,\n type: CstVisitorDefinitionError.MISSING_METHOD,\n methodName: currRuleName,\n };\n });\n return compact(errors);\n}\n//# sourceMappingURL=cst_visitor.js.map","import { addNoneTerminalToCst, addTerminalToCst, setNodeLocationFull, setNodeLocationOnlyOffset, } from \"../../cst/cst.js\";\nimport { has, isUndefined, keys, noop } from \"lodash-es\";\nimport { createBaseSemanticVisitorConstructor, createBaseVisitorConstructorWithDefaults, } from \"../../cst/cst_visitor.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\n/**\n * This trait is responsible for the CST building logic.\n */\nexport class TreeBuilder {\n initTreeBuilder(config) {\n this.CST_STACK = [];\n // outputCst is no longer exposed/defined in the pubic API\n this.outputCst = config.outputCst;\n this.nodeLocationTracking = has(config, \"nodeLocationTracking\")\n ? config.nodeLocationTracking // assumes end user provides the correct config value/type\n : DEFAULT_PARSER_CONFIG.nodeLocationTracking;\n if (!this.outputCst) {\n this.cstInvocationStateUpdate = noop;\n this.cstFinallyStateUpdate = noop;\n this.cstPostTerminal = noop;\n this.cstPostNonTerminal = noop;\n this.cstPostRule = noop;\n }\n else {\n if (/full/i.test(this.nodeLocationTracking)) {\n if (this.recoveryEnabled) {\n this.setNodeLocationFromToken = setNodeLocationFull;\n this.setNodeLocationFromNode = setNodeLocationFull;\n this.cstPostRule = noop;\n this.setInitialNodeLocation = this.setInitialNodeLocationFullRecovery;\n }\n else {\n this.setNodeLocationFromToken = noop;\n this.setNodeLocationFromNode = noop;\n this.cstPostRule = this.cstPostRuleFull;\n this.setInitialNodeLocation = this.setInitialNodeLocationFullRegular;\n }\n }\n else if (/onlyOffset/i.test(this.nodeLocationTracking)) {\n if (this.recoveryEnabled) {\n this.setNodeLocationFromToken = setNodeLocationOnlyOffset;\n this.setNodeLocationFromNode = setNodeLocationOnlyOffset;\n this.cstPostRule = noop;\n this.setInitialNodeLocation =\n this.setInitialNodeLocationOnlyOffsetRecovery;\n }\n else {\n this.setNodeLocationFromToken = noop;\n this.setNodeLocationFromNode = noop;\n this.cstPostRule = this.cstPostRuleOnlyOffset;\n this.setInitialNodeLocation =\n this.setInitialNodeLocationOnlyOffsetRegular;\n }\n }\n else if (/none/i.test(this.nodeLocationTracking)) {\n this.setNodeLocationFromToken = noop;\n this.setNodeLocationFromNode = noop;\n this.cstPostRule = noop;\n this.setInitialNodeLocation = noop;\n }\n else {\n throw Error(`Invalid <nodeLocationTracking> config option: \"${config.nodeLocationTracking}\"`);\n }\n }\n }\n setInitialNodeLocationOnlyOffsetRecovery(cstNode) {\n cstNode.location = {\n startOffset: NaN,\n endOffset: NaN,\n };\n }\n setInitialNodeLocationOnlyOffsetRegular(cstNode) {\n cstNode.location = {\n // without error recovery the starting Location of a new CstNode is guaranteed\n // To be the next Token's startOffset (for valid inputs).\n // For invalid inputs there won't be any CSTOutput so this potential\n // inaccuracy does not matter\n startOffset: this.LA(1).startOffset,\n endOffset: NaN,\n };\n }\n setInitialNodeLocationFullRecovery(cstNode) {\n cstNode.location = {\n startOffset: NaN,\n startLine: NaN,\n startColumn: NaN,\n endOffset: NaN,\n endLine: NaN,\n endColumn: NaN,\n };\n }\n /**\n * @see setInitialNodeLocationOnlyOffsetRegular for explanation why this work\n \n * @param cstNode\n */\n setInitialNodeLocationFullRegular(cstNode) {\n const nextToken = this.LA(1);\n cstNode.location = {\n startOffset: nextToken.startOffset,\n startLine: nextToken.startLine,\n startColumn: nextToken.startColumn,\n endOffset: NaN,\n endLine: NaN,\n endColumn: NaN,\n };\n }\n cstInvocationStateUpdate(fullRuleName) {\n const cstNode = {\n name: fullRuleName,\n children: Object.create(null),\n };\n this.setInitialNodeLocation(cstNode);\n this.CST_STACK.push(cstNode);\n }\n cstFinallyStateUpdate() {\n this.CST_STACK.pop();\n }\n cstPostRuleFull(ruleCstNode) {\n // casts to `required<CstNodeLocation>` are safe because `cstPostRuleFull` should only be invoked when full location is enabled\n const prevToken = this.LA(0);\n const loc = ruleCstNode.location;\n // If this condition is true it means we consumed at least one Token\n // In this CstNode.\n if (loc.startOffset <= prevToken.startOffset === true) {\n loc.endOffset = prevToken.endOffset;\n loc.endLine = prevToken.endLine;\n loc.endColumn = prevToken.endColumn;\n }\n // \"empty\" CstNode edge case\n else {\n loc.startOffset = NaN;\n loc.startLine = NaN;\n loc.startColumn = NaN;\n }\n }\n cstPostRuleOnlyOffset(ruleCstNode) {\n const prevToken = this.LA(0);\n // `location' is not null because `cstPostRuleOnlyOffset` will only be invoked when location tracking is enabled.\n const loc = ruleCstNode.location;\n // If this condition is true it means we consumed at least one Token\n // In this CstNode.\n if (loc.startOffset <= prevToken.startOffset === true) {\n loc.endOffset = prevToken.endOffset;\n }\n // \"empty\" CstNode edge case\n else {\n loc.startOffset = NaN;\n }\n }\n cstPostTerminal(key, consumedToken) {\n const rootCst = this.CST_STACK[this.CST_STACK.length - 1];\n addTerminalToCst(rootCst, consumedToken, key);\n // This is only used when **both** error recovery and CST Output are enabled.\n this.setNodeLocationFromToken(rootCst.location, consumedToken);\n }\n cstPostNonTerminal(ruleCstResult, ruleName) {\n const preCstNode = this.CST_STACK[this.CST_STACK.length - 1];\n addNoneTerminalToCst(preCstNode, ruleName, ruleCstResult);\n // This is only used when **both** error recovery and CST Output are enabled.\n this.setNodeLocationFromNode(preCstNode.location, ruleCstResult.location);\n }\n getBaseCstVisitorConstructor() {\n if (isUndefined(this.baseCstVisitorConstructor)) {\n const newBaseCstVisitorConstructor = createBaseSemanticVisitorConstructor(this.className, keys(this.gastProductionsCache));\n this.baseCstVisitorConstructor = newBaseCstVisitorConstructor;\n return newBaseCstVisitorConstructor;\n }\n return this.baseCstVisitorConstructor;\n }\n getBaseCstVisitorConstructorWithDefaults() {\n if (isUndefined(this.baseCstVisitorWithDefaultsConstructor)) {\n const newConstructor = createBaseVisitorConstructorWithDefaults(this.className, keys(this.gastProductionsCache), this.getBaseCstVisitorConstructor());\n this.baseCstVisitorWithDefaultsConstructor = newConstructor;\n return newConstructor;\n }\n return this.baseCstVisitorWithDefaultsConstructor;\n }\n getLastExplicitRuleShortName() {\n const ruleStack = this.RULE_STACK;\n return ruleStack[ruleStack.length - 1];\n }\n getPreviousExplicitRuleShortName() {\n const ruleStack = this.RULE_STACK;\n return ruleStack[ruleStack.length - 2];\n }\n getLastExplicitRuleOccurrenceIndex() {\n const occurrenceStack = this.RULE_OCCURRENCE_STACK;\n return occurrenceStack[occurrenceStack.length - 1];\n }\n}\n//# sourceMappingURL=tree_builder.js.map","import { END_OF_FILE } from \"../parser.js\";\n/**\n * Trait responsible abstracting over the interaction with Lexer output (Token vector).\n *\n * This could be generalized to support other kinds of lexers, e.g.\n * - Just in Time Lexing / Lexer-Less parsing.\n * - Streaming Lexer.\n */\nexport class LexerAdapter {\n initLexerAdapter() {\n this.tokVector = [];\n this.tokVectorLength = 0;\n this.currIdx = -1;\n }\n set input(newInput) {\n // @ts-ignore - `this parameter` not supported in setters/getters\n // - https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters\n if (this.selfAnalysisDone !== true) {\n throw Error(`Missing <performSelfAnalysis> invocation at the end of the Parser's constructor.`);\n }\n // @ts-ignore - `this parameter` not supported in setters/getters\n // - https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters\n this.reset();\n this.tokVector = newInput;\n this.tokVectorLength = newInput.length;\n }\n get input() {\n return this.tokVector;\n }\n // skips a token and returns the next token\n SKIP_TOKEN() {\n if (this.currIdx <= this.tokVector.length - 2) {\n this.consumeToken();\n return this.LA(1);\n }\n else {\n return END_OF_FILE;\n }\n }\n // Lexer (accessing Token vector) related methods which can be overridden to implement lazy lexers\n // or lexers dependent on parser context.\n LA(howMuch) {\n const soughtIdx = this.currIdx + howMuch;\n if (soughtIdx < 0 || this.tokVectorLength <= soughtIdx) {\n return END_OF_FILE;\n }\n else {\n return this.tokVector[soughtIdx];\n }\n }\n consumeToken() {\n this.currIdx++;\n }\n exportLexerState() {\n return this.currIdx;\n }\n importLexerState(newState) {\n this.currIdx = newState;\n }\n resetLexerState() {\n this.currIdx = -1;\n }\n moveToTerminatedState() {\n this.currIdx = this.tokVector.length - 1;\n }\n getLexerPosition() {\n return this.exportLexerState();\n }\n}\n//# sourceMappingURL=lexer_adapter.js.map","import { includes, values } from \"lodash-es\";\nimport { isRecognitionException } from \"../../exceptions_public.js\";\nimport { DEFAULT_RULE_CONFIG, ParserDefinitionErrorType } from \"../parser.js\";\nimport { defaultGrammarValidatorErrorProvider } from \"../../errors_public.js\";\nimport { validateRuleIsOverridden } from \"../../grammar/checks.js\";\nimport { serializeGrammar } from \"@chevrotain/gast\";\n/**\n * This trait is responsible for implementing the public API\n * for defining Chevrotain parsers, i.e:\n * - CONSUME\n * - RULE\n * - OPTION\n * - ...\n */\nexport class RecognizerApi {\n ACTION(impl) {\n return impl.call(this);\n }\n consume(idx, tokType, options) {\n return this.consumeInternal(tokType, idx, options);\n }\n subrule(idx, ruleToCall, options) {\n return this.subruleInternal(ruleToCall, idx, options);\n }\n option(idx, actionORMethodDef) {\n return this.optionInternal(actionORMethodDef, idx);\n }\n or(idx, altsOrOpts) {\n return this.orInternal(altsOrOpts, idx);\n }\n many(idx, actionORMethodDef) {\n return this.manyInternal(idx, actionORMethodDef);\n }\n atLeastOne(idx, actionORMethodDef) {\n return this.atLeastOneInternal(idx, actionORMethodDef);\n }\n CONSUME(tokType, options) {\n return this.consumeInternal(tokType, 0, options);\n }\n CONSUME1(tokType, options) {\n return this.consumeInternal(tokType, 1, options);\n }\n CONSUME2(tokType, options) {\n return this.consumeInternal(tokType, 2, options);\n }\n CONSUME3(tokType, options) {\n return this.consumeInternal(tokType, 3, options);\n }\n CONSUME4(tokType, options) {\n return this.consumeInternal(tokType, 4, options);\n }\n CONSUME5(tokType, options) {\n return this.consumeInternal(tokType, 5, options);\n }\n CONSUME6(tokType, options) {\n return this.consumeInternal(tokType, 6, options);\n }\n CONSUME7(tokType, options) {\n return this.consumeInternal(tokType, 7, options);\n }\n CONSUME8(tokType, options) {\n return this.consumeInternal(tokType, 8, options);\n }\n CONSUME9(tokType, options) {\n return this.consumeInternal(tokType, 9, options);\n }\n SUBRULE(ruleToCall, options) {\n return this.subruleInternal(ruleToCall, 0, options);\n }\n SUBRULE1(ruleToCall, options) {\n return this.subruleInternal(ruleToCall, 1, options);\n }\n SUBRULE2(ruleToCall, options) {\n return this.subruleInternal(ruleToCall, 2, options);\n }\n SUBRULE3(ruleToCall, options) {\n return this.subruleInternal(ruleToCall, 3, options);\n }\n SUBRULE4(ruleToCall, options) {\n return this.subruleInternal(ruleToCall, 4, options);\n }\n SUBRULE5(ruleToCall, options) {\n return this.subruleInternal(ruleToCall, 5, options);\n }\n SUBRULE6(ruleToCall, options) {\n return this.subruleInternal(ruleToCall, 6, options);\n }\n SUBRULE7(ruleToCall, options) {\n return this.subruleInternal(ruleToCall, 7, options);\n }\n SUBRULE8(ruleToCall, options) {\n return this.subruleInternal(ruleToCall, 8, options);\n }\n SUBRULE9(ruleToCall, options) {\n return this.subruleInternal(ruleToCall, 9, options);\n }\n OPTION(actionORMethodDef) {\n return this.optionInternal(actionORMethodDef, 0);\n }\n OPTION1(actionORMethodDef) {\n return this.optionInternal(actionORMethodDef, 1);\n }\n OPTION2(actionORMethodDef) {\n return this.optionInternal(actionORMethodDef, 2);\n }\n OPTION3(actionORMethodDef) {\n return this.optionInternal(actionORMethodDef, 3);\n }\n OPTION4(actionORMethodDef) {\n return this.optionInternal(actionORMethodDef, 4);\n }\n OPTION5(actionORMethodDef) {\n return this.optionInternal(actionORMethodDef, 5);\n }\n OPTION6(actionORMethodDef) {\n return this.optionInternal(actionORMethodDef, 6);\n }\n OPTION7(actionORMethodDef) {\n return this.optionInternal(actionORMethodDef, 7);\n }\n OPTION8(actionORMethodDef) {\n return this.optionInternal(actionORMethodDef, 8);\n }\n OPTION9(actionORMethodDef) {\n return this.optionInternal(actionORMethodDef, 9);\n }\n OR(altsOrOpts) {\n return this.orInternal(altsOrOpts, 0);\n }\n OR1(altsOrOpts) {\n return this.orInternal(altsOrOpts, 1);\n }\n OR2(altsOrOpts) {\n return this.orInternal(altsOrOpts, 2);\n }\n OR3(altsOrOpts) {\n return this.orInternal(altsOrOpts, 3);\n }\n OR4(altsOrOpts) {\n return this.orInternal(altsOrOpts, 4);\n }\n OR5(altsOrOpts) {\n return this.orInternal(altsOrOpts, 5);\n }\n OR6(altsOrOpts) {\n return this.orInternal(altsOrOpts, 6);\n }\n OR7(altsOrOpts) {\n return this.orInternal(altsOrOpts, 7);\n }\n OR8(altsOrOpts) {\n return this.orInternal(altsOrOpts, 8);\n }\n OR9(altsOrOpts) {\n return this.orInternal(altsOrOpts, 9);\n }\n MANY(actionORMethodDef) {\n this.manyInternal(0, actionORMethodDef);\n }\n MANY1(actionORMethodDef) {\n this.manyInternal(1, actionORMethodDef);\n }\n MANY2(actionORMethodDef) {\n this.manyInternal(2, actionORMethodDef);\n }\n MANY3(actionORMethodDef) {\n this.manyInternal(3, actionORMethodDef);\n }\n MANY4(actionORMethodDef) {\n this.manyInternal(4, actionORMethodDef);\n }\n MANY5(actionORMethodDef) {\n this.manyInternal(5, actionORMethodDef);\n }\n MANY6(actionORMethodDef) {\n this.manyInternal(6, actionORMethodDef);\n }\n MANY7(actionORMethodDef) {\n this.manyInternal(7, actionORMethodDef);\n }\n MANY8(actionORMethodDef) {\n this.manyInternal(8, actionORMethodDef);\n }\n MANY9(actionORMethodDef) {\n this.manyInternal(9, actionORMethodDef);\n }\n MANY_SEP(options) {\n this.manySepFirstInternal(0, options);\n }\n MANY_SEP1(options) {\n this.manySepFirstInternal(1, options);\n }\n MANY_SEP2(options) {\n this.manySepFirstInternal(2, options);\n }\n MANY_SEP3(options) {\n this.manySepFirstInternal(3, options);\n }\n MANY_SEP4(options) {\n this.manySepFirstInternal(4, options);\n }\n MANY_SEP5(options) {\n this.manySepFirstInternal(5, options);\n }\n MANY_SEP6(options) {\n this.manySepFirstInternal(6, options);\n }\n MANY_SEP7(options) {\n this.manySepFirstInternal(7, options);\n }\n MANY_SEP8(options) {\n this.manySepFirstInternal(8, options);\n }\n MANY_SEP9(options) {\n this.manySepFirstInternal(9, options);\n }\n AT_LEAST_ONE(actionORMethodDef) {\n this.atLeastOneInternal(0, actionORMethodDef);\n }\n AT_LEAST_ONE1(actionORMethodDef) {\n return this.atLeastOneInternal(1, actionORMethodDef);\n }\n AT_LEAST_ONE2(actionORMethodDef) {\n this.atLeastOneInternal(2, actionORMethodDef);\n }\n AT_LEAST_ONE3(actionORMethodDef) {\n this.atLeastOneInternal(3, actionORMethodDef);\n }\n AT_LEAST_ONE4(actionORMethodDef) {\n this.atLeastOneInternal(4, actionORMethodDef);\n }\n AT_LEAST_ONE5(actionORMethodDef) {\n this.atLeastOneInternal(5, actionORMethodDef);\n }\n AT_LEAST_ONE6(actionORMethodDef) {\n this.atLeastOneInternal(6, actionORMethodDef);\n }\n AT_LEAST_ONE7(actionORMethodDef) {\n this.atLeastOneInternal(7, actionORMethodDef);\n }\n AT_LEAST_ONE8(actionORMethodDef) {\n this.atLeastOneInternal(8, actionORMethodDef);\n }\n AT_LEAST_ONE9(actionORMethodDef) {\n this.atLeastOneInternal(9, actionORMethodDef);\n }\n AT_LEAST_ONE_SEP(options) {\n this.atLeastOneSepFirstInternal(0, options);\n }\n AT_LEAST_ONE_SEP1(options) {\n this.atLeastOneSepFirstInternal(1, options);\n }\n AT_LEAST_ONE_SEP2(options) {\n this.atLeastOneSepFirstInternal(2, options);\n }\n AT_LEAST_ONE_SEP3(options) {\n this.atLeastOneSepFirstInternal(3, options);\n }\n AT_LEAST_ONE_SEP4(options) {\n this.atLeastOneSepFirstInternal(4, options);\n }\n AT_LEAST_ONE_SEP5(options) {\n this.atLeastOneSepFirstInternal(5, options);\n }\n AT_LEAST_ONE_SEP6(options) {\n this.atLeastOneSepFirstInternal(6, options);\n }\n AT_LEAST_ONE_SEP7(options) {\n this.atLeastOneSepFirstInternal(7, options);\n }\n AT_LEAST_ONE_SEP8(options) {\n this.atLeastOneSepFirstInternal(8, options);\n }\n AT_LEAST_ONE_SEP9(options) {\n this.atLeastOneSepFirstInternal(9, options);\n }\n RULE(name, implementation, config = DEFAULT_RULE_CONFIG) {\n if (includes(this.definedRulesNames, name)) {\n const errMsg = defaultGrammarValidatorErrorProvider.buildDuplicateRuleNameError({\n topLevelRule: name,\n grammarName: this.className,\n });\n const error = {\n message: errMsg,\n type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,\n ruleName: name,\n };\n this.definitionErrors.push(error);\n }\n this.definedRulesNames.push(name);\n const ruleImplementation = this.defineRule(name, implementation, config);\n this[name] = ruleImplementation;\n return ruleImplementation;\n }\n OVERRIDE_RULE(name, impl, config = DEFAULT_RULE_CONFIG) {\n const ruleErrors = validateRuleIsOverridden(name, this.definedRulesNames, this.className);\n this.definitionErrors = this.definitionErrors.concat(ruleErrors);\n const ruleImplementation = this.defineRule(name, impl, config);\n this[name] = ruleImplementation;\n return ruleImplementation;\n }\n BACKTRACK(grammarRule, args) {\n return function () {\n // save org state\n this.isBackTrackingStack.push(1);\n const orgState = this.saveRecogState();\n try {\n grammarRule.apply(this, args);\n // if no exception was thrown we have succeed parsing the rule.\n return true;\n }\n catch (e) {\n if (isRecognitionException(e)) {\n return false;\n }\n else {\n throw e;\n }\n }\n finally {\n this.reloadRecogState(orgState);\n this.isBackTrackingStack.pop();\n }\n };\n }\n // GAST export APIs\n getGAstProductions() {\n return this.gastProductionsCache;\n }\n getSerializedGastProductions() {\n return serializeGrammar(values(this.gastProductionsCache));\n }\n}\n//# sourceMappingURL=recognizer_api.js.map","import { clone, every, flatten, has, isArray, isEmpty, isObject, reduce, uniq, values, } from \"lodash-es\";\nimport { AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, BITS_FOR_METHOD_TYPE, BITS_FOR_OCCURRENCE_IDX, MANY_IDX, MANY_SEP_IDX, OPTION_IDX, OR_IDX, } from \"../../grammar/keys.js\";\nimport { isRecognitionException, MismatchedTokenException, NotAllInputParsedException, } from \"../../exceptions_public.js\";\nimport { PROD_TYPE } from \"../../grammar/lookahead.js\";\nimport { NextTerminalAfterAtLeastOneSepWalker, NextTerminalAfterAtLeastOneWalker, NextTerminalAfterManySepWalker, NextTerminalAfterManyWalker, } from \"../../grammar/interpreter.js\";\nimport { DEFAULT_RULE_CONFIG } from \"../parser.js\";\nimport { IN_RULE_RECOVERY_EXCEPTION } from \"./recoverable.js\";\nimport { EOF } from \"../../../scan/tokens_public.js\";\nimport { augmentTokenTypes, isTokenType, tokenStructuredMatcher, tokenStructuredMatcherNoCategories, } from \"../../../scan/tokens.js\";\n/**\n * This trait is responsible for the runtime parsing engine\n * Used by the official API (recognizer_api.ts)\n */\nexport class RecognizerEngine {\n initRecognizerEngine(tokenVocabulary, config) {\n this.className = this.constructor.name;\n // TODO: would using an ES6 Map or plain object be faster (CST building scenario)\n this.shortRuleNameToFull = {};\n this.fullRuleNameToShort = {};\n this.ruleShortNameIdx = 256;\n this.tokenMatcher = tokenStructuredMatcherNoCategories;\n this.subruleIdx = 0;\n this.definedRulesNames = [];\n this.tokensMap = {};\n this.isBackTrackingStack = [];\n this.RULE_STACK = [];\n this.RULE_OCCURRENCE_STACK = [];\n this.gastProductionsCache = {};\n if (has(config, \"serializedGrammar\")) {\n throw Error(\"The Parser's configuration can no longer contain a <serializedGrammar> property.\\n\" +\n \"\\tSee: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_6-0-0\\n\" +\n \"\\tFor Further details.\");\n }\n if (isArray(tokenVocabulary)) {\n // This only checks for Token vocabularies provided as arrays.\n // That is good enough because the main objective is to detect users of pre-V4.0 APIs\n // rather than all edge cases of empty Token vocabularies.\n if (isEmpty(tokenVocabulary)) {\n throw Error(\"A Token Vocabulary cannot be empty.\\n\" +\n \"\\tNote that the first argument for the parser constructor\\n\" +\n \"\\tis no longer a Token vector (since v4.0).\");\n }\n if (typeof tokenVocabulary[0].startOffset === \"number\") {\n throw Error(\"The Parser constructor no longer accepts a token vector as the first argument.\\n\" +\n \"\\tSee: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_4-0-0\\n\" +\n \"\\tFor Further details.\");\n }\n }\n if (isArray(tokenVocabulary)) {\n this.tokensMap = reduce(tokenVocabulary, (acc, tokType) => {\n acc[tokType.name] = tokType;\n return acc;\n }, {});\n }\n else if (has(tokenVocabulary, \"modes\") &&\n every(flatten(values(tokenVocabulary.modes)), isTokenType)) {\n const allTokenTypes = flatten(values(tokenVocabulary.modes));\n const uniqueTokens = uniq(allTokenTypes);\n this.tokensMap = reduce(uniqueTokens, (acc, tokType) => {\n acc[tokType.name] = tokType;\n return acc;\n }, {});\n }\n else if (isObject(tokenVocabulary)) {\n this.tokensMap = clone(tokenVocabulary);\n }\n else {\n throw new Error(\"<tokensDictionary> argument must be An Array of Token constructors,\" +\n \" A dictionary of Token constructors or an IMultiModeLexerDefinition\");\n }\n // always add EOF to the tokenNames -> constructors map. it is useful to assure all the input has been\n // parsed with a clear error message (\"expecting EOF but found ...\")\n this.tokensMap[\"EOF\"] = EOF;\n const allTokenTypes = has(tokenVocabulary, \"modes\")\n ? flatten(values(tokenVocabulary.modes))\n : values(tokenVocabulary);\n const noTokenCategoriesUsed = every(allTokenTypes, (tokenConstructor) => isEmpty(tokenConstructor.categoryMatches));\n this.tokenMatcher = noTokenCategoriesUsed\n ? tokenStructuredMatcherNoCategories\n : tokenStructuredMatcher;\n // Because ES2015+ syntax should be supported for creating Token classes\n // We cannot assume that the Token classes were created using the \"extendToken\" utilities\n // Therefore we must augment the Token classes both on Lexer initialization and on Parser initialization\n augmentTokenTypes(values(this.tokensMap));\n }\n defineRule(ruleName, impl, config) {\n if (this.selfAnalysisDone) {\n throw Error(`Grammar rule <${ruleName}> may not be defined after the 'performSelfAnalysis' method has been called'\\n` +\n `Make sure that all grammar rule definitions are done before 'performSelfAnalysis' is called.`);\n }\n const resyncEnabled = has(config, \"resyncEnabled\")\n ? config.resyncEnabled // assumes end user provides the correct config value/type\n : DEFAULT_RULE_CONFIG.resyncEnabled;\n const recoveryValueFunc = has(config, \"recoveryValueFunc\")\n ? config.recoveryValueFunc // assumes end user provides the correct config value/type\n : DEFAULT_RULE_CONFIG.recoveryValueFunc;\n // performance optimization: Use small integers as keys for the longer human readable \"full\" rule names.\n // this greatly improves Map access time (as much as 8% for some performance benchmarks).\n const shortName = this.ruleShortNameIdx << (BITS_FOR_METHOD_TYPE + BITS_FOR_OCCURRENCE_IDX);\n this.ruleShortNameIdx++;\n this.shortRuleNameToFull[shortName] = ruleName;\n this.fullRuleNameToShort[ruleName] = shortName;\n let invokeRuleWithTry;\n // Micro optimization, only check the condition **once** on rule definition\n // instead of **every single** rule invocation.\n if (this.outputCst === true) {\n invokeRuleWithTry = function invokeRuleWithTry(...args) {\n try {\n this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);\n impl.apply(this, args);\n const cst = this.CST_STACK[this.CST_STACK.length - 1];\n this.cstPostRule(cst);\n return cst;\n }\n catch (e) {\n return this.invokeRuleCatch(e, resyncEnabled, recoveryValueFunc);\n }\n finally {\n this.ruleFinallyStateUpdate();\n }\n };\n }\n else {\n invokeRuleWithTry = function invokeRuleWithTryCst(...args) {\n try {\n this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);\n return impl.apply(this, args);\n }\n catch (e) {\n return this.invokeRuleCatch(e, resyncEnabled, recoveryValueFunc);\n }\n finally {\n this.ruleFinallyStateUpdate();\n }\n };\n }\n const wrappedGrammarRule = Object.assign(invokeRuleWithTry, { ruleName, originalGrammarAction: impl });\n return wrappedGrammarRule;\n }\n invokeRuleCatch(e, resyncEnabledConfig, recoveryValueFunc) {\n const isFirstInvokedRule = this.RULE_STACK.length === 1;\n // note the reSync is always enabled for the first rule invocation, because we must always be able to\n // reSync with EOF and just output some INVALID ParseTree\n // during backtracking reSync recovery is disabled, otherwise we can't be certain the backtracking\n // path is really the most valid one\n const reSyncEnabled = resyncEnabledConfig && !this.isBackTracking() && this.recoveryEnabled;\n if (isRecognitionException(e)) {\n const recogError = e;\n if (reSyncEnabled) {\n const reSyncTokType = this.findReSyncTokenType();\n if (this.isInCurrentRuleReSyncSet(reSyncTokType)) {\n recogError.resyncedTokens = this.reSyncTo(reSyncTokType);\n if (this.outputCst) {\n const partialCstResult = this.CST_STACK[this.CST_STACK.length - 1];\n partialCstResult.recoveredNode = true;\n return partialCstResult;\n }\n else {\n return recoveryValueFunc(e);\n }\n }\n else {\n if (this.outputCst) {\n const partialCstResult = this.CST_STACK[this.CST_STACK.length - 1];\n partialCstResult.recoveredNode = true;\n recogError.partialCstResult = partialCstResult;\n }\n // to be handled Further up the call stack\n throw recogError;\n }\n }\n else if (isFirstInvokedRule) {\n // otherwise a Redundant input error will be created as well and we cannot guarantee that this is indeed the case\n this.moveToTerminatedState();\n // the parser should never throw one of its own errors outside its flow.\n // even if error recovery is disabled\n return recoveryValueFunc(e);\n }\n else {\n // to be recovered Further up the call stack\n throw recogError;\n }\n }\n else {\n // some other Error type which we don't know how to handle (for example a built in JavaScript Error)\n throw e;\n }\n }\n // Implementation of parsing DSL\n optionInternal(actionORMethodDef, occurrence) {\n const key = this.getKeyForAutomaticLookahead(OPTION_IDX, occurrence);\n return this.optionInternalLogic(actionORMethodDef, occurrence, key);\n }\n optionInternalLogic(actionORMethodDef, occurrence, key) {\n let lookAheadFunc = this.getLaFuncFromCache(key);\n let action;\n if (typeof actionORMethodDef !== \"function\") {\n action = actionORMethodDef.DEF;\n const predicate = actionORMethodDef.GATE;\n // predicate present\n if (predicate !== undefined) {\n const orgLookaheadFunction = lookAheadFunc;\n lookAheadFunc = () => {\n return predicate.call(this) && orgLookaheadFunction.call(this);\n };\n }\n }\n else {\n action = actionORMethodDef;\n }\n if (lookAheadFunc.call(this) === true) {\n return action.call(this);\n }\n return undefined;\n }\n atLeastOneInternal(prodOccurrence, actionORMethodDef) {\n const laKey = this.getKeyForAutomaticLookahead(AT_LEAST_ONE_IDX, prodOccurrence);\n return this.atLeastOneInternalLogic(prodOccurrence, actionORMethodDef, laKey);\n }\n atLeastOneInternalLogic(prodOccurrence, actionORMethodDef, key) {\n let lookAheadFunc = this.getLaFuncFromCache(key);\n let action;\n if (typeof actionORMethodDef !== \"function\") {\n action = actionORMethodDef.DEF;\n const predicate = actionORMethodDef.GATE;\n // predicate present\n if (predicate !== undefined) {\n const orgLookaheadFunction = lookAheadFunc;\n lookAheadFunc = () => {\n return predicate.call(this) && orgLookaheadFunction.call(this);\n };\n }\n }\n else {\n action = actionORMethodDef;\n }\n if (lookAheadFunc.call(this) === true) {\n let notStuck = this.doSingleRepetition(action);\n while (lookAheadFunc.call(this) === true &&\n notStuck === true) {\n notStuck = this.doSingleRepetition(action);\n }\n }\n else {\n throw this.raiseEarlyExitException(prodOccurrence, PROD_TYPE.REPETITION_MANDATORY, actionORMethodDef.ERR_MSG);\n }\n // note that while it may seem that this can cause an error because by using a recursive call to\n // AT_LEAST_ONE we change the grammar to AT_LEAST_TWO, AT_LEAST_THREE ... , the possible recursive call\n // from the tryInRepetitionRecovery(...) will only happen IFF there really are TWO/THREE/.... items.\n // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n this.attemptInRepetitionRecovery(this.atLeastOneInternal, [prodOccurrence, actionORMethodDef], lookAheadFunc, AT_LEAST_ONE_IDX, prodOccurrence, NextTerminalAfterAtLeastOneWalker);\n }\n atLeastOneSepFirstInternal(prodOccurrence, options) {\n const laKey = this.getKeyForAutomaticLookahead(AT_LEAST_ONE_SEP_IDX, prodOccurrence);\n this.atLeastOneSepFirstInternalLogic(prodOccurrence, options, laKey);\n }\n atLeastOneSepFirstInternalLogic(prodOccurrence, options, key) {\n const action = options.DEF;\n const separator = options.SEP;\n const firstIterationLookaheadFunc = this.getLaFuncFromCache(key);\n // 1st iteration\n if (firstIterationLookaheadFunc.call(this) === true) {\n action.call(this);\n // TODO: Optimization can move this function construction into \"attemptInRepetitionRecovery\"\n // because it is only needed in error recovery scenarios.\n const separatorLookAheadFunc = () => {\n return this.tokenMatcher(this.LA(1), separator);\n };\n // 2nd..nth iterations\n while (this.tokenMatcher(this.LA(1), separator) === true) {\n // note that this CONSUME will never enter recovery because\n // the separatorLookAheadFunc checks that the separator really does exist.\n this.CONSUME(separator);\n // No need for checking infinite loop here due to consuming the separator.\n action.call(this);\n }\n // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [\n prodOccurrence,\n separator,\n separatorLookAheadFunc,\n action,\n NextTerminalAfterAtLeastOneSepWalker,\n ], separatorLookAheadFunc, AT_LEAST_ONE_SEP_IDX, prodOccurrence, NextTerminalAfterAtLeastOneSepWalker);\n }\n else {\n throw this.raiseEarlyExitException(prodOccurrence, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, options.ERR_MSG);\n }\n }\n manyInternal(prodOccurrence, actionORMethodDef) {\n const laKey = this.getKeyForAutomaticLookahead(MANY_IDX, prodOccurrence);\n return this.manyInternalLogic(prodOccurrence, actionORMethodDef, laKey);\n }\n manyInternalLogic(prodOccurrence, actionORMethodDef, key) {\n let lookaheadFunction = this.getLaFuncFromCache(key);\n let action;\n if (typeof actionORMethodDef !== \"function\") {\n action = actionORMethodDef.DEF;\n const predicate = actionORMethodDef.GATE;\n // predicate present\n if (predicate !== undefined) {\n const orgLookaheadFunction = lookaheadFunction;\n lookaheadFunction = () => {\n return predicate.call(this) && orgLookaheadFunction.call(this);\n };\n }\n }\n else {\n action = actionORMethodDef;\n }\n let notStuck = true;\n while (lookaheadFunction.call(this) === true && notStuck === true) {\n notStuck = this.doSingleRepetition(action);\n }\n // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n this.attemptInRepetitionRecovery(this.manyInternal, [prodOccurrence, actionORMethodDef], lookaheadFunction, MANY_IDX, prodOccurrence, NextTerminalAfterManyWalker, \n // The notStuck parameter is only relevant when \"attemptInRepetitionRecovery\"\n // is invoked from manyInternal, in the MANY_SEP case and AT_LEAST_ONE[_SEP]\n // An infinite loop cannot occur as:\n // - Either the lookahead is guaranteed to consume something (Single Token Separator)\n // - AT_LEAST_ONE by definition is guaranteed to consume something (or error out).\n notStuck);\n }\n manySepFirstInternal(prodOccurrence, options) {\n const laKey = this.getKeyForAutomaticLookahead(MANY_SEP_IDX, prodOccurrence);\n this.manySepFirstInternalLogic(prodOccurrence, options, laKey);\n }\n manySepFirstInternalLogic(prodOccurrence, options, key) {\n const action = options.DEF;\n const separator = options.SEP;\n const firstIterationLaFunc = this.getLaFuncFromCache(key);\n // 1st iteration\n if (firstIterationLaFunc.call(this) === true) {\n action.call(this);\n const separatorLookAheadFunc = () => {\n return this.tokenMatcher(this.LA(1), separator);\n };\n // 2nd..nth iterations\n while (this.tokenMatcher(this.LA(1), separator) === true) {\n // note that this CONSUME will never enter recovery because\n // the separatorLookAheadFunc checks that the separator really does exist.\n this.CONSUME(separator);\n // No need for checking infinite loop here due to consuming the separator.\n action.call(this);\n }\n // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [\n prodOccurrence,\n separator,\n separatorLookAheadFunc,\n action,\n NextTerminalAfterManySepWalker,\n ], separatorLookAheadFunc, MANY_SEP_IDX, prodOccurrence, NextTerminalAfterManySepWalker);\n }\n }\n repetitionSepSecondInternal(prodOccurrence, separator, separatorLookAheadFunc, action, nextTerminalAfterWalker) {\n while (separatorLookAheadFunc()) {\n // note that this CONSUME will never enter recovery because\n // the separatorLookAheadFunc checks that the separator really does exist.\n this.CONSUME(separator);\n action.call(this);\n }\n // we can only arrive to this function after an error\n // has occurred (hence the name 'second') so the following\n // IF will always be entered, its possible to remove it...\n // however it is kept to avoid confusion and be consistent.\n // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n /* istanbul ignore else */\n this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [\n prodOccurrence,\n separator,\n separatorLookAheadFunc,\n action,\n nextTerminalAfterWalker,\n ], separatorLookAheadFunc, AT_LEAST_ONE_SEP_IDX, prodOccurrence, nextTerminalAfterWalker);\n }\n doSingleRepetition(action) {\n const beforeIteration = this.getLexerPosition();\n action.call(this);\n const afterIteration = this.getLexerPosition();\n // This boolean will indicate if this repetition progressed\n // or if we are \"stuck\" (potential infinite loop in the repetition).\n return afterIteration > beforeIteration;\n }\n orInternal(altsOrOpts, occurrence) {\n const laKey = this.getKeyForAutomaticLookahead(OR_IDX, occurrence);\n const alts = isArray(altsOrOpts) ? altsOrOpts : altsOrOpts.DEF;\n const laFunc = this.getLaFuncFromCache(laKey);\n const altIdxToTake = laFunc.call(this, alts);\n if (altIdxToTake !== undefined) {\n const chosenAlternative = alts[altIdxToTake];\n return chosenAlternative.ALT.call(this);\n }\n this.raiseNoAltException(occurrence, altsOrOpts.ERR_MSG);\n }\n ruleFinallyStateUpdate() {\n this.RULE_STACK.pop();\n this.RULE_OCCURRENCE_STACK.pop();\n // NOOP when cst is disabled\n this.cstFinallyStateUpdate();\n if (this.RULE_STACK.length === 0 && this.isAtEndOfInput() === false) {\n const firstRedundantTok = this.LA(1);\n const errMsg = this.errorMessageProvider.buildNotAllInputParsedMessage({\n firstRedundant: firstRedundantTok,\n ruleName: this.getCurrRuleFullName(),\n });\n this.SAVE_ERROR(new NotAllInputParsedException(errMsg, firstRedundantTok));\n }\n }\n subruleInternal(ruleToCall, idx, options) {\n let ruleResult;\n try {\n const args = options !== undefined ? options.ARGS : undefined;\n this.subruleIdx = idx;\n ruleResult = ruleToCall.apply(this, args);\n this.cstPostNonTerminal(ruleResult, options !== undefined && options.LABEL !== undefined\n ? options.LABEL\n : ruleToCall.ruleName);\n return ruleResult;\n }\n catch (e) {\n throw this.subruleInternalError(e, options, ruleToCall.ruleName);\n }\n }\n subruleInternalError(e, options, ruleName) {\n if (isRecognitionException(e) && e.partialCstResult !== undefined) {\n this.cstPostNonTerminal(e.partialCstResult, options !== undefined && options.LABEL !== undefined\n ? options.LABEL\n : ruleName);\n delete e.partialCstResult;\n }\n throw e;\n }\n consumeInternal(tokType, idx, options) {\n let consumedToken;\n try {\n const nextToken = this.LA(1);\n if (this.tokenMatcher(nextToken, tokType) === true) {\n this.consumeToken();\n consumedToken = nextToken;\n }\n else {\n this.consumeInternalError(tokType, nextToken, options);\n }\n }\n catch (eFromConsumption) {\n consumedToken = this.consumeInternalRecovery(tokType, idx, eFromConsumption);\n }\n this.cstPostTerminal(options !== undefined && options.LABEL !== undefined\n ? options.LABEL\n : tokType.name, consumedToken);\n return consumedToken;\n }\n consumeInternalError(tokType, nextToken, options) {\n let msg;\n const previousToken = this.LA(0);\n if (options !== undefined && options.ERR_MSG) {\n msg = options.ERR_MSG;\n }\n else {\n msg = this.errorMessageProvider.buildMismatchTokenMessage({\n expected: tokType,\n actual: nextToken,\n previous: previousToken,\n ruleName: this.getCurrRuleFullName(),\n });\n }\n throw this.SAVE_ERROR(new MismatchedTokenException(msg, nextToken, previousToken));\n }\n consumeInternalRecovery(tokType, idx, eFromConsumption) {\n // no recovery allowed during backtracking, otherwise backtracking may recover invalid syntax and accept it\n // but the original syntax could have been parsed successfully without any backtracking + recovery\n if (this.recoveryEnabled &&\n // TODO: more robust checking of the exception type. Perhaps Typescript extending expressions?\n eFromConsumption.name === \"MismatchedTokenException\" &&\n !this.isBackTracking()) {\n const follows = this.getFollowsForInRuleRecovery(tokType, idx);\n try {\n return this.tryInRuleRecovery(tokType, follows);\n }\n catch (eFromInRuleRecovery) {\n if (eFromInRuleRecovery.name === IN_RULE_RECOVERY_EXCEPTION) {\n // failed in RuleRecovery.\n // throw the original error in order to trigger reSync error recovery\n throw eFromConsumption;\n }\n else {\n throw eFromInRuleRecovery;\n }\n }\n }\n else {\n throw eFromConsumption;\n }\n }\n saveRecogState() {\n // errors is a getter which will clone the errors array\n const savedErrors = this.errors;\n const savedRuleStack = clone(this.RULE_STACK);\n return {\n errors: savedErrors,\n lexerState: this.exportLexerState(),\n RULE_STACK: savedRuleStack,\n CST_STACK: this.CST_STACK,\n };\n }\n reloadRecogState(newState) {\n this.errors = newState.errors;\n this.importLexerState(newState.lexerState);\n this.RULE_STACK = newState.RULE_STACK;\n }\n ruleInvocationStateUpdate(shortName, fullName, idxInCallingRule) {\n this.RULE_OCCURRENCE_STACK.push(idxInCallingRule);\n this.RULE_STACK.push(shortName);\n // NOOP when cst is disabled\n this.cstInvocationStateUpdate(fullName);\n }\n isBackTracking() {\n return this.isBackTrackingStack.length !== 0;\n }\n getCurrRuleFullName() {\n const shortName = this.getLastExplicitRuleShortName();\n return this.shortRuleNameToFull[shortName];\n }\n shortRuleNameToFullName(shortName) {\n return this.shortRuleNameToFull[shortName];\n }\n isAtEndOfInput() {\n return this.tokenMatcher(this.LA(1), EOF);\n }\n reset() {\n this.resetLexerState();\n this.subruleIdx = 0;\n this.isBackTrackingStack = [];\n this.errors = [];\n this.RULE_STACK = [];\n // TODO: extract a specific reset for TreeBuilder trait\n this.CST_STACK = [];\n this.RULE_OCCURRENCE_STACK = [];\n }\n}\n//# sourceMappingURL=recognizer_engine.js.map","import { EarlyExitException, isRecognitionException, NoViableAltException, } from \"../../exceptions_public.js\";\nimport { clone, has } from \"lodash-es\";\nimport { getLookaheadPathsForOptionalProd, getLookaheadPathsForOr, } from \"../../grammar/lookahead.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\n/**\n * Trait responsible for runtime parsing errors.\n */\nexport class ErrorHandler {\n initErrorHandler(config) {\n this._errors = [];\n this.errorMessageProvider = has(config, \"errorMessageProvider\")\n ? config.errorMessageProvider // assumes end user provides the correct config value/type\n : DEFAULT_PARSER_CONFIG.errorMessageProvider;\n }\n SAVE_ERROR(error) {\n if (isRecognitionException(error)) {\n error.context = {\n ruleStack: this.getHumanReadableRuleStack(),\n ruleOccurrenceStack: clone(this.RULE_OCCURRENCE_STACK),\n };\n this._errors.push(error);\n return error;\n }\n else {\n throw Error(\"Trying to save an Error which is not a RecognitionException\");\n }\n }\n get errors() {\n return clone(this._errors);\n }\n set errors(newErrors) {\n this._errors = newErrors;\n }\n // TODO: consider caching the error message computed information\n raiseEarlyExitException(occurrence, prodType, userDefinedErrMsg) {\n const ruleName = this.getCurrRuleFullName();\n const ruleGrammar = this.getGAstProductions()[ruleName];\n const lookAheadPathsPerAlternative = getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, this.maxLookahead);\n const insideProdPaths = lookAheadPathsPerAlternative[0];\n const actualTokens = [];\n for (let i = 1; i <= this.maxLookahead; i++) {\n actualTokens.push(this.LA(i));\n }\n const msg = this.errorMessageProvider.buildEarlyExitMessage({\n expectedIterationPaths: insideProdPaths,\n actual: actualTokens,\n previous: this.LA(0),\n customUserDescription: userDefinedErrMsg,\n ruleName: ruleName,\n });\n throw this.SAVE_ERROR(new EarlyExitException(msg, this.LA(1), this.LA(0)));\n }\n // TODO: consider caching the error message computed information\n raiseNoAltException(occurrence, errMsgTypes) {\n const ruleName = this.getCurrRuleFullName();\n const ruleGrammar = this.getGAstProductions()[ruleName];\n // TODO: getLookaheadPathsForOr can be slow for large enough maxLookahead and certain grammars, consider caching ?\n const lookAheadPathsPerAlternative = getLookaheadPathsForOr(occurrence, ruleGrammar, this.maxLookahead);\n const actualTokens = [];\n for (let i = 1; i <= this.maxLookahead; i++) {\n actualTokens.push(this.LA(i));\n }\n const previousToken = this.LA(0);\n const errMsg = this.errorMessageProvider.buildNoViableAltMessage({\n expectedPathsPerAlt: lookAheadPathsPerAlternative,\n actual: actualTokens,\n previous: previousToken,\n customUserDescription: errMsgTypes,\n ruleName: this.getCurrRuleFullName(),\n });\n throw this.SAVE_ERROR(new NoViableAltException(errMsg, this.LA(1), previousToken));\n }\n}\n//# sourceMappingURL=error_handler.js.map","import { NextAfterTokenWalker, nextPossibleTokensAfter, } from \"../../grammar/interpreter.js\";\nimport { first, isUndefined } from \"lodash-es\";\nexport class ContentAssist {\n initContentAssist() { }\n computeContentAssist(startRuleName, precedingInput) {\n const startRuleGast = this.gastProductionsCache[startRuleName];\n if (isUndefined(startRuleGast)) {\n throw Error(`Rule ->${startRuleName}<- does not exist in this grammar.`);\n }\n return nextPossibleTokensAfter([startRuleGast], precedingInput, this.tokenMatcher, this.maxLookahead);\n }\n // TODO: should this be a member method or a utility? it does not have any state or usage of 'this'...\n // TODO: should this be more explicitly part of the public API?\n getNextPossibleTokenTypes(grammarPath) {\n const topRuleName = first(grammarPath.ruleStack);\n const gastProductions = this.getGAstProductions();\n const topProduction = gastProductions[topRuleName];\n const nextPossibleTokenTypes = new NextAfterTokenWalker(topProduction, grammarPath).startWalking();\n return nextPossibleTokenTypes;\n }\n}\n//# sourceMappingURL=context_assist.js.map","import { forEach, has, isArray, isFunction, last as peek, some, } from \"lodash-es\";\nimport { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, } from \"@chevrotain/gast\";\nimport { Lexer } from \"../../../scan/lexer_public.js\";\nimport { augmentTokenTypes, hasShortKeyProperty, } from \"../../../scan/tokens.js\";\nimport { createToken, createTokenInstance, } from \"../../../scan/tokens_public.js\";\nimport { END_OF_FILE } from \"../parser.js\";\nimport { BITS_FOR_OCCURRENCE_IDX } from \"../../grammar/keys.js\";\nconst RECORDING_NULL_OBJECT = {\n description: \"This Object indicates the Parser is during Recording Phase\",\n};\nObject.freeze(RECORDING_NULL_OBJECT);\nconst HANDLE_SEPARATOR = true;\nconst MAX_METHOD_IDX = Math.pow(2, BITS_FOR_OCCURRENCE_IDX) - 1;\nconst RFT = createToken({ name: \"RECORDING_PHASE_TOKEN\", pattern: Lexer.NA });\naugmentTokenTypes([RFT]);\nconst RECORDING_PHASE_TOKEN = createTokenInstance(RFT, \"This IToken indicates the Parser is in Recording Phase\\n\\t\" +\n \"\" +\n \"See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details\", \n// Using \"-1\" instead of NaN (as in EOF) because an actual number is less likely to\n// cause errors if the output of LA or CONSUME would be (incorrectly) used during the recording phase.\n-1, -1, -1, -1, -1, -1);\nObject.freeze(RECORDING_PHASE_TOKEN);\nconst RECORDING_PHASE_CSTNODE = {\n name: \"This CSTNode indicates the Parser is in Recording Phase\\n\\t\" +\n \"See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details\",\n children: {},\n};\n/**\n * This trait handles the creation of the GAST structure for Chevrotain Grammars\n */\nexport class GastRecorder {\n initGastRecorder(config) {\n this.recordingProdStack = [];\n this.RECORDING_PHASE = false;\n }\n enableRecording() {\n this.RECORDING_PHASE = true;\n this.TRACE_INIT(\"Enable Recording\", () => {\n /**\n * Warning Dark Voodoo Magic upcoming!\n * We are \"replacing\" the public parsing DSL methods API\n * With **new** alternative implementations on the Parser **instance**\n *\n * So far this is the only way I've found to avoid performance regressions during parsing time.\n * - Approx 30% performance regression was measured on Chrome 75 Canary when attempting to replace the \"internal\"\n * implementations directly instead.\n */\n for (let i = 0; i < 10; i++) {\n const idx = i > 0 ? i : \"\";\n this[`CONSUME${idx}`] = function (arg1, arg2) {\n return this.consumeInternalRecord(arg1, i, arg2);\n };\n this[`SUBRULE${idx}`] = function (arg1, arg2) {\n return this.subruleInternalRecord(arg1, i, arg2);\n };\n this[`OPTION${idx}`] = function (arg1) {\n return this.optionInternalRecord(arg1, i);\n };\n this[`OR${idx}`] = function (arg1) {\n return this.orInternalRecord(arg1, i);\n };\n this[`MANY${idx}`] = function (arg1) {\n this.manyInternalRecord(i, arg1);\n };\n this[`MANY_SEP${idx}`] = function (arg1) {\n this.manySepFirstInternalRecord(i, arg1);\n };\n this[`AT_LEAST_ONE${idx}`] = function (arg1) {\n this.atLeastOneInternalRecord(i, arg1);\n };\n this[`AT_LEAST_ONE_SEP${idx}`] = function (arg1) {\n this.atLeastOneSepFirstInternalRecord(i, arg1);\n };\n }\n // DSL methods with the idx(suffix) as an argument\n this[`consume`] = function (idx, arg1, arg2) {\n return this.consumeInternalRecord(arg1, idx, arg2);\n };\n this[`subrule`] = function (idx, arg1, arg2) {\n return this.subruleInternalRecord(arg1, idx, arg2);\n };\n this[`option`] = function (idx, arg1) {\n return this.optionInternalRecord(arg1, idx);\n };\n this[`or`] = function (idx, arg1) {\n return this.orInternalRecord(arg1, idx);\n };\n this[`many`] = function (idx, arg1) {\n this.manyInternalRecord(idx, arg1);\n };\n this[`atLeastOne`] = function (idx, arg1) {\n this.atLeastOneInternalRecord(idx, arg1);\n };\n this.ACTION = this.ACTION_RECORD;\n this.BACKTRACK = this.BACKTRACK_RECORD;\n this.LA = this.LA_RECORD;\n });\n }\n disableRecording() {\n this.RECORDING_PHASE = false;\n // By deleting these **instance** properties, any future invocation\n // will be deferred to the original methods on the **prototype** object\n // This seems to get rid of any incorrect optimizations that V8 may\n // do during the recording phase.\n this.TRACE_INIT(\"Deleting Recording methods\", () => {\n const that = this;\n for (let i = 0; i < 10; i++) {\n const idx = i > 0 ? i : \"\";\n delete that[`CONSUME${idx}`];\n delete that[`SUBRULE${idx}`];\n delete that[`OPTION${idx}`];\n delete that[`OR${idx}`];\n delete that[`MANY${idx}`];\n delete that[`MANY_SEP${idx}`];\n delete that[`AT_LEAST_ONE${idx}`];\n delete that[`AT_LEAST_ONE_SEP${idx}`];\n }\n delete that[`consume`];\n delete that[`subrule`];\n delete that[`option`];\n delete that[`or`];\n delete that[`many`];\n delete that[`atLeastOne`];\n delete that.ACTION;\n delete that.BACKTRACK;\n delete that.LA;\n });\n }\n // Parser methods are called inside an ACTION?\n // Maybe try/catch/finally on ACTIONS while disabling the recorders state changes?\n // @ts-expect-error -- noop place holder\n ACTION_RECORD(impl) {\n // NO-OP during recording\n }\n // Executing backtracking logic will break our recording logic assumptions\n BACKTRACK_RECORD(grammarRule, args) {\n return () => true;\n }\n // LA is part of the official API and may be used for custom lookahead logic\n // by end users who may forget to wrap it in ACTION or inside a GATE\n LA_RECORD(howMuch) {\n // We cannot use the RECORD_PHASE_TOKEN here because someone may depend\n // On LA return EOF at the end of the input so an infinite loop may occur.\n return END_OF_FILE;\n }\n topLevelRuleRecord(name, def) {\n try {\n const newTopLevelRule = new Rule({ definition: [], name: name });\n newTopLevelRule.name = name;\n this.recordingProdStack.push(newTopLevelRule);\n def.call(this);\n this.recordingProdStack.pop();\n return newTopLevelRule;\n }\n catch (originalError) {\n if (originalError.KNOWN_RECORDER_ERROR !== true) {\n try {\n originalError.message =\n originalError.message +\n '\\n\\t This error was thrown during the \"grammar recording phase\" For more info see:\\n\\t' +\n \"https://chevrotain.io/docs/guide/internals.html#grammar-recording\";\n }\n catch (mutabilityError) {\n // We may not be able to modify the original error object\n throw originalError;\n }\n }\n throw originalError;\n }\n }\n // Implementation of parsing DSL\n optionInternalRecord(actionORMethodDef, occurrence) {\n return recordProd.call(this, Option, actionORMethodDef, occurrence);\n }\n atLeastOneInternalRecord(occurrence, actionORMethodDef) {\n recordProd.call(this, RepetitionMandatory, actionORMethodDef, occurrence);\n }\n atLeastOneSepFirstInternalRecord(occurrence, options) {\n recordProd.call(this, RepetitionMandatoryWithSeparator, options, occurrence, HANDLE_SEPARATOR);\n }\n manyInternalRecord(occurrence, actionORMethodDef) {\n recordProd.call(this, Repetition, actionORMethodDef, occurrence);\n }\n manySepFirstInternalRecord(occurrence, options) {\n recordProd.call(this, RepetitionWithSeparator, options, occurrence, HANDLE_SEPARATOR);\n }\n orInternalRecord(altsOrOpts, occurrence) {\n return recordOrProd.call(this, altsOrOpts, occurrence);\n }\n subruleInternalRecord(ruleToCall, occurrence, options) {\n assertMethodIdxIsValid(occurrence);\n if (!ruleToCall || has(ruleToCall, \"ruleName\") === false) {\n const error = new Error(`<SUBRULE${getIdxSuffix(occurrence)}> argument is invalid` +\n ` expecting a Parser method reference but got: <${JSON.stringify(ruleToCall)}>` +\n `\\n inside top level rule: <${this.recordingProdStack[0].name}>`);\n error.KNOWN_RECORDER_ERROR = true;\n throw error;\n }\n const prevProd = peek(this.recordingProdStack);\n const ruleName = ruleToCall.ruleName;\n const newNoneTerminal = new NonTerminal({\n idx: occurrence,\n nonTerminalName: ruleName,\n label: options === null || options === void 0 ? void 0 : options.LABEL,\n // The resolving of the `referencedRule` property will be done once all the Rule's GASTs have been created\n referencedRule: undefined,\n });\n prevProd.definition.push(newNoneTerminal);\n return this.outputCst\n ? RECORDING_PHASE_CSTNODE\n : RECORDING_NULL_OBJECT;\n }\n consumeInternalRecord(tokType, occurrence, options) {\n assertMethodIdxIsValid(occurrence);\n if (!hasShortKeyProperty(tokType)) {\n const error = new Error(`<CONSUME${getIdxSuffix(occurrence)}> argument is invalid` +\n ` expecting a TokenType reference but got: <${JSON.stringify(tokType)}>` +\n `\\n inside top level rule: <${this.recordingProdStack[0].name}>`);\n error.KNOWN_RECORDER_ERROR = true;\n throw error;\n }\n const prevProd = peek(this.recordingProdStack);\n const newNoneTerminal = new Terminal({\n idx: occurrence,\n terminalType: tokType,\n label: options === null || options === void 0 ? void 0 : options.LABEL,\n });\n prevProd.definition.push(newNoneTerminal);\n return RECORDING_PHASE_TOKEN;\n }\n}\nfunction recordProd(prodConstructor, mainProdArg, occurrence, handleSep = false) {\n assertMethodIdxIsValid(occurrence);\n const prevProd = peek(this.recordingProdStack);\n const grammarAction = isFunction(mainProdArg) ? mainProdArg : mainProdArg.DEF;\n const newProd = new prodConstructor({ definition: [], idx: occurrence });\n if (handleSep) {\n newProd.separator = mainProdArg.SEP;\n }\n if (has(mainProdArg, \"MAX_LOOKAHEAD\")) {\n newProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;\n }\n this.recordingProdStack.push(newProd);\n grammarAction.call(this);\n prevProd.definition.push(newProd);\n this.recordingProdStack.pop();\n return RECORDING_NULL_OBJECT;\n}\nfunction recordOrProd(mainProdArg, occurrence) {\n assertMethodIdxIsValid(occurrence);\n const prevProd = peek(this.recordingProdStack);\n // Only an array of alternatives\n const hasOptions = isArray(mainProdArg) === false;\n const alts = hasOptions === false ? mainProdArg : mainProdArg.DEF;\n const newOrProd = new Alternation({\n definition: [],\n idx: occurrence,\n ignoreAmbiguities: hasOptions && mainProdArg.IGNORE_AMBIGUITIES === true,\n });\n if (has(mainProdArg, \"MAX_LOOKAHEAD\")) {\n newOrProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;\n }\n const hasPredicates = some(alts, (currAlt) => isFunction(currAlt.GATE));\n newOrProd.hasPredicates = hasPredicates;\n prevProd.definition.push(newOrProd);\n forEach(alts, (currAlt) => {\n const currAltFlat = new Alternative({ definition: [] });\n newOrProd.definition.push(currAltFlat);\n if (has(currAlt, \"IGNORE_AMBIGUITIES\")) {\n currAltFlat.ignoreAmbiguities = currAlt.IGNORE_AMBIGUITIES; // assumes end user provides the correct config value/type\n }\n // **implicit** ignoreAmbiguities due to usage of gate\n else if (has(currAlt, \"GATE\")) {\n currAltFlat.ignoreAmbiguities = true;\n }\n this.recordingProdStack.push(currAltFlat);\n currAlt.ALT.call(this);\n this.recordingProdStack.pop();\n });\n return RECORDING_NULL_OBJECT;\n}\nfunction getIdxSuffix(idx) {\n return idx === 0 ? \"\" : `${idx}`;\n}\nfunction assertMethodIdxIsValid(idx) {\n if (idx < 0 || idx > MAX_METHOD_IDX) {\n const error = new Error(\n // The stack trace will contain all the needed details\n `Invalid DSL Method idx value: <${idx}>\\n\\t` +\n `Idx value must be a none negative value smaller than ${MAX_METHOD_IDX + 1}`);\n error.KNOWN_RECORDER_ERROR = true;\n throw error;\n }\n}\n//# sourceMappingURL=gast_recorder.js.map","import { has } from \"lodash-es\";\nimport { timer } from \"@chevrotain/utils\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\n/**\n * Trait responsible for runtime parsing errors.\n */\nexport class PerformanceTracer {\n initPerformanceTracer(config) {\n if (has(config, \"traceInitPerf\")) {\n const userTraceInitPerf = config.traceInitPerf;\n const traceIsNumber = typeof userTraceInitPerf === \"number\";\n this.traceInitMaxIdent = traceIsNumber\n ? userTraceInitPerf\n : Infinity;\n this.traceInitPerf = traceIsNumber\n ? userTraceInitPerf > 0\n : userTraceInitPerf; // assumes end user provides the correct config value/type\n }\n else {\n this.traceInitMaxIdent = 0;\n this.traceInitPerf = DEFAULT_PARSER_CONFIG.traceInitPerf;\n }\n this.traceInitIndent = -1;\n }\n TRACE_INIT(phaseDesc, phaseImpl) {\n // No need to optimize this using NOOP pattern because\n // It is not called in a hot spot...\n if (this.traceInitPerf === true) {\n this.traceInitIndent++;\n const indent = new Array(this.traceInitIndent + 1).join(\"\\t\");\n if (this.traceInitIndent < this.traceInitMaxIdent) {\n console.log(`${indent}--> <${phaseDesc}>`);\n }\n const { time, value } = timer(phaseImpl);\n /* istanbul ignore next - Difficult to reproduce specific performance behavior (>10ms) in tests */\n const traceMethod = time > 10 ? console.warn : console.log;\n if (this.traceInitIndent < this.traceInitMaxIdent) {\n traceMethod(`${indent}<-- <${phaseDesc}> time: ${time}ms`);\n }\n this.traceInitIndent--;\n return value;\n }\n else {\n return phaseImpl();\n }\n }\n}\n//# sourceMappingURL=perf_tracer.js.map","export function applyMixins(derivedCtor, baseCtors) {\n baseCtors.forEach((baseCtor) => {\n const baseProto = baseCtor.prototype;\n Object.getOwnPropertyNames(baseProto).forEach((propName) => {\n if (propName === \"constructor\") {\n return;\n }\n const basePropDescriptor = Object.getOwnPropertyDescriptor(baseProto, propName);\n // Handle Accessors\n if (basePropDescriptor &&\n (basePropDescriptor.get || basePropDescriptor.set)) {\n Object.defineProperty(derivedCtor.prototype, propName, basePropDescriptor);\n }\n else {\n derivedCtor.prototype[propName] = baseCtor.prototype[propName];\n }\n });\n });\n}\n//# sourceMappingURL=apply_mixins.js.map","import { clone, forEach, has, isEmpty, map, values } from \"lodash-es\";\nimport { toFastProperties } from \"@chevrotain/utils\";\nimport { computeAllProdsFollows } from \"../grammar/follow.js\";\nimport { createTokenInstance, EOF } from \"../../scan/tokens_public.js\";\nimport { defaultGrammarValidatorErrorProvider, defaultParserErrorProvider, } from \"../errors_public.js\";\nimport { resolveGrammar, validateGrammar, } from \"../grammar/gast/gast_resolver_public.js\";\nimport { Recoverable } from \"./traits/recoverable.js\";\nimport { LooksAhead } from \"./traits/looksahead.js\";\nimport { TreeBuilder } from \"./traits/tree_builder.js\";\nimport { LexerAdapter } from \"./traits/lexer_adapter.js\";\nimport { RecognizerApi } from \"./traits/recognizer_api.js\";\nimport { RecognizerEngine } from \"./traits/recognizer_engine.js\";\nimport { ErrorHandler } from \"./traits/error_handler.js\";\nimport { ContentAssist } from \"./traits/context_assist.js\";\nimport { GastRecorder } from \"./traits/gast_recorder.js\";\nimport { PerformanceTracer } from \"./traits/perf_tracer.js\";\nimport { applyMixins } from \"./utils/apply_mixins.js\";\nimport { validateLookahead } from \"../grammar/checks.js\";\nexport const END_OF_FILE = createTokenInstance(EOF, \"\", NaN, NaN, NaN, NaN, NaN, NaN);\nObject.freeze(END_OF_FILE);\nexport const DEFAULT_PARSER_CONFIG = Object.freeze({\n recoveryEnabled: false,\n maxLookahead: 3,\n dynamicTokensEnabled: false,\n outputCst: true,\n errorMessageProvider: defaultParserErrorProvider,\n nodeLocationTracking: \"none\",\n traceInitPerf: false,\n skipValidations: false,\n});\nexport const DEFAULT_RULE_CONFIG = Object.freeze({\n recoveryValueFunc: () => undefined,\n resyncEnabled: true,\n});\nexport var ParserDefinitionErrorType;\n(function (ParserDefinitionErrorType) {\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"INVALID_RULE_NAME\"] = 0] = \"INVALID_RULE_NAME\";\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"DUPLICATE_RULE_NAME\"] = 1] = \"DUPLICATE_RULE_NAME\";\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"INVALID_RULE_OVERRIDE\"] = 2] = \"INVALID_RULE_OVERRIDE\";\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"DUPLICATE_PRODUCTIONS\"] = 3] = \"DUPLICATE_PRODUCTIONS\";\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"UNRESOLVED_SUBRULE_REF\"] = 4] = \"UNRESOLVED_SUBRULE_REF\";\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"LEFT_RECURSION\"] = 5] = \"LEFT_RECURSION\";\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"NONE_LAST_EMPTY_ALT\"] = 6] = \"NONE_LAST_EMPTY_ALT\";\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"AMBIGUOUS_ALTS\"] = 7] = \"AMBIGUOUS_ALTS\";\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"CONFLICT_TOKENS_RULES_NAMESPACE\"] = 8] = \"CONFLICT_TOKENS_RULES_NAMESPACE\";\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"INVALID_TOKEN_NAME\"] = 9] = \"INVALID_TOKEN_NAME\";\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"NO_NON_EMPTY_LOOKAHEAD\"] = 10] = \"NO_NON_EMPTY_LOOKAHEAD\";\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"AMBIGUOUS_PREFIX_ALTS\"] = 11] = \"AMBIGUOUS_PREFIX_ALTS\";\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"TOO_MANY_ALTS\"] = 12] = \"TOO_MANY_ALTS\";\n ParserDefinitionErrorType[ParserDefinitionErrorType[\"CUSTOM_LOOKAHEAD_VALIDATION\"] = 13] = \"CUSTOM_LOOKAHEAD_VALIDATION\";\n})(ParserDefinitionErrorType || (ParserDefinitionErrorType = {}));\nexport function EMPTY_ALT(value = undefined) {\n return function () {\n return value;\n };\n}\nexport class Parser {\n /**\n * @deprecated use the **instance** method with the same name instead\n */\n static performSelfAnalysis(parserInstance) {\n throw Error(\"The **static** `performSelfAnalysis` method has been deprecated.\" +\n \"\\t\\nUse the **instance** method with the same name instead.\");\n }\n performSelfAnalysis() {\n this.TRACE_INIT(\"performSelfAnalysis\", () => {\n let defErrorsMsgs;\n this.selfAnalysisDone = true;\n const className = this.className;\n this.TRACE_INIT(\"toFastProps\", () => {\n // Without this voodoo magic the parser would be x3-x4 slower\n // It seems it is better to invoke `toFastProperties` **before**\n // Any manipulations of the `this` object done during the recording phase.\n toFastProperties(this);\n });\n this.TRACE_INIT(\"Grammar Recording\", () => {\n try {\n this.enableRecording();\n // Building the GAST\n forEach(this.definedRulesNames, (currRuleName) => {\n const wrappedRule = this[currRuleName];\n const originalGrammarAction = wrappedRule[\"originalGrammarAction\"];\n let recordedRuleGast;\n this.TRACE_INIT(`${currRuleName} Rule`, () => {\n recordedRuleGast = this.topLevelRuleRecord(currRuleName, originalGrammarAction);\n });\n this.gastProductionsCache[currRuleName] = recordedRuleGast;\n });\n }\n finally {\n this.disableRecording();\n }\n });\n let resolverErrors = [];\n this.TRACE_INIT(\"Grammar Resolving\", () => {\n resolverErrors = resolveGrammar({\n rules: values(this.gastProductionsCache),\n });\n this.definitionErrors = this.definitionErrors.concat(resolverErrors);\n });\n this.TRACE_INIT(\"Grammar Validations\", () => {\n // only perform additional grammar validations IFF no resolving errors have occurred.\n // as unresolved grammar may lead to unhandled runtime exceptions in the follow up validations.\n if (isEmpty(resolverErrors) && this.skipValidations === false) {\n const validationErrors = validateGrammar({\n rules: values(this.gastProductionsCache),\n tokenTypes: values(this.tokensMap),\n errMsgProvider: defaultGrammarValidatorErrorProvider,\n grammarName: className,\n });\n const lookaheadValidationErrors = validateLookahead({\n lookaheadStrategy: this.lookaheadStrategy,\n rules: values(this.gastProductionsCache),\n tokenTypes: values(this.tokensMap),\n grammarName: className,\n });\n this.definitionErrors = this.definitionErrors.concat(validationErrors, lookaheadValidationErrors);\n }\n });\n // this analysis may fail if the grammar is not perfectly valid\n if (isEmpty(this.definitionErrors)) {\n // The results of these computations are not needed unless error recovery is enabled.\n if (this.recoveryEnabled) {\n this.TRACE_INIT(\"computeAllProdsFollows\", () => {\n const allFollows = computeAllProdsFollows(values(this.gastProductionsCache));\n this.resyncFollows = allFollows;\n });\n }\n this.TRACE_INIT(\"ComputeLookaheadFunctions\", () => {\n var _a, _b;\n (_b = (_a = this.lookaheadStrategy).initialize) === null || _b === void 0 ? void 0 : _b.call(_a, {\n rules: values(this.gastProductionsCache),\n });\n this.preComputeLookaheadFunctions(values(this.gastProductionsCache));\n });\n }\n if (!Parser.DEFER_DEFINITION_ERRORS_HANDLING &&\n !isEmpty(this.definitionErrors)) {\n defErrorsMsgs = map(this.definitionErrors, (defError) => defError.message);\n throw new Error(`Parser Definition Errors detected:\\n ${defErrorsMsgs.join(\"\\n-------------------------------\\n\")}`);\n }\n });\n }\n constructor(tokenVocabulary, config) {\n this.definitionErrors = [];\n this.selfAnalysisDone = false;\n const that = this;\n that.initErrorHandler(config);\n that.initLexerAdapter();\n that.initLooksAhead(config);\n that.initRecognizerEngine(tokenVocabulary, config);\n that.initRecoverable(config);\n that.initTreeBuilder(config);\n that.initContentAssist();\n that.initGastRecorder(config);\n that.initPerformanceTracer(config);\n if (has(config, \"ignoredIssues\")) {\n throw new Error(\"The <ignoredIssues> IParserConfig property has been deprecated.\\n\\t\" +\n \"Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.\\n\\t\" +\n \"See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES\\n\\t\" +\n \"For further details.\");\n }\n this.skipValidations = has(config, \"skipValidations\")\n ? config.skipValidations // casting assumes the end user passing the correct type\n : DEFAULT_PARSER_CONFIG.skipValidations;\n }\n}\n// Set this flag to true if you don't want the Parser to throw error when problems in it's definition are detected.\n// (normally during the parser's constructor).\n// This is a design time flag, it will not affect the runtime error handling of the parser, just design time errors,\n// for example: duplicate rule names, referencing an unresolved subrule, ect...\n// This flag should not be enabled during normal usage, it is used in special situations, for example when\n// needing to display the parser definition errors in some GUI(online playground).\nParser.DEFER_DEFINITION_ERRORS_HANDLING = false;\napplyMixins(Parser, [\n Recoverable,\n LooksAhead,\n TreeBuilder,\n LexerAdapter,\n RecognizerEngine,\n RecognizerApi,\n ErrorHandler,\n ContentAssist,\n GastRecorder,\n PerformanceTracer,\n]);\nexport class CstParser extends Parser {\n constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {\n const configClone = clone(config);\n configClone.outputCst = true;\n super(tokenVocabulary, configClone);\n }\n}\nexport class EmbeddedActionsParser extends Parser {\n constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {\n const configClone = clone(config);\n configClone.outputCst = false;\n super(tokenVocabulary, configClone);\n }\n}\n//# sourceMappingURL=parser.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport map from \"lodash-es/map.js\";\nimport filter from \"lodash-es/filter.js\";\nimport { Alternation, NonTerminal, Option, RepetitionMandatory, Repetition, Terminal, RepetitionWithSeparator, RepetitionMandatoryWithSeparator } from \"chevrotain\";\nexport function buildATNKey(rule, type, occurrence) {\n return `${rule.name}_${type}_${occurrence}`;\n}\nexport const ATN_INVALID_TYPE = 0;\nexport const ATN_BASIC = 1;\nexport const ATN_RULE_START = 2;\nexport const ATN_PLUS_BLOCK_START = 4;\nexport const ATN_STAR_BLOCK_START = 5;\n// Currently unused as the ATN is not used for lexing\nexport const ATN_TOKEN_START = 6;\nexport const ATN_RULE_STOP = 7;\nexport const ATN_BLOCK_END = 8;\nexport const ATN_STAR_LOOP_BACK = 9;\nexport const ATN_STAR_LOOP_ENTRY = 10;\nexport const ATN_PLUS_LOOP_BACK = 11;\nexport const ATN_LOOP_END = 12;\nexport class AbstractTransition {\n constructor(target) {\n this.target = target;\n }\n isEpsilon() {\n return false;\n }\n}\nexport class AtomTransition extends AbstractTransition {\n constructor(target, tokenType) {\n super(target);\n this.tokenType = tokenType;\n }\n}\nexport class EpsilonTransition extends AbstractTransition {\n constructor(target) {\n super(target);\n }\n isEpsilon() {\n return true;\n }\n}\nexport class RuleTransition extends AbstractTransition {\n constructor(ruleStart, rule, followState) {\n super(ruleStart);\n this.rule = rule;\n this.followState = followState;\n }\n isEpsilon() {\n return true;\n }\n}\nexport function createATN(rules) {\n const atn = {\n decisionMap: {},\n decisionStates: [],\n ruleToStartState: new Map(),\n ruleToStopState: new Map(),\n states: []\n };\n createRuleStartAndStopATNStates(atn, rules);\n const ruleLength = rules.length;\n for (let i = 0; i < ruleLength; i++) {\n const rule = rules[i];\n const ruleBlock = block(atn, rule, rule);\n if (ruleBlock === undefined) {\n continue;\n }\n buildRuleHandle(atn, rule, ruleBlock);\n }\n return atn;\n}\nfunction createRuleStartAndStopATNStates(atn, rules) {\n const ruleLength = rules.length;\n for (let i = 0; i < ruleLength; i++) {\n const rule = rules[i];\n const start = newState(atn, rule, undefined, {\n type: ATN_RULE_START\n });\n const stop = newState(atn, rule, undefined, {\n type: ATN_RULE_STOP\n });\n start.stop = stop;\n atn.ruleToStartState.set(rule, start);\n atn.ruleToStopState.set(rule, stop);\n }\n}\nfunction atom(atn, rule, production) {\n if (production instanceof Terminal) {\n return tokenRef(atn, rule, production.terminalType, production);\n }\n else if (production instanceof NonTerminal) {\n return ruleRef(atn, rule, production);\n }\n else if (production instanceof Alternation) {\n return alternation(atn, rule, production);\n }\n else if (production instanceof Option) {\n return option(atn, rule, production);\n }\n else if (production instanceof Repetition) {\n return repetition(atn, rule, production);\n }\n else if (production instanceof RepetitionWithSeparator) {\n return repetitionSep(atn, rule, production);\n }\n else if (production instanceof RepetitionMandatory) {\n return repetitionMandatory(atn, rule, production);\n }\n else if (production instanceof RepetitionMandatoryWithSeparator) {\n return repetitionMandatorySep(atn, rule, production);\n }\n else {\n return block(atn, rule, production);\n }\n}\nfunction repetition(atn, rule, repetition) {\n const starState = newState(atn, rule, repetition, {\n type: ATN_STAR_BLOCK_START\n });\n defineDecisionState(atn, starState);\n const handle = makeAlts(atn, rule, starState, repetition, block(atn, rule, repetition));\n return star(atn, rule, repetition, handle);\n}\nfunction repetitionSep(atn, rule, repetition) {\n const starState = newState(atn, rule, repetition, {\n type: ATN_STAR_BLOCK_START\n });\n defineDecisionState(atn, starState);\n const handle = makeAlts(atn, rule, starState, repetition, block(atn, rule, repetition));\n const sep = tokenRef(atn, rule, repetition.separator, repetition);\n return star(atn, rule, repetition, handle, sep);\n}\nfunction repetitionMandatory(atn, rule, repetition) {\n const plusState = newState(atn, rule, repetition, {\n type: ATN_PLUS_BLOCK_START\n });\n defineDecisionState(atn, plusState);\n const handle = makeAlts(atn, rule, plusState, repetition, block(atn, rule, repetition));\n return plus(atn, rule, repetition, handle);\n}\nfunction repetitionMandatorySep(atn, rule, repetition) {\n const plusState = newState(atn, rule, repetition, {\n type: ATN_PLUS_BLOCK_START\n });\n defineDecisionState(atn, plusState);\n const handle = makeAlts(atn, rule, plusState, repetition, block(atn, rule, repetition));\n const sep = tokenRef(atn, rule, repetition.separator, repetition);\n return plus(atn, rule, repetition, handle, sep);\n}\nfunction alternation(atn, rule, alternation) {\n const start = newState(atn, rule, alternation, {\n type: ATN_BASIC\n });\n defineDecisionState(atn, start);\n const alts = map(alternation.definition, (e) => atom(atn, rule, e));\n const handle = makeAlts(atn, rule, start, alternation, ...alts);\n return handle;\n}\nfunction option(atn, rule, option) {\n const start = newState(atn, rule, option, {\n type: ATN_BASIC\n });\n defineDecisionState(atn, start);\n const handle = makeAlts(atn, rule, start, option, block(atn, rule, option));\n return optional(atn, rule, option, handle);\n}\nfunction block(atn, rule, block) {\n const handles = filter(map(block.definition, (e) => atom(atn, rule, e)), (e) => e !== undefined);\n if (handles.length === 1) {\n return handles[0];\n }\n else if (handles.length === 0) {\n return undefined;\n }\n else {\n return makeBlock(atn, handles);\n }\n}\nfunction plus(atn, rule, plus, handle, sep) {\n const blkStart = handle.left;\n const blkEnd = handle.right;\n const loop = newState(atn, rule, plus, {\n type: ATN_PLUS_LOOP_BACK\n });\n defineDecisionState(atn, loop);\n const end = newState(atn, rule, plus, {\n type: ATN_LOOP_END\n });\n blkStart.loopback = loop;\n end.loopback = loop;\n atn.decisionMap[buildATNKey(rule, sep ? 'RepetitionMandatoryWithSeparator' : 'RepetitionMandatory', plus.idx)] = loop;\n epsilon(blkEnd, loop); // block can see loop back\n // Depending on whether we have a separator we put the exit transition at index 1 or 0\n // This influences the chosen option in the lookahead DFA\n if (sep === undefined) {\n epsilon(loop, blkStart); // loop back to start\n epsilon(loop, end); // exit\n }\n else {\n epsilon(loop, end); // exit\n // loop back to start with separator\n epsilon(loop, sep.left);\n epsilon(sep.right, blkStart);\n }\n return {\n left: blkStart,\n right: end\n };\n}\nfunction star(atn, rule, star, handle, sep) {\n const start = handle.left;\n const end = handle.right;\n const entry = newState(atn, rule, star, {\n type: ATN_STAR_LOOP_ENTRY\n });\n defineDecisionState(atn, entry);\n const loopEnd = newState(atn, rule, star, {\n type: ATN_LOOP_END\n });\n const loop = newState(atn, rule, star, {\n type: ATN_STAR_LOOP_BACK\n });\n entry.loopback = loop;\n loopEnd.loopback = loop;\n epsilon(entry, start); // loop enter edge (alt 2)\n epsilon(entry, loopEnd); // bypass loop edge (alt 1)\n epsilon(end, loop); // block end hits loop back\n if (sep !== undefined) {\n epsilon(loop, loopEnd); // end loop\n // loop back to start of handle using separator\n epsilon(loop, sep.left);\n epsilon(sep.right, start);\n }\n else {\n epsilon(loop, entry); // loop back to entry/exit decision\n }\n atn.decisionMap[buildATNKey(rule, sep ? 'RepetitionWithSeparator' : 'Repetition', star.idx)] = entry;\n return {\n left: entry,\n right: loopEnd\n };\n}\nfunction optional(atn, rule, optional, handle) {\n const start = handle.left;\n const end = handle.right;\n epsilon(start, end);\n atn.decisionMap[buildATNKey(rule, 'Option', optional.idx)] = start;\n return handle;\n}\nfunction defineDecisionState(atn, state) {\n atn.decisionStates.push(state);\n state.decision = atn.decisionStates.length - 1;\n return state.decision;\n}\nfunction makeAlts(atn, rule, start, production, ...alts) {\n const end = newState(atn, rule, production, {\n type: ATN_BLOCK_END,\n start\n });\n start.end = end;\n for (const alt of alts) {\n if (alt !== undefined) {\n // hook alts up to decision block\n epsilon(start, alt.left);\n epsilon(alt.right, end);\n }\n else {\n epsilon(start, end);\n }\n }\n const handle = {\n left: start,\n right: end\n };\n atn.decisionMap[buildATNKey(rule, getProdType(production), production.idx)] = start;\n return handle;\n}\nfunction getProdType(production) {\n if (production instanceof Alternation) {\n return 'Alternation';\n }\n else if (production instanceof Option) {\n return 'Option';\n }\n else if (production instanceof Repetition) {\n return 'Repetition';\n }\n else if (production instanceof RepetitionWithSeparator) {\n return 'RepetitionWithSeparator';\n }\n else if (production instanceof RepetitionMandatory) {\n return 'RepetitionMandatory';\n }\n else if (production instanceof RepetitionMandatoryWithSeparator) {\n return 'RepetitionMandatoryWithSeparator';\n }\n else {\n throw new Error('Invalid production type encountered');\n }\n}\nfunction makeBlock(atn, alts) {\n const altsLength = alts.length;\n for (let i = 0; i < altsLength - 1; i++) {\n const handle = alts[i];\n let transition;\n if (handle.left.transitions.length === 1) {\n transition = handle.left.transitions[0];\n }\n const isRuleTransition = transition instanceof RuleTransition;\n const ruleTransition = transition;\n const next = alts[i + 1].left;\n if (handle.left.type === ATN_BASIC &&\n handle.right.type === ATN_BASIC &&\n transition !== undefined &&\n ((isRuleTransition && ruleTransition.followState === handle.right) ||\n transition.target === handle.right)) {\n // we can avoid epsilon edge to next element\n if (isRuleTransition) {\n ruleTransition.followState = next;\n }\n else {\n transition.target = next;\n }\n removeState(atn, handle.right); // we skipped over this state\n }\n else {\n // need epsilon if previous block's right end node is complex\n epsilon(handle.right, next);\n }\n }\n const first = alts[0];\n const last = alts[altsLength - 1];\n return {\n left: first.left,\n right: last.right\n };\n}\nfunction tokenRef(atn, rule, tokenType, production) {\n const left = newState(atn, rule, production, {\n type: ATN_BASIC\n });\n const right = newState(atn, rule, production, {\n type: ATN_BASIC\n });\n addTransition(left, new AtomTransition(right, tokenType));\n return {\n left,\n right\n };\n}\nfunction ruleRef(atn, currentRule, nonTerminal) {\n const rule = nonTerminal.referencedRule;\n const start = atn.ruleToStartState.get(rule);\n const left = newState(atn, currentRule, nonTerminal, {\n type: ATN_BASIC\n });\n const right = newState(atn, currentRule, nonTerminal, {\n type: ATN_BASIC\n });\n const call = new RuleTransition(start, rule, right);\n addTransition(left, call);\n return {\n left,\n right\n };\n}\nfunction buildRuleHandle(atn, rule, block) {\n const start = atn.ruleToStartState.get(rule);\n epsilon(start, block.left);\n const stop = atn.ruleToStopState.get(rule);\n epsilon(block.right, stop);\n const handle = {\n left: start,\n right: stop\n };\n return handle;\n}\nfunction epsilon(a, b) {\n const transition = new EpsilonTransition(b);\n addTransition(a, transition);\n}\nfunction newState(atn, rule, production, partial) {\n const t = Object.assign({ atn,\n production, epsilonOnlyTransitions: false, rule, transitions: [], nextTokenWithinRule: [], stateNumber: atn.states.length }, partial);\n atn.states.push(t);\n return t;\n}\nfunction addTransition(state, transition) {\n // A single ATN state can only contain epsilon transitions or non-epsilon transitions\n // Because they are never mixed, only setting the property for the first transition is fine\n if (state.transitions.length === 0) {\n state.epsilonOnlyTransitions = transition.isEpsilon();\n }\n state.transitions.push(transition);\n}\nfunction removeState(atn, state) {\n atn.states.splice(atn.states.indexOf(state), 1);\n}\n//# sourceMappingURL=atn.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport map from \"lodash-es/map.js\";\nexport const DFA_ERROR = {};\nexport class ATNConfigSet {\n constructor() {\n this.map = {};\n this.configs = [];\n }\n get size() {\n return this.configs.length;\n }\n finalize() {\n // Empties the map to free up memory\n this.map = {};\n }\n add(config) {\n const key = getATNConfigKey(config);\n // Only add configs which don't exist in our map already\n // While this does not influence the actual algorithm, adding them anyway would massively increase memory consumption\n if (!(key in this.map)) {\n this.map[key] = this.configs.length;\n this.configs.push(config);\n }\n }\n get elements() {\n return this.configs;\n }\n get alts() {\n return map(this.configs, (e) => e.alt);\n }\n get key() {\n let value = \"\";\n for (const k in this.map) {\n value += k + \":\";\n }\n return value;\n }\n}\nexport function getATNConfigKey(config, alt = true) {\n return `${alt ? `a${config.alt}` : \"\"}s${config.state.stateNumber}:${config.stack.map((e) => e.stateNumber.toString()).join(\"_\")}`;\n}\n//# sourceMappingURL=dfa.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { tokenMatcher, tokenLabel, NonTerminal, Alternation, Option, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Repetition, Terminal, LLkLookaheadStrategy, getLookaheadPaths } from \"chevrotain\";\nimport { ATN_RULE_STOP, AtomTransition, buildATNKey, createATN, EpsilonTransition, RuleTransition } from \"./atn.js\";\nimport { ATNConfigSet, DFA_ERROR, getATNConfigKey } from \"./dfa.js\";\nimport min from \"lodash-es/min.js\";\nimport flatMap from \"lodash-es/flatMap.js\";\nimport uniqBy from \"lodash-es/uniqBy.js\";\nimport map from \"lodash-es/map.js\";\nimport flatten from \"lodash-es/flatten.js\";\nimport forEach from \"lodash-es/forEach.js\";\nimport isEmpty from \"lodash-es/isEmpty.js\";\nimport reduce from \"lodash-es/reduce.js\";\nfunction createDFACache(startState, decision) {\n const map = {};\n return (predicateSet) => {\n const key = predicateSet.toString();\n let existing = map[key];\n if (existing !== undefined) {\n return existing;\n }\n else {\n existing = {\n atnStartState: startState,\n decision,\n states: {}\n };\n map[key] = existing;\n return existing;\n }\n };\n}\nclass PredicateSet {\n constructor() {\n this.predicates = [];\n }\n is(index) {\n return index >= this.predicates.length || this.predicates[index];\n }\n set(index, value) {\n this.predicates[index] = value;\n }\n toString() {\n let value = \"\";\n const size = this.predicates.length;\n for (let i = 0; i < size; i++) {\n value += this.predicates[i] === true ? \"1\" : \"0\";\n }\n return value;\n }\n}\nconst EMPTY_PREDICATES = new PredicateSet();\nexport class LLStarLookaheadStrategy extends LLkLookaheadStrategy {\n constructor(options) {\n var _a;\n super();\n this.logging = (_a = options === null || options === void 0 ? void 0 : options.logging) !== null && _a !== void 0 ? _a : ((message) => console.log(message));\n }\n initialize(options) {\n this.atn = createATN(options.rules);\n this.dfas = initATNSimulator(this.atn);\n }\n validateAmbiguousAlternationAlternatives() {\n return [];\n }\n validateEmptyOrAlternatives() {\n return [];\n }\n buildLookaheadForAlternation(options) {\n const { prodOccurrence, rule, hasPredicates, dynamicTokensEnabled } = options;\n const dfas = this.dfas;\n const logging = this.logging;\n const key = buildATNKey(rule, 'Alternation', prodOccurrence);\n const decisionState = this.atn.decisionMap[key];\n const decisionIndex = decisionState.decision;\n const partialAlts = map(getLookaheadPaths({\n maxLookahead: 1,\n occurrence: prodOccurrence,\n prodType: \"Alternation\",\n rule: rule\n }), (currAlt) => map(currAlt, (path) => path[0]));\n if (isLL1Sequence(partialAlts, false) && !dynamicTokensEnabled) {\n const choiceToAlt = reduce(partialAlts, (result, currAlt, idx) => {\n forEach(currAlt, (currTokType) => {\n if (currTokType) {\n result[currTokType.tokenTypeIdx] = idx;\n forEach(currTokType.categoryMatches, (currExtendingType) => {\n result[currExtendingType] = idx;\n });\n }\n });\n return result;\n }, {});\n if (hasPredicates) {\n return function (orAlts) {\n var _a;\n const nextToken = this.LA(1);\n const prediction = choiceToAlt[nextToken.tokenTypeIdx];\n if (orAlts !== undefined && prediction !== undefined) {\n const gate = (_a = orAlts[prediction]) === null || _a === void 0 ? void 0 : _a.GATE;\n if (gate !== undefined && gate.call(this) === false) {\n return undefined;\n }\n }\n return prediction;\n };\n }\n else {\n return function () {\n const nextToken = this.LA(1);\n return choiceToAlt[nextToken.tokenTypeIdx];\n };\n }\n }\n else if (hasPredicates) {\n return function (orAlts) {\n const predicates = new PredicateSet();\n const length = orAlts === undefined ? 0 : orAlts.length;\n for (let i = 0; i < length; i++) {\n const gate = orAlts === null || orAlts === void 0 ? void 0 : orAlts[i].GATE;\n predicates.set(i, gate === undefined || gate.call(this));\n }\n const result = adaptivePredict.call(this, dfas, decisionIndex, predicates, logging);\n return typeof result === 'number' ? result : undefined;\n };\n }\n else {\n return function () {\n const result = adaptivePredict.call(this, dfas, decisionIndex, EMPTY_PREDICATES, logging);\n return typeof result === 'number' ? result : undefined;\n };\n }\n }\n buildLookaheadForOptional(options) {\n const { prodOccurrence, rule, prodType, dynamicTokensEnabled } = options;\n const dfas = this.dfas;\n const logging = this.logging;\n const key = buildATNKey(rule, prodType, prodOccurrence);\n const decisionState = this.atn.decisionMap[key];\n const decisionIndex = decisionState.decision;\n const alts = map(getLookaheadPaths({\n maxLookahead: 1,\n occurrence: prodOccurrence,\n prodType,\n rule\n }), (e) => {\n return map(e, (g) => g[0]);\n });\n if (isLL1Sequence(alts) && alts[0][0] && !dynamicTokensEnabled) {\n const alt = alts[0];\n const singleTokensTypes = flatten(alt);\n if (singleTokensTypes.length === 1 &&\n isEmpty(singleTokensTypes[0].categoryMatches)) {\n const expectedTokenType = singleTokensTypes[0];\n const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;\n return function () {\n return this.LA(1).tokenTypeIdx === expectedTokenUniqueKey;\n };\n }\n else {\n const choiceToAlt = reduce(singleTokensTypes, (result, currTokType) => {\n if (currTokType !== undefined) {\n result[currTokType.tokenTypeIdx] = true;\n forEach(currTokType.categoryMatches, (currExtendingType) => {\n result[currExtendingType] = true;\n });\n }\n return result;\n }, {});\n return function () {\n const nextToken = this.LA(1);\n return choiceToAlt[nextToken.tokenTypeIdx] === true;\n };\n }\n }\n return function () {\n const result = adaptivePredict.call(this, dfas, decisionIndex, EMPTY_PREDICATES, logging);\n return typeof result === \"object\" ? false : result === 0;\n };\n }\n}\nfunction isLL1Sequence(sequences, allowEmpty = true) {\n const fullSet = new Set();\n for (const alt of sequences) {\n const altSet = new Set();\n for (const tokType of alt) {\n if (tokType === undefined) {\n if (allowEmpty) {\n // Epsilon production encountered\n break;\n }\n else {\n return false;\n }\n }\n const indices = [tokType.tokenTypeIdx].concat(tokType.categoryMatches);\n for (const index of indices) {\n if (fullSet.has(index)) {\n if (!altSet.has(index)) {\n return false;\n }\n }\n else {\n fullSet.add(index);\n altSet.add(index);\n }\n }\n }\n }\n return true;\n}\nfunction initATNSimulator(atn) {\n const decisionLength = atn.decisionStates.length;\n const decisionToDFA = Array(decisionLength);\n for (let i = 0; i < decisionLength; i++) {\n decisionToDFA[i] = createDFACache(atn.decisionStates[i], i);\n }\n return decisionToDFA;\n}\nfunction adaptivePredict(dfaCaches, decision, predicateSet, logging) {\n const dfa = dfaCaches[decision](predicateSet);\n let start = dfa.start;\n if (start === undefined) {\n const closure = computeStartState(dfa.atnStartState);\n start = addDFAState(dfa, newDFAState(closure));\n dfa.start = start;\n }\n const alt = performLookahead.apply(this, [dfa, start, predicateSet, logging]);\n return alt;\n}\nfunction performLookahead(dfa, s0, predicateSet, logging) {\n let previousD = s0;\n let i = 1;\n const path = [];\n let t = this.LA(i++);\n while (true) {\n let d = getExistingTargetState(previousD, t);\n if (d === undefined) {\n d = computeLookaheadTarget.apply(this, [dfa, previousD, t, i, predicateSet, logging]);\n }\n if (d === DFA_ERROR) {\n return buildAdaptivePredictError(path, previousD, t);\n }\n if (d.isAcceptState === true) {\n return d.prediction;\n }\n previousD = d;\n path.push(t);\n t = this.LA(i++);\n }\n}\nfunction computeLookaheadTarget(dfa, previousD, token, lookahead, predicateSet, logging) {\n const reach = computeReachSet(previousD.configs, token, predicateSet);\n if (reach.size === 0) {\n addDFAEdge(dfa, previousD, token, DFA_ERROR);\n return DFA_ERROR;\n }\n let newState = newDFAState(reach);\n const predictedAlt = getUniqueAlt(reach, predicateSet);\n if (predictedAlt !== undefined) {\n newState.isAcceptState = true;\n newState.prediction = predictedAlt;\n newState.configs.uniqueAlt = predictedAlt;\n }\n else if (hasConflictTerminatingPrediction(reach)) {\n const prediction = min(reach.alts);\n newState.isAcceptState = true;\n newState.prediction = prediction;\n newState.configs.uniqueAlt = prediction;\n reportLookaheadAmbiguity.apply(this, [dfa, lookahead, reach.alts, logging]);\n }\n newState = addDFAEdge(dfa, previousD, token, newState);\n return newState;\n}\nfunction reportLookaheadAmbiguity(dfa, lookahead, ambiguityIndices, logging) {\n const prefixPath = [];\n for (let i = 1; i <= lookahead; i++) {\n prefixPath.push(this.LA(i).tokenType);\n }\n const atnState = dfa.atnStartState;\n const topLevelRule = atnState.rule;\n const production = atnState.production;\n const message = buildAmbiguityError({\n topLevelRule,\n ambiguityIndices,\n production,\n prefixPath\n });\n logging(message);\n}\nfunction buildAmbiguityError(options) {\n const pathMsg = map(options.prefixPath, (currtok) => tokenLabel(currtok)).join(\", \");\n const occurrence = options.production.idx === 0 ? \"\" : options.production.idx;\n let currMessage = `Ambiguous Alternatives Detected: <${options.ambiguityIndices.join(\", \")}> in <${getProductionDslName(options.production)}${occurrence}>` +\n ` inside <${options.topLevelRule.name}> Rule,\\n` +\n `<${pathMsg}> may appears as a prefix path in all these alternatives.\\n`;\n currMessage =\n currMessage +\n `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES\\n` +\n `For Further details.`;\n return currMessage;\n}\nfunction getProductionDslName(prod) {\n if (prod instanceof NonTerminal) {\n return \"SUBRULE\";\n }\n else if (prod instanceof Option) {\n return \"OPTION\";\n }\n else if (prod instanceof Alternation) {\n return \"OR\";\n }\n else if (prod instanceof RepetitionMandatory) {\n return \"AT_LEAST_ONE\";\n }\n else if (prod instanceof RepetitionMandatoryWithSeparator) {\n return \"AT_LEAST_ONE_SEP\";\n }\n else if (prod instanceof RepetitionWithSeparator) {\n return \"MANY_SEP\";\n }\n else if (prod instanceof Repetition) {\n return \"MANY\";\n }\n else if (prod instanceof Terminal) {\n return \"CONSUME\";\n }\n else {\n throw Error(\"non exhaustive match\");\n }\n}\nfunction buildAdaptivePredictError(path, previous, current) {\n const nextTransitions = flatMap(previous.configs.elements, (e) => e.state.transitions);\n const nextTokenTypes = uniqBy(nextTransitions\n .filter((e) => e instanceof AtomTransition)\n .map((e) => e.tokenType), (e) => e.tokenTypeIdx);\n return {\n actualToken: current,\n possibleTokenTypes: nextTokenTypes,\n tokenPath: path\n };\n}\nfunction getExistingTargetState(state, token) {\n return state.edges[token.tokenTypeIdx];\n}\nfunction computeReachSet(configs, token, predicateSet) {\n const intermediate = new ATNConfigSet();\n const skippedStopStates = [];\n for (const c of configs.elements) {\n if (predicateSet.is(c.alt) === false) {\n continue;\n }\n if (c.state.type === ATN_RULE_STOP) {\n skippedStopStates.push(c);\n continue;\n }\n const transitionLength = c.state.transitions.length;\n for (let i = 0; i < transitionLength; i++) {\n const transition = c.state.transitions[i];\n const target = getReachableTarget(transition, token);\n if (target !== undefined) {\n intermediate.add({\n state: target,\n alt: c.alt,\n stack: c.stack\n });\n }\n }\n }\n let reach;\n if (skippedStopStates.length === 0 && intermediate.size === 1) {\n reach = intermediate;\n }\n if (reach === undefined) {\n reach = new ATNConfigSet();\n for (const c of intermediate.elements) {\n closure(c, reach);\n }\n }\n if (skippedStopStates.length > 0 && !hasConfigInRuleStopState(reach)) {\n for (const c of skippedStopStates) {\n reach.add(c);\n }\n }\n return reach;\n}\nfunction getReachableTarget(transition, token) {\n if (transition instanceof AtomTransition &&\n tokenMatcher(token, transition.tokenType)) {\n return transition.target;\n }\n return undefined;\n}\nfunction getUniqueAlt(configs, predicateSet) {\n let alt;\n for (const c of configs.elements) {\n if (predicateSet.is(c.alt) === true) {\n if (alt === undefined) {\n alt = c.alt;\n }\n else if (alt !== c.alt) {\n return undefined;\n }\n }\n }\n return alt;\n}\nfunction newDFAState(closure) {\n return {\n configs: closure,\n edges: {},\n isAcceptState: false,\n prediction: -1\n };\n}\nfunction addDFAEdge(dfa, from, token, to) {\n to = addDFAState(dfa, to);\n from.edges[token.tokenTypeIdx] = to;\n return to;\n}\nfunction addDFAState(dfa, state) {\n if (state === DFA_ERROR) {\n return state;\n }\n // Repetitions have the same config set\n // Therefore, storing the key of the config in a map allows us to create a loop in our DFA\n const mapKey = state.configs.key;\n const existing = dfa.states[mapKey];\n if (existing !== undefined) {\n return existing;\n }\n state.configs.finalize();\n dfa.states[mapKey] = state;\n return state;\n}\nfunction computeStartState(atnState) {\n const configs = new ATNConfigSet();\n const numberOfTransitions = atnState.transitions.length;\n for (let i = 0; i < numberOfTransitions; i++) {\n const target = atnState.transitions[i].target;\n const config = {\n state: target,\n alt: i,\n stack: []\n };\n closure(config, configs);\n }\n return configs;\n}\nfunction closure(config, configs) {\n const p = config.state;\n if (p.type === ATN_RULE_STOP) {\n if (config.stack.length > 0) {\n const atnStack = [...config.stack];\n const followState = atnStack.pop();\n const followConfig = {\n state: followState,\n alt: config.alt,\n stack: atnStack\n };\n closure(followConfig, configs);\n }\n else {\n // Dipping into outer context, simply add the config\n // This will stop computation once every config is at the rule stop state\n configs.add(config);\n }\n return;\n }\n if (!p.epsilonOnlyTransitions) {\n configs.add(config);\n }\n const transitionLength = p.transitions.length;\n for (let i = 0; i < transitionLength; i++) {\n const transition = p.transitions[i];\n const c = getEpsilonTarget(config, transition);\n if (c !== undefined) {\n closure(c, configs);\n }\n }\n}\nfunction getEpsilonTarget(config, transition) {\n if (transition instanceof EpsilonTransition) {\n return {\n state: transition.target,\n alt: config.alt,\n stack: config.stack\n };\n }\n else if (transition instanceof RuleTransition) {\n const stack = [...config.stack, transition.followState];\n return {\n state: transition.target,\n alt: config.alt,\n stack\n };\n }\n return undefined;\n}\nfunction hasConfigInRuleStopState(configs) {\n for (const c of configs.elements) {\n if (c.state.type === ATN_RULE_STOP) {\n return true;\n }\n }\n return false;\n}\nfunction allConfigsInRuleStopStates(configs) {\n for (const c of configs.elements) {\n if (c.state.type !== ATN_RULE_STOP) {\n return false;\n }\n }\n return true;\n}\nfunction hasConflictTerminatingPrediction(configs) {\n if (allConfigsInRuleStopStates(configs)) {\n return true;\n }\n const altSets = getConflictingAltSets(configs.elements);\n const heuristic = hasConflictingAltSet(altSets) && !hasStateAssociatedWithOneAlt(altSets);\n return heuristic;\n}\nfunction getConflictingAltSets(configs) {\n const configToAlts = new Map();\n for (const c of configs) {\n const key = getATNConfigKey(c, false);\n let alts = configToAlts.get(key);\n if (alts === undefined) {\n alts = {};\n configToAlts.set(key, alts);\n }\n alts[c.alt] = true;\n }\n return configToAlts;\n}\nfunction hasConflictingAltSet(altSets) {\n for (const value of Array.from(altSets.values())) {\n if (Object.keys(value).length > 1) {\n return true;\n }\n }\n return false;\n}\nfunction hasStateAssociatedWithOneAlt(altSets) {\n for (const value of Array.from(altSets.values())) {\n if (Object.keys(value).length === 1) {\n return true;\n }\n }\n return false;\n}\n//# sourceMappingURL=all-star-lookahead.js.map","/* --------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n * ------------------------------------------------------------------------------------------ */\n'use strict';\nexport var DocumentUri;\n(function (DocumentUri) {\n function is(value) {\n return typeof value === 'string';\n }\n DocumentUri.is = is;\n})(DocumentUri || (DocumentUri = {}));\nexport var URI;\n(function (URI) {\n function is(value) {\n return typeof value === 'string';\n }\n URI.is = is;\n})(URI || (URI = {}));\nexport var integer;\n(function (integer) {\n integer.MIN_VALUE = -2147483648;\n integer.MAX_VALUE = 2147483647;\n function is(value) {\n return typeof value === 'number' && integer.MIN_VALUE <= value && value <= integer.MAX_VALUE;\n }\n integer.is = is;\n})(integer || (integer = {}));\nexport var uinteger;\n(function (uinteger) {\n uinteger.MIN_VALUE = 0;\n uinteger.MAX_VALUE = 2147483647;\n function is(value) {\n return typeof value === 'number' && uinteger.MIN_VALUE <= value && value <= uinteger.MAX_VALUE;\n }\n uinteger.is = is;\n})(uinteger || (uinteger = {}));\n/**\n * The Position namespace provides helper functions to work with\n * {@link Position} literals.\n */\nexport var Position;\n(function (Position) {\n /**\n * Creates a new Position literal from the given line and character.\n * @param line The position's line.\n * @param character The position's character.\n */\n function create(line, character) {\n if (line === Number.MAX_VALUE) {\n line = uinteger.MAX_VALUE;\n }\n if (character === Number.MAX_VALUE) {\n character = uinteger.MAX_VALUE;\n }\n return { line, character };\n }\n Position.create = create;\n /**\n * Checks whether the given literal conforms to the {@link Position} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);\n }\n Position.is = is;\n})(Position || (Position = {}));\n/**\n * The Range namespace provides helper functions to work with\n * {@link Range} literals.\n */\nexport var Range;\n(function (Range) {\n function create(one, two, three, four) {\n if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {\n return { start: Position.create(one, two), end: Position.create(three, four) };\n }\n else if (Position.is(one) && Position.is(two)) {\n return { start: one, end: two };\n }\n else {\n throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);\n }\n }\n Range.create = create;\n /**\n * Checks whether the given literal conforms to the {@link Range} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);\n }\n Range.is = is;\n})(Range || (Range = {}));\n/**\n * The Location namespace provides helper functions to work with\n * {@link Location} literals.\n */\nexport var Location;\n(function (Location) {\n /**\n * Creates a Location literal.\n * @param uri The location's uri.\n * @param range The location's range.\n */\n function create(uri, range) {\n return { uri, range };\n }\n Location.create = create;\n /**\n * Checks whether the given literal conforms to the {@link Location} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.objectLiteral(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));\n }\n Location.is = is;\n})(Location || (Location = {}));\n/**\n * The LocationLink namespace provides helper functions to work with\n * {@link LocationLink} literals.\n */\nexport var LocationLink;\n(function (LocationLink) {\n /**\n * Creates a LocationLink literal.\n * @param targetUri The definition's uri.\n * @param targetRange The full range of the definition.\n * @param targetSelectionRange The span of the symbol definition at the target.\n * @param originSelectionRange The span of the symbol being defined in the originating source file.\n */\n function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {\n return { targetUri, targetRange, targetSelectionRange, originSelectionRange };\n }\n LocationLink.create = create;\n /**\n * Checks whether the given literal conforms to the {@link LocationLink} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.objectLiteral(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri)\n && Range.is(candidate.targetSelectionRange)\n && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));\n }\n LocationLink.is = is;\n})(LocationLink || (LocationLink = {}));\n/**\n * The Color namespace provides helper functions to work with\n * {@link Color} literals.\n */\nexport var Color;\n(function (Color) {\n /**\n * Creates a new Color literal.\n */\n function create(red, green, blue, alpha) {\n return {\n red,\n green,\n blue,\n alpha,\n };\n }\n Color.create = create;\n /**\n * Checks whether the given literal conforms to the {@link Color} interface.\n */\n function is(value) {\n const candidate = value;\n return Is.objectLiteral(candidate) && Is.numberRange(candidate.red, 0, 1)\n && Is.numberRange(candidate.green, 0, 1)\n && Is.numberRange(candidate.blue, 0, 1)\n && Is.numberRange(candidate.alpha, 0, 1);\n }\n Color.is = is;\n})(Color || (Color = {}));\n/**\n * The ColorInformation namespace provides helper functions to work with\n * {@link ColorInformation} literals.\n */\nexport var ColorInformation;\n(function (ColorInformation) {\n /**\n * Creates a new ColorInformation literal.\n */\n function create(range, color) {\n return {\n range,\n color,\n };\n }\n ColorInformation.create = create;\n /**\n * Checks whether the given literal conforms to the {@link ColorInformation} interface.\n */\n function is(value) {\n const candidate = value;\n return Is.objectLiteral(candidate) && Range.is(candidate.range) && Color.is(candidate.color);\n }\n ColorInformation.is = is;\n})(ColorInformation || (ColorInformation = {}));\n/**\n * The Color namespace provides helper functions to work with\n * {@link ColorPresentation} literals.\n */\nexport var ColorPresentation;\n(function (ColorPresentation) {\n /**\n * Creates a new ColorInformation literal.\n */\n function create(label, textEdit, additionalTextEdits) {\n return {\n label,\n textEdit,\n additionalTextEdits,\n };\n }\n ColorPresentation.create = create;\n /**\n * Checks whether the given literal conforms to the {@link ColorInformation} interface.\n */\n function is(value) {\n const candidate = value;\n return Is.objectLiteral(candidate) && Is.string(candidate.label)\n && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate))\n && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));\n }\n ColorPresentation.is = is;\n})(ColorPresentation || (ColorPresentation = {}));\n/**\n * A set of predefined range kinds.\n */\nexport var FoldingRangeKind;\n(function (FoldingRangeKind) {\n /**\n * Folding range for a comment\n */\n FoldingRangeKind.Comment = 'comment';\n /**\n * Folding range for an import or include\n */\n FoldingRangeKind.Imports = 'imports';\n /**\n * Folding range for a region (e.g. `#region`)\n */\n FoldingRangeKind.Region = 'region';\n})(FoldingRangeKind || (FoldingRangeKind = {}));\n/**\n * The folding range namespace provides helper functions to work with\n * {@link FoldingRange} literals.\n */\nexport var FoldingRange;\n(function (FoldingRange) {\n /**\n * Creates a new FoldingRange literal.\n */\n function create(startLine, endLine, startCharacter, endCharacter, kind, collapsedText) {\n const result = {\n startLine,\n endLine\n };\n if (Is.defined(startCharacter)) {\n result.startCharacter = startCharacter;\n }\n if (Is.defined(endCharacter)) {\n result.endCharacter = endCharacter;\n }\n if (Is.defined(kind)) {\n result.kind = kind;\n }\n if (Is.defined(collapsedText)) {\n result.collapsedText = collapsedText;\n }\n return result;\n }\n FoldingRange.create = create;\n /**\n * Checks whether the given literal conforms to the {@link FoldingRange} interface.\n */\n function is(value) {\n const candidate = value;\n return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine)\n && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter))\n && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter))\n && (Is.undefined(candidate.kind) || Is.string(candidate.kind));\n }\n FoldingRange.is = is;\n})(FoldingRange || (FoldingRange = {}));\n/**\n * The DiagnosticRelatedInformation namespace provides helper functions to work with\n * {@link DiagnosticRelatedInformation} literals.\n */\nexport var DiagnosticRelatedInformation;\n(function (DiagnosticRelatedInformation) {\n /**\n * Creates a new DiagnosticRelatedInformation literal.\n */\n function create(location, message) {\n return {\n location,\n message\n };\n }\n DiagnosticRelatedInformation.create = create;\n /**\n * Checks whether the given literal conforms to the {@link DiagnosticRelatedInformation} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);\n }\n DiagnosticRelatedInformation.is = is;\n})(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));\n/**\n * The diagnostic's severity.\n */\nexport var DiagnosticSeverity;\n(function (DiagnosticSeverity) {\n /**\n * Reports an error.\n */\n DiagnosticSeverity.Error = 1;\n /**\n * Reports a warning.\n */\n DiagnosticSeverity.Warning = 2;\n /**\n * Reports an information.\n */\n DiagnosticSeverity.Information = 3;\n /**\n * Reports a hint.\n */\n DiagnosticSeverity.Hint = 4;\n})(DiagnosticSeverity || (DiagnosticSeverity = {}));\n/**\n * The diagnostic tags.\n *\n * @since 3.15.0\n */\nexport var DiagnosticTag;\n(function (DiagnosticTag) {\n /**\n * Unused or unnecessary code.\n *\n * Clients are allowed to render diagnostics with this tag faded out instead of having\n * an error squiggle.\n */\n DiagnosticTag.Unnecessary = 1;\n /**\n * Deprecated or obsolete code.\n *\n * Clients are allowed to rendered diagnostics with this tag strike through.\n */\n DiagnosticTag.Deprecated = 2;\n})(DiagnosticTag || (DiagnosticTag = {}));\n/**\n * The CodeDescription namespace provides functions to deal with descriptions for diagnostic codes.\n *\n * @since 3.16.0\n */\nexport var CodeDescription;\n(function (CodeDescription) {\n function is(value) {\n const candidate = value;\n return Is.objectLiteral(candidate) && Is.string(candidate.href);\n }\n CodeDescription.is = is;\n})(CodeDescription || (CodeDescription = {}));\n/**\n * The Diagnostic namespace provides helper functions to work with\n * {@link Diagnostic} literals.\n */\nexport var Diagnostic;\n(function (Diagnostic) {\n /**\n * Creates a new Diagnostic literal.\n */\n function create(range, message, severity, code, source, relatedInformation) {\n let result = { range, message };\n if (Is.defined(severity)) {\n result.severity = severity;\n }\n if (Is.defined(code)) {\n result.code = code;\n }\n if (Is.defined(source)) {\n result.source = source;\n }\n if (Is.defined(relatedInformation)) {\n result.relatedInformation = relatedInformation;\n }\n return result;\n }\n Diagnostic.create = create;\n /**\n * Checks whether the given literal conforms to the {@link Diagnostic} interface.\n */\n function is(value) {\n var _a;\n let candidate = value;\n return Is.defined(candidate)\n && Range.is(candidate.range)\n && Is.string(candidate.message)\n && (Is.number(candidate.severity) || Is.undefined(candidate.severity))\n && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code))\n && (Is.undefined(candidate.codeDescription) || (Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)))\n && (Is.string(candidate.source) || Is.undefined(candidate.source))\n && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));\n }\n Diagnostic.is = is;\n})(Diagnostic || (Diagnostic = {}));\n/**\n * The Command namespace provides helper functions to work with\n * {@link Command} literals.\n */\nexport var Command;\n(function (Command) {\n /**\n * Creates a new Command literal.\n */\n function create(title, command, ...args) {\n let result = { title, command };\n if (Is.defined(args) && args.length > 0) {\n result.arguments = args;\n }\n return result;\n }\n Command.create = create;\n /**\n * Checks whether the given literal conforms to the {@link Command} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);\n }\n Command.is = is;\n})(Command || (Command = {}));\n/**\n * The TextEdit namespace provides helper function to create replace,\n * insert and delete edits more easily.\n */\nexport var TextEdit;\n(function (TextEdit) {\n /**\n * Creates a replace text edit.\n * @param range The range of text to be replaced.\n * @param newText The new text.\n */\n function replace(range, newText) {\n return { range, newText };\n }\n TextEdit.replace = replace;\n /**\n * Creates an insert text edit.\n * @param position The position to insert the text at.\n * @param newText The text to be inserted.\n */\n function insert(position, newText) {\n return { range: { start: position, end: position }, newText };\n }\n TextEdit.insert = insert;\n /**\n * Creates a delete text edit.\n * @param range The range of text to be deleted.\n */\n function del(range) {\n return { range, newText: '' };\n }\n TextEdit.del = del;\n function is(value) {\n const candidate = value;\n return Is.objectLiteral(candidate)\n && Is.string(candidate.newText)\n && Range.is(candidate.range);\n }\n TextEdit.is = is;\n})(TextEdit || (TextEdit = {}));\nexport var ChangeAnnotation;\n(function (ChangeAnnotation) {\n function create(label, needsConfirmation, description) {\n const result = { label };\n if (needsConfirmation !== undefined) {\n result.needsConfirmation = needsConfirmation;\n }\n if (description !== undefined) {\n result.description = description;\n }\n return result;\n }\n ChangeAnnotation.create = create;\n function is(value) {\n const candidate = value;\n return Is.objectLiteral(candidate) && Is.string(candidate.label) &&\n (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === undefined) &&\n (Is.string(candidate.description) || candidate.description === undefined);\n }\n ChangeAnnotation.is = is;\n})(ChangeAnnotation || (ChangeAnnotation = {}));\nexport var ChangeAnnotationIdentifier;\n(function (ChangeAnnotationIdentifier) {\n function is(value) {\n const candidate = value;\n return Is.string(candidate);\n }\n ChangeAnnotationIdentifier.is = is;\n})(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));\nexport var AnnotatedTextEdit;\n(function (AnnotatedTextEdit) {\n /**\n * Creates an annotated replace text edit.\n *\n * @param range The range of text to be replaced.\n * @param newText The new text.\n * @param annotation The annotation.\n */\n function replace(range, newText, annotation) {\n return { range, newText, annotationId: annotation };\n }\n AnnotatedTextEdit.replace = replace;\n /**\n * Creates an annotated insert text edit.\n *\n * @param position The position to insert the text at.\n * @param newText The text to be inserted.\n * @param annotation The annotation.\n */\n function insert(position, newText, annotation) {\n return { range: { start: position, end: position }, newText, annotationId: annotation };\n }\n AnnotatedTextEdit.insert = insert;\n /**\n * Creates an annotated delete text edit.\n *\n * @param range The range of text to be deleted.\n * @param annotation The annotation.\n */\n function del(range, annotation) {\n return { range, newText: '', annotationId: annotation };\n }\n AnnotatedTextEdit.del = del;\n function is(value) {\n const candidate = value;\n return TextEdit.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));\n }\n AnnotatedTextEdit.is = is;\n})(AnnotatedTextEdit || (AnnotatedTextEdit = {}));\n/**\n * The TextDocumentEdit namespace provides helper function to create\n * an edit that manipulates a text document.\n */\nexport var TextDocumentEdit;\n(function (TextDocumentEdit) {\n /**\n * Creates a new `TextDocumentEdit`\n */\n function create(textDocument, edits) {\n return { textDocument, edits };\n }\n TextDocumentEdit.create = create;\n function is(value) {\n let candidate = value;\n return Is.defined(candidate)\n && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument)\n && Array.isArray(candidate.edits);\n }\n TextDocumentEdit.is = is;\n})(TextDocumentEdit || (TextDocumentEdit = {}));\nexport var CreateFile;\n(function (CreateFile) {\n function create(uri, options, annotation) {\n let result = {\n kind: 'create',\n uri\n };\n if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {\n result.options = options;\n }\n if (annotation !== undefined) {\n result.annotationId = annotation;\n }\n return result;\n }\n CreateFile.create = create;\n function is(value) {\n let candidate = value;\n return candidate && candidate.kind === 'create' && Is.string(candidate.uri) && (candidate.options === undefined ||\n ((candidate.options.overwrite === undefined || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is.boolean(candidate.options.ignoreIfExists)))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));\n }\n CreateFile.is = is;\n})(CreateFile || (CreateFile = {}));\nexport var RenameFile;\n(function (RenameFile) {\n function create(oldUri, newUri, options, annotation) {\n let result = {\n kind: 'rename',\n oldUri,\n newUri\n };\n if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {\n result.options = options;\n }\n if (annotation !== undefined) {\n result.annotationId = annotation;\n }\n return result;\n }\n RenameFile.create = create;\n function is(value) {\n let candidate = value;\n return candidate && candidate.kind === 'rename' && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === undefined ||\n ((candidate.options.overwrite === undefined || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is.boolean(candidate.options.ignoreIfExists)))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));\n }\n RenameFile.is = is;\n})(RenameFile || (RenameFile = {}));\nexport var DeleteFile;\n(function (DeleteFile) {\n function create(uri, options, annotation) {\n let result = {\n kind: 'delete',\n uri\n };\n if (options !== undefined && (options.recursive !== undefined || options.ignoreIfNotExists !== undefined)) {\n result.options = options;\n }\n if (annotation !== undefined) {\n result.annotationId = annotation;\n }\n return result;\n }\n DeleteFile.create = create;\n function is(value) {\n let candidate = value;\n return candidate && candidate.kind === 'delete' && Is.string(candidate.uri) && (candidate.options === undefined ||\n ((candidate.options.recursive === undefined || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === undefined || Is.boolean(candidate.options.ignoreIfNotExists)))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));\n }\n DeleteFile.is = is;\n})(DeleteFile || (DeleteFile = {}));\nexport var WorkspaceEdit;\n(function (WorkspaceEdit) {\n function is(value) {\n let candidate = value;\n return candidate &&\n (candidate.changes !== undefined || candidate.documentChanges !== undefined) &&\n (candidate.documentChanges === undefined || candidate.documentChanges.every((change) => {\n if (Is.string(change.kind)) {\n return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);\n }\n else {\n return TextDocumentEdit.is(change);\n }\n }));\n }\n WorkspaceEdit.is = is;\n})(WorkspaceEdit || (WorkspaceEdit = {}));\nclass TextEditChangeImpl {\n constructor(edits, changeAnnotations) {\n this.edits = edits;\n this.changeAnnotations = changeAnnotations;\n }\n insert(position, newText, annotation) {\n let edit;\n let id;\n if (annotation === undefined) {\n edit = TextEdit.insert(position, newText);\n }\n else if (ChangeAnnotationIdentifier.is(annotation)) {\n id = annotation;\n edit = AnnotatedTextEdit.insert(position, newText, annotation);\n }\n else {\n this.assertChangeAnnotations(this.changeAnnotations);\n id = this.changeAnnotations.manage(annotation);\n edit = AnnotatedTextEdit.insert(position, newText, id);\n }\n this.edits.push(edit);\n if (id !== undefined) {\n return id;\n }\n }\n replace(range, newText, annotation) {\n let edit;\n let id;\n if (annotation === undefined) {\n edit = TextEdit.replace(range, newText);\n }\n else if (ChangeAnnotationIdentifier.is(annotation)) {\n id = annotation;\n edit = AnnotatedTextEdit.replace(range, newText, annotation);\n }\n else {\n this.assertChangeAnnotations(this.changeAnnotations);\n id = this.changeAnnotations.manage(annotation);\n edit = AnnotatedTextEdit.replace(range, newText, id);\n }\n this.edits.push(edit);\n if (id !== undefined) {\n return id;\n }\n }\n delete(range, annotation) {\n let edit;\n let id;\n if (annotation === undefined) {\n edit = TextEdit.del(range);\n }\n else if (ChangeAnnotationIdentifier.is(annotation)) {\n id = annotation;\n edit = AnnotatedTextEdit.del(range, annotation);\n }\n else {\n this.assertChangeAnnotations(this.changeAnnotations);\n id = this.changeAnnotations.manage(annotation);\n edit = AnnotatedTextEdit.del(range, id);\n }\n this.edits.push(edit);\n if (id !== undefined) {\n return id;\n }\n }\n add(edit) {\n this.edits.push(edit);\n }\n all() {\n return this.edits;\n }\n clear() {\n this.edits.splice(0, this.edits.length);\n }\n assertChangeAnnotations(value) {\n if (value === undefined) {\n throw new Error(`Text edit change is not configured to manage change annotations.`);\n }\n }\n}\n/**\n * A helper class\n */\nclass ChangeAnnotations {\n constructor(annotations) {\n this._annotations = annotations === undefined ? Object.create(null) : annotations;\n this._counter = 0;\n this._size = 0;\n }\n all() {\n return this._annotations;\n }\n get size() {\n return this._size;\n }\n manage(idOrAnnotation, annotation) {\n let id;\n if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {\n id = idOrAnnotation;\n }\n else {\n id = this.nextId();\n annotation = idOrAnnotation;\n }\n if (this._annotations[id] !== undefined) {\n throw new Error(`Id ${id} is already in use.`);\n }\n if (annotation === undefined) {\n throw new Error(`No annotation provided for id ${id}`);\n }\n this._annotations[id] = annotation;\n this._size++;\n return id;\n }\n nextId() {\n this._counter++;\n return this._counter.toString();\n }\n}\n/**\n * A workspace change helps constructing changes to a workspace.\n */\nexport class WorkspaceChange {\n constructor(workspaceEdit) {\n this._textEditChanges = Object.create(null);\n if (workspaceEdit !== undefined) {\n this._workspaceEdit = workspaceEdit;\n if (workspaceEdit.documentChanges) {\n this._changeAnnotations = new ChangeAnnotations(workspaceEdit.changeAnnotations);\n workspaceEdit.changeAnnotations = this._changeAnnotations.all();\n workspaceEdit.documentChanges.forEach((change) => {\n if (TextDocumentEdit.is(change)) {\n const textEditChange = new TextEditChangeImpl(change.edits, this._changeAnnotations);\n this._textEditChanges[change.textDocument.uri] = textEditChange;\n }\n });\n }\n else if (workspaceEdit.changes) {\n Object.keys(workspaceEdit.changes).forEach((key) => {\n const textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);\n this._textEditChanges[key] = textEditChange;\n });\n }\n }\n else {\n this._workspaceEdit = {};\n }\n }\n /**\n * Returns the underlying {@link WorkspaceEdit} literal\n * use to be returned from a workspace edit operation like rename.\n */\n get edit() {\n this.initDocumentChanges();\n if (this._changeAnnotations !== undefined) {\n if (this._changeAnnotations.size === 0) {\n this._workspaceEdit.changeAnnotations = undefined;\n }\n else {\n this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();\n }\n }\n return this._workspaceEdit;\n }\n getTextEditChange(key) {\n if (OptionalVersionedTextDocumentIdentifier.is(key)) {\n this.initDocumentChanges();\n if (this._workspaceEdit.documentChanges === undefined) {\n throw new Error('Workspace edit is not configured for document changes.');\n }\n const textDocument = { uri: key.uri, version: key.version };\n let result = this._textEditChanges[textDocument.uri];\n if (!result) {\n const edits = [];\n const textDocumentEdit = {\n textDocument,\n edits\n };\n this._workspaceEdit.documentChanges.push(textDocumentEdit);\n result = new TextEditChangeImpl(edits, this._changeAnnotations);\n this._textEditChanges[textDocument.uri] = result;\n }\n return result;\n }\n else {\n this.initChanges();\n if (this._workspaceEdit.changes === undefined) {\n throw new Error('Workspace edit is not configured for normal text edit changes.');\n }\n let result = this._textEditChanges[key];\n if (!result) {\n let edits = [];\n this._workspaceEdit.changes[key] = edits;\n result = new TextEditChangeImpl(edits);\n this._textEditChanges[key] = result;\n }\n return result;\n }\n }\n initDocumentChanges() {\n if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {\n this._changeAnnotations = new ChangeAnnotations();\n this._workspaceEdit.documentChanges = [];\n this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();\n }\n }\n initChanges() {\n if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {\n this._workspaceEdit.changes = Object.create(null);\n }\n }\n createFile(uri, optionsOrAnnotation, options) {\n this.initDocumentChanges();\n if (this._workspaceEdit.documentChanges === undefined) {\n throw new Error('Workspace edit is not configured for document changes.');\n }\n let annotation;\n if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {\n annotation = optionsOrAnnotation;\n }\n else {\n options = optionsOrAnnotation;\n }\n let operation;\n let id;\n if (annotation === undefined) {\n operation = CreateFile.create(uri, options);\n }\n else {\n id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);\n operation = CreateFile.create(uri, options, id);\n }\n this._workspaceEdit.documentChanges.push(operation);\n if (id !== undefined) {\n return id;\n }\n }\n renameFile(oldUri, newUri, optionsOrAnnotation, options) {\n this.initDocumentChanges();\n if (this._workspaceEdit.documentChanges === undefined) {\n throw new Error('Workspace edit is not configured for document changes.');\n }\n let annotation;\n if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {\n annotation = optionsOrAnnotation;\n }\n else {\n options = optionsOrAnnotation;\n }\n let operation;\n let id;\n if (annotation === undefined) {\n operation = RenameFile.create(oldUri, newUri, options);\n }\n else {\n id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);\n operation = RenameFile.create(oldUri, newUri, options, id);\n }\n this._workspaceEdit.documentChanges.push(operation);\n if (id !== undefined) {\n return id;\n }\n }\n deleteFile(uri, optionsOrAnnotation, options) {\n this.initDocumentChanges();\n if (this._workspaceEdit.documentChanges === undefined) {\n throw new Error('Workspace edit is not configured for document changes.');\n }\n let annotation;\n if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {\n annotation = optionsOrAnnotation;\n }\n else {\n options = optionsOrAnnotation;\n }\n let operation;\n let id;\n if (annotation === undefined) {\n operation = DeleteFile.create(uri, options);\n }\n else {\n id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);\n operation = DeleteFile.create(uri, options, id);\n }\n this._workspaceEdit.documentChanges.push(operation);\n if (id !== undefined) {\n return id;\n }\n }\n}\n/**\n * The TextDocumentIdentifier namespace provides helper functions to work with\n * {@link TextDocumentIdentifier} literals.\n */\nexport var TextDocumentIdentifier;\n(function (TextDocumentIdentifier) {\n /**\n * Creates a new TextDocumentIdentifier literal.\n * @param uri The document's uri.\n */\n function create(uri) {\n return { uri };\n }\n TextDocumentIdentifier.create = create;\n /**\n * Checks whether the given literal conforms to the {@link TextDocumentIdentifier} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.defined(candidate) && Is.string(candidate.uri);\n }\n TextDocumentIdentifier.is = is;\n})(TextDocumentIdentifier || (TextDocumentIdentifier = {}));\n/**\n * The VersionedTextDocumentIdentifier namespace provides helper functions to work with\n * {@link VersionedTextDocumentIdentifier} literals.\n */\nexport var VersionedTextDocumentIdentifier;\n(function (VersionedTextDocumentIdentifier) {\n /**\n * Creates a new VersionedTextDocumentIdentifier literal.\n * @param uri The document's uri.\n * @param version The document's version.\n */\n function create(uri, version) {\n return { uri, version };\n }\n VersionedTextDocumentIdentifier.create = create;\n /**\n * Checks whether the given literal conforms to the {@link VersionedTextDocumentIdentifier} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);\n }\n VersionedTextDocumentIdentifier.is = is;\n})(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));\n/**\n * The OptionalVersionedTextDocumentIdentifier namespace provides helper functions to work with\n * {@link OptionalVersionedTextDocumentIdentifier} literals.\n */\nexport var OptionalVersionedTextDocumentIdentifier;\n(function (OptionalVersionedTextDocumentIdentifier) {\n /**\n * Creates a new OptionalVersionedTextDocumentIdentifier literal.\n * @param uri The document's uri.\n * @param version The document's version.\n */\n function create(uri, version) {\n return { uri, version };\n }\n OptionalVersionedTextDocumentIdentifier.create = create;\n /**\n * Checks whether the given literal conforms to the {@link OptionalVersionedTextDocumentIdentifier} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));\n }\n OptionalVersionedTextDocumentIdentifier.is = is;\n})(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));\n/**\n * The TextDocumentItem namespace provides helper functions to work with\n * {@link TextDocumentItem} literals.\n */\nexport var TextDocumentItem;\n(function (TextDocumentItem) {\n /**\n * Creates a new TextDocumentItem literal.\n * @param uri The document's uri.\n * @param languageId The document's language identifier.\n * @param version The document's version number.\n * @param text The document's text.\n */\n function create(uri, languageId, version, text) {\n return { uri, languageId, version, text };\n }\n TextDocumentItem.create = create;\n /**\n * Checks whether the given literal conforms to the {@link TextDocumentItem} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);\n }\n TextDocumentItem.is = is;\n})(TextDocumentItem || (TextDocumentItem = {}));\n/**\n * Describes the content type that a client supports in various\n * result literals like `Hover`, `ParameterInfo` or `CompletionItem`.\n *\n * Please note that `MarkupKinds` must not start with a `$`. This kinds\n * are reserved for internal usage.\n */\nexport var MarkupKind;\n(function (MarkupKind) {\n /**\n * Plain text is supported as a content format\n */\n MarkupKind.PlainText = 'plaintext';\n /**\n * Markdown is supported as a content format\n */\n MarkupKind.Markdown = 'markdown';\n /**\n * Checks whether the given value is a value of the {@link MarkupKind} type.\n */\n function is(value) {\n const candidate = value;\n return candidate === MarkupKind.PlainText || candidate === MarkupKind.Markdown;\n }\n MarkupKind.is = is;\n})(MarkupKind || (MarkupKind = {}));\nexport var MarkupContent;\n(function (MarkupContent) {\n /**\n * Checks whether the given value conforms to the {@link MarkupContent} interface.\n */\n function is(value) {\n const candidate = value;\n return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);\n }\n MarkupContent.is = is;\n})(MarkupContent || (MarkupContent = {}));\n/**\n * The kind of a completion entry.\n */\nexport var CompletionItemKind;\n(function (CompletionItemKind) {\n CompletionItemKind.Text = 1;\n CompletionItemKind.Method = 2;\n CompletionItemKind.Function = 3;\n CompletionItemKind.Constructor = 4;\n CompletionItemKind.Field = 5;\n CompletionItemKind.Variable = 6;\n CompletionItemKind.Class = 7;\n CompletionItemKind.Interface = 8;\n CompletionItemKind.Module = 9;\n CompletionItemKind.Property = 10;\n CompletionItemKind.Unit = 11;\n CompletionItemKind.Value = 12;\n CompletionItemKind.Enum = 13;\n CompletionItemKind.Keyword = 14;\n CompletionItemKind.Snippet = 15;\n CompletionItemKind.Color = 16;\n CompletionItemKind.File = 17;\n CompletionItemKind.Reference = 18;\n CompletionItemKind.Folder = 19;\n CompletionItemKind.EnumMember = 20;\n CompletionItemKind.Constant = 21;\n CompletionItemKind.Struct = 22;\n CompletionItemKind.Event = 23;\n CompletionItemKind.Operator = 24;\n CompletionItemKind.TypeParameter = 25;\n})(CompletionItemKind || (CompletionItemKind = {}));\n/**\n * Defines whether the insert text in a completion item should be interpreted as\n * plain text or a snippet.\n */\nexport var InsertTextFormat;\n(function (InsertTextFormat) {\n /**\n * The primary text to be inserted is treated as a plain string.\n */\n InsertTextFormat.PlainText = 1;\n /**\n * The primary text to be inserted is treated as a snippet.\n *\n * A snippet can define tab stops and placeholders with `$1`, `$2`\n * and `${3:foo}`. `$0` defines the final tab stop, it defaults to\n * the end of the snippet. Placeholders with equal identifiers are linked,\n * that is typing in one will update others too.\n *\n * See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#snippet_syntax\n */\n InsertTextFormat.Snippet = 2;\n})(InsertTextFormat || (InsertTextFormat = {}));\n/**\n * Completion item tags are extra annotations that tweak the rendering of a completion\n * item.\n *\n * @since 3.15.0\n */\nexport var CompletionItemTag;\n(function (CompletionItemTag) {\n /**\n * Render a completion as obsolete, usually using a strike-out.\n */\n CompletionItemTag.Deprecated = 1;\n})(CompletionItemTag || (CompletionItemTag = {}));\n/**\n * The InsertReplaceEdit namespace provides functions to deal with insert / replace edits.\n *\n * @since 3.16.0\n */\nexport var InsertReplaceEdit;\n(function (InsertReplaceEdit) {\n /**\n * Creates a new insert / replace edit\n */\n function create(newText, insert, replace) {\n return { newText, insert, replace };\n }\n InsertReplaceEdit.create = create;\n /**\n * Checks whether the given literal conforms to the {@link InsertReplaceEdit} interface.\n */\n function is(value) {\n const candidate = value;\n return candidate && Is.string(candidate.newText) && Range.is(candidate.insert) && Range.is(candidate.replace);\n }\n InsertReplaceEdit.is = is;\n})(InsertReplaceEdit || (InsertReplaceEdit = {}));\n/**\n * How whitespace and indentation is handled during completion\n * item insertion.\n *\n * @since 3.16.0\n */\nexport var InsertTextMode;\n(function (InsertTextMode) {\n /**\n * The insertion or replace strings is taken as it is. If the\n * value is multi line the lines below the cursor will be\n * inserted using the indentation defined in the string value.\n * The client will not apply any kind of adjustments to the\n * string.\n */\n InsertTextMode.asIs = 1;\n /**\n * The editor adjusts leading whitespace of new lines so that\n * they match the indentation up to the cursor of the line for\n * which the item is accepted.\n *\n * Consider a line like this: <2tabs><cursor><3tabs>foo. Accepting a\n * multi line completion item is indented using 2 tabs and all\n * following lines inserted will be indented using 2 tabs as well.\n */\n InsertTextMode.adjustIndentation = 2;\n})(InsertTextMode || (InsertTextMode = {}));\nexport var CompletionItemLabelDetails;\n(function (CompletionItemLabelDetails) {\n function is(value) {\n const candidate = value;\n return candidate && (Is.string(candidate.detail) || candidate.detail === undefined) &&\n (Is.string(candidate.description) || candidate.description === undefined);\n }\n CompletionItemLabelDetails.is = is;\n})(CompletionItemLabelDetails || (CompletionItemLabelDetails = {}));\n/**\n * The CompletionItem namespace provides functions to deal with\n * completion items.\n */\nexport var CompletionItem;\n(function (CompletionItem) {\n /**\n * Create a completion item and seed it with a label.\n * @param label The completion item's label\n */\n function create(label) {\n return { label };\n }\n CompletionItem.create = create;\n})(CompletionItem || (CompletionItem = {}));\n/**\n * The CompletionList namespace provides functions to deal with\n * completion lists.\n */\nexport var CompletionList;\n(function (CompletionList) {\n /**\n * Creates a new completion list.\n *\n * @param items The completion items.\n * @param isIncomplete The list is not complete.\n */\n function create(items, isIncomplete) {\n return { items: items ? items : [], isIncomplete: !!isIncomplete };\n }\n CompletionList.create = create;\n})(CompletionList || (CompletionList = {}));\nexport var MarkedString;\n(function (MarkedString) {\n /**\n * Creates a marked string from plain text.\n *\n * @param plainText The plain text.\n */\n function fromPlainText(plainText) {\n return plainText.replace(/[\\\\`*_{}[\\]()#+\\-.!]/g, '\\\\$&'); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash\n }\n MarkedString.fromPlainText = fromPlainText;\n /**\n * Checks whether the given value conforms to the {@link MarkedString} type.\n */\n function is(value) {\n const candidate = value;\n return Is.string(candidate) || (Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value));\n }\n MarkedString.is = is;\n})(MarkedString || (MarkedString = {}));\nexport var Hover;\n(function (Hover) {\n /**\n * Checks whether the given value conforms to the {@link Hover} interface.\n */\n function is(value) {\n let candidate = value;\n return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) ||\n MarkedString.is(candidate.contents) ||\n Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === undefined || Range.is(value.range));\n }\n Hover.is = is;\n})(Hover || (Hover = {}));\n/**\n * The ParameterInformation namespace provides helper functions to work with\n * {@link ParameterInformation} literals.\n */\nexport var ParameterInformation;\n(function (ParameterInformation) {\n /**\n * Creates a new parameter information literal.\n *\n * @param label A label string.\n * @param documentation A doc string.\n */\n function create(label, documentation) {\n return documentation ? { label, documentation } : { label };\n }\n ParameterInformation.create = create;\n})(ParameterInformation || (ParameterInformation = {}));\n/**\n * The SignatureInformation namespace provides helper functions to work with\n * {@link SignatureInformation} literals.\n */\nexport var SignatureInformation;\n(function (SignatureInformation) {\n function create(label, documentation, ...parameters) {\n let result = { label };\n if (Is.defined(documentation)) {\n result.documentation = documentation;\n }\n if (Is.defined(parameters)) {\n result.parameters = parameters;\n }\n else {\n result.parameters = [];\n }\n return result;\n }\n SignatureInformation.create = create;\n})(SignatureInformation || (SignatureInformation = {}));\n/**\n * A document highlight kind.\n */\nexport var DocumentHighlightKind;\n(function (DocumentHighlightKind) {\n /**\n * A textual occurrence.\n */\n DocumentHighlightKind.Text = 1;\n /**\n * Read-access of a symbol, like reading a variable.\n */\n DocumentHighlightKind.Read = 2;\n /**\n * Write-access of a symbol, like writing to a variable.\n */\n DocumentHighlightKind.Write = 3;\n})(DocumentHighlightKind || (DocumentHighlightKind = {}));\n/**\n * DocumentHighlight namespace to provide helper functions to work with\n * {@link DocumentHighlight} literals.\n */\nexport var DocumentHighlight;\n(function (DocumentHighlight) {\n /**\n * Create a DocumentHighlight object.\n * @param range The range the highlight applies to.\n * @param kind The highlight kind\n */\n function create(range, kind) {\n let result = { range };\n if (Is.number(kind)) {\n result.kind = kind;\n }\n return result;\n }\n DocumentHighlight.create = create;\n})(DocumentHighlight || (DocumentHighlight = {}));\n/**\n * A symbol kind.\n */\nexport var SymbolKind;\n(function (SymbolKind) {\n SymbolKind.File = 1;\n SymbolKind.Module = 2;\n SymbolKind.Namespace = 3;\n SymbolKind.Package = 4;\n SymbolKind.Class = 5;\n SymbolKind.Method = 6;\n SymbolKind.Property = 7;\n SymbolKind.Field = 8;\n SymbolKind.Constructor = 9;\n SymbolKind.Enum = 10;\n SymbolKind.Interface = 11;\n SymbolKind.Function = 12;\n SymbolKind.Variable = 13;\n SymbolKind.Constant = 14;\n SymbolKind.String = 15;\n SymbolKind.Number = 16;\n SymbolKind.Boolean = 17;\n SymbolKind.Array = 18;\n SymbolKind.Object = 19;\n SymbolKind.Key = 20;\n SymbolKind.Null = 21;\n SymbolKind.EnumMember = 22;\n SymbolKind.Struct = 23;\n SymbolKind.Event = 24;\n SymbolKind.Operator = 25;\n SymbolKind.TypeParameter = 26;\n})(SymbolKind || (SymbolKind = {}));\n/**\n * Symbol tags are extra annotations that tweak the rendering of a symbol.\n *\n * @since 3.16\n */\nexport var SymbolTag;\n(function (SymbolTag) {\n /**\n * Render a symbol as obsolete, usually using a strike-out.\n */\n SymbolTag.Deprecated = 1;\n})(SymbolTag || (SymbolTag = {}));\nexport var SymbolInformation;\n(function (SymbolInformation) {\n /**\n * Creates a new symbol information literal.\n *\n * @param name The name of the symbol.\n * @param kind The kind of the symbol.\n * @param range The range of the location of the symbol.\n * @param uri The resource of the location of symbol.\n * @param containerName The name of the symbol containing the symbol.\n */\n function create(name, kind, range, uri, containerName) {\n let result = {\n name,\n kind,\n location: { uri, range }\n };\n if (containerName) {\n result.containerName = containerName;\n }\n return result;\n }\n SymbolInformation.create = create;\n})(SymbolInformation || (SymbolInformation = {}));\nexport var WorkspaceSymbol;\n(function (WorkspaceSymbol) {\n /**\n * Create a new workspace symbol.\n *\n * @param name The name of the symbol.\n * @param kind The kind of the symbol.\n * @param uri The resource of the location of the symbol.\n * @param range An options range of the location.\n * @returns A WorkspaceSymbol.\n */\n function create(name, kind, uri, range) {\n return range !== undefined\n ? { name, kind, location: { uri, range } }\n : { name, kind, location: { uri } };\n }\n WorkspaceSymbol.create = create;\n})(WorkspaceSymbol || (WorkspaceSymbol = {}));\nexport var DocumentSymbol;\n(function (DocumentSymbol) {\n /**\n * Creates a new symbol information literal.\n *\n * @param name The name of the symbol.\n * @param detail The detail of the symbol.\n * @param kind The kind of the symbol.\n * @param range The range of the symbol.\n * @param selectionRange The selectionRange of the symbol.\n * @param children Children of the symbol.\n */\n function create(name, detail, kind, range, selectionRange, children) {\n let result = {\n name,\n detail,\n kind,\n range,\n selectionRange\n };\n if (children !== undefined) {\n result.children = children;\n }\n return result;\n }\n DocumentSymbol.create = create;\n /**\n * Checks whether the given literal conforms to the {@link DocumentSymbol} interface.\n */\n function is(value) {\n let candidate = value;\n return candidate &&\n Is.string(candidate.name) && Is.number(candidate.kind) &&\n Range.is(candidate.range) && Range.is(candidate.selectionRange) &&\n (candidate.detail === undefined || Is.string(candidate.detail)) &&\n (candidate.deprecated === undefined || Is.boolean(candidate.deprecated)) &&\n (candidate.children === undefined || Array.isArray(candidate.children)) &&\n (candidate.tags === undefined || Array.isArray(candidate.tags));\n }\n DocumentSymbol.is = is;\n})(DocumentSymbol || (DocumentSymbol = {}));\n/**\n * A set of predefined code action kinds\n */\nexport var CodeActionKind;\n(function (CodeActionKind) {\n /**\n * Empty kind.\n */\n CodeActionKind.Empty = '';\n /**\n * Base kind for quickfix actions: 'quickfix'\n */\n CodeActionKind.QuickFix = 'quickfix';\n /**\n * Base kind for refactoring actions: 'refactor'\n */\n CodeActionKind.Refactor = 'refactor';\n /**\n * Base kind for refactoring extraction actions: 'refactor.extract'\n *\n * Example extract actions:\n *\n * - Extract method\n * - Extract function\n * - Extract variable\n * - Extract interface from class\n * - ...\n */\n CodeActionKind.RefactorExtract = 'refactor.extract';\n /**\n * Base kind for refactoring inline actions: 'refactor.inline'\n *\n * Example inline actions:\n *\n * - Inline function\n * - Inline variable\n * - Inline constant\n * - ...\n */\n CodeActionKind.RefactorInline = 'refactor.inline';\n /**\n * Base kind for refactoring rewrite actions: 'refactor.rewrite'\n *\n * Example rewrite actions:\n *\n * - Convert JavaScript function to class\n * - Add or remove parameter\n * - Encapsulate field\n * - Make method static\n * - Move method to base class\n * - ...\n */\n CodeActionKind.RefactorRewrite = 'refactor.rewrite';\n /**\n * Base kind for source actions: `source`\n *\n * Source code actions apply to the entire file.\n */\n CodeActionKind.Source = 'source';\n /**\n * Base kind for an organize imports source action: `source.organizeImports`\n */\n CodeActionKind.SourceOrganizeImports = 'source.organizeImports';\n /**\n * Base kind for auto-fix source actions: `source.fixAll`.\n *\n * Fix all actions automatically fix errors that have a clear fix that do not require user input.\n * They should not suppress errors or perform unsafe fixes such as generating new types or classes.\n *\n * @since 3.15.0\n */\n CodeActionKind.SourceFixAll = 'source.fixAll';\n})(CodeActionKind || (CodeActionKind = {}));\n/**\n * The reason why code actions were requested.\n *\n * @since 3.17.0\n */\nexport var CodeActionTriggerKind;\n(function (CodeActionTriggerKind) {\n /**\n * Code actions were explicitly requested by the user or by an extension.\n */\n CodeActionTriggerKind.Invoked = 1;\n /**\n * Code actions were requested automatically.\n *\n * This typically happens when current selection in a file changes, but can\n * also be triggered when file content changes.\n */\n CodeActionTriggerKind.Automatic = 2;\n})(CodeActionTriggerKind || (CodeActionTriggerKind = {}));\n/**\n * The CodeActionContext namespace provides helper functions to work with\n * {@link CodeActionContext} literals.\n */\nexport var CodeActionContext;\n(function (CodeActionContext) {\n /**\n * Creates a new CodeActionContext literal.\n */\n function create(diagnostics, only, triggerKind) {\n let result = { diagnostics };\n if (only !== undefined && only !== null) {\n result.only = only;\n }\n if (triggerKind !== undefined && triggerKind !== null) {\n result.triggerKind = triggerKind;\n }\n return result;\n }\n CodeActionContext.create = create;\n /**\n * Checks whether the given literal conforms to the {@link CodeActionContext} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is)\n && (candidate.only === undefined || Is.typedArray(candidate.only, Is.string))\n && (candidate.triggerKind === undefined || candidate.triggerKind === CodeActionTriggerKind.Invoked || candidate.triggerKind === CodeActionTriggerKind.Automatic);\n }\n CodeActionContext.is = is;\n})(CodeActionContext || (CodeActionContext = {}));\nexport var CodeAction;\n(function (CodeAction) {\n function create(title, kindOrCommandOrEdit, kind) {\n let result = { title };\n let checkKind = true;\n if (typeof kindOrCommandOrEdit === 'string') {\n checkKind = false;\n result.kind = kindOrCommandOrEdit;\n }\n else if (Command.is(kindOrCommandOrEdit)) {\n result.command = kindOrCommandOrEdit;\n }\n else {\n result.edit = kindOrCommandOrEdit;\n }\n if (checkKind && kind !== undefined) {\n result.kind = kind;\n }\n return result;\n }\n CodeAction.create = create;\n function is(value) {\n let candidate = value;\n return candidate && Is.string(candidate.title) &&\n (candidate.diagnostics === undefined || Is.typedArray(candidate.diagnostics, Diagnostic.is)) &&\n (candidate.kind === undefined || Is.string(candidate.kind)) &&\n (candidate.edit !== undefined || candidate.command !== undefined) &&\n (candidate.command === undefined || Command.is(candidate.command)) &&\n (candidate.isPreferred === undefined || Is.boolean(candidate.isPreferred)) &&\n (candidate.edit === undefined || WorkspaceEdit.is(candidate.edit));\n }\n CodeAction.is = is;\n})(CodeAction || (CodeAction = {}));\n/**\n * The CodeLens namespace provides helper functions to work with\n * {@link CodeLens} literals.\n */\nexport var CodeLens;\n(function (CodeLens) {\n /**\n * Creates a new CodeLens literal.\n */\n function create(range, data) {\n let result = { range };\n if (Is.defined(data)) {\n result.data = data;\n }\n return result;\n }\n CodeLens.create = create;\n /**\n * Checks whether the given literal conforms to the {@link CodeLens} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));\n }\n CodeLens.is = is;\n})(CodeLens || (CodeLens = {}));\n/**\n * The FormattingOptions namespace provides helper functions to work with\n * {@link FormattingOptions} literals.\n */\nexport var FormattingOptions;\n(function (FormattingOptions) {\n /**\n * Creates a new FormattingOptions literal.\n */\n function create(tabSize, insertSpaces) {\n return { tabSize, insertSpaces };\n }\n FormattingOptions.create = create;\n /**\n * Checks whether the given literal conforms to the {@link FormattingOptions} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);\n }\n FormattingOptions.is = is;\n})(FormattingOptions || (FormattingOptions = {}));\n/**\n * The DocumentLink namespace provides helper functions to work with\n * {@link DocumentLink} literals.\n */\nexport var DocumentLink;\n(function (DocumentLink) {\n /**\n * Creates a new DocumentLink literal.\n */\n function create(range, target, data) {\n return { range, target, data };\n }\n DocumentLink.create = create;\n /**\n * Checks whether the given literal conforms to the {@link DocumentLink} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));\n }\n DocumentLink.is = is;\n})(DocumentLink || (DocumentLink = {}));\n/**\n * The SelectionRange namespace provides helper function to work with\n * SelectionRange literals.\n */\nexport var SelectionRange;\n(function (SelectionRange) {\n /**\n * Creates a new SelectionRange\n * @param range the range.\n * @param parent an optional parent.\n */\n function create(range, parent) {\n return { range, parent };\n }\n SelectionRange.create = create;\n function is(value) {\n let candidate = value;\n return Is.objectLiteral(candidate) && Range.is(candidate.range) && (candidate.parent === undefined || SelectionRange.is(candidate.parent));\n }\n SelectionRange.is = is;\n})(SelectionRange || (SelectionRange = {}));\n/**\n * A set of predefined token types. This set is not fixed\n * an clients can specify additional token types via the\n * corresponding client capabilities.\n *\n * @since 3.16.0\n */\nexport var SemanticTokenTypes;\n(function (SemanticTokenTypes) {\n SemanticTokenTypes[\"namespace\"] = \"namespace\";\n /**\n * Represents a generic type. Acts as a fallback for types which can't be mapped to\n * a specific type like class or enum.\n */\n SemanticTokenTypes[\"type\"] = \"type\";\n SemanticTokenTypes[\"class\"] = \"class\";\n SemanticTokenTypes[\"enum\"] = \"enum\";\n SemanticTokenTypes[\"interface\"] = \"interface\";\n SemanticTokenTypes[\"struct\"] = \"struct\";\n SemanticTokenTypes[\"typeParameter\"] = \"typeParameter\";\n SemanticTokenTypes[\"parameter\"] = \"parameter\";\n SemanticTokenTypes[\"variable\"] = \"variable\";\n SemanticTokenTypes[\"property\"] = \"property\";\n SemanticTokenTypes[\"enumMember\"] = \"enumMember\";\n SemanticTokenTypes[\"event\"] = \"event\";\n SemanticTokenTypes[\"function\"] = \"function\";\n SemanticTokenTypes[\"method\"] = \"method\";\n SemanticTokenTypes[\"macro\"] = \"macro\";\n SemanticTokenTypes[\"keyword\"] = \"keyword\";\n SemanticTokenTypes[\"modifier\"] = \"modifier\";\n SemanticTokenTypes[\"comment\"] = \"comment\";\n SemanticTokenTypes[\"string\"] = \"string\";\n SemanticTokenTypes[\"number\"] = \"number\";\n SemanticTokenTypes[\"regexp\"] = \"regexp\";\n SemanticTokenTypes[\"operator\"] = \"operator\";\n /**\n * @since 3.17.0\n */\n SemanticTokenTypes[\"decorator\"] = \"decorator\";\n})(SemanticTokenTypes || (SemanticTokenTypes = {}));\n/**\n * A set of predefined token modifiers. This set is not fixed\n * an clients can specify additional token types via the\n * corresponding client capabilities.\n *\n * @since 3.16.0\n */\nexport var SemanticTokenModifiers;\n(function (SemanticTokenModifiers) {\n SemanticTokenModifiers[\"declaration\"] = \"declaration\";\n SemanticTokenModifiers[\"definition\"] = \"definition\";\n SemanticTokenModifiers[\"readonly\"] = \"readonly\";\n SemanticTokenModifiers[\"static\"] = \"static\";\n SemanticTokenModifiers[\"deprecated\"] = \"deprecated\";\n SemanticTokenModifiers[\"abstract\"] = \"abstract\";\n SemanticTokenModifiers[\"async\"] = \"async\";\n SemanticTokenModifiers[\"modification\"] = \"modification\";\n SemanticTokenModifiers[\"documentation\"] = \"documentation\";\n SemanticTokenModifiers[\"defaultLibrary\"] = \"defaultLibrary\";\n})(SemanticTokenModifiers || (SemanticTokenModifiers = {}));\n/**\n * @since 3.16.0\n */\nexport var SemanticTokens;\n(function (SemanticTokens) {\n function is(value) {\n const candidate = value;\n return Is.objectLiteral(candidate) && (candidate.resultId === undefined || typeof candidate.resultId === 'string') &&\n Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === 'number');\n }\n SemanticTokens.is = is;\n})(SemanticTokens || (SemanticTokens = {}));\n/**\n * The InlineValueText namespace provides functions to deal with InlineValueTexts.\n *\n * @since 3.17.0\n */\nexport var InlineValueText;\n(function (InlineValueText) {\n /**\n * Creates a new InlineValueText literal.\n */\n function create(range, text) {\n return { range, text };\n }\n InlineValueText.create = create;\n function is(value) {\n const candidate = value;\n return candidate !== undefined && candidate !== null && Range.is(candidate.range) && Is.string(candidate.text);\n }\n InlineValueText.is = is;\n})(InlineValueText || (InlineValueText = {}));\n/**\n * The InlineValueVariableLookup namespace provides functions to deal with InlineValueVariableLookups.\n *\n * @since 3.17.0\n */\nexport var InlineValueVariableLookup;\n(function (InlineValueVariableLookup) {\n /**\n * Creates a new InlineValueText literal.\n */\n function create(range, variableName, caseSensitiveLookup) {\n return { range, variableName, caseSensitiveLookup };\n }\n InlineValueVariableLookup.create = create;\n function is(value) {\n const candidate = value;\n return candidate !== undefined && candidate !== null && Range.is(candidate.range) && Is.boolean(candidate.caseSensitiveLookup)\n && (Is.string(candidate.variableName) || candidate.variableName === undefined);\n }\n InlineValueVariableLookup.is = is;\n})(InlineValueVariableLookup || (InlineValueVariableLookup = {}));\n/**\n * The InlineValueEvaluatableExpression namespace provides functions to deal with InlineValueEvaluatableExpression.\n *\n * @since 3.17.0\n */\nexport var InlineValueEvaluatableExpression;\n(function (InlineValueEvaluatableExpression) {\n /**\n * Creates a new InlineValueEvaluatableExpression literal.\n */\n function create(range, expression) {\n return { range, expression };\n }\n InlineValueEvaluatableExpression.create = create;\n function is(value) {\n const candidate = value;\n return candidate !== undefined && candidate !== null && Range.is(candidate.range)\n && (Is.string(candidate.expression) || candidate.expression === undefined);\n }\n InlineValueEvaluatableExpression.is = is;\n})(InlineValueEvaluatableExpression || (InlineValueEvaluatableExpression = {}));\n/**\n * The InlineValueContext namespace provides helper functions to work with\n * {@link InlineValueContext} literals.\n *\n * @since 3.17.0\n */\nexport var InlineValueContext;\n(function (InlineValueContext) {\n /**\n * Creates a new InlineValueContext literal.\n */\n function create(frameId, stoppedLocation) {\n return { frameId, stoppedLocation };\n }\n InlineValueContext.create = create;\n /**\n * Checks whether the given literal conforms to the {@link InlineValueContext} interface.\n */\n function is(value) {\n const candidate = value;\n return Is.defined(candidate) && Range.is(value.stoppedLocation);\n }\n InlineValueContext.is = is;\n})(InlineValueContext || (InlineValueContext = {}));\n/**\n * Inlay hint kinds.\n *\n * @since 3.17.0\n */\nexport var InlayHintKind;\n(function (InlayHintKind) {\n /**\n * An inlay hint that for a type annotation.\n */\n InlayHintKind.Type = 1;\n /**\n * An inlay hint that is for a parameter.\n */\n InlayHintKind.Parameter = 2;\n function is(value) {\n return value === 1 || value === 2;\n }\n InlayHintKind.is = is;\n})(InlayHintKind || (InlayHintKind = {}));\nexport var InlayHintLabelPart;\n(function (InlayHintLabelPart) {\n function create(value) {\n return { value };\n }\n InlayHintLabelPart.create = create;\n function is(value) {\n const candidate = value;\n return Is.objectLiteral(candidate)\n && (candidate.tooltip === undefined || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip))\n && (candidate.location === undefined || Location.is(candidate.location))\n && (candidate.command === undefined || Command.is(candidate.command));\n }\n InlayHintLabelPart.is = is;\n})(InlayHintLabelPart || (InlayHintLabelPart = {}));\nexport var InlayHint;\n(function (InlayHint) {\n function create(position, label, kind) {\n const result = { position, label };\n if (kind !== undefined) {\n result.kind = kind;\n }\n return result;\n }\n InlayHint.create = create;\n function is(value) {\n const candidate = value;\n return Is.objectLiteral(candidate) && Position.is(candidate.position)\n && (Is.string(candidate.label) || Is.typedArray(candidate.label, InlayHintLabelPart.is))\n && (candidate.kind === undefined || InlayHintKind.is(candidate.kind))\n && (candidate.textEdits === undefined) || Is.typedArray(candidate.textEdits, TextEdit.is)\n && (candidate.tooltip === undefined || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip))\n && (candidate.paddingLeft === undefined || Is.boolean(candidate.paddingLeft))\n && (candidate.paddingRight === undefined || Is.boolean(candidate.paddingRight));\n }\n InlayHint.is = is;\n})(InlayHint || (InlayHint = {}));\nexport var StringValue;\n(function (StringValue) {\n function createSnippet(value) {\n return { kind: 'snippet', value };\n }\n StringValue.createSnippet = createSnippet;\n})(StringValue || (StringValue = {}));\nexport var InlineCompletionItem;\n(function (InlineCompletionItem) {\n function create(insertText, filterText, range, command) {\n return { insertText, filterText, range, command };\n }\n InlineCompletionItem.create = create;\n})(InlineCompletionItem || (InlineCompletionItem = {}));\nexport var InlineCompletionList;\n(function (InlineCompletionList) {\n function create(items) {\n return { items };\n }\n InlineCompletionList.create = create;\n})(InlineCompletionList || (InlineCompletionList = {}));\n/**\n * Describes how an {@link InlineCompletionItemProvider inline completion provider} was triggered.\n *\n * @since 3.18.0\n * @proposed\n */\nexport var InlineCompletionTriggerKind;\n(function (InlineCompletionTriggerKind) {\n /**\n * Completion was triggered explicitly by a user gesture.\n */\n InlineCompletionTriggerKind.Invoked = 0;\n /**\n * Completion was triggered automatically while editing.\n */\n InlineCompletionTriggerKind.Automatic = 1;\n})(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));\nexport var SelectedCompletionInfo;\n(function (SelectedCompletionInfo) {\n function create(range, text) {\n return { range, text };\n }\n SelectedCompletionInfo.create = create;\n})(SelectedCompletionInfo || (SelectedCompletionInfo = {}));\nexport var InlineCompletionContext;\n(function (InlineCompletionContext) {\n function create(triggerKind, selectedCompletionInfo) {\n return { triggerKind, selectedCompletionInfo };\n }\n InlineCompletionContext.create = create;\n})(InlineCompletionContext || (InlineCompletionContext = {}));\nexport var WorkspaceFolder;\n(function (WorkspaceFolder) {\n function is(value) {\n const candidate = value;\n return Is.objectLiteral(candidate) && URI.is(candidate.uri) && Is.string(candidate.name);\n }\n WorkspaceFolder.is = is;\n})(WorkspaceFolder || (WorkspaceFolder = {}));\nexport const EOL = ['\\n', '\\r\\n', '\\r'];\n/**\n * @deprecated Use the text document from the new vscode-languageserver-textdocument package.\n */\nexport var TextDocument;\n(function (TextDocument) {\n /**\n * Creates a new ITextDocument literal from the given uri and content.\n * @param uri The document's uri.\n * @param languageId The document's language Id.\n * @param version The document's version.\n * @param content The document's content.\n */\n function create(uri, languageId, version, content) {\n return new FullTextDocument(uri, languageId, version, content);\n }\n TextDocument.create = create;\n /**\n * Checks whether the given literal conforms to the {@link ITextDocument} interface.\n */\n function is(value) {\n let candidate = value;\n return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount)\n && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;\n }\n TextDocument.is = is;\n function applyEdits(document, edits) {\n let text = document.getText();\n let sortedEdits = mergeSort(edits, (a, b) => {\n let diff = a.range.start.line - b.range.start.line;\n if (diff === 0) {\n return a.range.start.character - b.range.start.character;\n }\n return diff;\n });\n let lastModifiedOffset = text.length;\n for (let i = sortedEdits.length - 1; i >= 0; i--) {\n let e = sortedEdits[i];\n let startOffset = document.offsetAt(e.range.start);\n let endOffset = document.offsetAt(e.range.end);\n if (endOffset <= lastModifiedOffset) {\n text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);\n }\n else {\n throw new Error('Overlapping edit');\n }\n lastModifiedOffset = startOffset;\n }\n return text;\n }\n TextDocument.applyEdits = applyEdits;\n function mergeSort(data, compare) {\n if (data.length <= 1) {\n // sorted\n return data;\n }\n const p = (data.length / 2) | 0;\n const left = data.slice(0, p);\n const right = data.slice(p);\n mergeSort(left, compare);\n mergeSort(right, compare);\n let leftIdx = 0;\n let rightIdx = 0;\n let i = 0;\n while (leftIdx < left.length && rightIdx < right.length) {\n let ret = compare(left[leftIdx], right[rightIdx]);\n if (ret <= 0) {\n // smaller_equal -> take left to preserve order\n data[i++] = left[leftIdx++];\n }\n else {\n // greater -> take right\n data[i++] = right[rightIdx++];\n }\n }\n while (leftIdx < left.length) {\n data[i++] = left[leftIdx++];\n }\n while (rightIdx < right.length) {\n data[i++] = right[rightIdx++];\n }\n return data;\n }\n})(TextDocument || (TextDocument = {}));\n/**\n * @deprecated Use the text document from the new vscode-languageserver-textdocument package.\n */\nclass FullTextDocument {\n constructor(uri, languageId, version, content) {\n this._uri = uri;\n this._languageId = languageId;\n this._version = version;\n this._content = content;\n this._lineOffsets = undefined;\n }\n get uri() {\n return this._uri;\n }\n get languageId() {\n return this._languageId;\n }\n get version() {\n return this._version;\n }\n getText(range) {\n if (range) {\n let start = this.offsetAt(range.start);\n let end = this.offsetAt(range.end);\n return this._content.substring(start, end);\n }\n return this._content;\n }\n update(event, version) {\n this._content = event.text;\n this._version = version;\n this._lineOffsets = undefined;\n }\n getLineOffsets() {\n if (this._lineOffsets === undefined) {\n let lineOffsets = [];\n let text = this._content;\n let isLineStart = true;\n for (let i = 0; i < text.length; i++) {\n if (isLineStart) {\n lineOffsets.push(i);\n isLineStart = false;\n }\n let ch = text.charAt(i);\n isLineStart = (ch === '\\r' || ch === '\\n');\n if (ch === '\\r' && i + 1 < text.length && text.charAt(i + 1) === '\\n') {\n i++;\n }\n }\n if (isLineStart && text.length > 0) {\n lineOffsets.push(text.length);\n }\n this._lineOffsets = lineOffsets;\n }\n return this._lineOffsets;\n }\n positionAt(offset) {\n offset = Math.max(Math.min(offset, this._content.length), 0);\n let lineOffsets = this.getLineOffsets();\n let low = 0, high = lineOffsets.length;\n if (high === 0) {\n return Position.create(0, offset);\n }\n while (low < high) {\n let mid = Math.floor((low + high) / 2);\n if (lineOffsets[mid] > offset) {\n high = mid;\n }\n else {\n low = mid + 1;\n }\n }\n // low is the least x for which the line offset is larger than the current offset\n // or array.length if no line offset is larger than the current offset\n let line = low - 1;\n return Position.create(line, offset - lineOffsets[line]);\n }\n offsetAt(position) {\n let lineOffsets = this.getLineOffsets();\n if (position.line >= lineOffsets.length) {\n return this._content.length;\n }\n else if (position.line < 0) {\n return 0;\n }\n let lineOffset = lineOffsets[position.line];\n let nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;\n return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);\n }\n get lineCount() {\n return this.getLineOffsets().length;\n }\n}\nvar Is;\n(function (Is) {\n const toString = Object.prototype.toString;\n function defined(value) {\n return typeof value !== 'undefined';\n }\n Is.defined = defined;\n function undefined(value) {\n return typeof value === 'undefined';\n }\n Is.undefined = undefined;\n function boolean(value) {\n return value === true || value === false;\n }\n Is.boolean = boolean;\n function string(value) {\n return toString.call(value) === '[object String]';\n }\n Is.string = string;\n function number(value) {\n return toString.call(value) === '[object Number]';\n }\n Is.number = number;\n function numberRange(value, min, max) {\n return toString.call(value) === '[object Number]' && min <= value && value <= max;\n }\n Is.numberRange = numberRange;\n function integer(value) {\n return toString.call(value) === '[object Number]' && -2147483648 <= value && value <= 2147483647;\n }\n Is.integer = integer;\n function uinteger(value) {\n return toString.call(value) === '[object Number]' && 0 <= value && value <= 2147483647;\n }\n Is.uinteger = uinteger;\n function func(value) {\n return toString.call(value) === '[object Function]';\n }\n Is.func = func;\n function objectLiteral(value) {\n // Strictly speaking class instances pass this check as well. Since the LSP\n // doesn't use classes we ignore this for now. If we do we need to add something\n // like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null`\n return value !== null && typeof value === 'object';\n }\n Is.objectLiteral = objectLiteral;\n function typedArray(value, check) {\n return Array.isArray(value) && value.every(check);\n }\n Is.typedArray = typedArray;\n})(Is || (Is = {}));\n","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Position } from 'vscode-languageserver-types';\nimport { tokenToRange } from '../utils/cst-utils.js';\nexport class CstNodeBuilder {\n constructor() {\n this.nodeStack = [];\n }\n get current() {\n var _a;\n return (_a = this.nodeStack[this.nodeStack.length - 1]) !== null && _a !== void 0 ? _a : this.rootNode;\n }\n buildRootNode(input) {\n this.rootNode = new RootCstNodeImpl(input);\n this.rootNode.root = this.rootNode;\n this.nodeStack = [this.rootNode];\n return this.rootNode;\n }\n buildCompositeNode(feature) {\n const compositeNode = new CompositeCstNodeImpl();\n compositeNode.grammarSource = feature;\n compositeNode.root = this.rootNode;\n this.current.content.push(compositeNode);\n this.nodeStack.push(compositeNode);\n return compositeNode;\n }\n buildLeafNode(token, feature) {\n const leafNode = new LeafCstNodeImpl(token.startOffset, token.image.length, tokenToRange(token), token.tokenType, !feature);\n leafNode.grammarSource = feature;\n leafNode.root = this.rootNode;\n this.current.content.push(leafNode);\n return leafNode;\n }\n removeNode(node) {\n const parent = node.container;\n if (parent) {\n const index = parent.content.indexOf(node);\n if (index >= 0) {\n parent.content.splice(index, 1);\n }\n }\n }\n addHiddenNodes(tokens) {\n const nodes = [];\n for (const token of tokens) {\n const leafNode = new LeafCstNodeImpl(token.startOffset, token.image.length, tokenToRange(token), token.tokenType, true);\n leafNode.root = this.rootNode;\n nodes.push(leafNode);\n }\n let current = this.current;\n let added = false;\n // If we are within a composite node, we add the hidden nodes to the content\n if (current.content.length > 0) {\n current.content.push(...nodes);\n return;\n }\n // Otherwise we are at a newly created node\n // Instead of adding the hidden nodes here, we search for the first parent node with content\n while (current.container) {\n const index = current.container.content.indexOf(current);\n if (index > 0) {\n // Add the hidden nodes before the current node\n current.container.content.splice(index, 0, ...nodes);\n added = true;\n break;\n }\n current = current.container;\n }\n // If we arrive at the root node, we add the hidden nodes at the beginning\n // This is the case if the hidden nodes are the first nodes in the tree\n if (!added) {\n this.rootNode.content.unshift(...nodes);\n }\n }\n construct(item) {\n const current = this.current;\n // The specified item could be a datatype ($type is symbol) or a fragment ($type is undefined)\n // Only if the $type is a string, we actually assign the element\n if (typeof item.$type === 'string') {\n this.current.astNode = item;\n }\n item.$cstNode = current;\n const node = this.nodeStack.pop();\n // Empty composite nodes are not valid\n // Simply remove the node from the tree\n if ((node === null || node === void 0 ? void 0 : node.content.length) === 0) {\n this.removeNode(node);\n }\n }\n}\nexport class AbstractCstNode {\n /** @deprecated use `container` instead. */\n get parent() {\n return this.container;\n }\n /** @deprecated use `grammarSource` instead. */\n get feature() {\n return this.grammarSource;\n }\n get hidden() {\n return false;\n }\n get astNode() {\n var _a, _b;\n const node = typeof ((_a = this._astNode) === null || _a === void 0 ? void 0 : _a.$type) === 'string' ? this._astNode : (_b = this.container) === null || _b === void 0 ? void 0 : _b.astNode;\n if (!node) {\n throw new Error('This node has no associated AST element');\n }\n return node;\n }\n set astNode(value) {\n this._astNode = value;\n }\n /** @deprecated use `astNode` instead. */\n get element() {\n return this.astNode;\n }\n get text() {\n return this.root.fullText.substring(this.offset, this.end);\n }\n}\nexport class LeafCstNodeImpl extends AbstractCstNode {\n get offset() {\n return this._offset;\n }\n get length() {\n return this._length;\n }\n get end() {\n return this._offset + this._length;\n }\n get hidden() {\n return this._hidden;\n }\n get tokenType() {\n return this._tokenType;\n }\n get range() {\n return this._range;\n }\n constructor(offset, length, range, tokenType, hidden = false) {\n super();\n this._hidden = hidden;\n this._offset = offset;\n this._tokenType = tokenType;\n this._length = length;\n this._range = range;\n }\n}\nexport class CompositeCstNodeImpl extends AbstractCstNode {\n constructor() {\n super(...arguments);\n this.content = new CstNodeContainer(this);\n }\n /** @deprecated use `content` instead. */\n get children() {\n return this.content;\n }\n get offset() {\n var _a, _b;\n return (_b = (_a = this.firstNonHiddenNode) === null || _a === void 0 ? void 0 : _a.offset) !== null && _b !== void 0 ? _b : 0;\n }\n get length() {\n return this.end - this.offset;\n }\n get end() {\n var _a, _b;\n return (_b = (_a = this.lastNonHiddenNode) === null || _a === void 0 ? void 0 : _a.end) !== null && _b !== void 0 ? _b : 0;\n }\n get range() {\n const firstNode = this.firstNonHiddenNode;\n const lastNode = this.lastNonHiddenNode;\n if (firstNode && lastNode) {\n if (this._rangeCache === undefined) {\n const { range: firstRange } = firstNode;\n const { range: lastRange } = lastNode;\n this._rangeCache = { start: firstRange.start, end: lastRange.end.line < firstRange.start.line ? firstRange.start : lastRange.end };\n }\n return this._rangeCache;\n }\n else {\n return { start: Position.create(0, 0), end: Position.create(0, 0) };\n }\n }\n get firstNonHiddenNode() {\n for (const child of this.content) {\n if (!child.hidden) {\n return child;\n }\n }\n return this.content[0];\n }\n get lastNonHiddenNode() {\n for (let i = this.content.length - 1; i >= 0; i--) {\n const child = this.content[i];\n if (!child.hidden) {\n return child;\n }\n }\n return this.content[this.content.length - 1];\n }\n}\nclass CstNodeContainer extends Array {\n constructor(parent) {\n super();\n this.parent = parent;\n Object.setPrototypeOf(this, CstNodeContainer.prototype);\n }\n push(...items) {\n this.addParents(items);\n return super.push(...items);\n }\n unshift(...items) {\n this.addParents(items);\n return super.unshift(...items);\n }\n splice(start, count, ...items) {\n this.addParents(items);\n return super.splice(start, count, ...items);\n }\n addParents(items) {\n for (const item of items) {\n item.container = this.parent;\n }\n }\n}\nexport class RootCstNodeImpl extends CompositeCstNodeImpl {\n get text() {\n return this._text.substring(this.offset, this.end);\n }\n get fullText() {\n return this._text;\n }\n constructor(input) {\n super();\n this._text = '';\n this._text = input !== null && input !== void 0 ? input : '';\n }\n}\n//# sourceMappingURL=cst-node-builder.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { defaultParserErrorProvider, EmbeddedActionsParser, LLkLookaheadStrategy } from 'chevrotain';\nimport { LLStarLookaheadStrategy } from 'chevrotain-allstar';\nimport { isAssignment, isCrossReference, isKeyword } from '../languages/generated/ast.js';\nimport { getExplicitRuleType, isDataTypeRule } from '../utils/grammar-utils.js';\nimport { assignMandatoryProperties, getContainerOfType, linkContentToContainer } from '../utils/ast-utils.js';\nimport { CstNodeBuilder } from './cst-node-builder.js';\nexport const DatatypeSymbol = Symbol('Datatype');\nfunction isDataTypeNode(node) {\n return node.$type === DatatypeSymbol;\n}\nconst ruleSuffix = '\\u200B';\nconst withRuleSuffix = (name) => name.endsWith(ruleSuffix) ? name : name + ruleSuffix;\nexport class AbstractLangiumParser {\n constructor(services) {\n this._unorderedGroups = new Map();\n this.allRules = new Map();\n this.lexer = services.parser.Lexer;\n const tokens = this.lexer.definition;\n const production = services.LanguageMetaData.mode === 'production';\n this.wrapper = new ChevrotainWrapper(tokens, Object.assign(Object.assign({}, services.parser.ParserConfig), { skipValidations: production, errorMessageProvider: services.parser.ParserErrorMessageProvider }));\n }\n alternatives(idx, choices) {\n this.wrapper.wrapOr(idx, choices);\n }\n optional(idx, callback) {\n this.wrapper.wrapOption(idx, callback);\n }\n many(idx, callback) {\n this.wrapper.wrapMany(idx, callback);\n }\n atLeastOne(idx, callback) {\n this.wrapper.wrapAtLeastOne(idx, callback);\n }\n getRule(name) {\n return this.allRules.get(name);\n }\n isRecording() {\n return this.wrapper.IS_RECORDING;\n }\n get unorderedGroups() {\n return this._unorderedGroups;\n }\n getRuleStack() {\n return this.wrapper.RULE_STACK;\n }\n finalize() {\n this.wrapper.wrapSelfAnalysis();\n }\n}\nexport class LangiumParser extends AbstractLangiumParser {\n get current() {\n return this.stack[this.stack.length - 1];\n }\n constructor(services) {\n super(services);\n this.nodeBuilder = new CstNodeBuilder();\n this.stack = [];\n this.assignmentMap = new Map();\n this.linker = services.references.Linker;\n this.converter = services.parser.ValueConverter;\n this.astReflection = services.shared.AstReflection;\n }\n rule(rule, impl) {\n const type = this.computeRuleType(rule);\n const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(type, impl).bind(this));\n this.allRules.set(rule.name, ruleMethod);\n if (rule.entry) {\n this.mainRule = ruleMethod;\n }\n return ruleMethod;\n }\n computeRuleType(rule) {\n if (rule.fragment) {\n return undefined;\n }\n else if (isDataTypeRule(rule)) {\n return DatatypeSymbol;\n }\n else {\n const explicit = getExplicitRuleType(rule);\n return explicit !== null && explicit !== void 0 ? explicit : rule.name;\n }\n }\n parse(input, options = {}) {\n this.nodeBuilder.buildRootNode(input);\n const lexerResult = this.lexerResult = this.lexer.tokenize(input);\n this.wrapper.input = lexerResult.tokens;\n const ruleMethod = options.rule ? this.allRules.get(options.rule) : this.mainRule;\n if (!ruleMethod) {\n throw new Error(options.rule ? `No rule found with name '${options.rule}'` : 'No main rule available.');\n }\n const result = ruleMethod.call(this.wrapper, {});\n this.nodeBuilder.addHiddenNodes(lexerResult.hidden);\n this.unorderedGroups.clear();\n this.lexerResult = undefined;\n return {\n value: result,\n lexerErrors: lexerResult.errors,\n lexerReport: lexerResult.report,\n parserErrors: this.wrapper.errors\n };\n }\n startImplementation($type, implementation) {\n return (args) => {\n // Only create a new AST node in case the calling rule is not a fragment rule\n const createNode = !this.isRecording() && $type !== undefined;\n if (createNode) {\n const node = { $type };\n this.stack.push(node);\n if ($type === DatatypeSymbol) {\n node.value = '';\n }\n }\n let result;\n try {\n result = implementation(args);\n }\n catch (err) {\n result = undefined;\n }\n if (result === undefined && createNode) {\n result = this.construct();\n }\n return result;\n };\n }\n extractHiddenTokens(token) {\n const hiddenTokens = this.lexerResult.hidden;\n if (!hiddenTokens.length) {\n return [];\n }\n const offset = token.startOffset;\n for (let i = 0; i < hiddenTokens.length; i++) {\n const token = hiddenTokens[i];\n if (token.startOffset > offset) {\n return hiddenTokens.splice(0, i);\n }\n }\n return hiddenTokens.splice(0, hiddenTokens.length);\n }\n consume(idx, tokenType, feature) {\n const token = this.wrapper.wrapConsume(idx, tokenType);\n if (!this.isRecording() && this.isValidToken(token)) {\n const hiddenTokens = this.extractHiddenTokens(token);\n this.nodeBuilder.addHiddenNodes(hiddenTokens);\n const leafNode = this.nodeBuilder.buildLeafNode(token, feature);\n const { assignment, isCrossRef } = this.getAssignment(feature);\n const current = this.current;\n if (assignment) {\n const convertedValue = isKeyword(feature) ? token.image : this.converter.convert(token.image, leafNode);\n this.assign(assignment.operator, assignment.feature, convertedValue, leafNode, isCrossRef);\n }\n else if (isDataTypeNode(current)) {\n let text = token.image;\n if (!isKeyword(feature)) {\n text = this.converter.convert(text, leafNode).toString();\n }\n current.value += text;\n }\n }\n }\n /**\n * Most consumed parser tokens are valid. However there are two cases in which they are not valid:\n *\n * 1. They were inserted during error recovery by the parser. These tokens don't really exist and should not be further processed\n * 2. They contain invalid token ranges. This might include the special EOF token, or other tokens produced by invalid token builders.\n */\n isValidToken(token) {\n return !token.isInsertedInRecovery && !isNaN(token.startOffset) && typeof token.endOffset === 'number' && !isNaN(token.endOffset);\n }\n subrule(idx, rule, fragment, feature, args) {\n let cstNode;\n if (!this.isRecording() && !fragment) {\n // We only want to create a new CST node if the subrule actually creates a new AST node.\n // In other cases like calls of fragment rules the current CST/AST is populated further.\n // Note that skipping this initialization and leaving cstNode unassigned also skips the subrule assignment later on.\n // This is intended, as fragment rules only enrich the current AST node\n cstNode = this.nodeBuilder.buildCompositeNode(feature);\n }\n const subruleResult = this.wrapper.wrapSubrule(idx, rule, args);\n if (!this.isRecording() && cstNode && cstNode.length > 0) {\n this.performSubruleAssignment(subruleResult, feature, cstNode);\n }\n }\n performSubruleAssignment(result, feature, cstNode) {\n const { assignment, isCrossRef } = this.getAssignment(feature);\n if (assignment) {\n this.assign(assignment.operator, assignment.feature, result, cstNode, isCrossRef);\n }\n else if (!assignment) {\n // If we call a subrule without an assignment we either:\n // 1. append the result of the subrule (data type rule)\n // 2. override the current object with the newly parsed object\n // If the current element is an AST node and the result of the subrule\n // is a data type rule, we can safely discard the results.\n const current = this.current;\n if (isDataTypeNode(current)) {\n current.value += result.toString();\n }\n else if (typeof result === 'object' && result) {\n const object = this.assignWithoutOverride(result, current);\n const newItem = object;\n this.stack.pop();\n this.stack.push(newItem);\n }\n }\n }\n action($type, action) {\n if (!this.isRecording()) {\n let last = this.current;\n if (action.feature && action.operator) {\n last = this.construct();\n this.nodeBuilder.removeNode(last.$cstNode);\n const node = this.nodeBuilder.buildCompositeNode(action);\n node.content.push(last.$cstNode);\n const newItem = { $type };\n this.stack.push(newItem);\n this.assign(action.operator, action.feature, last, last.$cstNode, false);\n }\n else {\n last.$type = $type;\n }\n }\n }\n construct() {\n if (this.isRecording()) {\n return undefined;\n }\n const obj = this.current;\n linkContentToContainer(obj);\n this.nodeBuilder.construct(obj);\n this.stack.pop();\n if (isDataTypeNode(obj)) {\n return this.converter.convert(obj.value, obj.$cstNode);\n }\n else {\n assignMandatoryProperties(this.astReflection, obj);\n }\n return obj;\n }\n getAssignment(feature) {\n if (!this.assignmentMap.has(feature)) {\n const assignment = getContainerOfType(feature, isAssignment);\n this.assignmentMap.set(feature, {\n assignment: assignment,\n isCrossRef: assignment ? isCrossReference(assignment.terminal) : false\n });\n }\n return this.assignmentMap.get(feature);\n }\n assign(operator, feature, value, cstNode, isCrossRef) {\n const obj = this.current;\n let item;\n if (isCrossRef && typeof value === 'string') {\n item = this.linker.buildReference(obj, feature, cstNode, value);\n }\n else {\n item = value;\n }\n switch (operator) {\n case '=': {\n obj[feature] = item;\n break;\n }\n case '?=': {\n obj[feature] = true;\n break;\n }\n case '+=': {\n if (!Array.isArray(obj[feature])) {\n obj[feature] = [];\n }\n obj[feature].push(item);\n }\n }\n }\n assignWithoutOverride(target, source) {\n for (const [name, existingValue] of Object.entries(source)) {\n const newValue = target[name];\n if (newValue === undefined) {\n target[name] = existingValue;\n }\n else if (Array.isArray(newValue) && Array.isArray(existingValue)) {\n existingValue.push(...newValue);\n target[name] = existingValue;\n }\n }\n // The target was parsed from a unassigned subrule\n // After the subrule construction, it received a cst node\n // This CST node will later be overriden by the cst node builder\n // To prevent references to stale AST nodes in the CST,\n // we need to remove the reference here\n const targetCstNode = target.$cstNode;\n if (targetCstNode) {\n targetCstNode.astNode = undefined;\n target.$cstNode = undefined;\n }\n return target;\n }\n get definitionErrors() {\n return this.wrapper.definitionErrors;\n }\n}\nexport class AbstractParserErrorMessageProvider {\n buildMismatchTokenMessage(options) {\n return defaultParserErrorProvider.buildMismatchTokenMessage(options);\n }\n buildNotAllInputParsedMessage(options) {\n return defaultParserErrorProvider.buildNotAllInputParsedMessage(options);\n }\n buildNoViableAltMessage(options) {\n return defaultParserErrorProvider.buildNoViableAltMessage(options);\n }\n buildEarlyExitMessage(options) {\n return defaultParserErrorProvider.buildEarlyExitMessage(options);\n }\n}\nexport class LangiumParserErrorMessageProvider extends AbstractParserErrorMessageProvider {\n buildMismatchTokenMessage({ expected, actual }) {\n const expectedMsg = expected.LABEL\n ? '`' + expected.LABEL + '`'\n : expected.name.endsWith(':KW')\n ? `keyword '${expected.name.substring(0, expected.name.length - 3)}'`\n : `token of type '${expected.name}'`;\n return `Expecting ${expectedMsg} but found \\`${actual.image}\\`.`;\n }\n buildNotAllInputParsedMessage({ firstRedundant }) {\n return `Expecting end of file but found \\`${firstRedundant.image}\\`.`;\n }\n}\nexport class LangiumCompletionParser extends AbstractLangiumParser {\n constructor() {\n super(...arguments);\n this.tokens = [];\n this.elementStack = [];\n this.lastElementStack = [];\n this.nextTokenIndex = 0;\n this.stackSize = 0;\n }\n action() {\n // NOOP\n }\n construct() {\n // NOOP\n return undefined;\n }\n parse(input) {\n this.resetState();\n const tokens = this.lexer.tokenize(input, { mode: 'partial' });\n this.tokens = tokens.tokens;\n this.wrapper.input = [...this.tokens];\n this.mainRule.call(this.wrapper, {});\n this.unorderedGroups.clear();\n return {\n tokens: this.tokens,\n elementStack: [...this.lastElementStack],\n tokenIndex: this.nextTokenIndex\n };\n }\n rule(rule, impl) {\n const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(impl).bind(this));\n this.allRules.set(rule.name, ruleMethod);\n if (rule.entry) {\n this.mainRule = ruleMethod;\n }\n return ruleMethod;\n }\n resetState() {\n this.elementStack = [];\n this.lastElementStack = [];\n this.nextTokenIndex = 0;\n this.stackSize = 0;\n }\n startImplementation(implementation) {\n return (args) => {\n const size = this.keepStackSize();\n try {\n implementation(args);\n }\n finally {\n this.resetStackSize(size);\n }\n };\n }\n removeUnexpectedElements() {\n this.elementStack.splice(this.stackSize);\n }\n keepStackSize() {\n const size = this.elementStack.length;\n this.stackSize = size;\n return size;\n }\n resetStackSize(size) {\n this.removeUnexpectedElements();\n this.stackSize = size;\n }\n consume(idx, tokenType, feature) {\n this.wrapper.wrapConsume(idx, tokenType);\n if (!this.isRecording()) {\n this.lastElementStack = [...this.elementStack, feature];\n this.nextTokenIndex = this.currIdx + 1;\n }\n }\n subrule(idx, rule, fragment, feature, args) {\n this.before(feature);\n this.wrapper.wrapSubrule(idx, rule, args);\n this.after(feature);\n }\n before(element) {\n if (!this.isRecording()) {\n this.elementStack.push(element);\n }\n }\n after(element) {\n if (!this.isRecording()) {\n const index = this.elementStack.lastIndexOf(element);\n if (index >= 0) {\n this.elementStack.splice(index);\n }\n }\n }\n get currIdx() {\n return this.wrapper.currIdx;\n }\n}\nconst defaultConfig = {\n recoveryEnabled: true,\n nodeLocationTracking: 'full',\n skipValidations: true,\n errorMessageProvider: new LangiumParserErrorMessageProvider()\n};\n/**\n * This class wraps the embedded actions parser of chevrotain and exposes protected methods.\n * This way, we can build the `LangiumParser` as a composition.\n */\nclass ChevrotainWrapper extends EmbeddedActionsParser {\n constructor(tokens, config) {\n const useDefaultLookahead = config && 'maxLookahead' in config;\n super(tokens, Object.assign(Object.assign(Object.assign({}, defaultConfig), { lookaheadStrategy: useDefaultLookahead\n ? new LLkLookaheadStrategy({ maxLookahead: config.maxLookahead })\n : new LLStarLookaheadStrategy({\n // If validations are skipped, don't log the lookahead warnings\n logging: config.skipValidations ? () => { } : undefined\n }) }), config));\n }\n get IS_RECORDING() {\n return this.RECORDING_PHASE;\n }\n DEFINE_RULE(name, impl) {\n return this.RULE(name, impl);\n }\n wrapSelfAnalysis() {\n this.performSelfAnalysis();\n }\n wrapConsume(idx, tokenType) {\n return this.consume(idx, tokenType);\n }\n wrapSubrule(idx, rule, args) {\n return this.subrule(idx, rule, {\n ARGS: [args]\n });\n }\n wrapOr(idx, choices) {\n this.or(idx, choices);\n }\n wrapOption(idx, callback) {\n this.option(idx, callback);\n }\n wrapMany(idx, callback) {\n this.many(idx, callback);\n }\n wrapAtLeastOne(idx, callback) {\n this.atLeastOne(idx, callback);\n }\n}\n//# sourceMappingURL=langium-parser.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { EMPTY_ALT, EOF } from 'chevrotain';\nimport { isAction, isAlternatives, isEndOfFile, isAssignment, isConjunction, isCrossReference, isDisjunction, isGroup, isKeyword, isNegation, isParameterReference, isParserRule, isRuleCall, isTerminalRule, isUnorderedGroup, isBooleanLiteral } from '../languages/generated/ast.js';\nimport { assertUnreachable, ErrorWithLocation } from '../utils/errors.js';\nimport { stream } from '../utils/stream.js';\nimport { findNameAssignment, getAllReachableRules, getTypeName } from '../utils/grammar-utils.js';\nexport function createParser(grammar, parser, tokens) {\n const parserContext = {\n parser,\n tokens,\n ruleNames: new Map()\n };\n buildRules(parserContext, grammar);\n return parser;\n}\nfunction buildRules(parserContext, grammar) {\n const reachable = getAllReachableRules(grammar, false);\n const parserRules = stream(grammar.rules).filter(isParserRule).filter(rule => reachable.has(rule));\n for (const rule of parserRules) {\n const ctx = Object.assign(Object.assign({}, parserContext), { consume: 1, optional: 1, subrule: 1, many: 1, or: 1 });\n parserContext.parser.rule(rule, buildElement(ctx, rule.definition));\n }\n}\nfunction buildElement(ctx, element, ignoreGuard = false) {\n let method;\n if (isKeyword(element)) {\n method = buildKeyword(ctx, element);\n }\n else if (isAction(element)) {\n method = buildAction(ctx, element);\n }\n else if (isAssignment(element)) {\n method = buildElement(ctx, element.terminal);\n }\n else if (isCrossReference(element)) {\n method = buildCrossReference(ctx, element);\n }\n else if (isRuleCall(element)) {\n method = buildRuleCall(ctx, element);\n }\n else if (isAlternatives(element)) {\n method = buildAlternatives(ctx, element);\n }\n else if (isUnorderedGroup(element)) {\n method = buildUnorderedGroup(ctx, element);\n }\n else if (isGroup(element)) {\n method = buildGroup(ctx, element);\n }\n else if (isEndOfFile(element)) {\n const idx = ctx.consume++;\n method = () => ctx.parser.consume(idx, EOF, element);\n }\n else {\n throw new ErrorWithLocation(element.$cstNode, `Unexpected element type: ${element.$type}`);\n }\n return wrap(ctx, ignoreGuard ? undefined : getGuardCondition(element), method, element.cardinality);\n}\nfunction buildAction(ctx, action) {\n const actionType = getTypeName(action);\n return () => ctx.parser.action(actionType, action);\n}\nfunction buildRuleCall(ctx, ruleCall) {\n const rule = ruleCall.rule.ref;\n if (isParserRule(rule)) {\n const idx = ctx.subrule++;\n const fragment = rule.fragment;\n const predicate = ruleCall.arguments.length > 0 ? buildRuleCallPredicate(rule, ruleCall.arguments) : () => ({});\n return (args) => ctx.parser.subrule(idx, getRule(ctx, rule), fragment, ruleCall, predicate(args));\n }\n else if (isTerminalRule(rule)) {\n const idx = ctx.consume++;\n const method = getToken(ctx, rule.name);\n return () => ctx.parser.consume(idx, method, ruleCall);\n }\n else if (!rule) {\n throw new ErrorWithLocation(ruleCall.$cstNode, `Undefined rule: ${ruleCall.rule.$refText}`);\n }\n else {\n assertUnreachable(rule);\n }\n}\nfunction buildRuleCallPredicate(rule, namedArgs) {\n const predicates = namedArgs.map(e => buildPredicate(e.value));\n return (args) => {\n const ruleArgs = {};\n for (let i = 0; i < predicates.length; i++) {\n const ruleTarget = rule.parameters[i];\n const predicate = predicates[i];\n ruleArgs[ruleTarget.name] = predicate(args);\n }\n return ruleArgs;\n };\n}\nfunction buildPredicate(condition) {\n if (isDisjunction(condition)) {\n const left = buildPredicate(condition.left);\n const right = buildPredicate(condition.right);\n return (args) => (left(args) || right(args));\n }\n else if (isConjunction(condition)) {\n const left = buildPredicate(condition.left);\n const right = buildPredicate(condition.right);\n return (args) => (left(args) && right(args));\n }\n else if (isNegation(condition)) {\n const value = buildPredicate(condition.value);\n return (args) => !value(args);\n }\n else if (isParameterReference(condition)) {\n const name = condition.parameter.ref.name;\n return (args) => args !== undefined && args[name] === true;\n }\n else if (isBooleanLiteral(condition)) {\n const value = Boolean(condition.true);\n return () => value;\n }\n assertUnreachable(condition);\n}\nfunction buildAlternatives(ctx, alternatives) {\n if (alternatives.elements.length === 1) {\n return buildElement(ctx, alternatives.elements[0]);\n }\n else {\n const methods = [];\n for (const element of alternatives.elements) {\n const predicatedMethod = {\n // Since we handle the guard condition in the alternative already\n // We can ignore the group guard condition inside\n ALT: buildElement(ctx, element, true)\n };\n const guard = getGuardCondition(element);\n if (guard) {\n predicatedMethod.GATE = buildPredicate(guard);\n }\n methods.push(predicatedMethod);\n }\n const idx = ctx.or++;\n return (args) => ctx.parser.alternatives(idx, methods.map(method => {\n const alt = {\n ALT: () => method.ALT(args)\n };\n const gate = method.GATE;\n if (gate) {\n alt.GATE = () => gate(args);\n }\n return alt;\n }));\n }\n}\nfunction buildUnorderedGroup(ctx, group) {\n if (group.elements.length === 1) {\n return buildElement(ctx, group.elements[0]);\n }\n const methods = [];\n for (const element of group.elements) {\n const predicatedMethod = {\n // Since we handle the guard condition in the alternative already\n // We can ignore the group guard condition inside\n ALT: buildElement(ctx, element, true)\n };\n const guard = getGuardCondition(element);\n if (guard) {\n predicatedMethod.GATE = buildPredicate(guard);\n }\n methods.push(predicatedMethod);\n }\n const orIdx = ctx.or++;\n const idFunc = (groupIdx, lParser) => {\n const stackId = lParser.getRuleStack().join('-');\n return `uGroup_${groupIdx}_${stackId}`;\n };\n const alternatives = (args) => ctx.parser.alternatives(orIdx, methods.map((method, idx) => {\n const alt = { ALT: () => true };\n const parser = ctx.parser;\n alt.ALT = () => {\n method.ALT(args);\n if (!parser.isRecording()) {\n const key = idFunc(orIdx, parser);\n if (!parser.unorderedGroups.get(key)) {\n // init after clear state\n parser.unorderedGroups.set(key, []);\n }\n const groupState = parser.unorderedGroups.get(key);\n if (typeof (groupState === null || groupState === void 0 ? void 0 : groupState[idx]) === 'undefined') {\n // Not accessed yet\n groupState[idx] = true;\n }\n }\n };\n const gate = method.GATE;\n if (gate) {\n alt.GATE = () => gate(args);\n }\n else {\n alt.GATE = () => {\n const trackedAlternatives = parser.unorderedGroups.get(idFunc(orIdx, parser));\n const allow = !(trackedAlternatives === null || trackedAlternatives === void 0 ? void 0 : trackedAlternatives[idx]);\n return allow;\n };\n }\n return alt;\n }));\n const wrapped = wrap(ctx, getGuardCondition(group), alternatives, '*');\n return (args) => {\n wrapped(args);\n if (!ctx.parser.isRecording()) {\n ctx.parser.unorderedGroups.delete(idFunc(orIdx, ctx.parser));\n }\n };\n}\nfunction buildGroup(ctx, group) {\n const methods = group.elements.map(e => buildElement(ctx, e));\n return (args) => methods.forEach(method => method(args));\n}\nfunction getGuardCondition(element) {\n if (isGroup(element)) {\n return element.guardCondition;\n }\n return undefined;\n}\nfunction buildCrossReference(ctx, crossRef, terminal = crossRef.terminal) {\n if (!terminal) {\n if (!crossRef.type.ref) {\n throw new Error('Could not resolve reference to type: ' + crossRef.type.$refText);\n }\n const assignment = findNameAssignment(crossRef.type.ref);\n const assignTerminal = assignment === null || assignment === void 0 ? void 0 : assignment.terminal;\n if (!assignTerminal) {\n throw new Error('Could not find name assignment for type: ' + getTypeName(crossRef.type.ref));\n }\n return buildCrossReference(ctx, crossRef, assignTerminal);\n }\n else if (isRuleCall(terminal) && isParserRule(terminal.rule.ref)) {\n // The terminal is a data type rule here. Everything else will result in a validation error.\n const rule = terminal.rule.ref;\n const idx = ctx.subrule++;\n return (args) => ctx.parser.subrule(idx, getRule(ctx, rule), false, crossRef, args);\n }\n else if (isRuleCall(terminal) && isTerminalRule(terminal.rule.ref)) {\n const idx = ctx.consume++;\n const terminalRule = getToken(ctx, terminal.rule.ref.name);\n return () => ctx.parser.consume(idx, terminalRule, crossRef);\n }\n else if (isKeyword(terminal)) {\n const idx = ctx.consume++;\n const keyword = getToken(ctx, terminal.value);\n return () => ctx.parser.consume(idx, keyword, crossRef);\n }\n else {\n throw new Error('Could not build cross reference parser');\n }\n}\nfunction buildKeyword(ctx, keyword) {\n const idx = ctx.consume++;\n const token = ctx.tokens[keyword.value];\n if (!token) {\n throw new Error('Could not find token for keyword: ' + keyword.value);\n }\n return () => ctx.parser.consume(idx, token, keyword);\n}\nfunction wrap(ctx, guard, method, cardinality) {\n const gate = guard && buildPredicate(guard);\n if (!cardinality) {\n if (gate) {\n const idx = ctx.or++;\n return (args) => ctx.parser.alternatives(idx, [\n {\n ALT: () => method(args),\n GATE: () => gate(args)\n },\n {\n ALT: EMPTY_ALT(),\n GATE: () => !gate(args)\n }\n ]);\n }\n else {\n return method;\n }\n }\n if (cardinality === '*') {\n const idx = ctx.many++;\n return (args) => ctx.parser.many(idx, {\n DEF: () => method(args),\n GATE: gate ? () => gate(args) : undefined\n });\n }\n else if (cardinality === '+') {\n const idx = ctx.many++;\n if (gate) {\n const orIdx = ctx.or++;\n // In the case of a guard condition for the `+` group\n // We combine it with an empty alternative\n // If the condition returns true, it needs to parse at least a single iteration\n // If its false, it is not allowed to parse anything\n return (args) => ctx.parser.alternatives(orIdx, [\n {\n ALT: () => ctx.parser.atLeastOne(idx, {\n DEF: () => method(args)\n }),\n GATE: () => gate(args)\n },\n {\n ALT: EMPTY_ALT(),\n GATE: () => !gate(args)\n }\n ]);\n }\n else {\n return (args) => ctx.parser.atLeastOne(idx, {\n DEF: () => method(args),\n });\n }\n }\n else if (cardinality === '?') {\n const idx = ctx.optional++;\n return (args) => ctx.parser.optional(idx, {\n DEF: () => method(args),\n GATE: gate ? () => gate(args) : undefined\n });\n }\n else {\n assertUnreachable(cardinality);\n }\n}\nfunction getRule(ctx, element) {\n const name = getRuleName(ctx, element);\n const rule = ctx.parser.getRule(name);\n if (!rule)\n throw new Error(`Rule \"${name}\" not found.\"`);\n return rule;\n}\nfunction getRuleName(ctx, element) {\n if (isParserRule(element)) {\n return element.name;\n }\n else if (ctx.ruleNames.has(element)) {\n return ctx.ruleNames.get(element);\n }\n else {\n let item = element;\n let parent = item.$container;\n let ruleName = element.$type;\n while (!isParserRule(parent)) {\n if (isGroup(parent) || isAlternatives(parent) || isUnorderedGroup(parent)) {\n const index = parent.elements.indexOf(item);\n ruleName = index.toString() + ':' + ruleName;\n }\n item = parent;\n parent = parent.$container;\n }\n const rule = parent;\n ruleName = rule.name + ':' + ruleName;\n ctx.ruleNames.set(element, ruleName);\n return ruleName;\n }\n}\nfunction getToken(ctx, name) {\n const token = ctx.tokens[name];\n if (!token)\n throw new Error(`Token \"${name}\" not found.\"`);\n return token;\n}\n//# sourceMappingURL=parser-builder-base.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { LangiumCompletionParser } from './langium-parser.js';\nimport { createParser } from './parser-builder-base.js';\nexport function createCompletionParser(services) {\n const grammar = services.Grammar;\n const lexer = services.parser.Lexer;\n const parser = new LangiumCompletionParser(services);\n createParser(grammar, parser, lexer.definition);\n parser.finalize();\n return parser;\n}\n//# sourceMappingURL=completion-parser-builder.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { LangiumParser } from './langium-parser.js';\nimport { createParser } from './parser-builder-base.js';\n/**\n * Create and finalize a Langium parser. The parser rules are derived from the grammar, which is\n * available at `services.Grammar`.\n */\nexport function createLangiumParser(services) {\n const parser = prepareLangiumParser(services);\n parser.finalize();\n return parser;\n}\n/**\n * Create a Langium parser without finalizing it. This is used to extract more detailed error\n * information when the parser is initially validated.\n */\nexport function prepareLangiumParser(services) {\n const grammar = services.Grammar;\n const lexer = services.parser.Lexer;\n const parser = new LangiumParser(services);\n return createParser(grammar, parser, lexer.definition);\n}\n//# sourceMappingURL=langium-parser-builder.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Lexer } from 'chevrotain';\nimport { isKeyword, isParserRule, isTerminalRule } from '../languages/generated/ast.js';\nimport { streamAllContents } from '../utils/ast-utils.js';\nimport { getAllReachableRules, terminalRegex } from '../utils/grammar-utils.js';\nimport { getCaseInsensitivePattern, isWhitespace, partialMatches } from '../utils/regexp-utils.js';\nimport { stream } from '../utils/stream.js';\nexport class DefaultTokenBuilder {\n constructor() {\n /**\n * The list of diagnostics stored during the lexing process of a single text.\n */\n this.diagnostics = [];\n }\n buildTokens(grammar, options) {\n const reachableRules = stream(getAllReachableRules(grammar, false));\n const terminalTokens = this.buildTerminalTokens(reachableRules);\n const tokens = this.buildKeywordTokens(reachableRules, terminalTokens, options);\n terminalTokens.forEach(terminalToken => {\n const pattern = terminalToken.PATTERN;\n if (typeof pattern === 'object' && pattern && 'test' in pattern && isWhitespace(pattern)) {\n tokens.unshift(terminalToken);\n }\n else {\n tokens.push(terminalToken);\n }\n });\n // We don't need to add the EOF token explicitly.\n // It is automatically available at the end of the token stream.\n return tokens;\n }\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n flushLexingReport(text) {\n return { diagnostics: this.popDiagnostics() };\n }\n popDiagnostics() {\n const diagnostics = [...this.diagnostics];\n this.diagnostics = [];\n return diagnostics;\n }\n buildTerminalTokens(rules) {\n return rules.filter(isTerminalRule).filter(e => !e.fragment)\n .map(terminal => this.buildTerminalToken(terminal)).toArray();\n }\n buildTerminalToken(terminal) {\n const regex = terminalRegex(terminal);\n const pattern = this.requiresCustomPattern(regex) ? this.regexPatternFunction(regex) : regex;\n const tokenType = {\n name: terminal.name,\n PATTERN: pattern,\n };\n if (typeof pattern === 'function') {\n tokenType.LINE_BREAKS = true;\n }\n if (terminal.hidden) {\n // Only skip tokens that are able to accept whitespace\n tokenType.GROUP = isWhitespace(regex) ? Lexer.SKIPPED : 'hidden';\n }\n return tokenType;\n }\n requiresCustomPattern(regex) {\n if (regex.flags.includes('u') || regex.flags.includes('s')) {\n // Unicode and dotall regexes are not supported by Chevrotain.\n return true;\n }\n else if (regex.source.includes('?<=') || regex.source.includes('?<!')) {\n // Negative and positive lookbehind are not supported by Chevrotain yet.\n return true;\n }\n else {\n return false;\n }\n }\n regexPatternFunction(regex) {\n const stickyRegex = new RegExp(regex, regex.flags + 'y');\n return (text, offset) => {\n stickyRegex.lastIndex = offset;\n const execResult = stickyRegex.exec(text);\n return execResult;\n };\n }\n buildKeywordTokens(rules, terminalTokens, options) {\n return rules\n // We filter by parser rules, since keywords in terminal rules get transformed into regex and are not actual tokens\n .filter(isParserRule)\n .flatMap(rule => streamAllContents(rule).filter(isKeyword))\n .distinct(e => e.value).toArray()\n // Sort keywords by descending length\n .sort((a, b) => b.value.length - a.value.length)\n .map(keyword => this.buildKeywordToken(keyword, terminalTokens, Boolean(options === null || options === void 0 ? void 0 : options.caseInsensitive)));\n }\n buildKeywordToken(keyword, terminalTokens, caseInsensitive) {\n const keywordPattern = this.buildKeywordPattern(keyword, caseInsensitive);\n const tokenType = {\n name: keyword.value,\n PATTERN: keywordPattern,\n LONGER_ALT: this.findLongerAlt(keyword, terminalTokens)\n };\n if (typeof keywordPattern === 'function') {\n tokenType.LINE_BREAKS = true;\n }\n return tokenType;\n }\n buildKeywordPattern(keyword, caseInsensitive) {\n return caseInsensitive ?\n new RegExp(getCaseInsensitivePattern(keyword.value)) :\n keyword.value;\n }\n findLongerAlt(keyword, terminalTokens) {\n return terminalTokens.reduce((longerAlts, token) => {\n const pattern = token === null || token === void 0 ? void 0 : token.PATTERN;\n if ((pattern === null || pattern === void 0 ? void 0 : pattern.source) && partialMatches('^' + pattern.source + '$', keyword.value)) {\n longerAlts.push(token);\n }\n return longerAlts;\n }, []);\n }\n}\n//# sourceMappingURL=token-builder.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { isCrossReference, isRuleCall } from '../languages/generated/ast.js';\nimport { getCrossReferenceTerminal, getRuleType } from '../utils/grammar-utils.js';\nexport class DefaultValueConverter {\n convert(input, cstNode) {\n let feature = cstNode.grammarSource;\n if (isCrossReference(feature)) {\n feature = getCrossReferenceTerminal(feature);\n }\n if (isRuleCall(feature)) {\n const rule = feature.rule.ref;\n if (!rule) {\n throw new Error('This cst node was not parsed by a rule.');\n }\n return this.runConverter(rule, input, cstNode);\n }\n return input;\n }\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n runConverter(rule, input, cstNode) {\n var _a;\n switch (rule.name.toUpperCase()) {\n case 'INT': return ValueConverter.convertInt(input);\n case 'STRING': return ValueConverter.convertString(input);\n case 'ID': return ValueConverter.convertID(input);\n }\n switch ((_a = getRuleType(rule)) === null || _a === void 0 ? void 0 : _a.toLowerCase()) {\n case 'number': return ValueConverter.convertNumber(input);\n case 'boolean': return ValueConverter.convertBoolean(input);\n case 'bigint': return ValueConverter.convertBigint(input);\n case 'date': return ValueConverter.convertDate(input);\n default: return input;\n }\n }\n}\nexport var ValueConverter;\n(function (ValueConverter) {\n function convertString(input) {\n let result = '';\n for (let i = 1; i < input.length - 1; i++) {\n const c = input.charAt(i);\n if (c === '\\\\') {\n const c1 = input.charAt(++i);\n result += convertEscapeCharacter(c1);\n }\n else {\n result += c;\n }\n }\n return result;\n }\n ValueConverter.convertString = convertString;\n function convertEscapeCharacter(char) {\n switch (char) {\n case 'b': return '\\b';\n case 'f': return '\\f';\n case 'n': return '\\n';\n case 'r': return '\\r';\n case 't': return '\\t';\n case 'v': return '\\v';\n case '0': return '\\0';\n default: return char;\n }\n }\n function convertID(input) {\n if (input.charAt(0) === '^') {\n return input.substring(1);\n }\n else {\n return input;\n }\n }\n ValueConverter.convertID = convertID;\n function convertInt(input) {\n return parseInt(input);\n }\n ValueConverter.convertInt = convertInt;\n function convertBigint(input) {\n return BigInt(input);\n }\n ValueConverter.convertBigint = convertBigint;\n function convertDate(input) {\n return new Date(input);\n }\n ValueConverter.convertDate = convertDate;\n function convertNumber(input) {\n return Number(input);\n }\n ValueConverter.convertNumber = convertNumber;\n function convertBoolean(input) {\n return input.toLowerCase() === 'true';\n }\n ValueConverter.convertBoolean = convertBoolean;\n})(ValueConverter || (ValueConverter = {}));\n//# sourceMappingURL=value-converter.js.map","\"use strict\";\n/* --------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n * ------------------------------------------------------------------------------------------ */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nlet _ral;\nfunction RAL() {\n if (_ral === undefined) {\n throw new Error(`No runtime abstraction layer installed`);\n }\n return _ral;\n}\n(function (RAL) {\n function install(ral) {\n if (ral === undefined) {\n throw new Error(`No runtime abstraction layer provided`);\n }\n _ral = ral;\n }\n RAL.install = install;\n})(RAL || (RAL = {}));\nexports.default = RAL;\n","\"use strict\";\n/* --------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n * ------------------------------------------------------------------------------------------ */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;\nfunction boolean(value) {\n return value === true || value === false;\n}\nexports.boolean = boolean;\nfunction string(value) {\n return typeof value === 'string' || value instanceof String;\n}\nexports.string = string;\nfunction number(value) {\n return typeof value === 'number' || value instanceof Number;\n}\nexports.number = number;\nfunction error(value) {\n return value instanceof Error;\n}\nexports.error = error;\nfunction func(value) {\n return typeof value === 'function';\n}\nexports.func = func;\nfunction array(value) {\n return Array.isArray(value);\n}\nexports.array = array;\nfunction stringArray(value) {\n return array(value) && value.every(elem => string(elem));\n}\nexports.stringArray = stringArray;\n","\"use strict\";\n/* --------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n * ------------------------------------------------------------------------------------------ */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Emitter = exports.Event = void 0;\nconst ral_1 = require(\"./ral\");\nvar Event;\n(function (Event) {\n const _disposable = { dispose() { } };\n Event.None = function () { return _disposable; };\n})(Event || (exports.Event = Event = {}));\nclass CallbackList {\n add(callback, context = null, bucket) {\n if (!this._callbacks) {\n this._callbacks = [];\n this._contexts = [];\n }\n this._callbacks.push(callback);\n this._contexts.push(context);\n if (Array.isArray(bucket)) {\n bucket.push({ dispose: () => this.remove(callback, context) });\n }\n }\n remove(callback, context = null) {\n if (!this._callbacks) {\n return;\n }\n let foundCallbackWithDifferentContext = false;\n for (let i = 0, len = this._callbacks.length; i < len; i++) {\n if (this._callbacks[i] === callback) {\n if (this._contexts[i] === context) {\n // callback & context match => remove it\n this._callbacks.splice(i, 1);\n this._contexts.splice(i, 1);\n return;\n }\n else {\n foundCallbackWithDifferentContext = true;\n }\n }\n }\n if (foundCallbackWithDifferentContext) {\n throw new Error('When adding a listener with a context, you should remove it with the same context');\n }\n }\n invoke(...args) {\n if (!this._callbacks) {\n return [];\n }\n const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);\n for (let i = 0, len = callbacks.length; i < len; i++) {\n try {\n ret.push(callbacks[i].apply(contexts[i], args));\n }\n catch (e) {\n // eslint-disable-next-line no-console\n (0, ral_1.default)().console.error(e);\n }\n }\n return ret;\n }\n isEmpty() {\n return !this._callbacks || this._callbacks.length === 0;\n }\n dispose() {\n this._callbacks = undefined;\n this._contexts = undefined;\n }\n}\nclass Emitter {\n constructor(_options) {\n this._options = _options;\n }\n /**\n * For the public to allow to subscribe\n * to events from this Emitter\n */\n get event() {\n if (!this._event) {\n this._event = (listener, thisArgs, disposables) => {\n if (!this._callbacks) {\n this._callbacks = new CallbackList();\n }\n if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {\n this._options.onFirstListenerAdd(this);\n }\n this._callbacks.add(listener, thisArgs);\n const result = {\n dispose: () => {\n if (!this._callbacks) {\n // disposable is disposed after emitter is disposed.\n return;\n }\n this._callbacks.remove(listener, thisArgs);\n result.dispose = Emitter._noop;\n if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {\n this._options.onLastListenerRemove(this);\n }\n }\n };\n if (Array.isArray(disposables)) {\n disposables.push(result);\n }\n return result;\n };\n }\n return this._event;\n }\n /**\n * To be kept private to fire an event to\n * subscribers\n */\n fire(event) {\n if (this._callbacks) {\n this._callbacks.invoke.call(this._callbacks, event);\n }\n }\n dispose() {\n if (this._callbacks) {\n this._callbacks.dispose();\n this._callbacks = undefined;\n }\n }\n}\nexports.Emitter = Emitter;\nEmitter._noop = function () { };\n","\"use strict\";\n/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.CancellationTokenSource = exports.CancellationToken = void 0;\nconst ral_1 = require(\"./ral\");\nconst Is = require(\"./is\");\nconst events_1 = require(\"./events\");\nvar CancellationToken;\n(function (CancellationToken) {\n CancellationToken.None = Object.freeze({\n isCancellationRequested: false,\n onCancellationRequested: events_1.Event.None\n });\n CancellationToken.Cancelled = Object.freeze({\n isCancellationRequested: true,\n onCancellationRequested: events_1.Event.None\n });\n function is(value) {\n const candidate = value;\n return candidate && (candidate === CancellationToken.None\n || candidate === CancellationToken.Cancelled\n || (Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested));\n }\n CancellationToken.is = is;\n})(CancellationToken || (exports.CancellationToken = CancellationToken = {}));\nconst shortcutEvent = Object.freeze(function (callback, context) {\n const handle = (0, ral_1.default)().timer.setTimeout(callback.bind(context), 0);\n return { dispose() { handle.dispose(); } };\n});\nclass MutableToken {\n constructor() {\n this._isCancelled = false;\n }\n cancel() {\n if (!this._isCancelled) {\n this._isCancelled = true;\n if (this._emitter) {\n this._emitter.fire(undefined);\n this.dispose();\n }\n }\n }\n get isCancellationRequested() {\n return this._isCancelled;\n }\n get onCancellationRequested() {\n if (this._isCancelled) {\n return shortcutEvent;\n }\n if (!this._emitter) {\n this._emitter = new events_1.Emitter();\n }\n return this._emitter.event;\n }\n dispose() {\n if (this._emitter) {\n this._emitter.dispose();\n this._emitter = undefined;\n }\n }\n}\nclass CancellationTokenSource {\n get token() {\n if (!this._token) {\n // be lazy and create the token only when\n // actually needed\n this._token = new MutableToken();\n }\n return this._token;\n }\n cancel() {\n if (!this._token) {\n // save an object by returning the default\n // cancelled token when cancellation happens\n // before someone asks for the token\n this._token = CancellationToken.Cancelled;\n }\n else {\n this._token.cancel();\n }\n }\n dispose() {\n if (!this._token) {\n // ensure to initialize with an empty token if we had none\n this._token = CancellationToken.None;\n }\n else if (this._token instanceof MutableToken) {\n // actually dispose\n this._token.dispose();\n }\n }\n}\nexports.CancellationTokenSource = CancellationTokenSource;\n","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken, CancellationTokenSource } from '../utils/cancellation.js';\n/**\n * Delays the execution of the current code to the next tick of the event loop.\n * Don't call this method directly in a tight loop to prevent too many promises from being created.\n */\nexport function delayNextTick() {\n return new Promise(resolve => {\n // In case we are running in a non-node environment, `setImmediate` isn't available.\n // Using `setTimeout` of the browser API accomplishes the same result.\n if (typeof setImmediate === 'undefined') {\n setTimeout(resolve, 0);\n }\n else {\n setImmediate(resolve);\n }\n });\n}\nlet lastTick = 0;\nlet globalInterruptionPeriod = 10;\n/**\n * Reset the global interruption period and create a cancellation token source.\n */\nexport function startCancelableOperation() {\n lastTick = performance.now();\n return new CancellationTokenSource();\n}\n/**\n * Change the period duration for `interruptAndCheck` to the given number of milliseconds.\n * The default value is 10ms.\n */\nexport function setInterruptionPeriod(period) {\n globalInterruptionPeriod = period;\n}\n/**\n * This symbol may be thrown in an asynchronous context by any Langium service that receives\n * a `CancellationToken`. This means that the promise returned by such a service is rejected with\n * this symbol as rejection reason.\n */\nexport const OperationCancelled = Symbol('OperationCancelled');\n/**\n * Use this in a `catch` block to check whether the thrown object indicates that the operation\n * has been cancelled.\n */\nexport function isOperationCancelled(err) {\n return err === OperationCancelled;\n}\n/**\n * This function does two things:\n * 1. Check the elapsed time since the last call to this function or to `startCancelableOperation`. If the predefined\n * period (configured with `setInterruptionPeriod`) is exceeded, execution is delayed with `delayNextTick`.\n * 2. If the predefined period is not met yet or execution is resumed after an interruption, the given cancellation\n * token is checked, and if cancellation is requested, `OperationCanceled` is thrown.\n *\n * All services in Langium that receive a `CancellationToken` may potentially call this function, so the\n * `CancellationToken` must be caught (with an `async` try-catch block or a `catch` callback attached to\n * the promise) to avoid that event being exposed as an error.\n */\nexport async function interruptAndCheck(token) {\n if (token === CancellationToken.None) {\n // Early exit in case cancellation was disabled by the caller\n return;\n }\n const current = performance.now();\n if (current - lastTick >= globalInterruptionPeriod) {\n lastTick = current;\n await delayNextTick();\n // prevent calling delayNextTick every iteration of loop\n // where delayNextTick takes up the majority or all of the\n // globalInterruptionPeriod itself\n lastTick = performance.now();\n }\n if (token.isCancellationRequested) {\n throw OperationCancelled;\n }\n}\n/**\n * Simple implementation of the deferred pattern.\n * An object that exposes a promise and functions to resolve and reject it.\n */\nexport class Deferred {\n constructor() {\n this.promise = new Promise((resolve, reject) => {\n this.resolve = (arg) => {\n resolve(arg);\n return this;\n };\n this.reject = (err) => {\n reject(err);\n return this;\n };\n });\n }\n}\n//# sourceMappingURL=promise-utils.js.map","/* --------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n * ------------------------------------------------------------------------------------------ */\n'use strict';\nclass FullTextDocument {\n constructor(uri, languageId, version, content) {\n this._uri = uri;\n this._languageId = languageId;\n this._version = version;\n this._content = content;\n this._lineOffsets = undefined;\n }\n get uri() {\n return this._uri;\n }\n get languageId() {\n return this._languageId;\n }\n get version() {\n return this._version;\n }\n getText(range) {\n if (range) {\n const start = this.offsetAt(range.start);\n const end = this.offsetAt(range.end);\n return this._content.substring(start, end);\n }\n return this._content;\n }\n update(changes, version) {\n for (const change of changes) {\n if (FullTextDocument.isIncremental(change)) {\n // makes sure start is before end\n const range = getWellformedRange(change.range);\n // update content\n const startOffset = this.offsetAt(range.start);\n const endOffset = this.offsetAt(range.end);\n this._content = this._content.substring(0, startOffset) + change.text + this._content.substring(endOffset, this._content.length);\n // update the offsets\n const startLine = Math.max(range.start.line, 0);\n const endLine = Math.max(range.end.line, 0);\n let lineOffsets = this._lineOffsets;\n const addedLineOffsets = computeLineOffsets(change.text, false, startOffset);\n if (endLine - startLine === addedLineOffsets.length) {\n for (let i = 0, len = addedLineOffsets.length; i < len; i++) {\n lineOffsets[i + startLine + 1] = addedLineOffsets[i];\n }\n }\n else {\n if (addedLineOffsets.length < 10000) {\n lineOffsets.splice(startLine + 1, endLine - startLine, ...addedLineOffsets);\n }\n else { // avoid too many arguments for splice\n this._lineOffsets = lineOffsets = lineOffsets.slice(0, startLine + 1).concat(addedLineOffsets, lineOffsets.slice(endLine + 1));\n }\n }\n const diff = change.text.length - (endOffset - startOffset);\n if (diff !== 0) {\n for (let i = startLine + 1 + addedLineOffsets.length, len = lineOffsets.length; i < len; i++) {\n lineOffsets[i] = lineOffsets[i] + diff;\n }\n }\n }\n else if (FullTextDocument.isFull(change)) {\n this._content = change.text;\n this._lineOffsets = undefined;\n }\n else {\n throw new Error('Unknown change event received');\n }\n }\n this._version = version;\n }\n getLineOffsets() {\n if (this._lineOffsets === undefined) {\n this._lineOffsets = computeLineOffsets(this._content, true);\n }\n return this._lineOffsets;\n }\n positionAt(offset) {\n offset = Math.max(Math.min(offset, this._content.length), 0);\n const lineOffsets = this.getLineOffsets();\n let low = 0, high = lineOffsets.length;\n if (high === 0) {\n return { line: 0, character: offset };\n }\n while (low < high) {\n const mid = Math.floor((low + high) / 2);\n if (lineOffsets[mid] > offset) {\n high = mid;\n }\n else {\n low = mid + 1;\n }\n }\n // low is the least x for which the line offset is larger than the current offset\n // or array.length if no line offset is larger than the current offset\n const line = low - 1;\n offset = this.ensureBeforeEOL(offset, lineOffsets[line]);\n return { line, character: offset - lineOffsets[line] };\n }\n offsetAt(position) {\n const lineOffsets = this.getLineOffsets();\n if (position.line >= lineOffsets.length) {\n return this._content.length;\n }\n else if (position.line < 0) {\n return 0;\n }\n const lineOffset = lineOffsets[position.line];\n if (position.character <= 0) {\n return lineOffset;\n }\n const nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;\n const offset = Math.min(lineOffset + position.character, nextLineOffset);\n return this.ensureBeforeEOL(offset, lineOffset);\n }\n ensureBeforeEOL(offset, lineOffset) {\n while (offset > lineOffset && isEOL(this._content.charCodeAt(offset - 1))) {\n offset--;\n }\n return offset;\n }\n get lineCount() {\n return this.getLineOffsets().length;\n }\n static isIncremental(event) {\n const candidate = event;\n return candidate !== undefined && candidate !== null &&\n typeof candidate.text === 'string' && candidate.range !== undefined &&\n (candidate.rangeLength === undefined || typeof candidate.rangeLength === 'number');\n }\n static isFull(event) {\n const candidate = event;\n return candidate !== undefined && candidate !== null &&\n typeof candidate.text === 'string' && candidate.range === undefined && candidate.rangeLength === undefined;\n }\n}\nexport var TextDocument;\n(function (TextDocument) {\n /**\n * Creates a new text document.\n *\n * @param uri The document's uri.\n * @param languageId The document's language Id.\n * @param version The document's initial version number.\n * @param content The document's content.\n */\n function create(uri, languageId, version, content) {\n return new FullTextDocument(uri, languageId, version, content);\n }\n TextDocument.create = create;\n /**\n * Updates a TextDocument by modifying its content.\n *\n * @param document the document to update. Only documents created by TextDocument.create are valid inputs.\n * @param changes the changes to apply to the document.\n * @param version the changes version for the document.\n * @returns The updated TextDocument. Note: That's the same document instance passed in as first parameter.\n *\n */\n function update(document, changes, version) {\n if (document instanceof FullTextDocument) {\n document.update(changes, version);\n return document;\n }\n else {\n throw new Error('TextDocument.update: document must be created by TextDocument.create');\n }\n }\n TextDocument.update = update;\n function applyEdits(document, edits) {\n const text = document.getText();\n const sortedEdits = mergeSort(edits.map(getWellformedEdit), (a, b) => {\n const diff = a.range.start.line - b.range.start.line;\n if (diff === 0) {\n return a.range.start.character - b.range.start.character;\n }\n return diff;\n });\n let lastModifiedOffset = 0;\n const spans = [];\n for (const e of sortedEdits) {\n const startOffset = document.offsetAt(e.range.start);\n if (startOffset < lastModifiedOffset) {\n throw new Error('Overlapping edit');\n }\n else if (startOffset > lastModifiedOffset) {\n spans.push(text.substring(lastModifiedOffset, startOffset));\n }\n if (e.newText.length) {\n spans.push(e.newText);\n }\n lastModifiedOffset = document.offsetAt(e.range.end);\n }\n spans.push(text.substr(lastModifiedOffset));\n return spans.join('');\n }\n TextDocument.applyEdits = applyEdits;\n})(TextDocument || (TextDocument = {}));\nfunction mergeSort(data, compare) {\n if (data.length <= 1) {\n // sorted\n return data;\n }\n const p = (data.length / 2) | 0;\n const left = data.slice(0, p);\n const right = data.slice(p);\n mergeSort(left, compare);\n mergeSort(right, compare);\n let leftIdx = 0;\n let rightIdx = 0;\n let i = 0;\n while (leftIdx < left.length && rightIdx < right.length) {\n const ret = compare(left[leftIdx], right[rightIdx]);\n if (ret <= 0) {\n // smaller_equal -> take left to preserve order\n data[i++] = left[leftIdx++];\n }\n else {\n // greater -> take right\n data[i++] = right[rightIdx++];\n }\n }\n while (leftIdx < left.length) {\n data[i++] = left[leftIdx++];\n }\n while (rightIdx < right.length) {\n data[i++] = right[rightIdx++];\n }\n return data;\n}\nfunction computeLineOffsets(text, isAtLineStart, textOffset = 0) {\n const result = isAtLineStart ? [textOffset] : [];\n for (let i = 0; i < text.length; i++) {\n const ch = text.charCodeAt(i);\n if (isEOL(ch)) {\n if (ch === 13 /* CharCode.CarriageReturn */ && i + 1 < text.length && text.charCodeAt(i + 1) === 10 /* CharCode.LineFeed */) {\n i++;\n }\n result.push(textOffset + i + 1);\n }\n }\n return result;\n}\nfunction isEOL(char) {\n return char === 13 /* CharCode.CarriageReturn */ || char === 10 /* CharCode.LineFeed */;\n}\nfunction getWellformedRange(range) {\n const start = range.start;\n const end = range.end;\n if (start.line > end.line || (start.line === end.line && start.character > end.character)) {\n return { start: end, end: start };\n }\n return range;\n}\nfunction getWellformedEdit(textEdit) {\n const range = getWellformedRange(textEdit.range);\n if (range !== textEdit.range) {\n return { newText: textEdit.newText, range };\n }\n return textEdit;\n}\n","var LIB;(()=>{\"use strict\";var t={470:t=>{function e(t){if(\"string\"!=typeof t)throw new TypeError(\"Path must be a string. Received \"+JSON.stringify(t))}function r(t,e){for(var r,n=\"\",i=0,o=-1,s=0,h=0;h<=t.length;++h){if(h<t.length)r=t.charCodeAt(h);else{if(47===r)break;r=47}if(47===r){if(o===h-1||1===s);else if(o!==h-1&&2===s){if(n.length<2||2!==i||46!==n.charCodeAt(n.length-1)||46!==n.charCodeAt(n.length-2))if(n.length>2){var a=n.lastIndexOf(\"/\");if(a!==n.length-1){-1===a?(n=\"\",i=0):i=(n=n.slice(0,a)).length-1-n.lastIndexOf(\"/\"),o=h,s=0;continue}}else if(2===n.length||1===n.length){n=\"\",i=0,o=h,s=0;continue}e&&(n.length>0?n+=\"/..\":n=\"..\",i=2)}else n.length>0?n+=\"/\"+t.slice(o+1,h):n=t.slice(o+1,h),i=h-o-1;o=h,s=0}else 46===r&&-1!==s?++s:s=-1}return n}var n={resolve:function(){for(var t,n=\"\",i=!1,o=arguments.length-1;o>=-1&&!i;o--){var s;o>=0?s=arguments[o]:(void 0===t&&(t=process.cwd()),s=t),e(s),0!==s.length&&(n=s+\"/\"+n,i=47===s.charCodeAt(0))}return n=r(n,!i),i?n.length>0?\"/\"+n:\"/\":n.length>0?n:\".\"},normalize:function(t){if(e(t),0===t.length)return\".\";var n=47===t.charCodeAt(0),i=47===t.charCodeAt(t.length-1);return 0!==(t=r(t,!n)).length||n||(t=\".\"),t.length>0&&i&&(t+=\"/\"),n?\"/\"+t:t},isAbsolute:function(t){return e(t),t.length>0&&47===t.charCodeAt(0)},join:function(){if(0===arguments.length)return\".\";for(var t,r=0;r<arguments.length;++r){var i=arguments[r];e(i),i.length>0&&(void 0===t?t=i:t+=\"/\"+i)}return void 0===t?\".\":n.normalize(t)},relative:function(t,r){if(e(t),e(r),t===r)return\"\";if((t=n.resolve(t))===(r=n.resolve(r)))return\"\";for(var i=1;i<t.length&&47===t.charCodeAt(i);++i);for(var o=t.length,s=o-i,h=1;h<r.length&&47===r.charCodeAt(h);++h);for(var a=r.length-h,c=s<a?s:a,f=-1,u=0;u<=c;++u){if(u===c){if(a>c){if(47===r.charCodeAt(h+u))return r.slice(h+u+1);if(0===u)return r.slice(h+u)}else s>c&&(47===t.charCodeAt(i+u)?f=u:0===u&&(f=0));break}var l=t.charCodeAt(i+u);if(l!==r.charCodeAt(h+u))break;47===l&&(f=u)}var g=\"\";for(u=i+f+1;u<=o;++u)u!==o&&47!==t.charCodeAt(u)||(0===g.length?g+=\"..\":g+=\"/..\");return g.length>0?g+r.slice(h+f):(h+=f,47===r.charCodeAt(h)&&++h,r.slice(h))},_makeLong:function(t){return t},dirname:function(t){if(e(t),0===t.length)return\".\";for(var r=t.charCodeAt(0),n=47===r,i=-1,o=!0,s=t.length-1;s>=1;--s)if(47===(r=t.charCodeAt(s))){if(!o){i=s;break}}else o=!1;return-1===i?n?\"/\":\".\":n&&1===i?\"//\":t.slice(0,i)},basename:function(t,r){if(void 0!==r&&\"string\"!=typeof r)throw new TypeError('\"ext\" argument must be a string');e(t);var n,i=0,o=-1,s=!0;if(void 0!==r&&r.length>0&&r.length<=t.length){if(r.length===t.length&&r===t)return\"\";var h=r.length-1,a=-1;for(n=t.length-1;n>=0;--n){var c=t.charCodeAt(n);if(47===c){if(!s){i=n+1;break}}else-1===a&&(s=!1,a=n+1),h>=0&&(c===r.charCodeAt(h)?-1==--h&&(o=n):(h=-1,o=a))}return i===o?o=a:-1===o&&(o=t.length),t.slice(i,o)}for(n=t.length-1;n>=0;--n)if(47===t.charCodeAt(n)){if(!s){i=n+1;break}}else-1===o&&(s=!1,o=n+1);return-1===o?\"\":t.slice(i,o)},extname:function(t){e(t);for(var r=-1,n=0,i=-1,o=!0,s=0,h=t.length-1;h>=0;--h){var a=t.charCodeAt(h);if(47!==a)-1===i&&(o=!1,i=h+1),46===a?-1===r?r=h:1!==s&&(s=1):-1!==r&&(s=-1);else if(!o){n=h+1;break}}return-1===r||-1===i||0===s||1===s&&r===i-1&&r===n+1?\"\":t.slice(r,i)},format:function(t){if(null===t||\"object\"!=typeof t)throw new TypeError('The \"pathObject\" argument must be of type Object. Received type '+typeof t);return function(t,e){var r=e.dir||e.root,n=e.base||(e.name||\"\")+(e.ext||\"\");return r?r===e.root?r+n:r+\"/\"+n:n}(0,t)},parse:function(t){e(t);var r={root:\"\",dir:\"\",base:\"\",ext:\"\",name:\"\"};if(0===t.length)return r;var n,i=t.charCodeAt(0),o=47===i;o?(r.root=\"/\",n=1):n=0;for(var s=-1,h=0,a=-1,c=!0,f=t.length-1,u=0;f>=n;--f)if(47!==(i=t.charCodeAt(f)))-1===a&&(c=!1,a=f+1),46===i?-1===s?s=f:1!==u&&(u=1):-1!==s&&(u=-1);else if(!c){h=f+1;break}return-1===s||-1===a||0===u||1===u&&s===a-1&&s===h+1?-1!==a&&(r.base=r.name=0===h&&o?t.slice(1,a):t.slice(h,a)):(0===h&&o?(r.name=t.slice(1,s),r.base=t.slice(1,a)):(r.name=t.slice(h,s),r.base=t.slice(h,a)),r.ext=t.slice(s,a)),h>0?r.dir=t.slice(0,h-1):o&&(r.dir=\"/\"),r},sep:\"/\",delimiter:\":\",win32:null,posix:null};n.posix=n,t.exports=n}},e={};function r(n){var i=e[n];if(void 0!==i)return i.exports;var o=e[n]={exports:{}};return t[n](o,o.exports,r),o.exports}r.d=(t,e)=>{for(var n in e)r.o(e,n)&&!r.o(t,n)&&Object.defineProperty(t,n,{enumerable:!0,get:e[n]})},r.o=(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r.r=t=>{\"undefined\"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:\"Module\"}),Object.defineProperty(t,\"__esModule\",{value:!0})};var n={};(()=>{let t;if(r.r(n),r.d(n,{URI:()=>f,Utils:()=>P}),\"object\"==typeof process)t=\"win32\"===process.platform;else if(\"object\"==typeof navigator){let e=navigator.userAgent;t=e.indexOf(\"Windows\")>=0}const e=/^\\w[\\w\\d+.-]*$/,i=/^\\//,o=/^\\/\\//;function s(t,r){if(!t.scheme&&r)throw new Error(`[UriError]: Scheme is missing: {scheme: \"\", authority: \"${t.authority}\", path: \"${t.path}\", query: \"${t.query}\", fragment: \"${t.fragment}\"}`);if(t.scheme&&!e.test(t.scheme))throw new Error(\"[UriError]: Scheme contains illegal characters.\");if(t.path)if(t.authority){if(!i.test(t.path))throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash (\"/\") character')}else if(o.test(t.path))throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters (\"//\")')}const h=\"\",a=\"/\",c=/^(([^:/?#]+?):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?/;class f{static isUri(t){return t instanceof f||!!t&&\"string\"==typeof t.authority&&\"string\"==typeof t.fragment&&\"string\"==typeof t.path&&\"string\"==typeof t.query&&\"string\"==typeof t.scheme&&\"string\"==typeof t.fsPath&&\"function\"==typeof t.with&&\"function\"==typeof t.toString}scheme;authority;path;query;fragment;constructor(t,e,r,n,i,o=!1){\"object\"==typeof t?(this.scheme=t.scheme||h,this.authority=t.authority||h,this.path=t.path||h,this.query=t.query||h,this.fragment=t.fragment||h):(this.scheme=function(t,e){return t||e?t:\"file\"}(t,o),this.authority=e||h,this.path=function(t,e){switch(t){case\"https\":case\"http\":case\"file\":e?e[0]!==a&&(e=a+e):e=a}return e}(this.scheme,r||h),this.query=n||h,this.fragment=i||h,s(this,o))}get fsPath(){return m(this,!1)}with(t){if(!t)return this;let{scheme:e,authority:r,path:n,query:i,fragment:o}=t;return void 0===e?e=this.scheme:null===e&&(e=h),void 0===r?r=this.authority:null===r&&(r=h),void 0===n?n=this.path:null===n&&(n=h),void 0===i?i=this.query:null===i&&(i=h),void 0===o?o=this.fragment:null===o&&(o=h),e===this.scheme&&r===this.authority&&n===this.path&&i===this.query&&o===this.fragment?this:new l(e,r,n,i,o)}static parse(t,e=!1){const r=c.exec(t);return r?new l(r[2]||h,C(r[4]||h),C(r[5]||h),C(r[7]||h),C(r[9]||h),e):new l(h,h,h,h,h)}static file(e){let r=h;if(t&&(e=e.replace(/\\\\/g,a)),e[0]===a&&e[1]===a){const t=e.indexOf(a,2);-1===t?(r=e.substring(2),e=a):(r=e.substring(2,t),e=e.substring(t)||a)}return new l(\"file\",r,e,h,h)}static from(t){const e=new l(t.scheme,t.authority,t.path,t.query,t.fragment);return s(e,!0),e}toString(t=!1){return y(this,t)}toJSON(){return this}static revive(t){if(t){if(t instanceof f)return t;{const e=new l(t);return e._formatted=t.external,e._fsPath=t._sep===u?t.fsPath:null,e}}return t}}const u=t?1:void 0;class l extends f{_formatted=null;_fsPath=null;get fsPath(){return this._fsPath||(this._fsPath=m(this,!1)),this._fsPath}toString(t=!1){return t?y(this,!0):(this._formatted||(this._formatted=y(this,!1)),this._formatted)}toJSON(){const t={$mid:1};return this._fsPath&&(t.fsPath=this._fsPath,t._sep=u),this._formatted&&(t.external=this._formatted),this.path&&(t.path=this.path),this.scheme&&(t.scheme=this.scheme),this.authority&&(t.authority=this.authority),this.query&&(t.query=this.query),this.fragment&&(t.fragment=this.fragment),t}}const g={58:\"%3A\",47:\"%2F\",63:\"%3F\",35:\"%23\",91:\"%5B\",93:\"%5D\",64:\"%40\",33:\"%21\",36:\"%24\",38:\"%26\",39:\"%27\",40:\"%28\",41:\"%29\",42:\"%2A\",43:\"%2B\",44:\"%2C\",59:\"%3B\",61:\"%3D\",32:\"%20\"};function d(t,e,r){let n,i=-1;for(let o=0;o<t.length;o++){const s=t.charCodeAt(o);if(s>=97&&s<=122||s>=65&&s<=90||s>=48&&s<=57||45===s||46===s||95===s||126===s||e&&47===s||r&&91===s||r&&93===s||r&&58===s)-1!==i&&(n+=encodeURIComponent(t.substring(i,o)),i=-1),void 0!==n&&(n+=t.charAt(o));else{void 0===n&&(n=t.substr(0,o));const e=g[s];void 0!==e?(-1!==i&&(n+=encodeURIComponent(t.substring(i,o)),i=-1),n+=e):-1===i&&(i=o)}}return-1!==i&&(n+=encodeURIComponent(t.substring(i))),void 0!==n?n:t}function p(t){let e;for(let r=0;r<t.length;r++){const n=t.charCodeAt(r);35===n||63===n?(void 0===e&&(e=t.substr(0,r)),e+=g[n]):void 0!==e&&(e+=t[r])}return void 0!==e?e:t}function m(e,r){let n;return n=e.authority&&e.path.length>1&&\"file\"===e.scheme?`//${e.authority}${e.path}`:47===e.path.charCodeAt(0)&&(e.path.charCodeAt(1)>=65&&e.path.charCodeAt(1)<=90||e.path.charCodeAt(1)>=97&&e.path.charCodeAt(1)<=122)&&58===e.path.charCodeAt(2)?r?e.path.substr(1):e.path[1].toLowerCase()+e.path.substr(2):e.path,t&&(n=n.replace(/\\//g,\"\\\\\")),n}function y(t,e){const r=e?p:d;let n=\"\",{scheme:i,authority:o,path:s,query:h,fragment:c}=t;if(i&&(n+=i,n+=\":\"),(o||\"file\"===i)&&(n+=a,n+=a),o){let t=o.indexOf(\"@\");if(-1!==t){const e=o.substr(0,t);o=o.substr(t+1),t=e.lastIndexOf(\":\"),-1===t?n+=r(e,!1,!1):(n+=r(e.substr(0,t),!1,!1),n+=\":\",n+=r(e.substr(t+1),!1,!0)),n+=\"@\"}o=o.toLowerCase(),t=o.lastIndexOf(\":\"),-1===t?n+=r(o,!1,!0):(n+=r(o.substr(0,t),!1,!0),n+=o.substr(t))}if(s){if(s.length>=3&&47===s.charCodeAt(0)&&58===s.charCodeAt(2)){const t=s.charCodeAt(1);t>=65&&t<=90&&(s=`/${String.fromCharCode(t+32)}:${s.substr(3)}`)}else if(s.length>=2&&58===s.charCodeAt(1)){const t=s.charCodeAt(0);t>=65&&t<=90&&(s=`${String.fromCharCode(t+32)}:${s.substr(2)}`)}n+=r(s,!0,!1)}return h&&(n+=\"?\",n+=r(h,!1,!1)),c&&(n+=\"#\",n+=e?c:d(c,!1,!1)),n}function v(t){try{return decodeURIComponent(t)}catch{return t.length>3?t.substr(0,3)+v(t.substr(3)):t}}const b=/(%[0-9A-Za-z][0-9A-Za-z])+/g;function C(t){return t.match(b)?t.replace(b,(t=>v(t))):t}var A=r(470);const w=A.posix||A,x=\"/\";var P;!function(t){t.joinPath=function(t,...e){return t.with({path:w.join(t.path,...e)})},t.resolvePath=function(t,...e){let r=t.path,n=!1;r[0]!==x&&(r=x+r,n=!0);let i=w.resolve(r,...e);return n&&i[0]===x&&!t.authority&&(i=i.substring(1)),t.with({path:i})},t.dirname=function(t){if(0===t.path.length||t.path===x)return t;let e=w.dirname(t.path);return 1===e.length&&46===e.charCodeAt(0)&&(e=\"\"),t.with({path:e})},t.basename=function(t){return w.basename(t.path)},t.extname=function(t){return w.extname(t.path)}}(P||(P={}))})(),LIB=n})();export const{URI,Utils}=LIB;\n//# sourceMappingURL=index.mjs.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { URI, Utils } from 'vscode-uri';\nexport { URI };\nexport var UriUtils;\n(function (UriUtils) {\n UriUtils.basename = Utils.basename;\n UriUtils.dirname = Utils.dirname;\n UriUtils.extname = Utils.extname;\n UriUtils.joinPath = Utils.joinPath;\n UriUtils.resolvePath = Utils.resolvePath;\n function equals(a, b) {\n return (a === null || a === void 0 ? void 0 : a.toString()) === (b === null || b === void 0 ? void 0 : b.toString());\n }\n UriUtils.equals = equals;\n function relative(from, to) {\n const fromPath = typeof from === 'string' ? from : from.path;\n const toPath = typeof to === 'string' ? to : to.path;\n const fromParts = fromPath.split('/').filter(e => e.length > 0);\n const toParts = toPath.split('/').filter(e => e.length > 0);\n let i = 0;\n for (; i < fromParts.length; i++) {\n if (fromParts[i] !== toParts[i]) {\n break;\n }\n }\n const backPart = '../'.repeat(fromParts.length - i);\n const toPart = toParts.slice(i).join('/');\n return backPart + toPart;\n }\n UriUtils.relative = relative;\n function normalize(uri) {\n return URI.parse(uri.toString()).toString();\n }\n UriUtils.normalize = normalize;\n})(UriUtils || (UriUtils = {}));\n//# sourceMappingURL=uri-utils.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\n/**\n * Re-export 'TextDocument' from 'vscode-languageserver-textdocument' for convenience,\n * including both type _and_ symbol (namespace), as we here and there also refer to the symbol,\n * the overhead is very small, just a few kilobytes.\n * Everything else of that package (at the time contributing) is also defined\n * in 'vscode-languageserver-protocol' or 'vscode-languageserver-types'.\n */\nexport { TextDocument } from 'vscode-languageserver-textdocument';\nimport { TextDocument } from './documents.js';\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { stream } from '../utils/stream.js';\nimport { URI } from '../utils/uri-utils.js';\n/**\n * A document is subject to several phases that are run in predefined order. Any state value implies that\n * smaller state values are finished as well.\n */\nexport var DocumentState;\n(function (DocumentState) {\n /**\n * The text content has changed and needs to be parsed again. The AST held by this outdated\n * document instance is no longer valid.\n */\n DocumentState[DocumentState[\"Changed\"] = 0] = \"Changed\";\n /**\n * An AST has been created from the text content. The document structure can be traversed,\n * but cross-references cannot be resolved yet. If necessary, the structure can be manipulated\n * at this stage as a preprocessing step.\n */\n DocumentState[DocumentState[\"Parsed\"] = 1] = \"Parsed\";\n /**\n * The `IndexManager` service has processed AST nodes of this document. This means the\n * exported symbols are available in the global scope and can be resolved from other documents.\n */\n DocumentState[DocumentState[\"IndexedContent\"] = 2] = \"IndexedContent\";\n /**\n * The `ScopeComputation` service has processed this document. This means the local symbols\n * are stored in a MultiMap so they can be looked up by the `ScopeProvider` service.\n * Once a document has reached this state, you may follow every reference - it will lazily\n * resolve its `ref` property and yield either the target AST node or `undefined` in case\n * the target is not in scope.\n */\n DocumentState[DocumentState[\"ComputedScopes\"] = 3] = \"ComputedScopes\";\n /**\n * The `Linker` service has processed this document. All outgoing references have been\n * resolved or marked as erroneous.\n */\n DocumentState[DocumentState[\"Linked\"] = 4] = \"Linked\";\n /**\n * The `IndexManager` service has processed AST node references of this document. This is\n * necessary to determine which documents are affected by a change in one of the workspace\n * documents.\n */\n DocumentState[DocumentState[\"IndexedReferences\"] = 5] = \"IndexedReferences\";\n /**\n * The `DocumentValidator` service has processed this document. The language server listens\n * to the results of this phase and sends diagnostics to the client.\n */\n DocumentState[DocumentState[\"Validated\"] = 6] = \"Validated\";\n})(DocumentState || (DocumentState = {}));\nexport class DefaultLangiumDocumentFactory {\n constructor(services) {\n this.serviceRegistry = services.ServiceRegistry;\n this.textDocuments = services.workspace.TextDocuments;\n this.fileSystemProvider = services.workspace.FileSystemProvider;\n }\n async fromUri(uri, cancellationToken = CancellationToken.None) {\n const content = await this.fileSystemProvider.readFile(uri);\n return this.createAsync(uri, content, cancellationToken);\n }\n fromTextDocument(textDocument, uri, token) {\n uri = uri !== null && uri !== void 0 ? uri : URI.parse(textDocument.uri);\n if (CancellationToken.is(token)) {\n return this.createAsync(uri, textDocument, token);\n }\n else {\n return this.create(uri, textDocument, token);\n }\n }\n fromString(text, uri, token) {\n if (CancellationToken.is(token)) {\n return this.createAsync(uri, text, token);\n }\n else {\n return this.create(uri, text, token);\n }\n }\n fromModel(model, uri) {\n return this.create(uri, { $model: model });\n }\n create(uri, content, options) {\n if (typeof content === 'string') {\n const parseResult = this.parse(uri, content, options);\n return this.createLangiumDocument(parseResult, uri, undefined, content);\n }\n else if ('$model' in content) {\n const parseResult = { value: content.$model, parserErrors: [], lexerErrors: [] };\n return this.createLangiumDocument(parseResult, uri);\n }\n else {\n const parseResult = this.parse(uri, content.getText(), options);\n return this.createLangiumDocument(parseResult, uri, content);\n }\n }\n async createAsync(uri, content, cancelToken) {\n if (typeof content === 'string') {\n const parseResult = await this.parseAsync(uri, content, cancelToken);\n return this.createLangiumDocument(parseResult, uri, undefined, content);\n }\n else {\n const parseResult = await this.parseAsync(uri, content.getText(), cancelToken);\n return this.createLangiumDocument(parseResult, uri, content);\n }\n }\n /**\n * Create a LangiumDocument from a given parse result.\n *\n * A TextDocument is created on demand if it is not provided as argument here. Usually this\n * should not be necessary because the main purpose of the TextDocument is to convert between\n * text ranges and offsets, which is done solely in LSP request handling.\n *\n * With the introduction of {@link update} below this method is supposed to be mainly called\n * during workspace initialization and on addition/recognition of new files, while changes in\n * existing documents are processed via {@link update}.\n */\n createLangiumDocument(parseResult, uri, textDocument, text) {\n let document;\n if (textDocument) {\n document = {\n parseResult,\n uri,\n state: DocumentState.Parsed,\n references: [],\n textDocument\n };\n }\n else {\n const textDocumentGetter = this.createTextDocumentGetter(uri, text);\n document = {\n parseResult,\n uri,\n state: DocumentState.Parsed,\n references: [],\n get textDocument() {\n return textDocumentGetter();\n }\n };\n }\n parseResult.value.$document = document;\n return document;\n }\n async update(document, cancellationToken) {\n var _a, _b;\n // The CST full text property contains the original text that was used to create the AST.\n const oldText = (_a = document.parseResult.value.$cstNode) === null || _a === void 0 ? void 0 : _a.root.fullText;\n const textDocument = (_b = this.textDocuments) === null || _b === void 0 ? void 0 : _b.get(document.uri.toString());\n const text = textDocument ? textDocument.getText() : await this.fileSystemProvider.readFile(document.uri);\n if (textDocument) {\n Object.defineProperty(document, 'textDocument', {\n value: textDocument\n });\n }\n else {\n const textDocumentGetter = this.createTextDocumentGetter(document.uri, text);\n Object.defineProperty(document, 'textDocument', {\n get: textDocumentGetter\n });\n }\n // Some of these documents can be pretty large, so parsing them again can be quite expensive.\n // Therefore, we only parse if the text has actually changed.\n if (oldText !== text) {\n document.parseResult = await this.parseAsync(document.uri, text, cancellationToken);\n document.parseResult.value.$document = document;\n }\n document.state = DocumentState.Parsed;\n return document;\n }\n parse(uri, text, options) {\n const services = this.serviceRegistry.getServices(uri);\n return services.parser.LangiumParser.parse(text, options);\n }\n parseAsync(uri, text, cancellationToken) {\n const services = this.serviceRegistry.getServices(uri);\n return services.parser.AsyncParser.parse(text, cancellationToken);\n }\n createTextDocumentGetter(uri, text) {\n const serviceRegistry = this.serviceRegistry;\n let textDoc = undefined;\n return () => {\n return textDoc !== null && textDoc !== void 0 ? textDoc : (textDoc = TextDocument.create(uri.toString(), serviceRegistry.getServices(uri).LanguageMetaData.languageId, 0, text !== null && text !== void 0 ? text : ''));\n };\n }\n}\nexport class DefaultLangiumDocuments {\n constructor(services) {\n this.documentMap = new Map();\n this.langiumDocumentFactory = services.workspace.LangiumDocumentFactory;\n this.serviceRegistry = services.ServiceRegistry;\n }\n get all() {\n return stream(this.documentMap.values());\n }\n addDocument(document) {\n const uriString = document.uri.toString();\n if (this.documentMap.has(uriString)) {\n throw new Error(`A document with the URI '${uriString}' is already present.`);\n }\n this.documentMap.set(uriString, document);\n }\n getDocument(uri) {\n const uriString = uri.toString();\n return this.documentMap.get(uriString);\n }\n async getOrCreateDocument(uri, cancellationToken) {\n let document = this.getDocument(uri);\n if (document) {\n return document;\n }\n document = await this.langiumDocumentFactory.fromUri(uri, cancellationToken);\n this.addDocument(document);\n return document;\n }\n createDocument(uri, text, cancellationToken) {\n if (cancellationToken) {\n return this.langiumDocumentFactory.fromString(text, uri, cancellationToken).then(document => {\n this.addDocument(document);\n return document;\n });\n }\n else {\n const document = this.langiumDocumentFactory.fromString(text, uri);\n this.addDocument(document);\n return document;\n }\n }\n hasDocument(uri) {\n return this.documentMap.has(uri.toString());\n }\n invalidateDocument(uri) {\n const uriString = uri.toString();\n const langiumDoc = this.documentMap.get(uriString);\n if (langiumDoc) {\n const linker = this.serviceRegistry.getServices(uri).references.Linker;\n linker.unlink(langiumDoc);\n langiumDoc.state = DocumentState.Changed;\n langiumDoc.precomputedScopes = undefined;\n langiumDoc.diagnostics = undefined;\n }\n return langiumDoc;\n }\n deleteDocument(uri) {\n const uriString = uri.toString();\n const langiumDoc = this.documentMap.get(uriString);\n if (langiumDoc) {\n langiumDoc.state = DocumentState.Changed;\n this.documentMap.delete(uriString);\n }\n return langiumDoc;\n }\n}\n//# sourceMappingURL=documents.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { isAstNode, isAstNodeDescription, isLinkingError } from '../syntax-tree.js';\nimport { findRootNode, streamAst, streamReferences } from '../utils/ast-utils.js';\nimport { interruptAndCheck } from '../utils/promise-utils.js';\nimport { DocumentState } from '../workspace/documents.js';\nconst ref_resolving = Symbol('ref_resolving');\nexport class DefaultLinker {\n constructor(services) {\n this.reflection = services.shared.AstReflection;\n this.langiumDocuments = () => services.shared.workspace.LangiumDocuments;\n this.scopeProvider = services.references.ScopeProvider;\n this.astNodeLocator = services.workspace.AstNodeLocator;\n }\n async link(document, cancelToken = CancellationToken.None) {\n for (const node of streamAst(document.parseResult.value)) {\n await interruptAndCheck(cancelToken);\n streamReferences(node).forEach(ref => this.doLink(ref, document));\n }\n }\n doLink(refInfo, document) {\n var _a;\n const ref = refInfo.reference;\n // The reference may already have been resolved lazily by accessing its `ref` property.\n if (ref._ref === undefined) {\n ref._ref = ref_resolving;\n try {\n const description = this.getCandidate(refInfo);\n if (isLinkingError(description)) {\n ref._ref = description;\n }\n else {\n ref._nodeDescription = description;\n if (this.langiumDocuments().hasDocument(description.documentUri)) {\n // The target document is already loaded\n const linkedNode = this.loadAstNode(description);\n ref._ref = linkedNode !== null && linkedNode !== void 0 ? linkedNode : this.createLinkingError(refInfo, description);\n }\n else {\n // Try to load the target AST node later using the already provided description\n ref._ref = undefined;\n }\n }\n }\n catch (err) {\n console.error(`An error occurred while resolving reference to '${ref.$refText}':`, err);\n const errorMessage = (_a = err.message) !== null && _a !== void 0 ? _a : String(err);\n ref._ref = Object.assign(Object.assign({}, refInfo), { message: `An error occurred while resolving reference to '${ref.$refText}': ${errorMessage}` });\n }\n // Add the reference to the document's array of references\n // Only add if the reference has been not been resolved earlier\n // Otherwise we end up with duplicates\n // See also implementation of `buildReference`\n document.references.push(ref);\n }\n }\n unlink(document) {\n for (const ref of document.references) {\n delete ref._ref;\n delete ref._nodeDescription;\n }\n document.references = [];\n }\n getCandidate(refInfo) {\n const scope = this.scopeProvider.getScope(refInfo);\n const description = scope.getElement(refInfo.reference.$refText);\n return description !== null && description !== void 0 ? description : this.createLinkingError(refInfo);\n }\n buildReference(node, property, refNode, refText) {\n // See behavior description in doc of Linker, update that on changes in here.\n // eslint-disable-next-line @typescript-eslint/no-this-alias\n const linker = this;\n const reference = {\n $refNode: refNode,\n $refText: refText,\n get ref() {\n var _a;\n if (isAstNode(this._ref)) {\n // Most frequent case: the target is already resolved.\n return this._ref;\n }\n else if (isAstNodeDescription(this._nodeDescription)) {\n // A candidate has been found before, but it is not loaded yet.\n const linkedNode = linker.loadAstNode(this._nodeDescription);\n this._ref = linkedNode !== null && linkedNode !== void 0 ? linkedNode : linker.createLinkingError({ reference, container: node, property }, this._nodeDescription);\n }\n else if (this._ref === undefined) {\n // The reference has not been linked yet, so do that now.\n this._ref = ref_resolving;\n const document = findRootNode(node).$document;\n const refData = linker.getLinkedNode({ reference, container: node, property });\n if (refData.error && document && document.state < DocumentState.ComputedScopes) {\n // Document scope is not ready, don't set `this._ref` so linker can retry later.\n return this._ref = undefined;\n }\n this._ref = (_a = refData.node) !== null && _a !== void 0 ? _a : refData.error;\n this._nodeDescription = refData.descr;\n document === null || document === void 0 ? void 0 : document.references.push(this);\n }\n else if (this._ref === ref_resolving) {\n throw new Error(`Cyclic reference resolution detected: ${linker.astNodeLocator.getAstNodePath(node)}/${property} (symbol '${refText}')`);\n }\n return isAstNode(this._ref) ? this._ref : undefined;\n },\n get $nodeDescription() {\n return this._nodeDescription;\n },\n get error() {\n return isLinkingError(this._ref) ? this._ref : undefined;\n }\n };\n return reference;\n }\n getLinkedNode(refInfo) {\n var _a;\n try {\n const description = this.getCandidate(refInfo);\n if (isLinkingError(description)) {\n return { error: description };\n }\n const linkedNode = this.loadAstNode(description);\n if (linkedNode) {\n return { node: linkedNode, descr: description };\n }\n else {\n return {\n descr: description,\n error: this.createLinkingError(refInfo, description)\n };\n }\n }\n catch (err) {\n console.error(`An error occurred while resolving reference to '${refInfo.reference.$refText}':`, err);\n const errorMessage = (_a = err.message) !== null && _a !== void 0 ? _a : String(err);\n return {\n error: Object.assign(Object.assign({}, refInfo), { message: `An error occurred while resolving reference to '${refInfo.reference.$refText}': ${errorMessage}` })\n };\n }\n }\n loadAstNode(nodeDescription) {\n if (nodeDescription.node) {\n return nodeDescription.node;\n }\n const doc = this.langiumDocuments().getDocument(nodeDescription.documentUri);\n if (!doc) {\n return undefined;\n }\n return this.astNodeLocator.getAstNode(doc.parseResult.value, nodeDescription.path);\n }\n createLinkingError(refInfo, targetDescription) {\n // Check whether the document is sufficiently processed by the DocumentBuilder. If not, this is a hint for a bug\n // in the language implementation.\n const document = findRootNode(refInfo.container).$document;\n if (document && document.state < DocumentState.ComputedScopes) {\n console.warn(`Attempted reference resolution before document reached ComputedScopes state (${document.uri}).`);\n }\n const referenceType = this.reflection.getReferenceType(refInfo);\n return Object.assign(Object.assign({}, refInfo), { message: `Could not resolve reference to ${referenceType} named '${refInfo.reference.$refText}'.`, targetDescription });\n }\n}\n//# sourceMappingURL=linker.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { findNodeForProperty } from '../utils/grammar-utils.js';\nexport function isNamed(node) {\n return typeof node.name === 'string';\n}\nexport class DefaultNameProvider {\n getName(node) {\n if (isNamed(node)) {\n return node.name;\n }\n return undefined;\n }\n getNameNode(node) {\n return findNodeForProperty(node.$cstNode, 'name');\n }\n}\n//# sourceMappingURL=name-provider.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { findAssignment } from '../utils/grammar-utils.js';\nimport { isReference } from '../syntax-tree.js';\nimport { getDocument } from '../utils/ast-utils.js';\nimport { isChildNode, toDocumentSegment } from '../utils/cst-utils.js';\nimport { stream } from '../utils/stream.js';\nimport { UriUtils } from '../utils/uri-utils.js';\nexport class DefaultReferences {\n constructor(services) {\n this.nameProvider = services.references.NameProvider;\n this.index = services.shared.workspace.IndexManager;\n this.nodeLocator = services.workspace.AstNodeLocator;\n }\n findDeclaration(sourceCstNode) {\n if (sourceCstNode) {\n const assignment = findAssignment(sourceCstNode);\n const nodeElem = sourceCstNode.astNode;\n if (assignment && nodeElem) {\n const reference = nodeElem[assignment.feature];\n if (isReference(reference)) {\n return reference.ref;\n }\n else if (Array.isArray(reference)) {\n for (const ref of reference) {\n if (isReference(ref) && ref.$refNode\n && ref.$refNode.offset <= sourceCstNode.offset\n && ref.$refNode.end >= sourceCstNode.end) {\n return ref.ref;\n }\n }\n }\n }\n if (nodeElem) {\n const nameNode = this.nameProvider.getNameNode(nodeElem);\n // Only return the targeted node in case the targeted cst node is the name node or part of it\n if (nameNode && (nameNode === sourceCstNode || isChildNode(sourceCstNode, nameNode))) {\n return nodeElem;\n }\n }\n }\n return undefined;\n }\n findDeclarationNode(sourceCstNode) {\n const astNode = this.findDeclaration(sourceCstNode);\n if (astNode === null || astNode === void 0 ? void 0 : astNode.$cstNode) {\n const targetNode = this.nameProvider.getNameNode(astNode);\n return targetNode !== null && targetNode !== void 0 ? targetNode : astNode.$cstNode;\n }\n return undefined;\n }\n findReferences(targetNode, options) {\n const refs = [];\n if (options.includeDeclaration) {\n const ref = this.getReferenceToSelf(targetNode);\n if (ref) {\n refs.push(ref);\n }\n }\n let indexReferences = this.index.findAllReferences(targetNode, this.nodeLocator.getAstNodePath(targetNode));\n if (options.documentUri) {\n indexReferences = indexReferences.filter(ref => UriUtils.equals(ref.sourceUri, options.documentUri));\n }\n refs.push(...indexReferences);\n return stream(refs);\n }\n getReferenceToSelf(targetNode) {\n const nameNode = this.nameProvider.getNameNode(targetNode);\n if (nameNode) {\n const doc = getDocument(targetNode);\n const path = this.nodeLocator.getAstNodePath(targetNode);\n return {\n sourceUri: doc.uri,\n sourcePath: path,\n targetUri: doc.uri,\n targetPath: path,\n segment: toDocumentSegment(nameNode),\n local: true\n };\n }\n return undefined;\n }\n}\n//# sourceMappingURL=references.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Reduction, stream } from './stream.js';\n/**\n * A multimap is a variation of a Map that has potentially multiple values for every key.\n */\nexport class MultiMap {\n constructor(elements) {\n this.map = new Map();\n if (elements) {\n for (const [key, value] of elements) {\n this.add(key, value);\n }\n }\n }\n /**\n * The total number of values in the multimap.\n */\n get size() {\n return Reduction.sum(stream(this.map.values()).map(a => a.length));\n }\n /**\n * Clear all entries in the multimap.\n */\n clear() {\n this.map.clear();\n }\n /**\n * Operates differently depending on whether a `value` is given:\n * * With a value, this method deletes the specific key / value pair from the multimap.\n * * Without a value, all values associated with the given key are deleted.\n *\n * @returns `true` if a value existed and has been removed, or `false` if the specified\n * key / value does not exist.\n */\n delete(key, value) {\n if (value === undefined) {\n return this.map.delete(key);\n }\n else {\n const values = this.map.get(key);\n if (values) {\n const index = values.indexOf(value);\n if (index >= 0) {\n if (values.length === 1) {\n this.map.delete(key);\n }\n else {\n values.splice(index, 1);\n }\n return true;\n }\n }\n return false;\n }\n }\n /**\n * Returns an array of all values associated with the given key. If no value exists,\n * an empty array is returned.\n *\n * _Note:_ The returned array is assumed not to be modified. Use the `set` method to add a\n * value and `delete` to remove a value from the multimap.\n */\n get(key) {\n var _a;\n return (_a = this.map.get(key)) !== null && _a !== void 0 ? _a : [];\n }\n /**\n * Operates differently depending on whether a `value` is given:\n * * With a value, this method returns `true` if the specific key / value pair is present in the multimap.\n * * Without a value, this method returns `true` if the given key is present in the multimap.\n */\n has(key, value) {\n if (value === undefined) {\n return this.map.has(key);\n }\n else {\n const values = this.map.get(key);\n if (values) {\n return values.indexOf(value) >= 0;\n }\n return false;\n }\n }\n /**\n * Add the given key / value pair to the multimap.\n */\n add(key, value) {\n if (this.map.has(key)) {\n this.map.get(key).push(value);\n }\n else {\n this.map.set(key, [value]);\n }\n return this;\n }\n /**\n * Add the given set of key / value pairs to the multimap.\n */\n addAll(key, values) {\n if (this.map.has(key)) {\n this.map.get(key).push(...values);\n }\n else {\n this.map.set(key, Array.from(values));\n }\n return this;\n }\n /**\n * Invokes the given callback function for every key / value pair in the multimap.\n */\n forEach(callbackfn) {\n this.map.forEach((array, key) => array.forEach(value => callbackfn(value, key, this)));\n }\n /**\n * Returns an iterator of key, value pairs for every entry in the map.\n */\n [Symbol.iterator]() {\n return this.entries().iterator();\n }\n /**\n * Returns a stream of key, value pairs for every entry in the map.\n */\n entries() {\n return stream(this.map.entries())\n .flatMap(([key, array]) => array.map(value => [key, value]));\n }\n /**\n * Returns a stream of keys in the map.\n */\n keys() {\n return stream(this.map.keys());\n }\n /**\n * Returns a stream of values in the map.\n */\n values() {\n return stream(this.map.values()).flat();\n }\n /**\n * Returns a stream of key, value set pairs for every key in the map.\n */\n entriesGroupedByKey() {\n return stream(this.map.entries());\n }\n}\nexport class BiMap {\n get size() {\n return this.map.size;\n }\n constructor(elements) {\n this.map = new Map();\n this.inverse = new Map();\n if (elements) {\n for (const [key, value] of elements) {\n this.set(key, value);\n }\n }\n }\n clear() {\n this.map.clear();\n this.inverse.clear();\n }\n set(key, value) {\n this.map.set(key, value);\n this.inverse.set(value, key);\n return this;\n }\n get(key) {\n return this.map.get(key);\n }\n getKey(value) {\n return this.inverse.get(value);\n }\n delete(key) {\n const value = this.map.get(key);\n if (value !== undefined) {\n this.map.delete(key);\n this.inverse.delete(value);\n return true;\n }\n return false;\n }\n}\n//# sourceMappingURL=collections.js.map","/******************************************************************************\n * Copyright 2021-2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { streamAllContents, streamContents } from '../utils/ast-utils.js';\nimport { MultiMap } from '../utils/collections.js';\nimport { interruptAndCheck } from '../utils/promise-utils.js';\n/**\n * The default scope computation creates and collectes descriptions of the AST nodes to be exported into the\n * _global_ scope from the given document. By default those are the document's root AST node and its directly\n * contained child nodes.\n *\n * Besides, it gathers all AST nodes that have a name (according to the `NameProvider` service) and includes them\n * in the local scope of their particular container nodes. As a result, for every cross-reference in the AST,\n * target elements from the same level (siblings) and further up towards the root (parents and siblings of parents)\n * are visible. Elements being nested inside lower levels (children, children of siblings and parents' siblings)\n * are _invisible_ by default, but that can be changed by customizing this service.\n */\nexport class DefaultScopeComputation {\n constructor(services) {\n this.nameProvider = services.references.NameProvider;\n this.descriptions = services.workspace.AstNodeDescriptionProvider;\n }\n async computeExports(document, cancelToken = CancellationToken.None) {\n return this.computeExportsForNode(document.parseResult.value, document, undefined, cancelToken);\n }\n /**\n * Creates {@link AstNodeDescription AstNodeDescriptions} for the given {@link AstNode parentNode} and its children.\n * The list of children to be considered is determined by the function parameter {@link children}.\n * By default only the direct children of {@link parentNode} are visited, nested nodes are not exported.\n *\n * @param parentNode AST node to be exported, i.e., of which an {@link AstNodeDescription} shall be added to the returned list.\n * @param document The document containing the AST node to be exported.\n * @param children A function called with {@link parentNode} as single argument and returning an {@link Iterable} supplying the children to be visited, which must be directly or transitively contained in {@link parentNode}.\n * @param cancelToken Indicates when to cancel the current operation.\n * @throws `OperationCancelled` if a user action occurs during execution.\n * @returns A list of {@link AstNodeDescription AstNodeDescriptions} to be published to index.\n */\n async computeExportsForNode(parentNode, document, children = streamContents, cancelToken = CancellationToken.None) {\n const exports = [];\n this.exportNode(parentNode, exports, document);\n for (const node of children(parentNode)) {\n await interruptAndCheck(cancelToken);\n this.exportNode(node, exports, document);\n }\n return exports;\n }\n /**\n * Add a single node to the list of exports if it has a name. Override this method to change how\n * symbols are exported, e.g. by modifying their exported name.\n */\n exportNode(node, exports, document) {\n const name = this.nameProvider.getName(node);\n if (name) {\n exports.push(this.descriptions.createDescription(node, name, document));\n }\n }\n async computeLocalScopes(document, cancelToken = CancellationToken.None) {\n const rootNode = document.parseResult.value;\n const scopes = new MultiMap();\n // Here we navigate the full AST - local scopes shall be available in the whole document\n for (const node of streamAllContents(rootNode)) {\n await interruptAndCheck(cancelToken);\n this.processNode(node, document, scopes);\n }\n return scopes;\n }\n /**\n * Process a single node during scopes computation. The default implementation makes the node visible\n * in the subtree of its container (if the node has a name). Override this method to change this,\n * e.g. by increasing the visibility to a higher level in the AST.\n */\n processNode(node, document, scopes) {\n const container = node.$container;\n if (container) {\n const name = this.nameProvider.getName(node);\n if (name) {\n scopes.add(container, this.descriptions.createDescription(node, name, document));\n }\n }\n }\n}\n//# sourceMappingURL=scope-computation.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { EMPTY_STREAM, stream } from '../utils/stream.js';\n/**\n * The default scope implementation is based on a `Stream`. It has an optional _outer scope_ describing\n * the next level of elements, which are queried when a target element is not found in the stream provided\n * to this scope.\n */\nexport class StreamScope {\n constructor(elements, outerScope, options) {\n var _a;\n this.elements = elements;\n this.outerScope = outerScope;\n this.caseInsensitive = (_a = options === null || options === void 0 ? void 0 : options.caseInsensitive) !== null && _a !== void 0 ? _a : false;\n }\n getAllElements() {\n if (this.outerScope) {\n return this.elements.concat(this.outerScope.getAllElements());\n }\n else {\n return this.elements;\n }\n }\n getElement(name) {\n const local = this.caseInsensitive\n ? this.elements.find(e => e.name.toLowerCase() === name.toLowerCase())\n : this.elements.find(e => e.name === name);\n if (local) {\n return local;\n }\n if (this.outerScope) {\n return this.outerScope.getElement(name);\n }\n return undefined;\n }\n}\nexport class MapScope {\n constructor(elements, outerScope, options) {\n var _a;\n this.elements = new Map();\n this.caseInsensitive = (_a = options === null || options === void 0 ? void 0 : options.caseInsensitive) !== null && _a !== void 0 ? _a : false;\n for (const element of elements) {\n const name = this.caseInsensitive\n ? element.name.toLowerCase()\n : element.name;\n this.elements.set(name, element);\n }\n this.outerScope = outerScope;\n }\n getElement(name) {\n const localName = this.caseInsensitive ? name.toLowerCase() : name;\n const local = this.elements.get(localName);\n if (local) {\n return local;\n }\n if (this.outerScope) {\n return this.outerScope.getElement(name);\n }\n return undefined;\n }\n getAllElements() {\n let elementStream = stream(this.elements.values());\n if (this.outerScope) {\n elementStream = elementStream.concat(this.outerScope.getAllElements());\n }\n return elementStream;\n }\n}\nexport const EMPTY_SCOPE = {\n getElement() {\n return undefined;\n },\n getAllElements() {\n return EMPTY_STREAM;\n }\n};\n//# sourceMappingURL=scope.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport class DisposableCache {\n constructor() {\n this.toDispose = [];\n this.isDisposed = false;\n }\n onDispose(disposable) {\n this.toDispose.push(disposable);\n }\n dispose() {\n this.throwIfDisposed();\n this.clear();\n this.isDisposed = true;\n this.toDispose.forEach(disposable => disposable.dispose());\n }\n throwIfDisposed() {\n if (this.isDisposed) {\n throw new Error('This cache has already been disposed');\n }\n }\n}\nexport class SimpleCache extends DisposableCache {\n constructor() {\n super(...arguments);\n this.cache = new Map();\n }\n has(key) {\n this.throwIfDisposed();\n return this.cache.has(key);\n }\n set(key, value) {\n this.throwIfDisposed();\n this.cache.set(key, value);\n }\n get(key, provider) {\n this.throwIfDisposed();\n if (this.cache.has(key)) {\n return this.cache.get(key);\n }\n else if (provider) {\n const value = provider();\n this.cache.set(key, value);\n return value;\n }\n else {\n return undefined;\n }\n }\n delete(key) {\n this.throwIfDisposed();\n return this.cache.delete(key);\n }\n clear() {\n this.throwIfDisposed();\n this.cache.clear();\n }\n}\nexport class ContextCache extends DisposableCache {\n constructor(converter) {\n super();\n this.cache = new Map();\n this.converter = converter !== null && converter !== void 0 ? converter : (value => value);\n }\n has(contextKey, key) {\n this.throwIfDisposed();\n return this.cacheForContext(contextKey).has(key);\n }\n set(contextKey, key, value) {\n this.throwIfDisposed();\n this.cacheForContext(contextKey).set(key, value);\n }\n get(contextKey, key, provider) {\n this.throwIfDisposed();\n const contextCache = this.cacheForContext(contextKey);\n if (contextCache.has(key)) {\n return contextCache.get(key);\n }\n else if (provider) {\n const value = provider();\n contextCache.set(key, value);\n return value;\n }\n else {\n return undefined;\n }\n }\n delete(contextKey, key) {\n this.throwIfDisposed();\n return this.cacheForContext(contextKey).delete(key);\n }\n clear(contextKey) {\n this.throwIfDisposed();\n if (contextKey) {\n const mapKey = this.converter(contextKey);\n this.cache.delete(mapKey);\n }\n else {\n this.cache.clear();\n }\n }\n cacheForContext(contextKey) {\n const mapKey = this.converter(contextKey);\n let documentCache = this.cache.get(mapKey);\n if (!documentCache) {\n documentCache = new Map();\n this.cache.set(mapKey, documentCache);\n }\n return documentCache;\n }\n}\n/**\n * Every key/value pair in this cache is scoped to a document.\n * If this document is changed or deleted, all associated key/value pairs are deleted.\n */\nexport class DocumentCache extends ContextCache {\n /**\n * Creates a new document cache.\n *\n * @param sharedServices Service container instance to hook into document lifecycle events.\n * @param state Optional document state on which the cache should evict.\n * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.\n * *Deleted* documents are considered in both cases.\n *\n * Providing a state here will use `DocumentBuilder#onDocumentPhase` instead,\n * which triggers on all documents that have been affected by this change, assuming that the\n * state is `DocumentState.Linked` or a later state.\n */\n constructor(sharedServices, state) {\n super(uri => uri.toString());\n if (state) {\n this.toDispose.push(sharedServices.workspace.DocumentBuilder.onDocumentPhase(state, document => {\n this.clear(document.uri.toString());\n }));\n this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {\n for (const uri of deleted) { // react only on deleted documents\n this.clear(uri);\n }\n }));\n }\n else {\n this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((changed, deleted) => {\n const allUris = changed.concat(deleted); // react on both changed and deleted documents\n for (const uri of allUris) {\n this.clear(uri);\n }\n }));\n }\n }\n}\n/**\n * Every key/value pair in this cache is scoped to the whole workspace.\n * If any document in the workspace is added, changed or deleted, the whole cache is evicted.\n */\nexport class WorkspaceCache extends SimpleCache {\n /**\n * Creates a new workspace cache.\n *\n * @param sharedServices Service container instance to hook into document lifecycle events.\n * @param state Optional document state on which the cache should evict.\n * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.\n * *Deleted* documents are considered in both cases.\n */\n constructor(sharedServices, state) {\n super();\n if (state) {\n this.toDispose.push(sharedServices.workspace.DocumentBuilder.onBuildPhase(state, () => {\n this.clear();\n }));\n this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {\n if (deleted.length > 0) { // react only on deleted documents\n this.clear();\n }\n }));\n }\n else {\n this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate(() => {\n this.clear();\n }));\n }\n }\n}\n//# sourceMappingURL=caching.js.map","/******************************************************************************\n * Copyright 2021-2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { MapScope, StreamScope } from './scope.js';\nimport { getDocument } from '../utils/ast-utils.js';\nimport { stream } from '../utils/stream.js';\nimport { WorkspaceCache } from '../utils/caching.js';\nexport class DefaultScopeProvider {\n constructor(services) {\n this.reflection = services.shared.AstReflection;\n this.nameProvider = services.references.NameProvider;\n this.descriptions = services.workspace.AstNodeDescriptionProvider;\n this.indexManager = services.shared.workspace.IndexManager;\n this.globalScopeCache = new WorkspaceCache(services.shared);\n }\n getScope(context) {\n const scopes = [];\n const referenceType = this.reflection.getReferenceType(context);\n const precomputed = getDocument(context.container).precomputedScopes;\n if (precomputed) {\n let currentNode = context.container;\n do {\n const allDescriptions = precomputed.get(currentNode);\n if (allDescriptions.length > 0) {\n scopes.push(stream(allDescriptions).filter(desc => this.reflection.isSubtype(desc.type, referenceType)));\n }\n currentNode = currentNode.$container;\n } while (currentNode);\n }\n let result = this.getGlobalScope(referenceType, context);\n for (let i = scopes.length - 1; i >= 0; i--) {\n result = this.createScope(scopes[i], result);\n }\n return result;\n }\n /**\n * Create a scope for the given collection of AST node descriptions.\n */\n createScope(elements, outerScope, options) {\n return new StreamScope(stream(elements), outerScope, options);\n }\n /**\n * Create a scope for the given collection of AST nodes, which need to be transformed into respective\n * descriptions first. This is done using the `NameProvider` and `AstNodeDescriptionProvider` services.\n */\n createScopeForNodes(elements, outerScope, options) {\n const s = stream(elements).map(e => {\n const name = this.nameProvider.getName(e);\n if (name) {\n return this.descriptions.createDescription(e, name);\n }\n return undefined;\n }).nonNullable();\n return new StreamScope(s, outerScope, options);\n }\n /**\n * Create a global scope filtered for the given reference type.\n */\n getGlobalScope(referenceType, _context) {\n return this.globalScopeCache.get(referenceType, () => new MapScope(this.indexManager.allElements(referenceType)));\n }\n}\n//# sourceMappingURL=scope-provider.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { URI } from 'vscode-uri';\nimport { isAstNode, isReference } from '../syntax-tree.js';\nimport { getDocument } from '../utils/ast-utils.js';\nimport { findNodesForProperty } from '../utils/grammar-utils.js';\nexport function isAstNodeWithComment(node) {\n return typeof node.$comment === 'string';\n}\nfunction isIntermediateReference(obj) {\n return typeof obj === 'object' && !!obj && ('$ref' in obj || '$error' in obj);\n}\nexport class DefaultJsonSerializer {\n constructor(services) {\n /** The set of AstNode properties to be ignored by the serializer. */\n this.ignoreProperties = new Set(['$container', '$containerProperty', '$containerIndex', '$document', '$cstNode']);\n this.langiumDocuments = services.shared.workspace.LangiumDocuments;\n this.astNodeLocator = services.workspace.AstNodeLocator;\n this.nameProvider = services.references.NameProvider;\n this.commentProvider = services.documentation.CommentProvider;\n }\n serialize(node, options) {\n const serializeOptions = options !== null && options !== void 0 ? options : {};\n const specificReplacer = options === null || options === void 0 ? void 0 : options.replacer;\n const defaultReplacer = (key, value) => this.replacer(key, value, serializeOptions);\n const replacer = specificReplacer ? (key, value) => specificReplacer(key, value, defaultReplacer) : defaultReplacer;\n try {\n this.currentDocument = getDocument(node);\n return JSON.stringify(node, replacer, options === null || options === void 0 ? void 0 : options.space);\n }\n finally {\n this.currentDocument = undefined;\n }\n }\n deserialize(content, options) {\n const deserializeOptions = options !== null && options !== void 0 ? options : {};\n const root = JSON.parse(content);\n this.linkNode(root, root, deserializeOptions);\n return root;\n }\n replacer(key, value, { refText, sourceText, textRegions, comments, uriConverter }) {\n var _a, _b, _c, _d;\n if (this.ignoreProperties.has(key)) {\n return undefined;\n }\n else if (isReference(value)) {\n const refValue = value.ref;\n const $refText = refText ? value.$refText : undefined;\n if (refValue) {\n const targetDocument = getDocument(refValue);\n let targetUri = '';\n if (this.currentDocument && this.currentDocument !== targetDocument) {\n if (uriConverter) {\n targetUri = uriConverter(targetDocument.uri, value);\n }\n else {\n targetUri = targetDocument.uri.toString();\n }\n }\n const targetPath = this.astNodeLocator.getAstNodePath(refValue);\n return {\n $ref: `${targetUri}#${targetPath}`,\n $refText\n };\n }\n else {\n return {\n $error: (_b = (_a = value.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : 'Could not resolve reference',\n $refText\n };\n }\n }\n else if (isAstNode(value)) {\n let astNode = undefined;\n if (textRegions) {\n astNode = this.addAstNodeRegionWithAssignmentsTo(Object.assign({}, value));\n if ((!key || value.$document) && (astNode === null || astNode === void 0 ? void 0 : astNode.$textRegion)) {\n // The document URI is added to the root node of the resulting JSON tree\n astNode.$textRegion.documentURI = (_c = this.currentDocument) === null || _c === void 0 ? void 0 : _c.uri.toString();\n }\n }\n if (sourceText && !key) {\n astNode !== null && astNode !== void 0 ? astNode : (astNode = Object.assign({}, value));\n astNode.$sourceText = (_d = value.$cstNode) === null || _d === void 0 ? void 0 : _d.text;\n }\n if (comments) {\n astNode !== null && astNode !== void 0 ? astNode : (astNode = Object.assign({}, value));\n const comment = this.commentProvider.getComment(value);\n if (comment) {\n astNode.$comment = comment.replace(/\\r/g, '');\n }\n }\n return astNode !== null && astNode !== void 0 ? astNode : value;\n }\n else {\n return value;\n }\n }\n addAstNodeRegionWithAssignmentsTo(node) {\n const createDocumentSegment = cstNode => ({\n offset: cstNode.offset,\n end: cstNode.end,\n length: cstNode.length,\n range: cstNode.range,\n });\n if (node.$cstNode) {\n const textRegion = node.$textRegion = createDocumentSegment(node.$cstNode);\n const assignments = textRegion.assignments = {};\n Object.keys(node).filter(key => !key.startsWith('$')).forEach(key => {\n const propertyAssignments = findNodesForProperty(node.$cstNode, key).map(createDocumentSegment);\n if (propertyAssignments.length !== 0) {\n assignments[key] = propertyAssignments;\n }\n });\n return node;\n }\n return undefined;\n }\n linkNode(node, root, options, container, containerProperty, containerIndex) {\n for (const [propertyName, item] of Object.entries(node)) {\n if (Array.isArray(item)) {\n for (let index = 0; index < item.length; index++) {\n const element = item[index];\n if (isIntermediateReference(element)) {\n item[index] = this.reviveReference(node, propertyName, root, element, options);\n }\n else if (isAstNode(element)) {\n this.linkNode(element, root, options, node, propertyName, index);\n }\n }\n }\n else if (isIntermediateReference(item)) {\n node[propertyName] = this.reviveReference(node, propertyName, root, item, options);\n }\n else if (isAstNode(item)) {\n this.linkNode(item, root, options, node, propertyName);\n }\n }\n const mutable = node;\n mutable.$container = container;\n mutable.$containerProperty = containerProperty;\n mutable.$containerIndex = containerIndex;\n }\n reviveReference(container, property, root, reference, options) {\n let refText = reference.$refText;\n let error = reference.$error;\n if (reference.$ref) {\n const ref = this.getRefNode(root, reference.$ref, options.uriConverter);\n if (isAstNode(ref)) {\n if (!refText) {\n refText = this.nameProvider.getName(ref);\n }\n return {\n $refText: refText !== null && refText !== void 0 ? refText : '',\n ref\n };\n }\n else {\n error = ref;\n }\n }\n if (error) {\n const ref = {\n $refText: refText !== null && refText !== void 0 ? refText : ''\n };\n ref.error = {\n container,\n property,\n message: error,\n reference: ref\n };\n return ref;\n }\n else {\n return undefined;\n }\n }\n getRefNode(root, uri, uriConverter) {\n try {\n const fragmentIndex = uri.indexOf('#');\n if (fragmentIndex === 0) {\n const node = this.astNodeLocator.getAstNode(root, uri.substring(1));\n if (!node) {\n return 'Could not resolve path: ' + uri;\n }\n return node;\n }\n if (fragmentIndex < 0) {\n const documentUri = uriConverter ? uriConverter(uri) : URI.parse(uri);\n const document = this.langiumDocuments.getDocument(documentUri);\n if (!document) {\n return 'Could not find document for URI: ' + uri;\n }\n return document.parseResult.value;\n }\n const documentUri = uriConverter ? uriConverter(uri.substring(0, fragmentIndex)) : URI.parse(uri.substring(0, fragmentIndex));\n const document = this.langiumDocuments.getDocument(documentUri);\n if (!document) {\n return 'Could not find document for URI: ' + uri;\n }\n if (fragmentIndex === uri.length - 1) {\n return document.parseResult.value;\n }\n const node = this.astNodeLocator.getAstNode(document.parseResult.value, uri.substring(fragmentIndex + 1));\n if (!node) {\n return 'Could not resolve URI: ' + uri;\n }\n return node;\n }\n catch (err) {\n return String(err);\n }\n }\n}\n//# sourceMappingURL=json-serializer.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { UriUtils } from './utils/uri-utils.js';\n/**\n * Generic registry for Langium services, but capable of being used with extending service sets as well (such as the lsp-complete LangiumCoreServices set)\n */\nexport class DefaultServiceRegistry {\n /**\n * @deprecated Use the new `fileExtensionMap` (or `languageIdMap`) property instead.\n */\n get map() {\n return this.fileExtensionMap;\n }\n constructor(services) {\n this.languageIdMap = new Map();\n this.fileExtensionMap = new Map();\n this.textDocuments = services === null || services === void 0 ? void 0 : services.workspace.TextDocuments;\n }\n register(language) {\n const data = language.LanguageMetaData;\n for (const ext of data.fileExtensions) {\n if (this.fileExtensionMap.has(ext)) {\n console.warn(`The file extension ${ext} is used by multiple languages. It is now assigned to '${data.languageId}'.`);\n }\n this.fileExtensionMap.set(ext, language);\n }\n this.languageIdMap.set(data.languageId, language);\n if (this.languageIdMap.size === 1) {\n this.singleton = language;\n }\n else {\n this.singleton = undefined;\n }\n }\n getServices(uri) {\n var _a, _b;\n if (this.singleton !== undefined) {\n return this.singleton;\n }\n if (this.languageIdMap.size === 0) {\n throw new Error('The service registry is empty. Use `register` to register the services of a language.');\n }\n const languageId = (_b = (_a = this.textDocuments) === null || _a === void 0 ? void 0 : _a.get(uri)) === null || _b === void 0 ? void 0 : _b.languageId;\n if (languageId !== undefined) {\n const services = this.languageIdMap.get(languageId);\n if (services) {\n return services;\n }\n }\n const ext = UriUtils.extname(uri);\n const services = this.fileExtensionMap.get(ext);\n if (!services) {\n if (languageId) {\n throw new Error(`The service registry contains no services for the extension '${ext}' for language '${languageId}'.`);\n }\n else {\n throw new Error(`The service registry contains no services for the extension '${ext}'.`);\n }\n }\n return services;\n }\n hasServices(uri) {\n try {\n this.getServices(uri);\n return true;\n }\n catch (_a) {\n return false;\n }\n }\n get all() {\n return Array.from(this.languageIdMap.values());\n }\n}\n//# sourceMappingURL=service-registry.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { assertUnreachable } from '../index.js';\nimport { MultiMap } from '../utils/collections.js';\nimport { isOperationCancelled } from '../utils/promise-utils.js';\nimport { stream } from '../utils/stream.js';\n/**\n * Create DiagnosticData for a given diagnostic code. The result can be put into the `data` field of a DiagnosticInfo.\n */\nexport function diagnosticData(code) {\n return { code };\n}\nexport var ValidationCategory;\n(function (ValidationCategory) {\n ValidationCategory.all = ['fast', 'slow', 'built-in'];\n})(ValidationCategory || (ValidationCategory = {}));\n/**\n * Manages a set of `ValidationCheck`s to be applied when documents are validated.\n */\nexport class ValidationRegistry {\n constructor(services) {\n this.entries = new MultiMap();\n this.entriesBefore = [];\n this.entriesAfter = [];\n this.reflection = services.shared.AstReflection;\n }\n /**\n * Register a set of validation checks. Each value in the record can be either a single validation check (i.e. a function)\n * or an array of validation checks.\n *\n * @param checksRecord Set of validation checks to register.\n * @param category Optional category for the validation checks (defaults to `'fast'`).\n * @param thisObj Optional object to be used as `this` when calling the validation check functions.\n */\n register(checksRecord, thisObj = this, category = 'fast') {\n if (category === 'built-in') {\n throw new Error(\"The 'built-in' category is reserved for lexer, parser, and linker errors.\");\n }\n for (const [type, ch] of Object.entries(checksRecord)) {\n const callbacks = ch;\n if (Array.isArray(callbacks)) {\n for (const check of callbacks) {\n const entry = {\n check: this.wrapValidationException(check, thisObj),\n category\n };\n this.addEntry(type, entry);\n }\n }\n else if (typeof callbacks === 'function') {\n const entry = {\n check: this.wrapValidationException(callbacks, thisObj),\n category\n };\n this.addEntry(type, entry);\n }\n else {\n assertUnreachable(callbacks);\n }\n }\n }\n wrapValidationException(check, thisObj) {\n return async (node, accept, cancelToken) => {\n await this.handleException(() => check.call(thisObj, node, accept, cancelToken), 'An error occurred during validation', accept, node);\n };\n }\n async handleException(functionality, messageContext, accept, node) {\n try {\n await functionality();\n }\n catch (err) {\n if (isOperationCancelled(err)) {\n throw err;\n }\n console.error(`${messageContext}:`, err);\n if (err instanceof Error && err.stack) {\n console.error(err.stack);\n }\n const messageDetails = err instanceof Error ? err.message : String(err);\n accept('error', `${messageContext}: ${messageDetails}`, { node });\n }\n }\n addEntry(type, entry) {\n if (type === 'AstNode') {\n this.entries.add('AstNode', entry);\n return;\n }\n for (const subtype of this.reflection.getAllSubTypes(type)) {\n this.entries.add(subtype, entry);\n }\n }\n getChecks(type, categories) {\n let checks = stream(this.entries.get(type))\n .concat(this.entries.get('AstNode'));\n if (categories) {\n checks = checks.filter(entry => categories.includes(entry.category));\n }\n return checks.map(entry => entry.check);\n }\n /**\n * Register logic which will be executed once before validating all the nodes of an AST/Langium document.\n * This helps to prepare or initialize some information which are required or reusable for the following checks on the AstNodes.\n *\n * As an example, for validating unique fully-qualified names of nodes in the AST,\n * here the map for mapping names to nodes could be established.\n * During the usual checks on the nodes, they are put into this map with their name.\n *\n * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.\n * Therefore it is recommended to clear stored information\n * _before_ validating an AST to validate each AST unaffected from other ASTs\n * AND _after_ validating the AST to free memory by information which are no longer used.\n *\n * @param checkBefore a set-up function which will be called once before actually validating an AST\n * @param thisObj Optional object to be used as `this` when calling the validation check functions.\n */\n registerBeforeDocument(checkBefore, thisObj = this) {\n this.entriesBefore.push(this.wrapPreparationException(checkBefore, 'An error occurred during set-up of the validation', thisObj));\n }\n /**\n * Register logic which will be executed once after validating all the nodes of an AST/Langium document.\n * This helps to finally evaluate information which are collected during the checks on the AstNodes.\n *\n * As an example, for validating unique fully-qualified names of nodes in the AST,\n * here the map with all the collected nodes and their names is checked\n * and validation hints are created for all nodes with the same name.\n *\n * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.\n * Therefore it is recommended to clear stored information\n * _before_ validating an AST to validate each AST unaffected from other ASTs\n * AND _after_ validating the AST to free memory by information which are no longer used.\n *\n * @param checkBefore a set-up function which will be called once before actually validating an AST\n * @param thisObj Optional object to be used as `this` when calling the validation check functions.\n */\n registerAfterDocument(checkAfter, thisObj = this) {\n this.entriesAfter.push(this.wrapPreparationException(checkAfter, 'An error occurred during tear-down of the validation', thisObj));\n }\n wrapPreparationException(check, messageContext, thisObj) {\n return async (rootNode, accept, categories, cancelToken) => {\n await this.handleException(() => check.call(thisObj, rootNode, accept, categories, cancelToken), messageContext, accept, rootNode);\n };\n }\n get checksBefore() {\n return this.entriesBefore;\n }\n get checksAfter() {\n return this.entriesAfter;\n }\n}\n//# sourceMappingURL=validation-registry.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { findNodeForKeyword, findNodeForProperty } from '../utils/grammar-utils.js';\nimport { streamAst } from '../utils/ast-utils.js';\nimport { tokenToRange } from '../utils/cst-utils.js';\nimport { interruptAndCheck, isOperationCancelled } from '../utils/promise-utils.js';\nimport { diagnosticData } from './validation-registry.js';\nexport class DefaultDocumentValidator {\n constructor(services) {\n this.validationRegistry = services.validation.ValidationRegistry;\n this.metadata = services.LanguageMetaData;\n }\n async validateDocument(document, options = {}, cancelToken = CancellationToken.None) {\n const parseResult = document.parseResult;\n const diagnostics = [];\n await interruptAndCheck(cancelToken);\n if (!options.categories || options.categories.includes('built-in')) {\n this.processLexingErrors(parseResult, diagnostics, options);\n if (options.stopAfterLexingErrors && diagnostics.some(d => { var _a; return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.LexingError; })) {\n return diagnostics;\n }\n this.processParsingErrors(parseResult, diagnostics, options);\n if (options.stopAfterParsingErrors && diagnostics.some(d => { var _a; return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.ParsingError; })) {\n return diagnostics;\n }\n this.processLinkingErrors(document, diagnostics, options);\n if (options.stopAfterLinkingErrors && diagnostics.some(d => { var _a; return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.LinkingError; })) {\n return diagnostics;\n }\n }\n // Process custom validations\n try {\n diagnostics.push(...await this.validateAst(parseResult.value, options, cancelToken));\n }\n catch (err) {\n if (isOperationCancelled(err)) {\n throw err;\n }\n console.error('An error occurred during validation:', err);\n }\n await interruptAndCheck(cancelToken);\n return diagnostics;\n }\n processLexingErrors(parseResult, diagnostics, _options) {\n var _a, _b, _c;\n const lexerDiagnostics = [...parseResult.lexerErrors, ...(_b = (_a = parseResult.lexerReport) === null || _a === void 0 ? void 0 : _a.diagnostics) !== null && _b !== void 0 ? _b : []];\n for (const lexerDiagnostic of lexerDiagnostics) {\n const severity = (_c = lexerDiagnostic.severity) !== null && _c !== void 0 ? _c : 'error';\n const diagnostic = {\n severity: toDiagnosticSeverity(severity),\n range: {\n start: {\n line: lexerDiagnostic.line - 1,\n character: lexerDiagnostic.column - 1\n },\n end: {\n line: lexerDiagnostic.line - 1,\n character: lexerDiagnostic.column + lexerDiagnostic.length - 1\n }\n },\n message: lexerDiagnostic.message,\n data: toDiagnosticData(severity),\n source: this.getSource()\n };\n diagnostics.push(diagnostic);\n }\n }\n processParsingErrors(parseResult, diagnostics, _options) {\n for (const parserError of parseResult.parserErrors) {\n let range = undefined;\n // We can run into the chevrotain error recovery here\n // The token contained in the parser error might be automatically inserted\n // In this case every position value will be `NaN`\n if (isNaN(parserError.token.startOffset)) {\n // Some special parser error types contain a `previousToken`\n // We can simply append our diagnostic to that token\n if ('previousToken' in parserError) {\n const token = parserError.previousToken;\n if (!isNaN(token.startOffset)) {\n const position = { line: token.endLine - 1, character: token.endColumn };\n range = { start: position, end: position };\n }\n else {\n // No valid prev token. Might be empty document or containing only hidden tokens.\n // Point to document start\n const position = { line: 0, character: 0 };\n range = { start: position, end: position };\n }\n }\n }\n else {\n range = tokenToRange(parserError.token);\n }\n if (range) {\n const diagnostic = {\n severity: toDiagnosticSeverity('error'),\n range,\n message: parserError.message,\n data: diagnosticData(DocumentValidator.ParsingError),\n source: this.getSource()\n };\n diagnostics.push(diagnostic);\n }\n }\n }\n processLinkingErrors(document, diagnostics, _options) {\n for (const reference of document.references) {\n const linkingError = reference.error;\n if (linkingError) {\n const info = {\n node: linkingError.container,\n property: linkingError.property,\n index: linkingError.index,\n data: {\n code: DocumentValidator.LinkingError,\n containerType: linkingError.container.$type,\n property: linkingError.property,\n refText: linkingError.reference.$refText\n }\n };\n diagnostics.push(this.toDiagnostic('error', linkingError.message, info));\n }\n }\n }\n async validateAst(rootNode, options, cancelToken = CancellationToken.None) {\n const validationItems = [];\n const acceptor = (severity, message, info) => {\n validationItems.push(this.toDiagnostic(severity, message, info));\n };\n await this.validateAstBefore(rootNode, options, acceptor, cancelToken);\n await this.validateAstNodes(rootNode, options, acceptor, cancelToken);\n await this.validateAstAfter(rootNode, options, acceptor, cancelToken);\n return validationItems;\n }\n async validateAstBefore(rootNode, options, acceptor, cancelToken = CancellationToken.None) {\n var _a;\n const checksBefore = this.validationRegistry.checksBefore;\n for (const checkBefore of checksBefore) {\n await interruptAndCheck(cancelToken);\n await checkBefore(rootNode, acceptor, (_a = options.categories) !== null && _a !== void 0 ? _a : [], cancelToken);\n }\n }\n async validateAstNodes(rootNode, options, acceptor, cancelToken = CancellationToken.None) {\n await Promise.all(streamAst(rootNode).map(async (node) => {\n await interruptAndCheck(cancelToken);\n const checks = this.validationRegistry.getChecks(node.$type, options.categories);\n for (const check of checks) {\n await check(node, acceptor, cancelToken);\n }\n }));\n }\n async validateAstAfter(rootNode, options, acceptor, cancelToken = CancellationToken.None) {\n var _a;\n const checksAfter = this.validationRegistry.checksAfter;\n for (const checkAfter of checksAfter) {\n await interruptAndCheck(cancelToken);\n await checkAfter(rootNode, acceptor, (_a = options.categories) !== null && _a !== void 0 ? _a : [], cancelToken);\n }\n }\n toDiagnostic(severity, message, info) {\n return {\n message,\n range: getDiagnosticRange(info),\n severity: toDiagnosticSeverity(severity),\n code: info.code,\n codeDescription: info.codeDescription,\n tags: info.tags,\n relatedInformation: info.relatedInformation,\n data: info.data,\n source: this.getSource()\n };\n }\n getSource() {\n return this.metadata.languageId;\n }\n}\nexport function getDiagnosticRange(info) {\n if (info.range) {\n return info.range;\n }\n let cstNode;\n if (typeof info.property === 'string') {\n cstNode = findNodeForProperty(info.node.$cstNode, info.property, info.index);\n }\n else if (typeof info.keyword === 'string') {\n cstNode = findNodeForKeyword(info.node.$cstNode, info.keyword, info.index);\n }\n cstNode !== null && cstNode !== void 0 ? cstNode : (cstNode = info.node.$cstNode);\n if (!cstNode) {\n return {\n start: { line: 0, character: 0 },\n end: { line: 0, character: 0 }\n };\n }\n return cstNode.range;\n}\n/**\n * Transforms the diagnostic severity from the {@link LexingDiagnosticSeverity} format to LSP's `DiagnosticSeverity` format.\n *\n * @param severity The lexing diagnostic severity\n * @returns Diagnostic severity according to `vscode-languageserver-types/lib/esm/main.js#DiagnosticSeverity`\n */\nexport function toDiagnosticSeverity(severity) {\n switch (severity) {\n case 'error':\n return 1;\n case 'warning':\n return 2;\n case 'info':\n return 3;\n case 'hint':\n return 4;\n default:\n throw new Error('Invalid diagnostic severity: ' + severity);\n }\n}\nexport function toDiagnosticData(severity) {\n switch (severity) {\n case 'error':\n return diagnosticData(DocumentValidator.LexingError);\n case 'warning':\n return diagnosticData(DocumentValidator.LexingWarning);\n case 'info':\n return diagnosticData(DocumentValidator.LexingInfo);\n case 'hint':\n return diagnosticData(DocumentValidator.LexingHint);\n default:\n throw new Error('Invalid diagnostic severity: ' + severity);\n }\n}\nexport var DocumentValidator;\n(function (DocumentValidator) {\n DocumentValidator.LexingError = 'lexing-error';\n DocumentValidator.LexingWarning = 'lexing-warning';\n DocumentValidator.LexingInfo = 'lexing-info';\n DocumentValidator.LexingHint = 'lexing-hint';\n DocumentValidator.ParsingError = 'parsing-error';\n DocumentValidator.LinkingError = 'linking-error';\n})(DocumentValidator || (DocumentValidator = {}));\n//# sourceMappingURL=document-validator.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { isLinkingError } from '../syntax-tree.js';\nimport { getDocument, streamAst, streamReferences } from '../utils/ast-utils.js';\nimport { toDocumentSegment } from '../utils/cst-utils.js';\nimport { interruptAndCheck } from '../utils/promise-utils.js';\nimport { UriUtils } from '../utils/uri-utils.js';\nexport class DefaultAstNodeDescriptionProvider {\n constructor(services) {\n this.astNodeLocator = services.workspace.AstNodeLocator;\n this.nameProvider = services.references.NameProvider;\n }\n createDescription(node, name, document) {\n const doc = document !== null && document !== void 0 ? document : getDocument(node);\n name !== null && name !== void 0 ? name : (name = this.nameProvider.getName(node));\n const path = this.astNodeLocator.getAstNodePath(node);\n if (!name) {\n throw new Error(`Node at path ${path} has no name.`);\n }\n let nameNodeSegment;\n const nameSegmentGetter = () => { var _a; return nameNodeSegment !== null && nameNodeSegment !== void 0 ? nameNodeSegment : (nameNodeSegment = toDocumentSegment((_a = this.nameProvider.getNameNode(node)) !== null && _a !== void 0 ? _a : node.$cstNode)); };\n return {\n node,\n name,\n get nameSegment() {\n return nameSegmentGetter();\n },\n selectionSegment: toDocumentSegment(node.$cstNode),\n type: node.$type,\n documentUri: doc.uri,\n path\n };\n }\n}\nexport class DefaultReferenceDescriptionProvider {\n constructor(services) {\n this.nodeLocator = services.workspace.AstNodeLocator;\n }\n async createDescriptions(document, cancelToken = CancellationToken.None) {\n const descr = [];\n const rootNode = document.parseResult.value;\n for (const astNode of streamAst(rootNode)) {\n await interruptAndCheck(cancelToken);\n streamReferences(astNode).filter(refInfo => !isLinkingError(refInfo)).forEach(refInfo => {\n // TODO: Consider logging a warning or throw an exception when DocumentState is < than Linked\n const description = this.createDescription(refInfo);\n if (description) {\n descr.push(description);\n }\n });\n }\n return descr;\n }\n createDescription(refInfo) {\n const targetNodeDescr = refInfo.reference.$nodeDescription;\n const refCstNode = refInfo.reference.$refNode;\n if (!targetNodeDescr || !refCstNode) {\n return undefined;\n }\n const docUri = getDocument(refInfo.container).uri;\n return {\n sourceUri: docUri,\n sourcePath: this.nodeLocator.getAstNodePath(refInfo.container),\n targetUri: targetNodeDescr.documentUri,\n targetPath: targetNodeDescr.path,\n segment: toDocumentSegment(refCstNode),\n local: UriUtils.equals(targetNodeDescr.documentUri, docUri)\n };\n }\n}\n//# sourceMappingURL=ast-descriptions.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport class DefaultAstNodeLocator {\n constructor() {\n this.segmentSeparator = '/';\n this.indexSeparator = '@';\n }\n getAstNodePath(node) {\n if (node.$container) {\n const containerPath = this.getAstNodePath(node.$container);\n const newSegment = this.getPathSegment(node);\n const nodePath = containerPath + this.segmentSeparator + newSegment;\n return nodePath;\n }\n return '';\n }\n getPathSegment({ $containerProperty, $containerIndex }) {\n if (!$containerProperty) {\n throw new Error(\"Missing '$containerProperty' in AST node.\");\n }\n if ($containerIndex !== undefined) {\n return $containerProperty + this.indexSeparator + $containerIndex;\n }\n return $containerProperty;\n }\n getAstNode(node, path) {\n const segments = path.split(this.segmentSeparator);\n return segments.reduce((previousValue, currentValue) => {\n if (!previousValue || currentValue.length === 0) {\n return previousValue;\n }\n const propertyIndex = currentValue.indexOf(this.indexSeparator);\n if (propertyIndex > 0) {\n const property = currentValue.substring(0, propertyIndex);\n const arrayIndex = parseInt(currentValue.substring(propertyIndex + 1));\n const array = previousValue[property];\n return array === null || array === void 0 ? void 0 : array[arrayIndex];\n }\n return previousValue[currentValue];\n }, node);\n }\n}\n//# sourceMappingURL=ast-node-locator.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Emitter } from '../utils/event.js';\nimport { Deferred } from '../utils/promise-utils.js';\n/**\n * Base configuration provider for building up other configuration providers\n */\nexport class DefaultConfigurationProvider {\n constructor(services) {\n this._ready = new Deferred();\n this.settings = {};\n this.workspaceConfig = false;\n this.onConfigurationSectionUpdateEmitter = new Emitter();\n this.serviceRegistry = services.ServiceRegistry;\n }\n get ready() {\n return this._ready.promise;\n }\n initialize(params) {\n var _a, _b;\n this.workspaceConfig = (_b = (_a = params.capabilities.workspace) === null || _a === void 0 ? void 0 : _a.configuration) !== null && _b !== void 0 ? _b : false;\n }\n async initialized(params) {\n if (this.workspaceConfig) {\n if (params.register) {\n // params.register(...) is a function to be provided by the calling language server for the sake of\n // decoupling this implementation from the concrete LSP implementations, specifically the LSP Connection\n const languages = this.serviceRegistry.all;\n params.register({\n // Listen to configuration changes for all languages\n section: languages.map(lang => this.toSectionName(lang.LanguageMetaData.languageId))\n });\n }\n if (params.fetchConfiguration) {\n // params.fetchConfiguration(...) is a function to be provided by the calling language server for the sake of\n // decoupling this implementation from the concrete LSP implementations, specifically the LSP Connection\n const configToUpdate = this.serviceRegistry.all.map(lang => ({\n // Fetch the configuration changes for all languages\n section: this.toSectionName(lang.LanguageMetaData.languageId)\n }));\n // get workspace configurations (default scope URI)\n const configs = await params.fetchConfiguration(configToUpdate);\n configToUpdate.forEach((conf, idx) => {\n this.updateSectionConfiguration(conf.section, configs[idx]);\n });\n }\n }\n this._ready.resolve();\n }\n /**\n * Updates the cached configurations using the `change` notification parameters.\n *\n * @param change The parameters of a change configuration notification.\n * `settings` property of the change object could be expressed as `Record<string, Record<string, any>>`\n */\n updateConfiguration(change) {\n if (!change.settings) {\n return;\n }\n Object.keys(change.settings).forEach(section => {\n const configuration = change.settings[section];\n this.updateSectionConfiguration(section, configuration);\n this.onConfigurationSectionUpdateEmitter.fire({ section, configuration });\n });\n }\n updateSectionConfiguration(section, configuration) {\n this.settings[section] = configuration;\n }\n /**\n * Returns a configuration value stored for the given language.\n *\n * @param language The language id\n * @param configuration Configuration name\n */\n async getConfiguration(language, configuration) {\n await this.ready;\n const sectionName = this.toSectionName(language);\n if (this.settings[sectionName]) {\n return this.settings[sectionName][configuration];\n }\n }\n toSectionName(languageId) {\n return `${languageId}`;\n }\n get onConfigurationSectionUpdate() {\n return this.onConfigurationSectionUpdateEmitter.event;\n }\n}\n//# sourceMappingURL=configuration.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport var Disposable;\n(function (Disposable) {\n function create(callback) {\n return {\n dispose: async () => await callback()\n };\n }\n Disposable.create = create;\n})(Disposable || (Disposable = {}));\n//# sourceMappingURL=disposable.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { Disposable } from '../utils/disposable.js';\nimport { MultiMap } from '../utils/collections.js';\nimport { OperationCancelled, interruptAndCheck, isOperationCancelled } from '../utils/promise-utils.js';\nimport { stream } from '../utils/stream.js';\nimport { ValidationCategory } from '../validation/validation-registry.js';\nimport { DocumentState } from './documents.js';\nexport class DefaultDocumentBuilder {\n constructor(services) {\n this.updateBuildOptions = {\n // Default: run only the built-in validation checks and those in the _fast_ category (includes those without category)\n validation: {\n categories: ['built-in', 'fast']\n }\n };\n this.updateListeners = [];\n this.buildPhaseListeners = new MultiMap();\n this.documentPhaseListeners = new MultiMap();\n this.buildState = new Map();\n this.documentBuildWaiters = new Map();\n this.currentState = DocumentState.Changed;\n this.langiumDocuments = services.workspace.LangiumDocuments;\n this.langiumDocumentFactory = services.workspace.LangiumDocumentFactory;\n this.textDocuments = services.workspace.TextDocuments;\n this.indexManager = services.workspace.IndexManager;\n this.serviceRegistry = services.ServiceRegistry;\n }\n async build(documents, options = {}, cancelToken = CancellationToken.None) {\n var _a, _b;\n for (const document of documents) {\n const key = document.uri.toString();\n if (document.state === DocumentState.Validated) {\n if (typeof options.validation === 'boolean' && options.validation) {\n // Force re-running all validation checks\n document.state = DocumentState.IndexedReferences;\n document.diagnostics = undefined;\n this.buildState.delete(key);\n }\n else if (typeof options.validation === 'object') {\n const buildState = this.buildState.get(key);\n const previousCategories = (_a = buildState === null || buildState === void 0 ? void 0 : buildState.result) === null || _a === void 0 ? void 0 : _a.validationChecks;\n if (previousCategories) {\n // Validation with explicit options was requested for a document that has already been partly validated.\n // In this case, we need to merge the previous validation categories with the new ones.\n const newCategories = (_b = options.validation.categories) !== null && _b !== void 0 ? _b : ValidationCategory.all;\n const categories = newCategories.filter(c => !previousCategories.includes(c));\n if (categories.length > 0) {\n this.buildState.set(key, {\n completed: false,\n options: {\n validation: Object.assign(Object.assign({}, options.validation), { categories })\n },\n result: buildState.result\n });\n document.state = DocumentState.IndexedReferences;\n }\n }\n }\n }\n else {\n // Default: forget any previous build options\n this.buildState.delete(key);\n }\n }\n this.currentState = DocumentState.Changed;\n await this.emitUpdate(documents.map(e => e.uri), []);\n await this.buildDocuments(documents, options, cancelToken);\n }\n async update(changed, deleted, cancelToken = CancellationToken.None) {\n this.currentState = DocumentState.Changed;\n // Remove all metadata of documents that are reported as deleted\n for (const deletedUri of deleted) {\n this.langiumDocuments.deleteDocument(deletedUri);\n this.buildState.delete(deletedUri.toString());\n this.indexManager.remove(deletedUri);\n }\n // Set the state of all changed documents to `Changed` so they are completely rebuilt\n for (const changedUri of changed) {\n const invalidated = this.langiumDocuments.invalidateDocument(changedUri);\n if (!invalidated) {\n // We create an unparsed, invalid document.\n // This will be parsed as soon as we reach the first document builder phase.\n // This allows to cancel the parsing process later in case we need it.\n const newDocument = this.langiumDocumentFactory.fromModel({ $type: 'INVALID' }, changedUri);\n newDocument.state = DocumentState.Changed;\n this.langiumDocuments.addDocument(newDocument);\n }\n this.buildState.delete(changedUri.toString());\n }\n // Set the state of all documents that should be relinked to `ComputedScopes` (if not already lower)\n const allChangedUris = stream(changed).concat(deleted).map(uri => uri.toString()).toSet();\n this.langiumDocuments.all\n .filter(doc => !allChangedUris.has(doc.uri.toString()) && this.shouldRelink(doc, allChangedUris))\n .forEach(doc => {\n const linker = this.serviceRegistry.getServices(doc.uri).references.Linker;\n linker.unlink(doc);\n doc.state = Math.min(doc.state, DocumentState.ComputedScopes);\n doc.diagnostics = undefined;\n });\n // Notify listeners of the update\n await this.emitUpdate(changed, deleted);\n // Only allow interrupting the execution after all state changes are done\n await interruptAndCheck(cancelToken);\n // Collect and sort all documents that we should rebuild\n const rebuildDocuments = this.sortDocuments(this.langiumDocuments.all\n .filter(doc => {\n var _a;\n // This includes those that were reported as changed and those that we selected for relinking\n return doc.state < DocumentState.Linked\n // This includes those for which a previous build has been cancelled\n || !((_a = this.buildState.get(doc.uri.toString())) === null || _a === void 0 ? void 0 : _a.completed);\n })\n .toArray());\n await this.buildDocuments(rebuildDocuments, this.updateBuildOptions, cancelToken);\n }\n async emitUpdate(changed, deleted) {\n await Promise.all(this.updateListeners.map(listener => listener(changed, deleted)));\n }\n /**\n * Sort the given documents by priority. By default, documents with an open text document are prioritized.\n * This is useful to ensure that visible documents show their diagnostics before all other documents.\n *\n * This improves the responsiveness in large workspaces as users usually don't care about diagnostics\n * in files that are currently not opened in the editor.\n */\n sortDocuments(documents) {\n let left = 0;\n let right = documents.length - 1;\n while (left < right) {\n while (left < documents.length && this.hasTextDocument(documents[left])) {\n left++;\n }\n while (right >= 0 && !this.hasTextDocument(documents[right])) {\n right--;\n }\n if (left < right) {\n [documents[left], documents[right]] = [documents[right], documents[left]];\n }\n }\n return documents;\n }\n hasTextDocument(doc) {\n var _a;\n return Boolean((_a = this.textDocuments) === null || _a === void 0 ? void 0 : _a.get(doc.uri));\n }\n /**\n * Check whether the given document should be relinked after changes were found in the given URIs.\n */\n shouldRelink(document, changedUris) {\n // Relink documents with linking errors -- maybe those references can be resolved now\n if (document.references.some(ref => ref.error !== undefined)) {\n return true;\n }\n // Check whether the document is affected by any of the changed URIs\n return this.indexManager.isAffected(document, changedUris);\n }\n onUpdate(callback) {\n this.updateListeners.push(callback);\n return Disposable.create(() => {\n const index = this.updateListeners.indexOf(callback);\n if (index >= 0) {\n this.updateListeners.splice(index, 1);\n }\n });\n }\n /**\n * Build the given documents by stepping through all build phases. If a document's state indicates\n * that a certain build phase is already done, the phase is skipped for that document.\n *\n * @param documents The documents to build.\n * @param options the {@link BuildOptions} to use.\n * @param cancelToken A cancellation token that can be used to cancel the build.\n * @returns A promise that resolves when the build is done.\n */\n async buildDocuments(documents, options, cancelToken) {\n this.prepareBuild(documents, options);\n // 0. Parse content\n await this.runCancelable(documents, DocumentState.Parsed, cancelToken, doc => this.langiumDocumentFactory.update(doc, cancelToken));\n // 1. Index content\n await this.runCancelable(documents, DocumentState.IndexedContent, cancelToken, doc => this.indexManager.updateContent(doc, cancelToken));\n // 2. Compute scopes\n await this.runCancelable(documents, DocumentState.ComputedScopes, cancelToken, async (doc) => {\n const scopeComputation = this.serviceRegistry.getServices(doc.uri).references.ScopeComputation;\n doc.precomputedScopes = await scopeComputation.computeLocalScopes(doc, cancelToken);\n });\n // 3. Linking\n await this.runCancelable(documents, DocumentState.Linked, cancelToken, doc => {\n const linker = this.serviceRegistry.getServices(doc.uri).references.Linker;\n return linker.link(doc, cancelToken);\n });\n // 4. Index references\n await this.runCancelable(documents, DocumentState.IndexedReferences, cancelToken, doc => this.indexManager.updateReferences(doc, cancelToken));\n // 5. Validation\n const toBeValidated = documents.filter(doc => this.shouldValidate(doc));\n await this.runCancelable(toBeValidated, DocumentState.Validated, cancelToken, doc => this.validate(doc, cancelToken));\n // If we've made it to this point without being cancelled, we can mark the build state as completed.\n for (const doc of documents) {\n const state = this.buildState.get(doc.uri.toString());\n if (state) {\n state.completed = true;\n }\n }\n }\n /**\n * Runs prior to beginning the build process to update the {@link DocumentBuildState} for each document\n *\n * @param documents collection of documents to be built\n * @param options the {@link BuildOptions} to use\n */\n prepareBuild(documents, options) {\n for (const doc of documents) {\n const key = doc.uri.toString();\n const state = this.buildState.get(key);\n // If the document has no previous build state, we set it. If it has one, but it's already marked\n // as completed, we overwrite it. If the previous build was not completed, we keep its state\n // and continue where it was cancelled.\n if (!state || state.completed) {\n this.buildState.set(key, {\n completed: false,\n options,\n result: state === null || state === void 0 ? void 0 : state.result\n });\n }\n }\n }\n /**\n * Runs a cancelable operation on a set of documents to bring them to a specified {@link DocumentState}.\n *\n * @param documents The array of documents to process.\n * @param targetState The target {@link DocumentState} to bring the documents to.\n * @param cancelToken A token that can be used to cancel the operation.\n * @param callback A function to be called for each document.\n * @returns A promise that resolves when all documents have been processed or the operation is canceled.\n * @throws Will throw `OperationCancelled` if the operation is canceled via a `CancellationToken`.\n */\n async runCancelable(documents, targetState, cancelToken, callback) {\n const filtered = documents.filter(doc => doc.state < targetState);\n for (const document of filtered) {\n await interruptAndCheck(cancelToken);\n await callback(document);\n document.state = targetState;\n await this.notifyDocumentPhase(document, targetState, cancelToken);\n }\n // Do not use `filtered` here, as that will miss documents that have previously reached the current target state\n // For example, this happens in case the cancellation triggers between the processing of two documents\n // Or files that were picked up during the workspace initialization\n const targetStateDocs = documents.filter(doc => doc.state === targetState);\n await this.notifyBuildPhase(targetStateDocs, targetState, cancelToken);\n this.currentState = targetState;\n }\n onBuildPhase(targetState, callback) {\n this.buildPhaseListeners.add(targetState, callback);\n return Disposable.create(() => {\n this.buildPhaseListeners.delete(targetState, callback);\n });\n }\n onDocumentPhase(targetState, callback) {\n this.documentPhaseListeners.add(targetState, callback);\n return Disposable.create(() => {\n this.documentPhaseListeners.delete(targetState, callback);\n });\n }\n waitUntil(state, uriOrToken, cancelToken) {\n let uri = undefined;\n if (uriOrToken && 'path' in uriOrToken) {\n uri = uriOrToken;\n }\n else {\n cancelToken = uriOrToken;\n }\n cancelToken !== null && cancelToken !== void 0 ? cancelToken : (cancelToken = CancellationToken.None);\n if (uri) {\n const document = this.langiumDocuments.getDocument(uri);\n if (document && document.state > state) {\n return Promise.resolve(uri);\n }\n }\n if (this.currentState >= state) {\n return Promise.resolve(undefined);\n }\n else if (cancelToken.isCancellationRequested) {\n return Promise.reject(OperationCancelled);\n }\n return new Promise((resolve, reject) => {\n const buildDisposable = this.onBuildPhase(state, () => {\n buildDisposable.dispose();\n cancelDisposable.dispose();\n if (uri) {\n const document = this.langiumDocuments.getDocument(uri);\n resolve(document === null || document === void 0 ? void 0 : document.uri);\n }\n else {\n resolve(undefined);\n }\n });\n const cancelDisposable = cancelToken.onCancellationRequested(() => {\n buildDisposable.dispose();\n cancelDisposable.dispose();\n reject(OperationCancelled);\n });\n });\n }\n async notifyDocumentPhase(document, state, cancelToken) {\n const listeners = this.documentPhaseListeners.get(state);\n const listenersCopy = listeners.slice();\n for (const listener of listenersCopy) {\n try {\n await listener(document, cancelToken);\n }\n catch (err) {\n // Ignore cancellation errors\n // We want to finish the listeners before throwing\n if (!isOperationCancelled(err)) {\n throw err;\n }\n }\n }\n }\n async notifyBuildPhase(documents, state, cancelToken) {\n if (documents.length === 0) {\n // Don't notify when no document has been processed\n return;\n }\n const listeners = this.buildPhaseListeners.get(state);\n const listenersCopy = listeners.slice();\n for (const listener of listenersCopy) {\n await interruptAndCheck(cancelToken);\n await listener(documents, cancelToken);\n }\n }\n /**\n * Determine whether the given document should be validated during a build. The default\n * implementation checks the `validation` property of the build options. If it's set to `true`\n * or a `ValidationOptions` object, the document is included in the validation phase.\n */\n shouldValidate(document) {\n return Boolean(this.getBuildOptions(document).validation);\n }\n /**\n * Run validation checks on the given document and store the resulting diagnostics in the document.\n * If the document already contains diagnostics, the new ones are added to the list.\n */\n async validate(document, cancelToken) {\n var _a, _b;\n const validator = this.serviceRegistry.getServices(document.uri).validation.DocumentValidator;\n const validationSetting = this.getBuildOptions(document).validation;\n const options = typeof validationSetting === 'object' ? validationSetting : undefined;\n const diagnostics = await validator.validateDocument(document, options, cancelToken);\n if (document.diagnostics) {\n document.diagnostics.push(...diagnostics);\n }\n else {\n document.diagnostics = diagnostics;\n }\n // Store information about the executed validation in the build state\n const state = this.buildState.get(document.uri.toString());\n if (state) {\n (_a = state.result) !== null && _a !== void 0 ? _a : (state.result = {});\n const newCategories = (_b = options === null || options === void 0 ? void 0 : options.categories) !== null && _b !== void 0 ? _b : ValidationCategory.all;\n if (state.result.validationChecks) {\n state.result.validationChecks.push(...newCategories);\n }\n else {\n state.result.validationChecks = [...newCategories];\n }\n }\n }\n getBuildOptions(document) {\n var _a, _b;\n return (_b = (_a = this.buildState.get(document.uri.toString())) === null || _a === void 0 ? void 0 : _a.options) !== null && _b !== void 0 ? _b : {};\n }\n}\n//# sourceMappingURL=document-builder.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { getDocument } from '../utils/ast-utils.js';\nimport { ContextCache } from '../utils/caching.js';\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { stream } from '../utils/stream.js';\nimport { UriUtils } from '../utils/uri-utils.js';\nexport class DefaultIndexManager {\n constructor(services) {\n /**\n * The symbol index stores all `AstNodeDescription` items exported by a document.\n * The key used in this map is the string representation of the specific document URI.\n */\n this.symbolIndex = new Map();\n /**\n * This is a cache for the `allElements()` method.\n * It caches the descriptions from `symbolIndex` grouped by types.\n */\n this.symbolByTypeIndex = new ContextCache();\n /**\n * This index keeps track of all `ReferenceDescription` items exported by a document.\n * This is used to compute which elements are affected by a document change\n * and for finding references to an AST node.\n */\n this.referenceIndex = new Map();\n this.documents = services.workspace.LangiumDocuments;\n this.serviceRegistry = services.ServiceRegistry;\n this.astReflection = services.AstReflection;\n }\n findAllReferences(targetNode, astNodePath) {\n const targetDocUri = getDocument(targetNode).uri;\n const result = [];\n this.referenceIndex.forEach(docRefs => {\n docRefs.forEach(refDescr => {\n if (UriUtils.equals(refDescr.targetUri, targetDocUri) && refDescr.targetPath === astNodePath) {\n result.push(refDescr);\n }\n });\n });\n return stream(result);\n }\n allElements(nodeType, uris) {\n let documentUris = stream(this.symbolIndex.keys());\n if (uris) {\n documentUris = documentUris.filter(uri => !uris || uris.has(uri));\n }\n return documentUris\n .map(uri => this.getFileDescriptions(uri, nodeType))\n .flat();\n }\n getFileDescriptions(uri, nodeType) {\n var _a;\n if (!nodeType) {\n return (_a = this.symbolIndex.get(uri)) !== null && _a !== void 0 ? _a : [];\n }\n const descriptions = this.symbolByTypeIndex.get(uri, nodeType, () => {\n var _a;\n const allFileDescriptions = (_a = this.symbolIndex.get(uri)) !== null && _a !== void 0 ? _a : [];\n return allFileDescriptions.filter(e => this.astReflection.isSubtype(e.type, nodeType));\n });\n return descriptions;\n }\n remove(uri) {\n const uriString = uri.toString();\n this.symbolIndex.delete(uriString);\n this.symbolByTypeIndex.clear(uriString);\n this.referenceIndex.delete(uriString);\n }\n async updateContent(document, cancelToken = CancellationToken.None) {\n const services = this.serviceRegistry.getServices(document.uri);\n const exports = await services.references.ScopeComputation.computeExports(document, cancelToken);\n const uri = document.uri.toString();\n this.symbolIndex.set(uri, exports);\n this.symbolByTypeIndex.clear(uri);\n }\n async updateReferences(document, cancelToken = CancellationToken.None) {\n const services = this.serviceRegistry.getServices(document.uri);\n const indexData = await services.workspace.ReferenceDescriptionProvider.createDescriptions(document, cancelToken);\n this.referenceIndex.set(document.uri.toString(), indexData);\n }\n isAffected(document, changedUris) {\n const references = this.referenceIndex.get(document.uri.toString());\n if (!references) {\n return false;\n }\n return references.some(ref => !ref.local && changedUris.has(ref.targetUri.toString()));\n }\n}\n//# sourceMappingURL=index-manager.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { Deferred, interruptAndCheck } from '../utils/promise-utils.js';\nimport { URI, UriUtils } from '../utils/uri-utils.js';\nexport class DefaultWorkspaceManager {\n constructor(services) {\n this.initialBuildOptions = {};\n this._ready = new Deferred();\n this.serviceRegistry = services.ServiceRegistry;\n this.langiumDocuments = services.workspace.LangiumDocuments;\n this.documentBuilder = services.workspace.DocumentBuilder;\n this.fileSystemProvider = services.workspace.FileSystemProvider;\n this.mutex = services.workspace.WorkspaceLock;\n }\n get ready() {\n return this._ready.promise;\n }\n get workspaceFolders() {\n return this.folders;\n }\n initialize(params) {\n var _a;\n this.folders = (_a = params.workspaceFolders) !== null && _a !== void 0 ? _a : undefined;\n }\n initialized(_params) {\n // Initialize the workspace even if there are no workspace folders\n // We still want to load additional documents (language library or similar) during initialization\n return this.mutex.write(token => { var _a; return this.initializeWorkspace((_a = this.folders) !== null && _a !== void 0 ? _a : [], token); });\n }\n async initializeWorkspace(folders, cancelToken = CancellationToken.None) {\n const documents = await this.performStartup(folders);\n // Only after creating all documents do we check whether we need to cancel the initialization\n // The document builder will later pick up on all unprocessed documents\n await interruptAndCheck(cancelToken);\n await this.documentBuilder.build(documents, this.initialBuildOptions, cancelToken);\n }\n /**\n * Performs the uninterruptable startup sequence of the workspace manager.\n * This methods loads all documents in the workspace and other documents and returns them.\n */\n async performStartup(folders) {\n const fileExtensions = this.serviceRegistry.all.flatMap(e => e.LanguageMetaData.fileExtensions);\n const documents = [];\n const collector = (document) => {\n documents.push(document);\n if (!this.langiumDocuments.hasDocument(document.uri)) {\n this.langiumDocuments.addDocument(document);\n }\n };\n // Even though we don't await the initialization of the workspace manager,\n // we can still assume that all library documents and file documents are loaded by the time we start building documents.\n // The mutex prevents anything from performing a workspace build until we check the cancellation token\n await this.loadAdditionalDocuments(folders, collector);\n await Promise.all(folders.map(wf => [wf, this.getRootFolder(wf)])\n .map(async (entry) => this.traverseFolder(...entry, fileExtensions, collector)));\n this._ready.resolve();\n return documents;\n }\n /**\n * Load all additional documents that shall be visible in the context of the given workspace\n * folders and add them to the collector. This can be used to include built-in libraries of\n * your language, which can be either loaded from provided files or constructed in memory.\n */\n loadAdditionalDocuments(_folders, _collector) {\n return Promise.resolve();\n }\n /**\n * Determine the root folder of the source documents in the given workspace folder.\n * The default implementation returns the URI of the workspace folder, but you can override\n * this to return a subfolder like `src` instead.\n */\n getRootFolder(workspaceFolder) {\n return URI.parse(workspaceFolder.uri);\n }\n /**\n * Traverse the file system folder identified by the given URI and its subfolders. All\n * contained files that match the file extensions are added to the collector.\n */\n async traverseFolder(workspaceFolder, folderPath, fileExtensions, collector) {\n const content = await this.fileSystemProvider.readDirectory(folderPath);\n await Promise.all(content.map(async (entry) => {\n if (this.includeEntry(workspaceFolder, entry, fileExtensions)) {\n if (entry.isDirectory) {\n await this.traverseFolder(workspaceFolder, entry.uri, fileExtensions, collector);\n }\n else if (entry.isFile) {\n const document = await this.langiumDocuments.getOrCreateDocument(entry.uri);\n collector(document);\n }\n }\n }));\n }\n /**\n * Determine whether the given folder entry shall be included while indexing the workspace.\n */\n includeEntry(_workspaceFolder, entry, fileExtensions) {\n const name = UriUtils.basename(entry.uri);\n if (name.startsWith('.')) {\n return false;\n }\n if (entry.isDirectory) {\n return name !== 'node_modules' && name !== 'out';\n }\n else if (entry.isFile) {\n const extname = UriUtils.extname(entry.uri);\n return fileExtensions.includes(extname);\n }\n return false;\n }\n}\n//# sourceMappingURL=workspace-manager.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Lexer as ChevrotainLexer, defaultLexerErrorProvider } from 'chevrotain';\nexport class DefaultLexerErrorMessageProvider {\n buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column) {\n return defaultLexerErrorProvider.buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column);\n }\n buildUnableToPopLexerModeMessage(token) {\n return defaultLexerErrorProvider.buildUnableToPopLexerModeMessage(token);\n }\n}\nexport const DEFAULT_TOKENIZE_OPTIONS = { mode: 'full' };\nexport class DefaultLexer {\n constructor(services) {\n this.errorMessageProvider = services.parser.LexerErrorMessageProvider;\n this.tokenBuilder = services.parser.TokenBuilder;\n const tokens = this.tokenBuilder.buildTokens(services.Grammar, {\n caseInsensitive: services.LanguageMetaData.caseInsensitive\n });\n this.tokenTypes = this.toTokenTypeDictionary(tokens);\n const lexerTokens = isTokenTypeDictionary(tokens) ? Object.values(tokens) : tokens;\n const production = services.LanguageMetaData.mode === 'production';\n this.chevrotainLexer = new ChevrotainLexer(lexerTokens, {\n positionTracking: 'full',\n skipValidations: production,\n errorMessageProvider: this.errorMessageProvider\n });\n }\n get definition() {\n return this.tokenTypes;\n }\n tokenize(text, _options = DEFAULT_TOKENIZE_OPTIONS) {\n var _a, _b, _c;\n const chevrotainResult = this.chevrotainLexer.tokenize(text);\n return {\n tokens: chevrotainResult.tokens,\n errors: chevrotainResult.errors,\n hidden: (_a = chevrotainResult.groups.hidden) !== null && _a !== void 0 ? _a : [],\n report: (_c = (_b = this.tokenBuilder).flushLexingReport) === null || _c === void 0 ? void 0 : _c.call(_b, text)\n };\n }\n toTokenTypeDictionary(buildTokens) {\n if (isTokenTypeDictionary(buildTokens))\n return buildTokens;\n const tokens = isIMultiModeLexerDefinition(buildTokens) ? Object.values(buildTokens.modes).flat() : buildTokens;\n const res = {};\n tokens.forEach(token => res[token.name] = token);\n return res;\n }\n}\n/**\n * Returns a check whether the given TokenVocabulary is TokenType array\n */\nexport function isTokenTypeArray(tokenVocabulary) {\n return Array.isArray(tokenVocabulary) && (tokenVocabulary.length === 0 || 'name' in tokenVocabulary[0]);\n}\n/**\n * Returns a check whether the given TokenVocabulary is IMultiModeLexerDefinition\n */\nexport function isIMultiModeLexerDefinition(tokenVocabulary) {\n return tokenVocabulary && 'modes' in tokenVocabulary && 'defaultMode' in tokenVocabulary;\n}\n/**\n * Returns a check whether the given TokenVocabulary is TokenTypeDictionary\n */\nexport function isTokenTypeDictionary(tokenVocabulary) {\n return !isTokenTypeArray(tokenVocabulary) && !isIMultiModeLexerDefinition(tokenVocabulary);\n}\n//# sourceMappingURL=lexer.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Position, Range } from 'vscode-languageserver-types';\nimport { NEWLINE_REGEXP, escapeRegExp } from '../utils/regexp-utils.js';\nimport { URI } from '../utils/uri-utils.js';\nexport function parseJSDoc(node, start, options) {\n let opts;\n let position;\n if (typeof node === 'string') {\n position = start;\n opts = options;\n }\n else {\n position = node.range.start;\n opts = start;\n }\n if (!position) {\n position = Position.create(0, 0);\n }\n const lines = getLines(node);\n const normalizedOptions = normalizeOptions(opts);\n const tokens = tokenize({\n lines,\n position,\n options: normalizedOptions\n });\n return parseJSDocComment({\n index: 0,\n tokens,\n position\n });\n}\nexport function isJSDoc(node, options) {\n const normalizedOptions = normalizeOptions(options);\n const lines = getLines(node);\n if (lines.length === 0) {\n return false;\n }\n const first = lines[0];\n const last = lines[lines.length - 1];\n const firstRegex = normalizedOptions.start;\n const lastRegex = normalizedOptions.end;\n return Boolean(firstRegex === null || firstRegex === void 0 ? void 0 : firstRegex.exec(first)) && Boolean(lastRegex === null || lastRegex === void 0 ? void 0 : lastRegex.exec(last));\n}\nfunction getLines(node) {\n let content = '';\n if (typeof node === 'string') {\n content = node;\n }\n else {\n content = node.text;\n }\n const lines = content.split(NEWLINE_REGEXP);\n return lines;\n}\nconst tagRegex = /\\s*(@([\\p{L}][\\p{L}\\p{N}]*)?)/uy;\nconst inlineTagRegex = /\\{(@[\\p{L}][\\p{L}\\p{N}]*)(\\s*)([^\\r\\n}]+)?\\}/gu;\nfunction tokenize(context) {\n var _a, _b, _c;\n const tokens = [];\n let currentLine = context.position.line;\n let currentCharacter = context.position.character;\n for (let i = 0; i < context.lines.length; i++) {\n const first = i === 0;\n const last = i === context.lines.length - 1;\n let line = context.lines[i];\n let index = 0;\n if (first && context.options.start) {\n const match = (_a = context.options.start) === null || _a === void 0 ? void 0 : _a.exec(line);\n if (match) {\n index = match.index + match[0].length;\n }\n }\n else {\n const match = (_b = context.options.line) === null || _b === void 0 ? void 0 : _b.exec(line);\n if (match) {\n index = match.index + match[0].length;\n }\n }\n if (last) {\n const match = (_c = context.options.end) === null || _c === void 0 ? void 0 : _c.exec(line);\n if (match) {\n line = line.substring(0, match.index);\n }\n }\n line = line.substring(0, lastCharacter(line));\n const whitespaceEnd = skipWhitespace(line, index);\n if (whitespaceEnd >= line.length) {\n // Only create a break token when we already have previous tokens\n if (tokens.length > 0) {\n const position = Position.create(currentLine, currentCharacter);\n tokens.push({\n type: 'break',\n content: '',\n range: Range.create(position, position)\n });\n }\n }\n else {\n tagRegex.lastIndex = index;\n const tagMatch = tagRegex.exec(line);\n if (tagMatch) {\n const fullMatch = tagMatch[0];\n const value = tagMatch[1];\n const start = Position.create(currentLine, currentCharacter + index);\n const end = Position.create(currentLine, currentCharacter + index + fullMatch.length);\n tokens.push({\n type: 'tag',\n content: value,\n range: Range.create(start, end)\n });\n index += fullMatch.length;\n index = skipWhitespace(line, index);\n }\n if (index < line.length) {\n const rest = line.substring(index);\n const inlineTagMatches = Array.from(rest.matchAll(inlineTagRegex));\n tokens.push(...buildInlineTokens(inlineTagMatches, rest, currentLine, currentCharacter + index));\n }\n }\n currentLine++;\n currentCharacter = 0;\n }\n // Remove last break token if there is one\n if (tokens.length > 0 && tokens[tokens.length - 1].type === 'break') {\n return tokens.slice(0, -1);\n }\n return tokens;\n}\nfunction buildInlineTokens(tags, line, lineIndex, characterIndex) {\n const tokens = [];\n if (tags.length === 0) {\n const start = Position.create(lineIndex, characterIndex);\n const end = Position.create(lineIndex, characterIndex + line.length);\n tokens.push({\n type: 'text',\n content: line,\n range: Range.create(start, end)\n });\n }\n else {\n let lastIndex = 0;\n for (const match of tags) {\n const matchIndex = match.index;\n const startContent = line.substring(lastIndex, matchIndex);\n if (startContent.length > 0) {\n tokens.push({\n type: 'text',\n content: line.substring(lastIndex, matchIndex),\n range: Range.create(Position.create(lineIndex, lastIndex + characterIndex), Position.create(lineIndex, matchIndex + characterIndex))\n });\n }\n let offset = startContent.length + 1;\n const tagName = match[1];\n tokens.push({\n type: 'inline-tag',\n content: tagName,\n range: Range.create(Position.create(lineIndex, lastIndex + offset + characterIndex), Position.create(lineIndex, lastIndex + offset + tagName.length + characterIndex))\n });\n offset += tagName.length;\n if (match.length === 4) {\n offset += match[2].length;\n const value = match[3];\n tokens.push({\n type: 'text',\n content: value,\n range: Range.create(Position.create(lineIndex, lastIndex + offset + characterIndex), Position.create(lineIndex, lastIndex + offset + value.length + characterIndex))\n });\n }\n else {\n tokens.push({\n type: 'text',\n content: '',\n range: Range.create(Position.create(lineIndex, lastIndex + offset + characterIndex), Position.create(lineIndex, lastIndex + offset + characterIndex))\n });\n }\n lastIndex = matchIndex + match[0].length;\n }\n const endContent = line.substring(lastIndex);\n if (endContent.length > 0) {\n tokens.push({\n type: 'text',\n content: endContent,\n range: Range.create(Position.create(lineIndex, lastIndex + characterIndex), Position.create(lineIndex, lastIndex + characterIndex + endContent.length))\n });\n }\n }\n return tokens;\n}\nconst nonWhitespaceRegex = /\\S/;\nconst whitespaceEndRegex = /\\s*$/;\nfunction skipWhitespace(line, index) {\n const match = line.substring(index).match(nonWhitespaceRegex);\n if (match) {\n return index + match.index;\n }\n else {\n return line.length;\n }\n}\nfunction lastCharacter(line) {\n const match = line.match(whitespaceEndRegex);\n if (match && typeof match.index === 'number') {\n return match.index;\n }\n return undefined;\n}\n// Parsing\nfunction parseJSDocComment(context) {\n var _a, _b, _c, _d;\n const startPosition = Position.create(context.position.line, context.position.character);\n if (context.tokens.length === 0) {\n return new JSDocCommentImpl([], Range.create(startPosition, startPosition));\n }\n const elements = [];\n while (context.index < context.tokens.length) {\n const element = parseJSDocElement(context, elements[elements.length - 1]);\n if (element) {\n elements.push(element);\n }\n }\n const start = (_b = (_a = elements[0]) === null || _a === void 0 ? void 0 : _a.range.start) !== null && _b !== void 0 ? _b : startPosition;\n const end = (_d = (_c = elements[elements.length - 1]) === null || _c === void 0 ? void 0 : _c.range.end) !== null && _d !== void 0 ? _d : startPosition;\n return new JSDocCommentImpl(elements, Range.create(start, end));\n}\nfunction parseJSDocElement(context, last) {\n const next = context.tokens[context.index];\n if (next.type === 'tag') {\n return parseJSDocTag(context, false);\n }\n else if (next.type === 'text' || next.type === 'inline-tag') {\n return parseJSDocText(context);\n }\n else {\n appendEmptyLine(next, last);\n context.index++;\n return undefined;\n }\n}\nfunction appendEmptyLine(token, element) {\n if (element) {\n const line = new JSDocLineImpl('', token.range);\n if ('inlines' in element) {\n element.inlines.push(line);\n }\n else {\n element.content.inlines.push(line);\n }\n }\n}\nfunction parseJSDocText(context) {\n let token = context.tokens[context.index];\n const firstToken = token;\n let lastToken = token;\n const lines = [];\n while (token && token.type !== 'break' && token.type !== 'tag') {\n lines.push(parseJSDocInline(context));\n lastToken = token;\n token = context.tokens[context.index];\n }\n return new JSDocTextImpl(lines, Range.create(firstToken.range.start, lastToken.range.end));\n}\nfunction parseJSDocInline(context) {\n const token = context.tokens[context.index];\n if (token.type === 'inline-tag') {\n return parseJSDocTag(context, true);\n }\n else {\n return parseJSDocLine(context);\n }\n}\nfunction parseJSDocTag(context, inline) {\n const tagToken = context.tokens[context.index++];\n const name = tagToken.content.substring(1);\n const nextToken = context.tokens[context.index];\n if ((nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) === 'text') {\n if (inline) {\n const docLine = parseJSDocLine(context);\n return new JSDocTagImpl(name, new JSDocTextImpl([docLine], docLine.range), inline, Range.create(tagToken.range.start, docLine.range.end));\n }\n else {\n const textDoc = parseJSDocText(context);\n return new JSDocTagImpl(name, textDoc, inline, Range.create(tagToken.range.start, textDoc.range.end));\n }\n }\n else {\n const range = tagToken.range;\n return new JSDocTagImpl(name, new JSDocTextImpl([], range), inline, range);\n }\n}\nfunction parseJSDocLine(context) {\n const token = context.tokens[context.index++];\n return new JSDocLineImpl(token.content, token.range);\n}\nfunction normalizeOptions(options) {\n if (!options) {\n return normalizeOptions({\n start: '/**',\n end: '*/',\n line: '*'\n });\n }\n const { start, end, line } = options;\n return {\n start: normalizeOption(start, true),\n end: normalizeOption(end, false),\n line: normalizeOption(line, true)\n };\n}\nfunction normalizeOption(option, start) {\n if (typeof option === 'string' || typeof option === 'object') {\n const escaped = typeof option === 'string' ? escapeRegExp(option) : option.source;\n if (start) {\n return new RegExp(`^\\\\s*${escaped}`);\n }\n else {\n return new RegExp(`\\\\s*${escaped}\\\\s*$`);\n }\n }\n else {\n return option;\n }\n}\nclass JSDocCommentImpl {\n constructor(elements, range) {\n this.elements = elements;\n this.range = range;\n }\n getTag(name) {\n return this.getAllTags().find(e => e.name === name);\n }\n getTags(name) {\n return this.getAllTags().filter(e => e.name === name);\n }\n getAllTags() {\n return this.elements.filter((e) => 'name' in e);\n }\n toString() {\n let value = '';\n for (const element of this.elements) {\n if (value.length === 0) {\n value = element.toString();\n }\n else {\n const text = element.toString();\n value += fillNewlines(value) + text;\n }\n }\n return value.trim();\n }\n toMarkdown(options) {\n let value = '';\n for (const element of this.elements) {\n if (value.length === 0) {\n value = element.toMarkdown(options);\n }\n else {\n const text = element.toMarkdown(options);\n value += fillNewlines(value) + text;\n }\n }\n return value.trim();\n }\n}\nclass JSDocTagImpl {\n constructor(name, content, inline, range) {\n this.name = name;\n this.content = content;\n this.inline = inline;\n this.range = range;\n }\n toString() {\n let text = `@${this.name}`;\n const content = this.content.toString();\n if (this.content.inlines.length === 1) {\n text = `${text} ${content}`;\n }\n else if (this.content.inlines.length > 1) {\n text = `${text}\\n${content}`;\n }\n if (this.inline) {\n // Inline tags are surrounded by curly braces\n return `{${text}}`;\n }\n else {\n return text;\n }\n }\n toMarkdown(options) {\n var _a, _b;\n return (_b = (_a = options === null || options === void 0 ? void 0 : options.renderTag) === null || _a === void 0 ? void 0 : _a.call(options, this)) !== null && _b !== void 0 ? _b : this.toMarkdownDefault(options);\n }\n toMarkdownDefault(options) {\n const content = this.content.toMarkdown(options);\n if (this.inline) {\n const rendered = renderInlineTag(this.name, content, options !== null && options !== void 0 ? options : {});\n if (typeof rendered === 'string') {\n return rendered;\n }\n }\n let marker = '';\n if ((options === null || options === void 0 ? void 0 : options.tag) === 'italic' || (options === null || options === void 0 ? void 0 : options.tag) === undefined) {\n marker = '*';\n }\n else if ((options === null || options === void 0 ? void 0 : options.tag) === 'bold') {\n marker = '**';\n }\n else if ((options === null || options === void 0 ? void 0 : options.tag) === 'bold-italic') {\n marker = '***';\n }\n let text = `${marker}@${this.name}${marker}`;\n if (this.content.inlines.length === 1) {\n text = `${text} — ${content}`;\n }\n else if (this.content.inlines.length > 1) {\n text = `${text}\\n${content}`;\n }\n if (this.inline) {\n // Inline tags are surrounded by curly braces\n return `{${text}}`;\n }\n else {\n return text;\n }\n }\n}\nfunction renderInlineTag(tag, content, options) {\n var _a, _b;\n if (tag === 'linkplain' || tag === 'linkcode' || tag === 'link') {\n const index = content.indexOf(' ');\n let display = content;\n if (index > 0) {\n const displayStart = skipWhitespace(content, index);\n display = content.substring(displayStart);\n content = content.substring(0, index);\n }\n if (tag === 'linkcode' || (tag === 'link' && options.link === 'code')) {\n // Surround the display value in a markdown inline code block\n display = `\\`${display}\\``;\n }\n const renderedLink = (_b = (_a = options.renderLink) === null || _a === void 0 ? void 0 : _a.call(options, content, display)) !== null && _b !== void 0 ? _b : renderLinkDefault(content, display);\n return renderedLink;\n }\n return undefined;\n}\nfunction renderLinkDefault(content, display) {\n try {\n URI.parse(content, true);\n return `[${display}](${content})`;\n }\n catch (_a) {\n return content;\n }\n}\nclass JSDocTextImpl {\n constructor(lines, range) {\n this.inlines = lines;\n this.range = range;\n }\n toString() {\n let text = '';\n for (let i = 0; i < this.inlines.length; i++) {\n const inline = this.inlines[i];\n const next = this.inlines[i + 1];\n text += inline.toString();\n if (next && next.range.start.line > inline.range.start.line) {\n text += '\\n';\n }\n }\n return text;\n }\n toMarkdown(options) {\n let text = '';\n for (let i = 0; i < this.inlines.length; i++) {\n const inline = this.inlines[i];\n const next = this.inlines[i + 1];\n text += inline.toMarkdown(options);\n if (next && next.range.start.line > inline.range.start.line) {\n text += '\\n';\n }\n }\n return text;\n }\n}\nclass JSDocLineImpl {\n constructor(text, range) {\n this.text = text;\n this.range = range;\n }\n toString() {\n return this.text;\n }\n toMarkdown() {\n return this.text;\n }\n}\nfunction fillNewlines(text) {\n if (text.endsWith('\\n')) {\n return '\\n';\n }\n else {\n return '\\n\\n';\n }\n}\n//# sourceMappingURL=jsdoc.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { getDocument } from '../utils/ast-utils.js';\nimport { isJSDoc, parseJSDoc } from './jsdoc.js';\nexport class JSDocDocumentationProvider {\n constructor(services) {\n this.indexManager = services.shared.workspace.IndexManager;\n this.commentProvider = services.documentation.CommentProvider;\n }\n getDocumentation(node) {\n const comment = this.commentProvider.getComment(node);\n if (comment && isJSDoc(comment)) {\n const parsedJSDoc = parseJSDoc(comment);\n return parsedJSDoc.toMarkdown({\n renderLink: (link, display) => {\n return this.documentationLinkRenderer(node, link, display);\n },\n renderTag: (tag) => {\n return this.documentationTagRenderer(node, tag);\n }\n });\n }\n return undefined;\n }\n documentationLinkRenderer(node, name, display) {\n var _a;\n const description = (_a = this.findNameInPrecomputedScopes(node, name)) !== null && _a !== void 0 ? _a : this.findNameInGlobalScope(node, name);\n if (description && description.nameSegment) {\n const line = description.nameSegment.range.start.line + 1;\n const character = description.nameSegment.range.start.character + 1;\n const uri = description.documentUri.with({ fragment: `L${line},${character}` });\n return `[${display}](${uri.toString()})`;\n }\n else {\n return undefined;\n }\n }\n documentationTagRenderer(_node, _tag) {\n // Fall back to the default tag rendering\n return undefined;\n }\n findNameInPrecomputedScopes(node, name) {\n const document = getDocument(node);\n const precomputed = document.precomputedScopes;\n if (!precomputed) {\n return undefined;\n }\n let currentNode = node;\n do {\n const allDescriptions = precomputed.get(currentNode);\n const description = allDescriptions.find(e => e.name === name);\n if (description) {\n return description;\n }\n currentNode = currentNode.$container;\n } while (currentNode);\n return undefined;\n }\n findNameInGlobalScope(node, name) {\n const description = this.indexManager.allElements().find(e => e.name === name);\n return description;\n }\n}\n//# sourceMappingURL=documentation-provider.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { isAstNodeWithComment } from '../serializer/json-serializer.js';\nimport { findCommentNode } from '../utils/cst-utils.js';\nexport class DefaultCommentProvider {\n constructor(services) {\n this.grammarConfig = () => services.parser.GrammarConfig;\n }\n getComment(node) {\n var _a;\n if (isAstNodeWithComment(node)) {\n return node.$comment;\n }\n return (_a = findCommentNode(node.$cstNode, this.grammarConfig().multilineCommentRules)) === null || _a === void 0 ? void 0 : _a.text;\n }\n}\n//# sourceMappingURL=comment-provider.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Deferred, OperationCancelled } from '../utils/promise-utils.js';\nimport { Emitter } from '../utils/event.js';\n/**\n * Default implementation of the async parser which simply wraps the sync parser in a promise.\n *\n * @remarks\n * A real implementation would create worker threads or web workers to offload the parsing work.\n */\nexport class DefaultAsyncParser {\n constructor(services) {\n this.syncParser = services.parser.LangiumParser;\n }\n parse(text, _cancelToken) {\n return Promise.resolve(this.syncParser.parse(text));\n }\n}\nexport class AbstractThreadedAsyncParser {\n constructor(services) {\n /**\n * The thread count determines how many threads are used to parse files in parallel.\n * The default value is 8. Decreasing this value increases startup performance, but decreases parallel parsing performance.\n */\n this.threadCount = 8;\n /**\n * The termination delay determines how long the parser waits for a thread to finish after a cancellation request.\n * The default value is 200(ms).\n */\n this.terminationDelay = 200;\n this.workerPool = [];\n this.queue = [];\n this.hydrator = services.serializer.Hydrator;\n }\n initializeWorkers() {\n while (this.workerPool.length < this.threadCount) {\n const worker = this.createWorker();\n worker.onReady(() => {\n if (this.queue.length > 0) {\n const deferred = this.queue.shift();\n if (deferred) {\n worker.lock();\n deferred.resolve(worker);\n }\n }\n });\n this.workerPool.push(worker);\n }\n }\n async parse(text, cancelToken) {\n const worker = await this.acquireParserWorker(cancelToken);\n const deferred = new Deferred();\n let timeout;\n // If the cancellation token is requested, we wait for a certain time before terminating the worker.\n // Since the cancellation token lives longer than the parsing process, we need to dispose the event listener.\n // Otherwise, we might accidentally terminate the worker after the parsing process has finished.\n const cancellation = cancelToken.onCancellationRequested(() => {\n timeout = setTimeout(() => {\n this.terminateWorker(worker);\n }, this.terminationDelay);\n });\n worker.parse(text).then(result => {\n const hydrated = this.hydrator.hydrate(result);\n deferred.resolve(hydrated);\n }).catch(err => {\n deferred.reject(err);\n }).finally(() => {\n cancellation.dispose();\n clearTimeout(timeout);\n });\n return deferred.promise;\n }\n terminateWorker(worker) {\n worker.terminate();\n const index = this.workerPool.indexOf(worker);\n if (index >= 0) {\n this.workerPool.splice(index, 1);\n }\n }\n async acquireParserWorker(cancelToken) {\n this.initializeWorkers();\n for (const worker of this.workerPool) {\n if (worker.ready) {\n worker.lock();\n return worker;\n }\n }\n const deferred = new Deferred();\n cancelToken.onCancellationRequested(() => {\n const index = this.queue.indexOf(deferred);\n if (index >= 0) {\n this.queue.splice(index, 1);\n }\n deferred.reject(OperationCancelled);\n });\n this.queue.push(deferred);\n return deferred.promise;\n }\n}\nexport class ParserWorker {\n get ready() {\n return this._ready;\n }\n get onReady() {\n return this.onReadyEmitter.event;\n }\n constructor(sendMessage, onMessage, onError, terminate) {\n this.onReadyEmitter = new Emitter();\n this.deferred = new Deferred();\n this._ready = true;\n this._parsing = false;\n this.sendMessage = sendMessage;\n this._terminate = terminate;\n onMessage(result => {\n const parseResult = result;\n this.deferred.resolve(parseResult);\n this.unlock();\n });\n onError(error => {\n this.deferred.reject(error);\n this.unlock();\n });\n }\n terminate() {\n this.deferred.reject(OperationCancelled);\n this._terminate();\n }\n lock() {\n this._ready = false;\n }\n unlock() {\n this._parsing = false;\n this._ready = true;\n this.onReadyEmitter.fire();\n }\n parse(text) {\n if (this._parsing) {\n throw new Error('Parser worker is busy');\n }\n this._parsing = true;\n this.deferred = new Deferred();\n this.sendMessage(text);\n return this.deferred.promise;\n }\n}\n//# sourceMappingURL=async-parser.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken, CancellationTokenSource } from '../utils/cancellation.js';\nimport { Deferred, isOperationCancelled, startCancelableOperation } from '../utils/promise-utils.js';\nexport class DefaultWorkspaceLock {\n constructor() {\n this.previousTokenSource = new CancellationTokenSource();\n this.writeQueue = [];\n this.readQueue = [];\n this.done = true;\n }\n write(action) {\n this.cancelWrite();\n const tokenSource = startCancelableOperation();\n this.previousTokenSource = tokenSource;\n return this.enqueue(this.writeQueue, action, tokenSource.token);\n }\n read(action) {\n return this.enqueue(this.readQueue, action);\n }\n enqueue(queue, action, cancellationToken = CancellationToken.None) {\n const deferred = new Deferred();\n const entry = {\n action,\n deferred,\n cancellationToken\n };\n queue.push(entry);\n this.performNextOperation();\n return deferred.promise;\n }\n async performNextOperation() {\n if (!this.done) {\n return;\n }\n const entries = [];\n if (this.writeQueue.length > 0) {\n // Just perform the next write action\n entries.push(this.writeQueue.shift());\n }\n else if (this.readQueue.length > 0) {\n // Empty the read queue and perform all actions in parallel\n entries.push(...this.readQueue.splice(0, this.readQueue.length));\n }\n else {\n return;\n }\n this.done = false;\n await Promise.all(entries.map(async ({ action, deferred, cancellationToken }) => {\n try {\n // Move the execution of the action to the next event loop tick via `Promise.resolve()`\n const result = await Promise.resolve().then(() => action(cancellationToken));\n deferred.resolve(result);\n }\n catch (err) {\n if (isOperationCancelled(err)) {\n // If the operation was cancelled, we don't want to reject the promise\n deferred.resolve(undefined);\n }\n else {\n deferred.reject(err);\n }\n }\n }));\n this.done = true;\n this.performNextOperation();\n }\n cancelWrite() {\n this.previousTokenSource.cancel();\n }\n}\n//# sourceMappingURL=workspace-lock.js.map","/******************************************************************************\n * Copyright 2024 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CompositeCstNodeImpl, LeafCstNodeImpl, RootCstNodeImpl } from '../parser/cst-node-builder.js';\nimport { isAbstractElement } from '../languages/generated/ast.js';\nimport { isRootCstNode, isCompositeCstNode, isLeafCstNode, isAstNode, isReference } from '../syntax-tree.js';\nimport { streamAst } from '../utils/ast-utils.js';\nimport { BiMap } from '../utils/collections.js';\nimport { streamCst } from '../utils/cst-utils.js';\nexport class DefaultHydrator {\n constructor(services) {\n this.grammarElementIdMap = new BiMap();\n this.tokenTypeIdMap = new BiMap();\n this.grammar = services.Grammar;\n this.lexer = services.parser.Lexer;\n this.linker = services.references.Linker;\n }\n dehydrate(result) {\n return {\n lexerErrors: result.lexerErrors,\n lexerReport: result.lexerReport ? this.dehydrateLexerReport(result.lexerReport) : undefined,\n // We need to create shallow copies of the errors\n // The original errors inherit from the `Error` class, which is not transferable across worker threads\n parserErrors: result.parserErrors.map(e => (Object.assign(Object.assign({}, e), { message: e.message }))),\n value: this.dehydrateAstNode(result.value, this.createDehyrationContext(result.value))\n };\n }\n dehydrateLexerReport(lexerReport) {\n // By default, lexer reports are serializable\n return lexerReport;\n }\n createDehyrationContext(node) {\n const astNodes = new Map();\n const cstNodes = new Map();\n for (const astNode of streamAst(node)) {\n astNodes.set(astNode, {});\n }\n if (node.$cstNode) {\n for (const cstNode of streamCst(node.$cstNode)) {\n cstNodes.set(cstNode, {});\n }\n }\n return {\n astNodes,\n cstNodes\n };\n }\n dehydrateAstNode(node, context) {\n const obj = context.astNodes.get(node);\n obj.$type = node.$type;\n obj.$containerIndex = node.$containerIndex;\n obj.$containerProperty = node.$containerProperty;\n if (node.$cstNode !== undefined) {\n obj.$cstNode = this.dehydrateCstNode(node.$cstNode, context);\n }\n for (const [name, value] of Object.entries(node)) {\n if (name.startsWith('$')) {\n continue;\n }\n if (Array.isArray(value)) {\n const arr = [];\n obj[name] = arr;\n for (const item of value) {\n if (isAstNode(item)) {\n arr.push(this.dehydrateAstNode(item, context));\n }\n else if (isReference(item)) {\n arr.push(this.dehydrateReference(item, context));\n }\n else {\n arr.push(item);\n }\n }\n }\n else if (isAstNode(value)) {\n obj[name] = this.dehydrateAstNode(value, context);\n }\n else if (isReference(value)) {\n obj[name] = this.dehydrateReference(value, context);\n }\n else if (value !== undefined) {\n obj[name] = value;\n }\n }\n return obj;\n }\n dehydrateReference(reference, context) {\n const obj = {};\n obj.$refText = reference.$refText;\n if (reference.$refNode) {\n obj.$refNode = context.cstNodes.get(reference.$refNode);\n }\n return obj;\n }\n dehydrateCstNode(node, context) {\n const cstNode = context.cstNodes.get(node);\n if (isRootCstNode(node)) {\n cstNode.fullText = node.fullText;\n }\n else {\n // Note: This returns undefined for hidden nodes (i.e. comments)\n cstNode.grammarSource = this.getGrammarElementId(node.grammarSource);\n }\n cstNode.hidden = node.hidden;\n cstNode.astNode = context.astNodes.get(node.astNode);\n if (isCompositeCstNode(node)) {\n cstNode.content = node.content.map(child => this.dehydrateCstNode(child, context));\n }\n else if (isLeafCstNode(node)) {\n cstNode.tokenType = node.tokenType.name;\n cstNode.offset = node.offset;\n cstNode.length = node.length;\n cstNode.startLine = node.range.start.line;\n cstNode.startColumn = node.range.start.character;\n cstNode.endLine = node.range.end.line;\n cstNode.endColumn = node.range.end.character;\n }\n return cstNode;\n }\n hydrate(result) {\n const node = result.value;\n const context = this.createHydrationContext(node);\n if ('$cstNode' in node) {\n this.hydrateCstNode(node.$cstNode, context);\n }\n return {\n lexerErrors: result.lexerErrors,\n lexerReport: result.lexerReport,\n parserErrors: result.parserErrors,\n value: this.hydrateAstNode(node, context)\n };\n }\n createHydrationContext(node) {\n const astNodes = new Map();\n const cstNodes = new Map();\n for (const astNode of streamAst(node)) {\n astNodes.set(astNode, {});\n }\n let root;\n if (node.$cstNode) {\n for (const cstNode of streamCst(node.$cstNode)) {\n let cst;\n if ('fullText' in cstNode) {\n cst = new RootCstNodeImpl(cstNode.fullText);\n root = cst;\n }\n else if ('content' in cstNode) {\n cst = new CompositeCstNodeImpl();\n }\n else if ('tokenType' in cstNode) {\n cst = this.hydrateCstLeafNode(cstNode);\n }\n if (cst) {\n cstNodes.set(cstNode, cst);\n cst.root = root;\n }\n }\n }\n return {\n astNodes,\n cstNodes\n };\n }\n hydrateAstNode(node, context) {\n const astNode = context.astNodes.get(node);\n astNode.$type = node.$type;\n astNode.$containerIndex = node.$containerIndex;\n astNode.$containerProperty = node.$containerProperty;\n if (node.$cstNode) {\n astNode.$cstNode = context.cstNodes.get(node.$cstNode);\n }\n for (const [name, value] of Object.entries(node)) {\n if (name.startsWith('$')) {\n continue;\n }\n if (Array.isArray(value)) {\n const arr = [];\n astNode[name] = arr;\n for (const item of value) {\n if (isAstNode(item)) {\n arr.push(this.setParent(this.hydrateAstNode(item, context), astNode));\n }\n else if (isReference(item)) {\n arr.push(this.hydrateReference(item, astNode, name, context));\n }\n else {\n arr.push(item);\n }\n }\n }\n else if (isAstNode(value)) {\n astNode[name] = this.setParent(this.hydrateAstNode(value, context), astNode);\n }\n else if (isReference(value)) {\n astNode[name] = this.hydrateReference(value, astNode, name, context);\n }\n else if (value !== undefined) {\n astNode[name] = value;\n }\n }\n return astNode;\n }\n setParent(node, parent) {\n node.$container = parent;\n return node;\n }\n hydrateReference(reference, node, name, context) {\n return this.linker.buildReference(node, name, context.cstNodes.get(reference.$refNode), reference.$refText);\n }\n hydrateCstNode(cstNode, context, num = 0) {\n const cstNodeObj = context.cstNodes.get(cstNode);\n if (typeof cstNode.grammarSource === 'number') {\n cstNodeObj.grammarSource = this.getGrammarElement(cstNode.grammarSource);\n }\n cstNodeObj.astNode = context.astNodes.get(cstNode.astNode);\n if (isCompositeCstNode(cstNodeObj)) {\n for (const child of cstNode.content) {\n const hydrated = this.hydrateCstNode(child, context, num++);\n cstNodeObj.content.push(hydrated);\n }\n }\n return cstNodeObj;\n }\n hydrateCstLeafNode(cstNode) {\n const tokenType = this.getTokenType(cstNode.tokenType);\n const offset = cstNode.offset;\n const length = cstNode.length;\n const startLine = cstNode.startLine;\n const startColumn = cstNode.startColumn;\n const endLine = cstNode.endLine;\n const endColumn = cstNode.endColumn;\n const hidden = cstNode.hidden;\n const node = new LeafCstNodeImpl(offset, length, {\n start: {\n line: startLine,\n character: startColumn\n },\n end: {\n line: endLine,\n character: endColumn\n }\n }, tokenType, hidden);\n return node;\n }\n getTokenType(name) {\n return this.lexer.definition[name];\n }\n getGrammarElementId(node) {\n if (!node) {\n return undefined;\n }\n if (this.grammarElementIdMap.size === 0) {\n this.createGrammarElementIdMap();\n }\n return this.grammarElementIdMap.get(node);\n }\n getGrammarElement(id) {\n if (this.grammarElementIdMap.size === 0) {\n this.createGrammarElementIdMap();\n }\n const element = this.grammarElementIdMap.getKey(id);\n return element;\n }\n createGrammarElementIdMap() {\n let id = 0;\n for (const element of streamAst(this.grammar)) {\n if (isAbstractElement(element)) {\n this.grammarElementIdMap.set(element, id++);\n }\n }\n }\n}\n//# sourceMappingURL=hydrator.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n******************************************************************************/\nimport { createGrammarConfig } from './languages/grammar-config.js';\nimport { createCompletionParser } from './parser/completion-parser-builder.js';\nimport { createLangiumParser } from './parser/langium-parser-builder.js';\nimport { DefaultTokenBuilder } from './parser/token-builder.js';\nimport { DefaultValueConverter } from './parser/value-converter.js';\nimport { DefaultLinker } from './references/linker.js';\nimport { DefaultNameProvider } from './references/name-provider.js';\nimport { DefaultReferences } from './references/references.js';\nimport { DefaultScopeComputation } from './references/scope-computation.js';\nimport { DefaultScopeProvider } from './references/scope-provider.js';\nimport { DefaultJsonSerializer } from './serializer/json-serializer.js';\nimport { DefaultServiceRegistry } from './service-registry.js';\nimport { DefaultDocumentValidator } from './validation/document-validator.js';\nimport { ValidationRegistry } from './validation/validation-registry.js';\nimport { DefaultAstNodeDescriptionProvider, DefaultReferenceDescriptionProvider } from './workspace/ast-descriptions.js';\nimport { DefaultAstNodeLocator } from './workspace/ast-node-locator.js';\nimport { DefaultConfigurationProvider } from './workspace/configuration.js';\nimport { DefaultDocumentBuilder } from './workspace/document-builder.js';\nimport { DefaultLangiumDocumentFactory, DefaultLangiumDocuments } from './workspace/documents.js';\nimport { DefaultIndexManager } from './workspace/index-manager.js';\nimport { DefaultWorkspaceManager } from './workspace/workspace-manager.js';\nimport { DefaultLexer, DefaultLexerErrorMessageProvider } from './parser/lexer.js';\nimport { JSDocDocumentationProvider } from './documentation/documentation-provider.js';\nimport { DefaultCommentProvider } from './documentation/comment-provider.js';\nimport { LangiumParserErrorMessageProvider } from './parser/langium-parser.js';\nimport { DefaultAsyncParser } from './parser/async-parser.js';\nimport { DefaultWorkspaceLock } from './workspace/workspace-lock.js';\nimport { DefaultHydrator } from './serializer/hydrator.js';\n/**\n * Creates a dependency injection module configuring the default core services.\n * This is a set of services that are dedicated to a specific language.\n */\nexport function createDefaultCoreModule(context) {\n return {\n documentation: {\n CommentProvider: (services) => new DefaultCommentProvider(services),\n DocumentationProvider: (services) => new JSDocDocumentationProvider(services)\n },\n parser: {\n AsyncParser: (services) => new DefaultAsyncParser(services),\n GrammarConfig: (services) => createGrammarConfig(services),\n LangiumParser: (services) => createLangiumParser(services),\n CompletionParser: (services) => createCompletionParser(services),\n ValueConverter: () => new DefaultValueConverter(),\n TokenBuilder: () => new DefaultTokenBuilder(),\n Lexer: (services) => new DefaultLexer(services),\n ParserErrorMessageProvider: () => new LangiumParserErrorMessageProvider(),\n LexerErrorMessageProvider: () => new DefaultLexerErrorMessageProvider()\n },\n workspace: {\n AstNodeLocator: () => new DefaultAstNodeLocator(),\n AstNodeDescriptionProvider: (services) => new DefaultAstNodeDescriptionProvider(services),\n ReferenceDescriptionProvider: (services) => new DefaultReferenceDescriptionProvider(services)\n },\n references: {\n Linker: (services) => new DefaultLinker(services),\n NameProvider: () => new DefaultNameProvider(),\n ScopeProvider: (services) => new DefaultScopeProvider(services),\n ScopeComputation: (services) => new DefaultScopeComputation(services),\n References: (services) => new DefaultReferences(services)\n },\n serializer: {\n Hydrator: (services) => new DefaultHydrator(services),\n JsonSerializer: (services) => new DefaultJsonSerializer(services)\n },\n validation: {\n DocumentValidator: (services) => new DefaultDocumentValidator(services),\n ValidationRegistry: (services) => new ValidationRegistry(services)\n },\n shared: () => context.shared\n };\n}\n/**\n * Creates a dependency injection module configuring the default shared core services.\n * This is the set of services that are shared between multiple languages.\n */\nexport function createDefaultSharedCoreModule(context) {\n return {\n ServiceRegistry: (services) => new DefaultServiceRegistry(services),\n workspace: {\n LangiumDocuments: (services) => new DefaultLangiumDocuments(services),\n LangiumDocumentFactory: (services) => new DefaultLangiumDocumentFactory(services),\n DocumentBuilder: (services) => new DefaultDocumentBuilder(services),\n IndexManager: (services) => new DefaultIndexManager(services),\n WorkspaceManager: (services) => new DefaultWorkspaceManager(services),\n FileSystemProvider: (services) => context.fileSystemProvider(services),\n WorkspaceLock: () => new DefaultWorkspaceLock(),\n ConfigurationProvider: (services) => new DefaultConfigurationProvider(services)\n }\n };\n}\n//# sourceMappingURL=default-module.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport var Module;\n(function (Module) {\n Module.merge = (m1, m2) => _merge(_merge({}, m1), m2);\n})(Module || (Module = {}));\n/**\n * Given a set of modules, the inject function returns a lazily evaluated injector\n * that injects dependencies into the requested service when it is requested the\n * first time. Subsequent requests will return the same service.\n *\n * In the case of cyclic dependencies, an Error will be thrown. This can be fixed\n * by injecting a provider `() => T` instead of a `T`.\n *\n * Please note that the arguments may be objects or arrays. However, the result will\n * be an object. Using it with for..of will have no effect.\n *\n * @param module1 first Module\n * @param module2 (optional) second Module\n * @param module3 (optional) third Module\n * @param module4 (optional) fourth Module\n * @param module5 (optional) fifth Module\n * @param module6 (optional) sixth Module\n * @param module7 (optional) seventh Module\n * @param module8 (optional) eighth Module\n * @param module9 (optional) ninth Module\n * @returns a new object of type I\n */\nexport function inject(module1, module2, module3, module4, module5, module6, module7, module8, module9) {\n const module = [module1, module2, module3, module4, module5, module6, module7, module8, module9].reduce(_merge, {});\n return _inject(module);\n}\nconst isProxy = Symbol('isProxy');\n/**\n * Eagerly load all services in the given dependency injection container. This is sometimes\n * necessary because services can register event listeners in their constructors.\n */\nexport function eagerLoad(item) {\n if (item && item[isProxy]) {\n for (const value of Object.values(item)) {\n eagerLoad(value);\n }\n }\n return item;\n}\n/**\n * Helper function that returns an injector by creating a proxy.\n * Invariant: injector is of type I. If injector is undefined, then T = I.\n */\nfunction _inject(module, injector) {\n const proxy = new Proxy({}, {\n deleteProperty: () => false,\n set: () => {\n throw new Error('Cannot set property on injected service container');\n },\n get: (obj, prop) => {\n if (prop === isProxy) {\n return true;\n }\n else {\n return _resolve(obj, prop, module, injector || proxy);\n }\n },\n getOwnPropertyDescriptor: (obj, prop) => (_resolve(obj, prop, module, injector || proxy), Object.getOwnPropertyDescriptor(obj, prop)), // used by for..in\n has: (_, prop) => prop in module, // used by ..in..\n ownKeys: () => [...Object.getOwnPropertyNames(module)] // used by for..in\n });\n return proxy;\n}\n/**\n * Internally used to tag a requested dependency, directly before calling the factory.\n * This allows us to find cycles during instance creation.\n */\nconst __requested__ = Symbol();\n/**\n * Returns the value `obj[prop]`. If the value does not exist, yet, it is resolved from\n * the module description. The result of service factories is cached. Groups are\n * recursively proxied.\n *\n * @param obj an object holding all group proxies and services\n * @param prop the key of a value within obj\n * @param module an object containing groups and service factories\n * @param injector the first level proxy that provides access to all values\n * @returns the requested value `obj[prop]`\n * @throws Error if a dependency cycle is detected\n */\nfunction _resolve(obj, prop, module, injector) {\n if (prop in obj) {\n if (obj[prop] instanceof Error) {\n throw new Error('Construction failure. Please make sure that your dependencies are constructable.', { cause: obj[prop] });\n }\n if (obj[prop] === __requested__) {\n throw new Error('Cycle detected. Please make \"' + String(prop) + '\" lazy. Visit https://langium.org/docs/reference/configuration-services/#resolving-cyclic-dependencies');\n }\n return obj[prop];\n }\n else if (prop in module) {\n const value = module[prop];\n obj[prop] = __requested__;\n try {\n obj[prop] = (typeof value === 'function') ? value(injector) : _inject(value, injector);\n }\n catch (error) {\n obj[prop] = error instanceof Error ? error : undefined;\n throw error;\n }\n return obj[prop];\n }\n else {\n return undefined;\n }\n}\n/**\n * Performs a deep-merge of two modules by writing source entries into the target module.\n *\n * @param target the module which is written\n * @param source the module which is read\n * @returns the target module\n */\nfunction _merge(target, source) {\n if (source) {\n for (const [key, value2] of Object.entries(source)) {\n if (value2 !== undefined) {\n const value1 = target[key];\n if (value1 !== null && value2 !== null && typeof value1 === 'object' && typeof value2 === 'object') {\n target[key] = _merge(value1, value2);\n }\n else {\n target[key] = value2;\n }\n }\n }\n }\n return target;\n}\n//# sourceMappingURL=dependency-injection.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport class EmptyFileSystemProvider {\n readFile() {\n throw new Error('No file system is available.');\n }\n async readDirectory() {\n return [];\n }\n}\nexport const EmptyFileSystem = {\n fileSystemProvider: () => new EmptyFileSystemProvider()\n};\n//# sourceMappingURL=file-system-provider.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { createDefaultCoreModule, createDefaultSharedCoreModule } from '../default-module.js';\nimport { inject } from '../dependency-injection.js';\nimport * as ast from '../languages/generated/ast.js';\nimport { EmptyFileSystem } from '../workspace/file-system-provider.js';\nimport { URI } from './uri-utils.js';\nconst minimalGrammarModule = {\n Grammar: () => undefined,\n LanguageMetaData: () => ({\n caseInsensitive: false,\n fileExtensions: ['.langium'],\n languageId: 'langium'\n })\n};\nconst minimalSharedGrammarModule = {\n AstReflection: () => new ast.LangiumGrammarAstReflection()\n};\nfunction createMinimalGrammarServices() {\n const shared = inject(createDefaultSharedCoreModule(EmptyFileSystem), minimalSharedGrammarModule);\n const grammar = inject(createDefaultCoreModule({ shared }), minimalGrammarModule);\n shared.ServiceRegistry.register(grammar);\n return grammar;\n}\n/**\n * Load a Langium grammar for your language from a JSON string. This is used by several services,\n * most notably the parser builder which interprets the grammar to create a parser.\n */\nexport function loadGrammarFromJson(json) {\n var _a;\n const services = createMinimalGrammarServices();\n const astNode = services.serializer.JsonSerializer.deserialize(json);\n services.shared.workspace.LangiumDocumentFactory.fromModel(astNode, URI.parse(`memory://${(_a = astNode.name) !== null && _a !== void 0 ? _a : 'grammar'}.langium`));\n return astNode;\n}\n//# sourceMappingURL=grammar-loader.js.map","var __defProp = Object.defineProperty;\nvar __name = (target, value) => __defProp(target, \"name\", { value, configurable: true });\n\n// src/language/generated/ast.ts\nimport { AbstractAstReflection } from \"langium\";\nvar Statement = \"Statement\";\nvar Architecture = \"Architecture\";\nfunction isArchitecture(item) {\n return reflection.isInstance(item, Architecture);\n}\n__name(isArchitecture, \"isArchitecture\");\nvar Axis = \"Axis\";\nvar Branch = \"Branch\";\nfunction isBranch(item) {\n return reflection.isInstance(item, Branch);\n}\n__name(isBranch, \"isBranch\");\nvar Checkout = \"Checkout\";\nvar CherryPicking = \"CherryPicking\";\nvar ClassDefStatement = \"ClassDefStatement\";\nvar Commit = \"Commit\";\nfunction isCommit(item) {\n return reflection.isInstance(item, Commit);\n}\n__name(isCommit, \"isCommit\");\nvar Curve = \"Curve\";\nvar Edge = \"Edge\";\nvar Entry = \"Entry\";\nvar GitGraph = \"GitGraph\";\nfunction isGitGraph(item) {\n return reflection.isInstance(item, GitGraph);\n}\n__name(isGitGraph, \"isGitGraph\");\nvar Group = \"Group\";\nvar Info = \"Info\";\nfunction isInfo(item) {\n return reflection.isInstance(item, Info);\n}\n__name(isInfo, \"isInfo\");\nvar Item = \"Item\";\nvar Junction = \"Junction\";\nvar Merge = \"Merge\";\nfunction isMerge(item) {\n return reflection.isInstance(item, Merge);\n}\n__name(isMerge, \"isMerge\");\nvar Option = \"Option\";\nvar Packet = \"Packet\";\nfunction isPacket(item) {\n return reflection.isInstance(item, Packet);\n}\n__name(isPacket, \"isPacket\");\nvar PacketBlock = \"PacketBlock\";\nfunction isPacketBlock(item) {\n return reflection.isInstance(item, PacketBlock);\n}\n__name(isPacketBlock, \"isPacketBlock\");\nvar Pie = \"Pie\";\nfunction isPie(item) {\n return reflection.isInstance(item, Pie);\n}\n__name(isPie, \"isPie\");\nvar PieSection = \"PieSection\";\nfunction isPieSection(item) {\n return reflection.isInstance(item, PieSection);\n}\n__name(isPieSection, \"isPieSection\");\nvar Radar = \"Radar\";\nvar Service = \"Service\";\nvar Treemap = \"Treemap\";\nfunction isTreemap(item) {\n return reflection.isInstance(item, Treemap);\n}\n__name(isTreemap, \"isTreemap\");\nvar TreemapRow = \"TreemapRow\";\nvar Direction = \"Direction\";\nvar Leaf = \"Leaf\";\nvar Section = \"Section\";\nvar MermaidAstReflection = class extends AbstractAstReflection {\n static {\n __name(this, \"MermaidAstReflection\");\n }\n getAllTypes() {\n return [Architecture, Axis, Branch, Checkout, CherryPicking, ClassDefStatement, Commit, Curve, Direction, Edge, Entry, GitGraph, Group, Info, Item, Junction, Leaf, Merge, Option, Packet, PacketBlock, Pie, PieSection, Radar, Section, Service, Statement, Treemap, TreemapRow];\n }\n computeIsSubtype(subtype, supertype) {\n switch (subtype) {\n case Branch:\n case Checkout:\n case CherryPicking:\n case Commit:\n case Merge: {\n return this.isSubtype(Statement, supertype);\n }\n case Direction: {\n return this.isSubtype(GitGraph, supertype);\n }\n case Leaf:\n case Section: {\n return this.isSubtype(Item, supertype);\n }\n default: {\n return false;\n }\n }\n }\n getReferenceType(refInfo) {\n const referenceId = `${refInfo.container.$type}:${refInfo.property}`;\n switch (referenceId) {\n case \"Entry:axis\": {\n return Axis;\n }\n default: {\n throw new Error(`${referenceId} is not a valid reference id.`);\n }\n }\n }\n getTypeMetaData(type) {\n switch (type) {\n case Architecture: {\n return {\n name: Architecture,\n properties: [\n { name: \"accDescr\" },\n { name: \"accTitle\" },\n { name: \"edges\", defaultValue: [] },\n { name: \"groups\", defaultValue: [] },\n { name: \"junctions\", defaultValue: [] },\n { name: \"services\", defaultValue: [] },\n { name: \"title\" }\n ]\n };\n }\n case Axis: {\n return {\n name: Axis,\n properties: [\n { name: \"label\" },\n { name: \"name\" }\n ]\n };\n }\n case Branch: {\n return {\n name: Branch,\n properties: [\n { name: \"name\" },\n { name: \"order\" }\n ]\n };\n }\n case Checkout: {\n return {\n name: Checkout,\n properties: [\n { name: \"branch\" }\n ]\n };\n }\n case CherryPicking: {\n return {\n name: CherryPicking,\n properties: [\n { name: \"id\" },\n { name: \"parent\" },\n { name: \"tags\", defaultValue: [] }\n ]\n };\n }\n case ClassDefStatement: {\n return {\n name: ClassDefStatement,\n properties: [\n { name: \"className\" },\n { name: \"styleText\" }\n ]\n };\n }\n case Commit: {\n return {\n name: Commit,\n properties: [\n { name: \"id\" },\n { name: \"message\" },\n { name: \"tags\", defaultValue: [] },\n { name: \"type\" }\n ]\n };\n }\n case Curve: {\n return {\n name: Curve,\n properties: [\n { name: \"entries\", defaultValue: [] },\n { name: \"label\" },\n { name: \"name\" }\n ]\n };\n }\n case Edge: {\n return {\n name: Edge,\n properties: [\n { name: \"lhsDir\" },\n { name: \"lhsGroup\", defaultValue: false },\n { name: \"lhsId\" },\n { name: \"lhsInto\", defaultValue: false },\n { name: \"rhsDir\" },\n { name: \"rhsGroup\", defaultValue: false },\n { name: \"rhsId\" },\n { name: \"rhsInto\", defaultValue: false },\n { name: \"title\" }\n ]\n };\n }\n case Entry: {\n return {\n name: Entry,\n properties: [\n { name: \"axis\" },\n { name: \"value\" }\n ]\n };\n }\n case GitGraph: {\n return {\n name: GitGraph,\n properties: [\n { name: \"accDescr\" },\n { name: \"accTitle\" },\n { name: \"statements\", defaultValue: [] },\n { name: \"title\" }\n ]\n };\n }\n case Group: {\n return {\n name: Group,\n properties: [\n { name: \"icon\" },\n { name: \"id\" },\n { name: \"in\" },\n { name: \"title\" }\n ]\n };\n }\n case Info: {\n return {\n name: Info,\n properties: [\n { name: \"accDescr\" },\n { name: \"accTitle\" },\n { name: \"title\" }\n ]\n };\n }\n case Item: {\n return {\n name: Item,\n properties: [\n { name: \"classSelector\" },\n { name: \"name\" }\n ]\n };\n }\n case Junction: {\n return {\n name: Junction,\n properties: [\n { name: \"id\" },\n { name: \"in\" }\n ]\n };\n }\n case Merge: {\n return {\n name: Merge,\n properties: [\n { name: \"branch\" },\n { name: \"id\" },\n { name: \"tags\", defaultValue: [] },\n { name: \"type\" }\n ]\n };\n }\n case Option: {\n return {\n name: Option,\n properties: [\n { name: \"name\" },\n { name: \"value\", defaultValue: false }\n ]\n };\n }\n case Packet: {\n return {\n name: Packet,\n properties: [\n { name: \"accDescr\" },\n { name: \"accTitle\" },\n { name: \"blocks\", defaultValue: [] },\n { name: \"title\" }\n ]\n };\n }\n case PacketBlock: {\n return {\n name: PacketBlock,\n properties: [\n { name: \"bits\" },\n { name: \"end\" },\n { name: \"label\" },\n { name: \"start\" }\n ]\n };\n }\n case Pie: {\n return {\n name: Pie,\n properties: [\n { name: \"accDescr\" },\n { name: \"accTitle\" },\n { name: \"sections\", defaultValue: [] },\n { name: \"showData\", defaultValue: false },\n { name: \"title\" }\n ]\n };\n }\n case PieSection: {\n return {\n name: PieSection,\n properties: [\n { name: \"label\" },\n { name: \"value\" }\n ]\n };\n }\n case Radar: {\n return {\n name: Radar,\n properties: [\n { name: \"accDescr\" },\n { name: \"accTitle\" },\n { name: \"axes\", defaultValue: [] },\n { name: \"curves\", defaultValue: [] },\n { name: \"options\", defaultValue: [] },\n { name: \"title\" }\n ]\n };\n }\n case Service: {\n return {\n name: Service,\n properties: [\n { name: \"icon\" },\n { name: \"iconText\" },\n { name: \"id\" },\n { name: \"in\" },\n { name: \"title\" }\n ]\n };\n }\n case Treemap: {\n return {\n name: Treemap,\n properties: [\n { name: \"accDescr\" },\n { name: \"accTitle\" },\n { name: \"title\" },\n { name: \"TreemapRows\", defaultValue: [] }\n ]\n };\n }\n case TreemapRow: {\n return {\n name: TreemapRow,\n properties: [\n { name: \"indent\" },\n { name: \"item\" }\n ]\n };\n }\n case Direction: {\n return {\n name: Direction,\n properties: [\n { name: \"accDescr\" },\n { name: \"accTitle\" },\n { name: \"dir\" },\n { name: \"statements\", defaultValue: [] },\n { name: \"title\" }\n ]\n };\n }\n case Leaf: {\n return {\n name: Leaf,\n properties: [\n { name: \"classSelector\" },\n { name: \"name\" },\n { name: \"value\" }\n ]\n };\n }\n case Section: {\n return {\n name: Section,\n properties: [\n { name: \"classSelector\" },\n { name: \"name\" }\n ]\n };\n }\n default: {\n return {\n name: type,\n properties: []\n };\n }\n }\n }\n};\nvar reflection = new MermaidAstReflection();\n\n// src/language/generated/grammar.ts\nimport { loadGrammarFromJson } from \"langium\";\nvar loadedInfoGrammar;\nvar InfoGrammar = /* @__PURE__ */ __name(() => loadedInfoGrammar ?? (loadedInfoGrammar = loadGrammarFromJson(`{\"$type\":\"Grammar\",\"isDeclared\":true,\"name\":\"Info\",\"imports\":[],\"rules\":[{\"$type\":\"ParserRule\",\"entry\":true,\"name\":\"Info\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Keyword\",\"value\":\"info\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"showInfo\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[],\"cardinality\":\"*\"}],\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[],\"cardinality\":\"?\"}]},\"definesHiddenTokens\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"EOL\",\"dataType\":\"string\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[],\"cardinality\":\"+\"},{\"$type\":\"EndOfFile\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"TitleAndAccessibilities\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"accDescr\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@4\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"accTitle\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[]}}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]}],\"cardinality\":\"+\"},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"BOOLEAN\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"boolean\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"true\"}},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"false\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_DESCR\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accDescr(?:[\\\\\\\\t ]*:([^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)|\\\\\\\\s*{([^}]*)})/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accTitle[\\\\\\\\t ]*:(?:[^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*title(?:[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*|)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"FLOAT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[0-9]+\\\\\\\\.[0-9]+(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"INT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/0|[1-9][0-9]*(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NUMBER\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@7\"}},{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"STRING\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\"([^\\\\\"\\\\\\\\\\\\\\\\]|\\\\\\\\\\\\\\\\.)*\\\\\"|'([^'\\\\\\\\\\\\\\\\]|\\\\\\\\\\\\\\\\.)*'/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ID\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\w]([-\\\\\\\\w]*\\\\\\\\w)?/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NEWLINE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\r?\\\\\\\\n/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"WHITESPACE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]+/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"YAML\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/---[\\\\\\\\t ]*\\\\\\\\r?\\\\\\\\n(?:[\\\\\\\\S\\\\\\\\s]*?\\\\\\\\r?\\\\\\\\n)?---(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"DIRECTIVE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%{[\\\\\\\\S\\\\\\\\s]*?}%%(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"SINGLE_LINE_COMMENT\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%[^\\\\\\\\n\\\\\\\\r]*/\"},\"fragment\":false}],\"definesHiddenTokens\":false,\"hiddenTokens\":[],\"interfaces\":[],\"types\":[],\"usedGrammars\":[]}`)), \"InfoGrammar\");\nvar loadedPacketGrammar;\nvar PacketGrammar = /* @__PURE__ */ __name(() => loadedPacketGrammar ?? (loadedPacketGrammar = loadGrammarFromJson(`{\"$type\":\"Grammar\",\"isDeclared\":true,\"name\":\"Packet\",\"imports\":[],\"rules\":[{\"$type\":\"ParserRule\",\"entry\":true,\"name\":\"Packet\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@13\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"packet\"},{\"$type\":\"Keyword\",\"value\":\"packet-beta\"}]},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[]},{\"$type\":\"Assignment\",\"feature\":\"blocks\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]}},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@13\"},\"arguments\":[]}],\"cardinality\":\"*\"}]},\"definesHiddenTokens\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"PacketBlock\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"start\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"},\"arguments\":[]}},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"-\"},{\"$type\":\"Assignment\",\"feature\":\"end\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"},\"arguments\":[]}}],\"cardinality\":\"?\"}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"+\"},{\"$type\":\"Assignment\",\"feature\":\"bits\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"},\"arguments\":[]}}]}]},{\"$type\":\"Keyword\",\"value\":\":\"},{\"$type\":\"Assignment\",\"feature\":\"label\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@11\"},\"arguments\":[]}},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"EOL\",\"dataType\":\"string\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@13\"},\"arguments\":[],\"cardinality\":\"+\"},{\"$type\":\"EndOfFile\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"TitleAndAccessibilities\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"accDescr\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"accTitle\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@7\"},\"arguments\":[]}}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[]}],\"cardinality\":\"+\"},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"BOOLEAN\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"boolean\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"true\"}},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"false\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_DESCR\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accDescr(?:[\\\\\\\\t ]*:([^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)|\\\\\\\\s*{([^}]*)})/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accTitle[\\\\\\\\t ]*:(?:[^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*title(?:[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*|)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"FLOAT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[0-9]+\\\\\\\\.[0-9]+(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"INT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/0|[1-9][0-9]*(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NUMBER\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"}},{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"STRING\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\"([^\\\\\"\\\\\\\\\\\\\\\\]|\\\\\\\\\\\\\\\\.)*\\\\\"|'([^'\\\\\\\\\\\\\\\\]|\\\\\\\\\\\\\\\\.)*'/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ID\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\w]([-\\\\\\\\w]*\\\\\\\\w)?/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NEWLINE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\r?\\\\\\\\n/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"WHITESPACE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]+/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"YAML\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/---[\\\\\\\\t ]*\\\\\\\\r?\\\\\\\\n(?:[\\\\\\\\S\\\\\\\\s]*?\\\\\\\\r?\\\\\\\\n)?---(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"DIRECTIVE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%{[\\\\\\\\S\\\\\\\\s]*?}%%(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"SINGLE_LINE_COMMENT\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%[^\\\\\\\\n\\\\\\\\r]*/\"},\"fragment\":false}],\"definesHiddenTokens\":false,\"hiddenTokens\":[],\"interfaces\":[],\"types\":[],\"usedGrammars\":[]}`)), \"PacketGrammar\");\nvar loadedPieGrammar;\nvar PieGrammar = /* @__PURE__ */ __name(() => loadedPieGrammar ?? (loadedPieGrammar = loadGrammarFromJson(`{\"$type\":\"Grammar\",\"isDeclared\":true,\"name\":\"Pie\",\"imports\":[],\"rules\":[{\"$type\":\"ParserRule\",\"entry\":true,\"name\":\"Pie\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@16\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Keyword\",\"value\":\"pie\"},{\"$type\":\"Assignment\",\"feature\":\"showData\",\"operator\":\"?=\",\"terminal\":{\"$type\":\"Keyword\",\"value\":\"showData\"},\"cardinality\":\"?\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[]},{\"$type\":\"Assignment\",\"feature\":\"sections\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]}},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@16\"},\"arguments\":[]}],\"cardinality\":\"*\"}]},\"definesHiddenTokens\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"PieSection\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"label\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@14\"},\"arguments\":[]}},{\"$type\":\"Keyword\",\"value\":\":\"},{\"$type\":\"Assignment\",\"feature\":\"value\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@4\"},\"arguments\":[]}},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"FLOAT_PIE\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/-?[0-9]+\\\\\\\\.[0-9]+(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"INT_PIE\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/-?(0|[1-9][0-9]*)(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NUMBER_PIE\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"}},{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"EOL\",\"dataType\":\"string\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@16\"},\"arguments\":[],\"cardinality\":\"+\"},{\"$type\":\"EndOfFile\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"TitleAndAccessibilities\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"accDescr\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"accTitle\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@10\"},\"arguments\":[]}}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}],\"cardinality\":\"+\"},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"BOOLEAN\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"boolean\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"true\"}},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"false\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_DESCR\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accDescr(?:[\\\\\\\\t ]*:([^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)|\\\\\\\\s*{([^}]*)})/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accTitle[\\\\\\\\t ]*:(?:[^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*title(?:[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*|)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"FLOAT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[0-9]+\\\\\\\\.[0-9]+(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"INT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/0|[1-9][0-9]*(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NUMBER\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@11\"}},{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"STRING\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\"([^\\\\\"\\\\\\\\\\\\\\\\]|\\\\\\\\\\\\\\\\.)*\\\\\"|'([^'\\\\\\\\\\\\\\\\]|\\\\\\\\\\\\\\\\.)*'/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ID\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\w]([-\\\\\\\\w]*\\\\\\\\w)?/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NEWLINE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\r?\\\\\\\\n/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"WHITESPACE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]+/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"YAML\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/---[\\\\\\\\t ]*\\\\\\\\r?\\\\\\\\n(?:[\\\\\\\\S\\\\\\\\s]*?\\\\\\\\r?\\\\\\\\n)?---(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"DIRECTIVE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%{[\\\\\\\\S\\\\\\\\s]*?}%%(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"SINGLE_LINE_COMMENT\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%[^\\\\\\\\n\\\\\\\\r]*/\"},\"fragment\":false}],\"definesHiddenTokens\":false,\"hiddenTokens\":[],\"interfaces\":[],\"types\":[],\"usedGrammars\":[]}`)), \"PieGrammar\");\nvar loadedArchitectureGrammar;\nvar ArchitectureGrammar = /* @__PURE__ */ __name(() => loadedArchitectureGrammar ?? (loadedArchitectureGrammar = loadGrammarFromJson(`{\"$type\":\"Grammar\",\"isDeclared\":true,\"name\":\"Architecture\",\"imports\":[],\"rules\":[{\"$type\":\"ParserRule\",\"entry\":true,\"name\":\"Architecture\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@23\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Keyword\",\"value\":\"architecture-beta\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@23\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@13\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]}],\"cardinality\":\"*\"}]},\"definesHiddenTokens\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"Statement\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"groups\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"services\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"junctions\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@7\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"edges\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]}}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"LeftPort\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\":\"},{\"$type\":\"Assignment\",\"feature\":\"lhsDir\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"},\"arguments\":[]}}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"RightPort\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"rhsDir\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"},\"arguments\":[]}},{\"$type\":\"Keyword\",\"value\":\":\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"Arrow\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[]},{\"$type\":\"Assignment\",\"feature\":\"lhsInto\",\"operator\":\"?=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@11\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"--\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"-\"},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@29\"},\"arguments\":[]}},{\"$type\":\"Keyword\",\"value\":\"-\"}]}]},{\"$type\":\"Assignment\",\"feature\":\"rhsInto\",\"operator\":\"?=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@11\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Group\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"group\"},{\"$type\":\"Assignment\",\"feature\":\"id\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@22\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"icon\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@28\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@29\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"in\"},{\"$type\":\"Assignment\",\"feature\":\"in\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@22\"},\"arguments\":[]}}],\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Service\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"service\"},{\"$type\":\"Assignment\",\"feature\":\"id\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@22\"},\"arguments\":[]}},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"iconText\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@21\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"icon\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@28\"},\"arguments\":[]}}],\"cardinality\":\"?\"},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@29\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"in\"},{\"$type\":\"Assignment\",\"feature\":\"in\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@22\"},\"arguments\":[]}}],\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Junction\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"junction\"},{\"$type\":\"Assignment\",\"feature\":\"id\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@22\"},\"arguments\":[]}},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"in\"},{\"$type\":\"Assignment\",\"feature\":\"in\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@22\"},\"arguments\":[]}}],\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Edge\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"lhsId\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@22\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"lhsGroup\",\"operator\":\"?=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@10\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@4\"},\"arguments\":[]},{\"$type\":\"Assignment\",\"feature\":\"rhsId\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@22\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"rhsGroup\",\"operator\":\"?=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@10\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"ARROW_DIRECTION\",\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"L\"}},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"R\"}}]},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"T\"}}]},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"B\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ARROW_GROUP\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\{group\\\\\\\\}/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ARROW_INTO\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/<|>/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"EOL\",\"dataType\":\"string\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@23\"},\"arguments\":[],\"cardinality\":\"+\"},{\"$type\":\"EndOfFile\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"TitleAndAccessibilities\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"accDescr\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@15\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"accTitle\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@16\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[]}],\"cardinality\":\"+\"},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"BOOLEAN\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"boolean\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"true\"}},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"false\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_DESCR\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accDescr(?:[\\\\\\\\t ]*:([^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)|\\\\\\\\s*{([^}]*)})/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accTitle[\\\\\\\\t ]*:(?:[^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*title(?:[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*|)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"FLOAT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[0-9]+\\\\\\\\.[0-9]+(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"INT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/0|[1-9][0-9]*(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NUMBER\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@18\"}},{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"STRING\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\"([^\\\\\"\\\\\\\\\\\\\\\\]|\\\\\\\\\\\\\\\\.)*\\\\\"|'([^'\\\\\\\\\\\\\\\\]|\\\\\\\\\\\\\\\\.)*'/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ID\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\w]([-\\\\\\\\w]*\\\\\\\\w)?/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NEWLINE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\r?\\\\\\\\n/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"WHITESPACE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]+/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"YAML\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/---[\\\\\\\\t ]*\\\\\\\\r?\\\\\\\\n(?:[\\\\\\\\S\\\\\\\\s]*?\\\\\\\\r?\\\\\\\\n)?---(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"DIRECTIVE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%{[\\\\\\\\S\\\\\\\\s]*?}%%(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"SINGLE_LINE_COMMENT\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%[^\\\\\\\\n\\\\\\\\r]*/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"name\":\"ARCH_ICON\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\([\\\\\\\\w-:]+\\\\\\\\)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ARCH_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\[[\\\\\\\\w ]+\\\\\\\\]/\"},\"fragment\":false,\"hidden\":false}],\"definesHiddenTokens\":false,\"hiddenTokens\":[],\"interfaces\":[],\"types\":[],\"usedGrammars\":[]}`)), \"ArchitectureGrammar\");\nvar loadedGitGraphGrammar;\nvar GitGraphGrammar = /* @__PURE__ */ __name(() => loadedGitGraphGrammar ?? (loadedGitGraphGrammar = loadGrammarFromJson(`{\"$type\":\"Grammar\",\"isDeclared\":true,\"name\":\"GitGraph\",\"imports\":[],\"rules\":[{\"$type\":\"ParserRule\",\"entry\":true,\"name\":\"GitGraph\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"gitGraph\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"gitGraph\"},{\"$type\":\"Keyword\",\"value\":\":\"}]},{\"$type\":\"Keyword\",\"value\":\"gitGraph:\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"gitGraph\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[]},{\"$type\":\"Keyword\",\"value\":\":\"}]}]},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"},\"arguments\":[]},{\"$type\":\"Assignment\",\"feature\":\"statements\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]}}],\"cardinality\":\"*\"}]},\"definesHiddenTokens\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Statement\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@4\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@7\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Direction\",\"definition\":{\"$type\":\"Assignment\",\"feature\":\"dir\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"LR\"},{\"$type\":\"Keyword\",\"value\":\"TB\"},{\"$type\":\"Keyword\",\"value\":\"BT\"}]}},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Commit\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"commit\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"id:\"},{\"$type\":\"Assignment\",\"feature\":\"id\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"msg:\",\"cardinality\":\"?\"},{\"$type\":\"Assignment\",\"feature\":\"message\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"tag:\"},{\"$type\":\"Assignment\",\"feature\":\"tags\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"type:\"},{\"$type\":\"Assignment\",\"feature\":\"type\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"NORMAL\"},{\"$type\":\"Keyword\",\"value\":\"REVERSE\"},{\"$type\":\"Keyword\",\"value\":\"HIGHLIGHT\"}]}}]}],\"cardinality\":\"*\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Branch\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"branch\"},{\"$type\":\"Assignment\",\"feature\":\"name\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@24\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}]}},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"order:\"},{\"$type\":\"Assignment\",\"feature\":\"order\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@15\"},\"arguments\":[]}}],\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Merge\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"merge\"},{\"$type\":\"Assignment\",\"feature\":\"branch\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@24\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}]}},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"id:\"},{\"$type\":\"Assignment\",\"feature\":\"id\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"tag:\"},{\"$type\":\"Assignment\",\"feature\":\"tags\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"type:\"},{\"$type\":\"Assignment\",\"feature\":\"type\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"NORMAL\"},{\"$type\":\"Keyword\",\"value\":\"REVERSE\"},{\"$type\":\"Keyword\",\"value\":\"HIGHLIGHT\"}]}}]}],\"cardinality\":\"*\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Checkout\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"checkout\"},{\"$type\":\"Keyword\",\"value\":\"switch\"}]},{\"$type\":\"Assignment\",\"feature\":\"branch\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@24\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}]}},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"CherryPicking\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"cherry-pick\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"id:\"},{\"$type\":\"Assignment\",\"feature\":\"id\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"tag:\"},{\"$type\":\"Assignment\",\"feature\":\"tags\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"parent:\"},{\"$type\":\"Assignment\",\"feature\":\"parent\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}}]}],\"cardinality\":\"*\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"EOL\",\"dataType\":\"string\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"},\"arguments\":[],\"cardinality\":\"+\"},{\"$type\":\"EndOfFile\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"TitleAndAccessibilities\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"accDescr\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@11\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"accTitle\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@13\"},\"arguments\":[]}}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]}],\"cardinality\":\"+\"},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"BOOLEAN\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"boolean\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"true\"}},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"false\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_DESCR\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accDescr(?:[\\\\\\\\t ]*:([^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)|\\\\\\\\s*{([^}]*)})/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accTitle[\\\\\\\\t ]*:(?:[^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*title(?:[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*|)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"FLOAT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[0-9]+\\\\\\\\.[0-9]+(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"INT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/0|[1-9][0-9]*(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NUMBER\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@14\"}},{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@15\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"STRING\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\"([^\\\\\"\\\\\\\\\\\\\\\\]|\\\\\\\\\\\\\\\\.)*\\\\\"|'([^'\\\\\\\\\\\\\\\\]|\\\\\\\\\\\\\\\\.)*'/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ID\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\w]([-\\\\\\\\w]*\\\\\\\\w)?/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NEWLINE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\r?\\\\\\\\n/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"WHITESPACE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]+/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"YAML\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/---[\\\\\\\\t ]*\\\\\\\\r?\\\\\\\\n(?:[\\\\\\\\S\\\\\\\\s]*?\\\\\\\\r?\\\\\\\\n)?---(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"DIRECTIVE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%{[\\\\\\\\S\\\\\\\\s]*?}%%(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"SINGLE_LINE_COMMENT\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%[^\\\\\\\\n\\\\\\\\r]*/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"name\":\"REFERENCE\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\w([-\\\\\\\\./\\\\\\\\w]*[-\\\\\\\\w])?/\"},\"fragment\":false,\"hidden\":false}],\"definesHiddenTokens\":false,\"hiddenTokens\":[],\"interfaces\":[],\"types\":[],\"usedGrammars\":[]}`)), \"GitGraphGrammar\");\nvar loadedRadarGrammar;\nvar RadarGrammar = /* @__PURE__ */ __name(() => loadedRadarGrammar ?? (loadedRadarGrammar = loadGrammarFromJson(`{\"$type\":\"Grammar\",\"isDeclared\":true,\"name\":\"Radar\",\"imports\":[],\"rules\":[{\"$type\":\"ParserRule\",\"entry\":true,\"name\":\"Radar\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"radar-beta\"},{\"$type\":\"Keyword\",\"value\":\"radar-beta:\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"radar-beta\"},{\"$type\":\"Keyword\",\"value\":\":\"}]}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@10\"},\"arguments\":[]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"axis\"},{\"$type\":\"Assignment\",\"feature\":\"axes\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[]}},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\",\"},{\"$type\":\"Assignment\",\"feature\":\"axes\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[]}}],\"cardinality\":\"*\"}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"curve\"},{\"$type\":\"Assignment\",\"feature\":\"curves\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[]}},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\",\"},{\"$type\":\"Assignment\",\"feature\":\"curves\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[]}}],\"cardinality\":\"*\"}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"options\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@7\"},\"arguments\":[]}},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\",\"},{\"$type\":\"Assignment\",\"feature\":\"options\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@7\"},\"arguments\":[]}}],\"cardinality\":\"*\"}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}],\"cardinality\":\"*\"}]},\"definesHiddenTokens\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"Label\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"[\"},{\"$type\":\"Assignment\",\"feature\":\"label\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@18\"},\"arguments\":[]}},{\"$type\":\"Keyword\",\"value\":\"]\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Axis\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"name\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"},\"arguments\":[]}},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[],\"cardinality\":\"?\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Curve\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"name\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"},\"arguments\":[]}},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[],\"cardinality\":\"?\"},{\"$type\":\"Keyword\",\"value\":\"{\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@4\"},\"arguments\":[]},{\"$type\":\"Keyword\",\"value\":\"}\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"Entries\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Assignment\",\"feature\":\"entries\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[]}},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\",\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Assignment\",\"feature\":\"entries\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[]}}],\"cardinality\":\"*\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[],\"cardinality\":\"*\"}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Assignment\",\"feature\":\"entries\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\",\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Assignment\",\"feature\":\"entries\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}}],\"cardinality\":\"*\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[],\"cardinality\":\"*\"}]}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"DetailedEntry\",\"returnType\":{\"$ref\":\"#/interfaces@0\"},\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"axis\",\"operator\":\"=\",\"terminal\":{\"$type\":\"CrossReference\",\"type\":{\"$ref\":\"#/rules@2\"},\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"},\"arguments\":[]},\"deprecatedSyntax\":false}},{\"$type\":\"Keyword\",\"value\":\":\",\"cardinality\":\"?\"},{\"$type\":\"Assignment\",\"feature\":\"value\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"NumberEntry\",\"returnType\":{\"$ref\":\"#/interfaces@0\"},\"definition\":{\"$type\":\"Assignment\",\"feature\":\"value\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Option\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"name\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Keyword\",\"value\":\"showLegend\"}},{\"$type\":\"Assignment\",\"feature\":\"value\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@11\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"name\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Keyword\",\"value\":\"ticks\"}},{\"$type\":\"Assignment\",\"feature\":\"value\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"name\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Keyword\",\"value\":\"max\"}},{\"$type\":\"Assignment\",\"feature\":\"value\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"name\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Keyword\",\"value\":\"min\"}},{\"$type\":\"Assignment\",\"feature\":\"value\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"name\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Keyword\",\"value\":\"graticule\"}},{\"$type\":\"Assignment\",\"feature\":\"value\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]}}]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"GRATICULE\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"circle\"}},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"polygon\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"EOL\",\"dataType\":\"string\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[],\"cardinality\":\"+\"},{\"$type\":\"EndOfFile\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"TitleAndAccessibilities\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"accDescr\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"accTitle\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@13\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@14\"},\"arguments\":[]}}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"},\"arguments\":[]}],\"cardinality\":\"+\"},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"BOOLEAN\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"boolean\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"true\"}},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"false\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_DESCR\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accDescr(?:[\\\\\\\\t ]*:([^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)|\\\\\\\\s*{([^}]*)})/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accTitle[\\\\\\\\t ]*:(?:[^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*title(?:[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*|)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"FLOAT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[0-9]+\\\\\\\\.[0-9]+(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"INT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/0|[1-9][0-9]*(?!\\\\\\\\.)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NUMBER\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@15\"}},{\"$type\":\"TerminalRuleCall\",\"rule\":{\"$ref\":\"#/rules@16\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"STRING\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\"([^\\\\\"\\\\\\\\\\\\\\\\]|\\\\\\\\\\\\\\\\.)*\\\\\"|'([^'\\\\\\\\\\\\\\\\]|\\\\\\\\\\\\\\\\.)*'/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ID\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\w]([-\\\\\\\\w]*\\\\\\\\w)?/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NEWLINE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\r?\\\\\\\\n/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"WHITESPACE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]+/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"YAML\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/---[\\\\\\\\t ]*\\\\\\\\r?\\\\\\\\n(?:[\\\\\\\\S\\\\\\\\s]*?\\\\\\\\r?\\\\\\\\n)?---(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"DIRECTIVE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%{[\\\\\\\\S\\\\\\\\s]*?}%%(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"SINGLE_LINE_COMMENT\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%[^\\\\\\\\n\\\\\\\\r]*/\"},\"fragment\":false}],\"interfaces\":[{\"$type\":\"Interface\",\"name\":\"Entry\",\"attributes\":[{\"$type\":\"TypeAttribute\",\"name\":\"axis\",\"isOptional\":true,\"type\":{\"$type\":\"ReferenceType\",\"referenceType\":{\"$type\":\"SimpleType\",\"typeRef\":{\"$ref\":\"#/rules@2\"}}}},{\"$type\":\"TypeAttribute\",\"name\":\"value\",\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"number\"},\"isOptional\":false}],\"superTypes\":[]}],\"definesHiddenTokens\":false,\"hiddenTokens\":[],\"types\":[],\"usedGrammars\":[]}`)), \"RadarGrammar\");\nvar loadedTreemapGrammar;\nvar TreemapGrammar = /* @__PURE__ */ __name(() => loadedTreemapGrammar ?? (loadedTreemapGrammar = loadGrammarFromJson(`{\"$type\":\"Grammar\",\"isDeclared\":true,\"name\":\"Treemap\",\"rules\":[{\"$type\":\"ParserRule\",\"fragment\":true,\"name\":\"TitleAndAccessibilities\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"accDescr\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"accTitle\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@4\"},\"arguments\":[]}}],\"cardinality\":\"+\"},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"BOOLEAN\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"boolean\"},\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"true\"}},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"false\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_DESCR\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accDescr(?:[\\\\\\\\t ]*:([^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)|\\\\\\\\s*{([^}]*)})/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accTitle[\\\\\\\\t ]*:(?:[^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*title(?:[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*|)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"ParserRule\",\"entry\":true,\"name\":\"Treemap\",\"returnType\":{\"$ref\":\"#/interfaces@4\"},\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[]},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@0\"},\"arguments\":[]},{\"$type\":\"Assignment\",\"feature\":\"TreemapRows\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@14\"},\"arguments\":[]}}],\"cardinality\":\"*\"}]},\"definesHiddenTokens\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"TREEMAP_KEYWORD\",\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"treemap-beta\"}},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"treemap\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"CLASS_DEF\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/classDef\\\\\\\\s+([a-zA-Z_][a-zA-Z0-9_]+)(?:\\\\\\\\s+([^;\\\\\\\\r\\\\\\\\n]*))?(?:;)?/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"STYLE_SEPARATOR\",\"definition\":{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\":::\"}},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"SEPARATOR\",\"definition\":{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\":\"}},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"COMMA\",\"definition\":{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\",\"}},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"WS\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[ \\\\\\\\t]+/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"ML_COMMENT\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\%\\\\\\\\%[^\\\\\\\\n]*/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"NL\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\r?\\\\\\\\n/\"},\"fragment\":false},{\"$type\":\"ParserRule\",\"name\":\"TreemapRow\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"indent\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"item\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@16\"},\"arguments\":[]}},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@15\"},\"arguments\":[]}]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"ClassDef\",\"dataType\":\"string\",\"definition\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@7\"},\"arguments\":[]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Item\",\"returnType\":{\"$ref\":\"#/interfaces@0\"},\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@18\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Section\",\"returnType\":{\"$ref\":\"#/interfaces@1\"},\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"name\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@23\"},\"arguments\":[]}},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]},{\"$type\":\"Assignment\",\"feature\":\"classSelector\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}}],\"cardinality\":\"?\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Leaf\",\"returnType\":{\"$ref\":\"#/interfaces@2\"},\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"name\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@23\"},\"arguments\":[]}},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"},\"arguments\":[],\"cardinality\":\"?\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@10\"},\"arguments\":[]}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"},\"arguments\":[],\"cardinality\":\"?\"},{\"$type\":\"Assignment\",\"feature\":\"value\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@22\"},\"arguments\":[]}},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]},{\"$type\":\"Assignment\",\"feature\":\"classSelector\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}}],\"cardinality\":\"?\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"INDENTATION\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[ \\\\\\\\t]{1,}/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ID2\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[a-zA-Z_][a-zA-Z0-9_]*/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"NUMBER2\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[0-9_\\\\\\\\.\\\\\\\\,]+/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"ParserRule\",\"name\":\"MyNumber\",\"dataType\":\"number\",\"definition\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@21\"},\"arguments\":[]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"STRING2\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\"[^\\\\\"]*\\\\\"|'[^']*'/\"},\"fragment\":false,\"hidden\":false}],\"interfaces\":[{\"$type\":\"Interface\",\"name\":\"Item\",\"attributes\":[{\"$type\":\"TypeAttribute\",\"name\":\"name\",\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"},\"isOptional\":false},{\"$type\":\"TypeAttribute\",\"name\":\"classSelector\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}}],\"superTypes\":[]},{\"$type\":\"Interface\",\"name\":\"Section\",\"superTypes\":[{\"$ref\":\"#/interfaces@0\"}],\"attributes\":[]},{\"$type\":\"Interface\",\"name\":\"Leaf\",\"superTypes\":[{\"$ref\":\"#/interfaces@0\"}],\"attributes\":[{\"$type\":\"TypeAttribute\",\"name\":\"value\",\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"number\"},\"isOptional\":false}]},{\"$type\":\"Interface\",\"name\":\"ClassDefStatement\",\"attributes\":[{\"$type\":\"TypeAttribute\",\"name\":\"className\",\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"},\"isOptional\":false},{\"$type\":\"TypeAttribute\",\"name\":\"styleText\",\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"},\"isOptional\":false}],\"superTypes\":[]},{\"$type\":\"Interface\",\"name\":\"Treemap\",\"attributes\":[{\"$type\":\"TypeAttribute\",\"name\":\"TreemapRows\",\"type\":{\"$type\":\"ArrayType\",\"elementType\":{\"$type\":\"SimpleType\",\"typeRef\":{\"$ref\":\"#/rules@14\"}}},\"isOptional\":false},{\"$type\":\"TypeAttribute\",\"name\":\"title\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}},{\"$type\":\"TypeAttribute\",\"name\":\"accTitle\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}},{\"$type\":\"TypeAttribute\",\"name\":\"accDescr\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}}],\"superTypes\":[]}],\"definesHiddenTokens\":false,\"hiddenTokens\":[],\"imports\":[],\"types\":[],\"usedGrammars\":[],\"$comment\":\"/**\\\\n * Treemap grammar for Langium\\\\n * Converted from mindmap grammar\\\\n *\\\\n * The ML_COMMENT and NL hidden terminals handle whitespace, comments, and newlines\\\\n * before the treemap keyword, allowing for empty lines and comments before the\\\\n * treemap declaration.\\\\n */\"}`)), \"TreemapGrammar\");\n\n// src/language/generated/module.ts\nvar InfoLanguageMetaData = {\n languageId: \"info\",\n fileExtensions: [\".mmd\", \".mermaid\"],\n caseInsensitive: false,\n mode: \"production\"\n};\nvar PacketLanguageMetaData = {\n languageId: \"packet\",\n fileExtensions: [\".mmd\", \".mermaid\"],\n caseInsensitive: false,\n mode: \"production\"\n};\nvar PieLanguageMetaData = {\n languageId: \"pie\",\n fileExtensions: [\".mmd\", \".mermaid\"],\n caseInsensitive: false,\n mode: \"production\"\n};\nvar ArchitectureLanguageMetaData = {\n languageId: \"architecture\",\n fileExtensions: [\".mmd\", \".mermaid\"],\n caseInsensitive: false,\n mode: \"production\"\n};\nvar GitGraphLanguageMetaData = {\n languageId: \"gitGraph\",\n fileExtensions: [\".mmd\", \".mermaid\"],\n caseInsensitive: false,\n mode: \"production\"\n};\nvar RadarLanguageMetaData = {\n languageId: \"radar\",\n fileExtensions: [\".mmd\", \".mermaid\"],\n caseInsensitive: false,\n mode: \"production\"\n};\nvar TreemapLanguageMetaData = {\n languageId: \"treemap\",\n fileExtensions: [\".mmd\", \".mermaid\"],\n caseInsensitive: false,\n mode: \"production\"\n};\nvar MermaidGeneratedSharedModule = {\n AstReflection: /* @__PURE__ */ __name(() => new MermaidAstReflection(), \"AstReflection\")\n};\nvar InfoGeneratedModule = {\n Grammar: /* @__PURE__ */ __name(() => InfoGrammar(), \"Grammar\"),\n LanguageMetaData: /* @__PURE__ */ __name(() => InfoLanguageMetaData, \"LanguageMetaData\"),\n parser: {}\n};\nvar PacketGeneratedModule = {\n Grammar: /* @__PURE__ */ __name(() => PacketGrammar(), \"Grammar\"),\n LanguageMetaData: /* @__PURE__ */ __name(() => PacketLanguageMetaData, \"LanguageMetaData\"),\n parser: {}\n};\nvar PieGeneratedModule = {\n Grammar: /* @__PURE__ */ __name(() => PieGrammar(), \"Grammar\"),\n LanguageMetaData: /* @__PURE__ */ __name(() => PieLanguageMetaData, \"LanguageMetaData\"),\n parser: {}\n};\nvar ArchitectureGeneratedModule = {\n Grammar: /* @__PURE__ */ __name(() => ArchitectureGrammar(), \"Grammar\"),\n LanguageMetaData: /* @__PURE__ */ __name(() => ArchitectureLanguageMetaData, \"LanguageMetaData\"),\n parser: {}\n};\nvar GitGraphGeneratedModule = {\n Grammar: /* @__PURE__ */ __name(() => GitGraphGrammar(), \"Grammar\"),\n LanguageMetaData: /* @__PURE__ */ __name(() => GitGraphLanguageMetaData, \"LanguageMetaData\"),\n parser: {}\n};\nvar RadarGeneratedModule = {\n Grammar: /* @__PURE__ */ __name(() => RadarGrammar(), \"Grammar\"),\n LanguageMetaData: /* @__PURE__ */ __name(() => RadarLanguageMetaData, \"LanguageMetaData\"),\n parser: {}\n};\nvar TreemapGeneratedModule = {\n Grammar: /* @__PURE__ */ __name(() => TreemapGrammar(), \"Grammar\"),\n LanguageMetaData: /* @__PURE__ */ __name(() => TreemapLanguageMetaData, \"LanguageMetaData\"),\n parser: {}\n};\n\n// src/language/common/valueConverter.ts\nimport { DefaultValueConverter } from \"langium\";\n\n// src/language/common/matcher.ts\nvar accessibilityDescrRegex = /accDescr(?:[\\t ]*:([^\\n\\r]*)|\\s*{([^}]*)})/;\nvar accessibilityTitleRegex = /accTitle[\\t ]*:([^\\n\\r]*)/;\nvar titleRegex = /title([\\t ][^\\n\\r]*|)/;\n\n// src/language/common/valueConverter.ts\nvar rulesRegexes = {\n ACC_DESCR: accessibilityDescrRegex,\n ACC_TITLE: accessibilityTitleRegex,\n TITLE: titleRegex\n};\nvar AbstractMermaidValueConverter = class extends DefaultValueConverter {\n static {\n __name(this, \"AbstractMermaidValueConverter\");\n }\n runConverter(rule, input, cstNode) {\n let value = this.runCommonConverter(rule, input, cstNode);\n if (value === void 0) {\n value = this.runCustomConverter(rule, input, cstNode);\n }\n if (value === void 0) {\n return super.runConverter(rule, input, cstNode);\n }\n return value;\n }\n runCommonConverter(rule, input, _cstNode) {\n const regex = rulesRegexes[rule.name];\n if (regex === void 0) {\n return void 0;\n }\n const match = regex.exec(input);\n if (match === null) {\n return void 0;\n }\n if (match[1] !== void 0) {\n return match[1].trim().replace(/[\\t ]{2,}/gm, \" \");\n }\n if (match[2] !== void 0) {\n return match[2].replace(/^\\s*/gm, \"\").replace(/\\s+$/gm, \"\").replace(/[\\t ]{2,}/gm, \" \").replace(/[\\n\\r]{2,}/gm, \"\\n\");\n }\n return void 0;\n }\n};\nvar CommonValueConverter = class extends AbstractMermaidValueConverter {\n static {\n __name(this, \"CommonValueConverter\");\n }\n runCustomConverter(_rule, _input, _cstNode) {\n return void 0;\n }\n};\n\n// src/language/common/tokenBuilder.ts\nimport { DefaultTokenBuilder } from \"langium\";\nvar AbstractMermaidTokenBuilder = class extends DefaultTokenBuilder {\n static {\n __name(this, \"AbstractMermaidTokenBuilder\");\n }\n constructor(keywords) {\n super();\n this.keywords = new Set(keywords);\n }\n buildKeywordTokens(rules, terminalTokens, options) {\n const tokenTypes = super.buildKeywordTokens(rules, terminalTokens, options);\n tokenTypes.forEach((tokenType) => {\n if (this.keywords.has(tokenType.name) && tokenType.PATTERN !== void 0) {\n tokenType.PATTERN = new RegExp(tokenType.PATTERN.toString() + \"(?:(?=%%)|(?!\\\\S))\");\n }\n });\n return tokenTypes;\n }\n};\nvar CommonTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"CommonTokenBuilder\");\n }\n};\n\nexport {\n __name,\n Statement,\n Architecture,\n isArchitecture,\n Branch,\n isBranch,\n Commit,\n isCommit,\n GitGraph,\n isGitGraph,\n Info,\n isInfo,\n Merge,\n isMerge,\n Packet,\n isPacket,\n PacketBlock,\n isPacketBlock,\n Pie,\n isPie,\n PieSection,\n isPieSection,\n Radar,\n Treemap,\n isTreemap,\n MermaidGeneratedSharedModule,\n InfoGeneratedModule,\n PacketGeneratedModule,\n PieGeneratedModule,\n ArchitectureGeneratedModule,\n GitGraphGeneratedModule,\n RadarGeneratedModule,\n TreemapGeneratedModule,\n AbstractMermaidValueConverter,\n CommonValueConverter,\n AbstractMermaidTokenBuilder,\n CommonTokenBuilder\n};\n","import {\n AbstractMermaidTokenBuilder,\n CommonValueConverter,\n GitGraphGeneratedModule,\n MermaidGeneratedSharedModule,\n __name\n} from \"./chunk-FPAJGGOC.mjs\";\n\n// src/language/gitGraph/module.ts\nimport {\n inject,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n EmptyFileSystem\n} from \"langium\";\n\n// src/language/gitGraph/tokenBuilder.ts\nvar GitGraphTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"GitGraphTokenBuilder\");\n }\n constructor() {\n super([\"gitGraph\"]);\n }\n};\n\n// src/language/gitGraph/module.ts\nvar GitGraphModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new GitGraphTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n }\n};\nfunction createGitGraphServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const GitGraph = inject(\n createDefaultCoreModule({ shared }),\n GitGraphGeneratedModule,\n GitGraphModule\n );\n shared.ServiceRegistry.register(GitGraph);\n return { shared, GitGraph };\n}\n__name(createGitGraphServices, \"createGitGraphServices\");\n\nexport {\n GitGraphModule,\n createGitGraphServices\n};\n","import {\n AbstractMermaidTokenBuilder,\n CommonValueConverter,\n InfoGeneratedModule,\n MermaidGeneratedSharedModule,\n __name\n} from \"./chunk-FPAJGGOC.mjs\";\n\n// src/language/info/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/info/tokenBuilder.ts\nvar InfoTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"InfoTokenBuilder\");\n }\n constructor() {\n super([\"info\", \"showInfo\"]);\n }\n};\n\n// src/language/info/module.ts\nvar InfoModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new InfoTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n }\n};\nfunction createInfoServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const Info = inject(\n createDefaultCoreModule({ shared }),\n InfoGeneratedModule,\n InfoModule\n );\n shared.ServiceRegistry.register(Info);\n return { shared, Info };\n}\n__name(createInfoServices, \"createInfoServices\");\n\nexport {\n InfoModule,\n createInfoServices\n};\n","import {\n AbstractMermaidTokenBuilder,\n CommonValueConverter,\n MermaidGeneratedSharedModule,\n PacketGeneratedModule,\n __name\n} from \"./chunk-FPAJGGOC.mjs\";\n\n// src/language/packet/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/packet/tokenBuilder.ts\nvar PacketTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"PacketTokenBuilder\");\n }\n constructor() {\n super([\"packet\"]);\n }\n};\n\n// src/language/packet/module.ts\nvar PacketModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new PacketTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n }\n};\nfunction createPacketServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const Packet = inject(\n createDefaultCoreModule({ shared }),\n PacketGeneratedModule,\n PacketModule\n );\n shared.ServiceRegistry.register(Packet);\n return { shared, Packet };\n}\n__name(createPacketServices, \"createPacketServices\");\n\nexport {\n PacketModule,\n createPacketServices\n};\n","import {\n AbstractMermaidTokenBuilder,\n AbstractMermaidValueConverter,\n MermaidGeneratedSharedModule,\n PieGeneratedModule,\n __name\n} from \"./chunk-FPAJGGOC.mjs\";\n\n// src/language/pie/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/pie/tokenBuilder.ts\nvar PieTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"PieTokenBuilder\");\n }\n constructor() {\n super([\"pie\", \"showData\"]);\n }\n};\n\n// src/language/pie/valueConverter.ts\nvar PieValueConverter = class extends AbstractMermaidValueConverter {\n static {\n __name(this, \"PieValueConverter\");\n }\n runCustomConverter(rule, input, _cstNode) {\n if (rule.name !== \"PIE_SECTION_LABEL\") {\n return void 0;\n }\n return input.replace(/\"/g, \"\").trim();\n }\n};\n\n// src/language/pie/module.ts\nvar PieModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new PieTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new PieValueConverter(), \"ValueConverter\")\n }\n};\nfunction createPieServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const Pie = inject(\n createDefaultCoreModule({ shared }),\n PieGeneratedModule,\n PieModule\n );\n shared.ServiceRegistry.register(Pie);\n return { shared, Pie };\n}\n__name(createPieServices, \"createPieServices\");\n\nexport {\n PieModule,\n createPieServices\n};\n","import {\n AbstractMermaidTokenBuilder,\n AbstractMermaidValueConverter,\n ArchitectureGeneratedModule,\n MermaidGeneratedSharedModule,\n __name\n} from \"./chunk-FPAJGGOC.mjs\";\n\n// src/language/architecture/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/architecture/tokenBuilder.ts\nvar ArchitectureTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"ArchitectureTokenBuilder\");\n }\n constructor() {\n super([\"architecture\"]);\n }\n};\n\n// src/language/architecture/valueConverter.ts\nvar ArchitectureValueConverter = class extends AbstractMermaidValueConverter {\n static {\n __name(this, \"ArchitectureValueConverter\");\n }\n runCustomConverter(rule, input, _cstNode) {\n if (rule.name === \"ARCH_ICON\") {\n return input.replace(/[()]/g, \"\").trim();\n } else if (rule.name === \"ARCH_TEXT_ICON\") {\n return input.replace(/[\"()]/g, \"\");\n } else if (rule.name === \"ARCH_TITLE\") {\n return input.replace(/[[\\]]/g, \"\").trim();\n }\n return void 0;\n }\n};\n\n// src/language/architecture/module.ts\nvar ArchitectureModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new ArchitectureTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new ArchitectureValueConverter(), \"ValueConverter\")\n }\n};\nfunction createArchitectureServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const Architecture = inject(\n createDefaultCoreModule({ shared }),\n ArchitectureGeneratedModule,\n ArchitectureModule\n );\n shared.ServiceRegistry.register(Architecture);\n return { shared, Architecture };\n}\n__name(createArchitectureServices, \"createArchitectureServices\");\n\nexport {\n ArchitectureModule,\n createArchitectureServices\n};\n","import {\n AbstractMermaidTokenBuilder,\n CommonValueConverter,\n MermaidGeneratedSharedModule,\n RadarGeneratedModule,\n __name\n} from \"./chunk-FPAJGGOC.mjs\";\n\n// src/language/radar/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/radar/tokenBuilder.ts\nvar RadarTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"RadarTokenBuilder\");\n }\n constructor() {\n super([\"radar-beta\"]);\n }\n};\n\n// src/language/radar/module.ts\nvar RadarModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new RadarTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n }\n};\nfunction createRadarServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const Radar = inject(\n createDefaultCoreModule({ shared }),\n RadarGeneratedModule,\n RadarModule\n );\n shared.ServiceRegistry.register(Radar);\n return { shared, Radar };\n}\n__name(createRadarServices, \"createRadarServices\");\n\nexport {\n RadarModule,\n createRadarServices\n};\n","import {\n AbstractMermaidTokenBuilder,\n AbstractMermaidValueConverter,\n MermaidGeneratedSharedModule,\n TreemapGeneratedModule,\n __name\n} from \"./chunk-FPAJGGOC.mjs\";\n\n// src/language/treemap/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/treemap/tokenBuilder.ts\nvar TreemapTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"TreemapTokenBuilder\");\n }\n constructor() {\n super([\"treemap\"]);\n }\n};\n\n// src/language/treemap/valueConverter.ts\nvar classDefRegex = /classDef\\s+([A-Z_a-z]\\w+)(?:\\s+([^\\n\\r;]*))?;?/;\nvar TreemapValueConverter = class extends AbstractMermaidValueConverter {\n static {\n __name(this, \"TreemapValueConverter\");\n }\n runCustomConverter(rule, input, _cstNode) {\n if (rule.name === \"NUMBER2\") {\n return parseFloat(input.replace(/,/g, \"\"));\n } else if (rule.name === \"SEPARATOR\") {\n return input.substring(1, input.length - 1);\n } else if (rule.name === \"STRING2\") {\n return input.substring(1, input.length - 1);\n } else if (rule.name === \"INDENTATION\") {\n return input.length;\n } else if (rule.name === \"ClassDef\") {\n if (typeof input !== \"string\") {\n return input;\n }\n const match = classDefRegex.exec(input);\n if (match) {\n return {\n $type: \"ClassDefStatement\",\n className: match[1],\n styleText: match[2] || void 0\n };\n }\n }\n return void 0;\n }\n};\n\n// src/language/treemap/treemap-validator.ts\nfunction registerValidationChecks(services) {\n const validator = services.validation.TreemapValidator;\n const registry = services.validation.ValidationRegistry;\n if (registry) {\n const checks = {\n Treemap: validator.checkSingleRoot.bind(validator)\n // Remove unused validation for TreemapRow\n };\n registry.register(checks, validator);\n }\n}\n__name(registerValidationChecks, \"registerValidationChecks\");\nvar TreemapValidator = class {\n static {\n __name(this, \"TreemapValidator\");\n }\n /**\n * Validates that a treemap has only one root node.\n * A root node is defined as a node that has no indentation.\n */\n checkSingleRoot(doc, accept) {\n let rootNodeIndentation;\n for (const row of doc.TreemapRows) {\n if (!row.item) {\n continue;\n }\n if (rootNodeIndentation === void 0 && // Check if this is a root node (no indentation)\n row.indent === void 0) {\n rootNodeIndentation = 0;\n } else if (row.indent === void 0) {\n accept(\"error\", \"Multiple root nodes are not allowed in a treemap.\", {\n node: row,\n property: \"item\"\n });\n } else if (rootNodeIndentation !== void 0 && rootNodeIndentation >= parseInt(row.indent, 10)) {\n accept(\"error\", \"Multiple root nodes are not allowed in a treemap.\", {\n node: row,\n property: \"item\"\n });\n }\n }\n }\n};\n\n// src/language/treemap/module.ts\nvar TreemapModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new TreemapTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new TreemapValueConverter(), \"ValueConverter\")\n },\n validation: {\n TreemapValidator: /* @__PURE__ */ __name(() => new TreemapValidator(), \"TreemapValidator\")\n }\n};\nfunction createTreemapServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const Treemap = inject(\n createDefaultCoreModule({ shared }),\n TreemapGeneratedModule,\n TreemapModule\n );\n shared.ServiceRegistry.register(Treemap);\n registerValidationChecks(Treemap);\n return { shared, Treemap };\n}\n__name(createTreemapServices, \"createTreemapServices\");\n\nexport {\n TreemapModule,\n createTreemapServices\n};\n","import {\n GitGraphModule,\n createGitGraphServices\n} from \"./chunks/mermaid-parser.core/chunk-S6J4BHB3.mjs\";\nimport {\n InfoModule,\n createInfoServices\n} from \"./chunks/mermaid-parser.core/chunk-LBM3YZW2.mjs\";\nimport {\n PacketModule,\n createPacketServices\n} from \"./chunks/mermaid-parser.core/chunk-76Q3JFCE.mjs\";\nimport {\n PieModule,\n createPieServices\n} from \"./chunks/mermaid-parser.core/chunk-T53DSG4Q.mjs\";\nimport {\n ArchitectureModule,\n createArchitectureServices\n} from \"./chunks/mermaid-parser.core/chunk-O7ZBX7Z2.mjs\";\nimport {\n RadarModule,\n createRadarServices\n} from \"./chunks/mermaid-parser.core/chunk-LHMN2FUI.mjs\";\nimport {\n TreemapModule,\n createTreemapServices\n} from \"./chunks/mermaid-parser.core/chunk-FWNWRKHM.mjs\";\nimport {\n AbstractMermaidTokenBuilder,\n AbstractMermaidValueConverter,\n Architecture,\n ArchitectureGeneratedModule,\n Branch,\n Commit,\n CommonTokenBuilder,\n CommonValueConverter,\n GitGraph,\n GitGraphGeneratedModule,\n Info,\n InfoGeneratedModule,\n Merge,\n MermaidGeneratedSharedModule,\n Packet,\n PacketBlock,\n PacketGeneratedModule,\n Pie,\n PieGeneratedModule,\n PieSection,\n Radar,\n RadarGeneratedModule,\n Statement,\n Treemap,\n TreemapGeneratedModule,\n __name,\n isArchitecture,\n isBranch,\n isCommit,\n isGitGraph,\n isInfo,\n isMerge,\n isPacket,\n isPacketBlock,\n isPie,\n isPieSection,\n isTreemap\n} from \"./chunks/mermaid-parser.core/chunk-FPAJGGOC.mjs\";\n\n// src/parse.ts\nvar parsers = {};\nvar initializers = {\n info: /* @__PURE__ */ __name(async () => {\n const { createInfoServices: createInfoServices2 } = await import(\"./chunks/mermaid-parser.core/info-NVLQJR56.mjs\");\n const parser = createInfoServices2().Info.parser.LangiumParser;\n parsers.info = parser;\n }, \"info\"),\n packet: /* @__PURE__ */ __name(async () => {\n const { createPacketServices: createPacketServices2 } = await import(\"./chunks/mermaid-parser.core/packet-BFZMPI3H.mjs\");\n const parser = createPacketServices2().Packet.parser.LangiumParser;\n parsers.packet = parser;\n }, \"packet\"),\n pie: /* @__PURE__ */ __name(async () => {\n const { createPieServices: createPieServices2 } = await import(\"./chunks/mermaid-parser.core/pie-7BOR55EZ.mjs\");\n const parser = createPieServices2().Pie.parser.LangiumParser;\n parsers.pie = parser;\n }, \"pie\"),\n architecture: /* @__PURE__ */ __name(async () => {\n const { createArchitectureServices: createArchitectureServices2 } = await import(\"./chunks/mermaid-parser.core/architecture-U656AL7Q.mjs\");\n const parser = createArchitectureServices2().Architecture.parser.LangiumParser;\n parsers.architecture = parser;\n }, \"architecture\"),\n gitGraph: /* @__PURE__ */ __name(async () => {\n const { createGitGraphServices: createGitGraphServices2 } = await import(\"./chunks/mermaid-parser.core/gitGraph-F6HP7TQM.mjs\");\n const parser = createGitGraphServices2().GitGraph.parser.LangiumParser;\n parsers.gitGraph = parser;\n }, \"gitGraph\"),\n radar: /* @__PURE__ */ __name(async () => {\n const { createRadarServices: createRadarServices2 } = await import(\"./chunks/mermaid-parser.core/radar-NHE76QYJ.mjs\");\n const parser = createRadarServices2().Radar.parser.LangiumParser;\n parsers.radar = parser;\n }, \"radar\"),\n treemap: /* @__PURE__ */ __name(async () => {\n const { createTreemapServices: createTreemapServices2 } = await import(\"./chunks/mermaid-parser.core/treemap-KMMF4GRG.mjs\");\n const parser = createTreemapServices2().Treemap.parser.LangiumParser;\n parsers.treemap = parser;\n }, \"treemap\")\n};\nasync function parse(diagramType, text) {\n const initializer = initializers[diagramType];\n if (!initializer) {\n throw new Error(`Unknown diagram type: ${diagramType}`);\n }\n if (!parsers[diagramType]) {\n await initializer();\n }\n const parser = parsers[diagramType];\n const result = parser.parse(text);\n if (result.lexerErrors.length > 0 || result.parserErrors.length > 0) {\n throw new MermaidParseError(result);\n }\n return result.value;\n}\n__name(parse, \"parse\");\nvar MermaidParseError = class extends Error {\n constructor(result) {\n const lexerErrors = result.lexerErrors.map((err) => err.message).join(\"\\n\");\n const parserErrors = result.parserErrors.map((err) => err.message).join(\"\\n\");\n super(`Parsing failed: ${lexerErrors} ${parserErrors}`);\n this.result = result;\n }\n static {\n __name(this, \"MermaidParseError\");\n }\n};\nexport {\n AbstractMermaidTokenBuilder,\n AbstractMermaidValueConverter,\n Architecture,\n ArchitectureGeneratedModule,\n ArchitectureModule,\n Branch,\n Commit,\n CommonTokenBuilder,\n CommonValueConverter,\n GitGraph,\n GitGraphGeneratedModule,\n GitGraphModule,\n Info,\n InfoGeneratedModule,\n InfoModule,\n Merge,\n MermaidGeneratedSharedModule,\n MermaidParseError,\n Packet,\n PacketBlock,\n PacketGeneratedModule,\n PacketModule,\n Pie,\n PieGeneratedModule,\n PieModule,\n PieSection,\n Radar,\n RadarGeneratedModule,\n RadarModule,\n Statement,\n Treemap,\n TreemapGeneratedModule,\n TreemapModule,\n createArchitectureServices,\n createGitGraphServices,\n createInfoServices,\n createPacketServices,\n createPieServices,\n createRadarServices,\n createTreemapServices,\n isArchitecture,\n isBranch,\n isCommit,\n isGitGraph,\n isInfo,\n isMerge,\n isPacket,\n isPacketBlock,\n isPie,\n isPieSection,\n isTreemap,\n parse\n};\n"],"file":"treemap-KMMF4GRG-BHT9xVli.chunk.mjs"} |