@windrun-huaiin/third-ui 13.1.3 → 13.1.5

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/exceptions_public.js

@@ -1,66 +0,0 @@
-'use strict';
-
-var includes = require('../../../../../../lodash-es@4.17.23/node_modules/lodash-es/includes.js');
-
-const MISMATCHED_TOKEN_EXCEPTION = "MismatchedTokenException";
-const NO_VIABLE_ALT_EXCEPTION = "NoViableAltException";
-const EARLY_EXIT_EXCEPTION = "EarlyExitException";
-const NOT_ALL_INPUT_PARSED_EXCEPTION = "NotAllInputParsedException";
-const RECOGNITION_EXCEPTION_NAMES = [
-    MISMATCHED_TOKEN_EXCEPTION,
-    NO_VIABLE_ALT_EXCEPTION,
-    EARLY_EXIT_EXCEPTION,
-    NOT_ALL_INPUT_PARSED_EXCEPTION,
-];
-Object.freeze(RECOGNITION_EXCEPTION_NAMES);
-// hacks to bypass no support for custom Errors in javascript/typescript
-function isRecognitionException(error) {
-    // can't do instanceof on hacked custom js exceptions
-    return includes(RECOGNITION_EXCEPTION_NAMES, error.name);
-}
-class RecognitionException extends Error {
-    constructor(message, token) {
-        super(message);
-        this.token = token;
-        this.resyncedTokens = [];
-        // fix prototype chain when typescript target is ES5
-        Object.setPrototypeOf(this, new.target.prototype);
-        /* istanbul ignore next - V8 workaround to remove constructor from stacktrace when typescript target is ES5 */
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor);
-        }
-    }
-}
-class MismatchedTokenException extends RecognitionException {
-    constructor(message, token, previousToken) {
-        super(message, token);
-        this.previousToken = previousToken;
-        this.name = MISMATCHED_TOKEN_EXCEPTION;
-    }
-}
-class NoViableAltException extends RecognitionException {
-    constructor(message, token, previousToken) {
-        super(message, token);
-        this.previousToken = previousToken;
-        this.name = NO_VIABLE_ALT_EXCEPTION;
-    }
-}
-class NotAllInputParsedException extends RecognitionException {
-    constructor(message, token) {
-        super(message, token);
-        this.name = NOT_ALL_INPUT_PARSED_EXCEPTION;
-    }
-}
-class EarlyExitException extends RecognitionException {
-    constructor(message, token, previousToken) {
-        super(message, token);
-        this.previousToken = previousToken;
-        this.name = EARLY_EXIT_EXCEPTION;
-    }
-}
-
-exports.EarlyExitException = EarlyExitException;
-exports.MismatchedTokenException = MismatchedTokenException;
-exports.NoViableAltException = NoViableAltException;
-exports.NotAllInputParsedException = NotAllInputParsedException;
-exports.isRecognitionException = isRecognitionException;

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/exceptions_public.mjs

@@ -1,60 +0,0 @@
-import includes from '../../../../../../lodash-es@4.17.23/node_modules/lodash-es/includes.mjs';
-
-const MISMATCHED_TOKEN_EXCEPTION = "MismatchedTokenException";
-const NO_VIABLE_ALT_EXCEPTION = "NoViableAltException";
-const EARLY_EXIT_EXCEPTION = "EarlyExitException";
-const NOT_ALL_INPUT_PARSED_EXCEPTION = "NotAllInputParsedException";
-const RECOGNITION_EXCEPTION_NAMES = [
-    MISMATCHED_TOKEN_EXCEPTION,
-    NO_VIABLE_ALT_EXCEPTION,
-    EARLY_EXIT_EXCEPTION,
-    NOT_ALL_INPUT_PARSED_EXCEPTION,
-];
-Object.freeze(RECOGNITION_EXCEPTION_NAMES);
-// hacks to bypass no support for custom Errors in javascript/typescript
-function isRecognitionException(error) {
-    // can't do instanceof on hacked custom js exceptions
-    return includes(RECOGNITION_EXCEPTION_NAMES, error.name);
-}
-class RecognitionException extends Error {
-    constructor(message, token) {
-        super(message);
-        this.token = token;
-        this.resyncedTokens = [];
-        // fix prototype chain when typescript target is ES5
-        Object.setPrototypeOf(this, new.target.prototype);
-        /* istanbul ignore next - V8 workaround to remove constructor from stacktrace when typescript target is ES5 */
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor);
-        }
-    }
-}
-class MismatchedTokenException extends RecognitionException {
-    constructor(message, token, previousToken) {
-        super(message, token);
-        this.previousToken = previousToken;
-        this.name = MISMATCHED_TOKEN_EXCEPTION;
-    }
-}
-class NoViableAltException extends RecognitionException {
-    constructor(message, token, previousToken) {
-        super(message, token);
-        this.previousToken = previousToken;
-        this.name = NO_VIABLE_ALT_EXCEPTION;
-    }
-}
-class NotAllInputParsedException extends RecognitionException {
-    constructor(message, token) {
-        super(message, token);
-        this.name = NOT_ALL_INPUT_PARSED_EXCEPTION;
-    }
-}
-class EarlyExitException extends RecognitionException {
-    constructor(message, token, previousToken) {
-        super(message, token);
-        this.previousToken = previousToken;
-        this.name = EARLY_EXIT_EXCEPTION;
-    }
-}
-
-export { EarlyExitException, MismatchedTokenException, NoViableAltException, NotAllInputParsedException, isRecognitionException };

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/grammar/checks.js

@@ -1,469 +0,0 @@
-'use strict';
-
-var parser = require('../parser/parser.js');
-var model = require('../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/model.js');
-var visitor = require('../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/visitor.js');
-var helpers = require('../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/helpers.js');
-var lookahead = require('./lookahead.js');
-var interpreter = require('./interpreter.js');
-var tokens = require('../../scan/tokens.js');
-var forEach = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/forEach.js');
-var isEmpty = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isEmpty.js');
-var flatten = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/flatten.js');
-var map = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/map.js');
-var flatMap = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/flatMap.js');
-var groupBy = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/groupBy.js');
-var pickBy = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/pickBy.js');
-var head = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/head.js');
-var values = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/values.js');
-var includes = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/includes.js');
-var reduce = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/reduce.js');
-var difference = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/difference.js');
-var clone = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/clone.js');
-var dropRight = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/dropRight.js');
-var reject = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/reject.js');
-var drop = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/drop.js');
-var compact = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/compact.js');
-var filter = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/filter.js');
-
-function validateLookahead(options) {
-    const lookaheadValidationErrorMessages = options.lookaheadStrategy.validate({
-        rules: options.rules,
-        tokenTypes: options.tokenTypes,
-        grammarName: options.grammarName,
-    });
-    return map(lookaheadValidationErrorMessages, (errorMessage) => (Object.assign({ type: parser.ParserDefinitionErrorType.CUSTOM_LOOKAHEAD_VALIDATION }, errorMessage)));
-}
-function validateGrammar(topLevels, tokenTypes, errMsgProvider, grammarName) {
-    const duplicateErrors = flatMap(topLevels, (currTopLevel) => validateDuplicateProductions(currTopLevel, errMsgProvider));
-    const termsNamespaceConflictErrors = checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider);
-    const tooManyAltsErrors = flatMap(topLevels, (curRule) => validateTooManyAlts(curRule, errMsgProvider));
-    const duplicateRulesError = flatMap(topLevels, (curRule) => validateRuleDoesNotAlreadyExist(curRule, topLevels, grammarName, errMsgProvider));
-    return duplicateErrors.concat(termsNamespaceConflictErrors, tooManyAltsErrors, duplicateRulesError);
-}
-function validateDuplicateProductions(topLevelRule, errMsgProvider) {
-    const collectorVisitor = new OccurrenceValidationCollector();
-    topLevelRule.accept(collectorVisitor);
-    const allRuleProductions = collectorVisitor.allProductions;
-    const productionGroups = groupBy(allRuleProductions, identifyProductionForDuplicates);
-    const duplicates = pickBy(productionGroups, (currGroup) => {
-        return currGroup.length > 1;
-    });
-    const errors = map(values(duplicates), (currDuplicates) => {
-        const firstProd = head(currDuplicates);
-        const msg = errMsgProvider.buildDuplicateFoundError(topLevelRule, currDuplicates);
-        const dslName = helpers.getProductionDslName(firstProd);
-        const defError = {
-            message: msg,
-            type: parser.ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
-            ruleName: topLevelRule.name,
-            dslName: dslName,
-            occurrence: firstProd.idx,
-        };
-        const param = getExtraProductionArgument(firstProd);
-        if (param) {
-            defError.parameter = param;
-        }
-        return defError;
-    });
-    return errors;
-}
-function identifyProductionForDuplicates(prod) {
-    return `${helpers.getProductionDslName(prod)}_#_${prod.idx}_#_${getExtraProductionArgument(prod)}`;
-}
-function getExtraProductionArgument(prod) {
-    if (prod instanceof model.Terminal) {
-        return prod.terminalType.name;
-    }
-    else if (prod instanceof model.NonTerminal) {
-        return prod.nonTerminalName;
-    }
-    else {
-        return "";
-    }
-}
-class OccurrenceValidationCollector extends visitor.GAstVisitor {
-    constructor() {
-        super(...arguments);
-        this.allProductions = [];
-    }
-    visitNonTerminal(subrule) {
-        this.allProductions.push(subrule);
-    }
-    visitOption(option) {
-        this.allProductions.push(option);
-    }
-    visitRepetitionWithSeparator(manySep) {
-        this.allProductions.push(manySep);
-    }
-    visitRepetitionMandatory(atLeastOne) {
-        this.allProductions.push(atLeastOne);
-    }
-    visitRepetitionMandatoryWithSeparator(atLeastOneSep) {
-        this.allProductions.push(atLeastOneSep);
-    }
-    visitRepetition(many) {
-        this.allProductions.push(many);
-    }
-    visitAlternation(or) {
-        this.allProductions.push(or);
-    }
-    visitTerminal(terminal) {
-        this.allProductions.push(terminal);
-    }
-}
-function validateRuleDoesNotAlreadyExist(rule, allRules, className, errMsgProvider) {
-    const errors = [];
-    const occurrences = reduce(allRules, (result, curRule) => {
-        if (curRule.name === rule.name) {
-            return result + 1;
-        }
-        return result;
-    }, 0);
-    if (occurrences > 1) {
-        const errMsg = errMsgProvider.buildDuplicateRuleNameError({
-            topLevelRule: rule,
-            grammarName: className,
-        });
-        errors.push({
-            message: errMsg,
-            type: parser.ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
-            ruleName: rule.name,
-        });
-    }
-    return errors;
-}
-// TODO: is there anyway to get only the rule names of rules inherited from the super grammars?
-// This is not part of the IGrammarErrorProvider because the validation cannot be performed on
-// The grammar structure, only at runtime.
-function validateRuleIsOverridden(ruleName, definedRulesNames, className) {
-    const errors = [];
-    let errMsg;
-    if (!includes(definedRulesNames, ruleName)) {
-        errMsg =
-            `Invalid rule override, rule: ->${ruleName}<- cannot be overridden in the grammar: ->${className}<-` +
-                `as it is not defined in any of the super grammars `;
-        errors.push({
-            message: errMsg,
-            type: parser.ParserDefinitionErrorType.INVALID_RULE_OVERRIDE,
-            ruleName: ruleName,
-        });
-    }
-    return errors;
-}
-function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path = []) {
-    const errors = [];
-    const nextNonTerminals = getFirstNoneTerminal(currRule.definition);
-    if (isEmpty(nextNonTerminals)) {
-        return [];
-    }
-    else {
-        const ruleName = topRule.name;
-        const foundLeftRecursion = includes(nextNonTerminals, topRule);
-        if (foundLeftRecursion) {
-            errors.push({
-                message: errMsgProvider.buildLeftRecursionError({
-                    topLevelRule: topRule,
-                    leftRecursionPath: path,
-                }),
-                type: parser.ParserDefinitionErrorType.LEFT_RECURSION,
-                ruleName: ruleName,
-            });
-        }
-        // we are only looking for cyclic paths leading back to the specific topRule
-        // other cyclic paths are ignored, we still need this difference to avoid infinite loops...
-        const validNextSteps = difference(nextNonTerminals, path.concat([topRule]));
-        const errorsFromNextSteps = flatMap(validNextSteps, (currRefRule) => {
-            const newPath = clone(path);
-            newPath.push(currRefRule);
-            return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);
-        });
-        return errors.concat(errorsFromNextSteps);
-    }
-}
-function getFirstNoneTerminal(definition) {
-    let result = [];
-    if (isEmpty(definition)) {
-        return result;
-    }
-    const firstProd = head(definition);
-    /* istanbul ignore else */
-    if (firstProd instanceof model.NonTerminal) {
-        result.push(firstProd.referencedRule);
-    }
-    else if (firstProd instanceof model.Alternative ||
-        firstProd instanceof model.Option ||
-        firstProd instanceof model.RepetitionMandatory ||
-        firstProd instanceof model.RepetitionMandatoryWithSeparator ||
-        firstProd instanceof model.RepetitionWithSeparator ||
-        firstProd instanceof model.Repetition) {
-        result = result.concat(getFirstNoneTerminal(firstProd.definition));
-    }
-    else if (firstProd instanceof model.Alternation) {
-        // each sub definition in alternation is a FLAT
-        result = flatten(map(firstProd.definition, (currSubDef) => getFirstNoneTerminal(currSubDef.definition)));
-    }
-    else if (firstProd instanceof model.Terminal) ;
-    else {
-        throw Error("non exhaustive match");
-    }
-    const isFirstOptional = helpers.isOptionalProd(firstProd);
-    const hasMore = definition.length > 1;
-    if (isFirstOptional && hasMore) {
-        const rest = drop(definition);
-        return result.concat(getFirstNoneTerminal(rest));
-    }
-    else {
-        return result;
-    }
-}
-class OrCollector extends visitor.GAstVisitor {
-    constructor() {
-        super(...arguments);
-        this.alternations = [];
-    }
-    visitAlternation(node) {
-        this.alternations.push(node);
-    }
-}
-function validateEmptyOrAlternative(topLevelRule, errMsgProvider) {
-    const orCollector = new OrCollector();
-    topLevelRule.accept(orCollector);
-    const ors = orCollector.alternations;
-    const errors = flatMap(ors, (currOr) => {
-        const exceptLast = dropRight(currOr.definition);
-        return flatMap(exceptLast, (currAlternative, currAltIdx) => {
-            const possibleFirstInAlt = interpreter.nextPossibleTokensAfter([currAlternative], [], tokens.tokenStructuredMatcher, 1);
-            if (isEmpty(possibleFirstInAlt)) {
-                return [
-                    {
-                        message: errMsgProvider.buildEmptyAlternationError({
-                            topLevelRule: topLevelRule,
-                            alternation: currOr,
-                            emptyChoiceIdx: currAltIdx,
-                        }),
-                        type: parser.ParserDefinitionErrorType.NONE_LAST_EMPTY_ALT,
-                        ruleName: topLevelRule.name,
-                        occurrence: currOr.idx,
-                        alternative: currAltIdx + 1,
-                    },
-                ];
-            }
-            else {
-                return [];
-            }
-        });
-    });
-    return errors;
-}
-function validateAmbiguousAlternationAlternatives(topLevelRule, globalMaxLookahead, errMsgProvider) {
-    const orCollector = new OrCollector();
-    topLevelRule.accept(orCollector);
-    let ors = orCollector.alternations;
-    // New Handling of ignoring ambiguities
-    // - https://github.com/chevrotain/chevrotain/issues/869
-    ors = reject(ors, (currOr) => currOr.ignoreAmbiguities === true);
-    const errors = flatMap(ors, (currOr) => {
-        const currOccurrence = currOr.idx;
-        const actualMaxLookahead = currOr.maxLookahead || globalMaxLookahead;
-        const alternatives = lookahead.getLookaheadPathsForOr(currOccurrence, topLevelRule, actualMaxLookahead, currOr);
-        const altsAmbiguityErrors = checkAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);
-        const altsPrefixAmbiguityErrors = checkPrefixAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);
-        return altsAmbiguityErrors.concat(altsPrefixAmbiguityErrors);
-    });
-    return errors;
-}
-class RepetitionCollector extends visitor.GAstVisitor {
-    constructor() {
-        super(...arguments);
-        this.allProductions = [];
-    }
-    visitRepetitionWithSeparator(manySep) {
-        this.allProductions.push(manySep);
-    }
-    visitRepetitionMandatory(atLeastOne) {
-        this.allProductions.push(atLeastOne);
-    }
-    visitRepetitionMandatoryWithSeparator(atLeastOneSep) {
-        this.allProductions.push(atLeastOneSep);
-    }
-    visitRepetition(many) {
-        this.allProductions.push(many);
-    }
-}
-function validateTooManyAlts(topLevelRule, errMsgProvider) {
-    const orCollector = new OrCollector();
-    topLevelRule.accept(orCollector);
-    const ors = orCollector.alternations;
-    const errors = flatMap(ors, (currOr) => {
-        if (currOr.definition.length > 255) {
-            return [
-                {
-                    message: errMsgProvider.buildTooManyAlternativesError({
-                        topLevelRule: topLevelRule,
-                        alternation: currOr,
-                    }),
-                    type: parser.ParserDefinitionErrorType.TOO_MANY_ALTS,
-                    ruleName: topLevelRule.name,
-                    occurrence: currOr.idx,
-                },
-            ];
-        }
-        else {
-            return [];
-        }
-    });
-    return errors;
-}
-function validateSomeNonEmptyLookaheadPath(topLevelRules, maxLookahead, errMsgProvider) {
-    const errors = [];
-    forEach(topLevelRules, (currTopRule) => {
-        const collectorVisitor = new RepetitionCollector();
-        currTopRule.accept(collectorVisitor);
-        const allRuleProductions = collectorVisitor.allProductions;
-        forEach(allRuleProductions, (currProd) => {
-            const prodType = lookahead.getProdType(currProd);
-            const actualMaxLookahead = currProd.maxLookahead || maxLookahead;
-            const currOccurrence = currProd.idx;
-            const paths = lookahead.getLookaheadPathsForOptionalProd(currOccurrence, currTopRule, prodType, actualMaxLookahead);
-            const pathsInsideProduction = paths[0];
-            if (isEmpty(flatten(pathsInsideProduction))) {
-                const errMsg = errMsgProvider.buildEmptyRepetitionError({
-                    topLevelRule: currTopRule,
-                    repetition: currProd,
-                });
-                errors.push({
-                    message: errMsg,
-                    type: parser.ParserDefinitionErrorType.NO_NON_EMPTY_LOOKAHEAD,
-                    ruleName: currTopRule.name,
-                });
-            }
-        });
-    });
-    return errors;
-}
-function checkAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {
-    const foundAmbiguousPaths = [];
-    const identicalAmbiguities = reduce(alternatives, (result, currAlt, currAltIdx) => {
-        // ignore (skip) ambiguities with this alternative
-        if (alternation.definition[currAltIdx].ignoreAmbiguities === true) {
-            return result;
-        }
-        forEach(currAlt, (currPath) => {
-            const altsCurrPathAppearsIn = [currAltIdx];
-            forEach(alternatives, (currOtherAlt, currOtherAltIdx) => {
-                if (currAltIdx !== currOtherAltIdx &&
-                    lookahead.containsPath(currOtherAlt, currPath) &&
-                    // ignore (skip) ambiguities with this "other" alternative
-                    alternation.definition[currOtherAltIdx].ignoreAmbiguities !== true) {
-                    altsCurrPathAppearsIn.push(currOtherAltIdx);
-                }
-            });
-            if (altsCurrPathAppearsIn.length > 1 &&
-                !lookahead.containsPath(foundAmbiguousPaths, currPath)) {
-                foundAmbiguousPaths.push(currPath);
-                result.push({
-                    alts: altsCurrPathAppearsIn,
-                    path: currPath,
-                });
-            }
-        });
-        return result;
-    }, []);
-    const currErrors = map(identicalAmbiguities, (currAmbDescriptor) => {
-        const ambgIndices = map(currAmbDescriptor.alts, (currAltIdx) => currAltIdx + 1);
-        const currMessage = errMsgProvider.buildAlternationAmbiguityError({
-            topLevelRule: rule,
-            alternation: alternation,
-            ambiguityIndices: ambgIndices,
-            prefixPath: currAmbDescriptor.path,
-        });
-        return {
-            message: currMessage,
-            type: parser.ParserDefinitionErrorType.AMBIGUOUS_ALTS,
-            ruleName: rule.name,
-            occurrence: alternation.idx,
-            alternatives: currAmbDescriptor.alts,
-        };
-    });
-    return currErrors;
-}
-function checkPrefixAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {
-    // flatten
-    const pathsAndIndices = reduce(alternatives, (result, currAlt, idx) => {
-        const currPathsAndIdx = map(currAlt, (currPath) => {
-            return { idx: idx, path: currPath };
-        });
-        return result.concat(currPathsAndIdx);
-    }, []);
-    const errors = compact(flatMap(pathsAndIndices, (currPathAndIdx) => {
-        const alternativeGast = alternation.definition[currPathAndIdx.idx];
-        // ignore (skip) ambiguities with this alternative
-        if (alternativeGast.ignoreAmbiguities === true) {
-            return [];
-        }
-        const targetIdx = currPathAndIdx.idx;
-        const targetPath = currPathAndIdx.path;
-        const prefixAmbiguitiesPathsAndIndices = filter(pathsAndIndices, (searchPathAndIdx) => {
-            // prefix ambiguity can only be created from lower idx (higher priority) path
-            return (
-            // ignore (skip) ambiguities with this "other" alternative
-            alternation.definition[searchPathAndIdx.idx].ignoreAmbiguities !==
-                true &&
-                searchPathAndIdx.idx < targetIdx &&
-                // checking for strict prefix because identical lookaheads
-                // will be be detected using a different validation.
-                lookahead.isStrictPrefixOfPath(searchPathAndIdx.path, targetPath));
-        });
-        const currPathPrefixErrors = map(prefixAmbiguitiesPathsAndIndices, (currAmbPathAndIdx) => {
-            const ambgIndices = [currAmbPathAndIdx.idx + 1, targetIdx + 1];
-            const occurrence = alternation.idx === 0 ? "" : alternation.idx;
-            const message = errMsgProvider.buildAlternationPrefixAmbiguityError({
-                topLevelRule: rule,
-                alternation: alternation,
-                ambiguityIndices: ambgIndices,
-                prefixPath: currAmbPathAndIdx.path,
-            });
-            return {
-                message: message,
-                type: parser.ParserDefinitionErrorType.AMBIGUOUS_PREFIX_ALTS,
-                ruleName: rule.name,
-                occurrence: occurrence,
-                alternatives: ambgIndices,
-            };
-        });
-        return currPathPrefixErrors;
-    }));
-    return errors;
-}
-function checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider) {
-    const errors = [];
-    const tokenNames = map(tokenTypes, (currToken) => currToken.name);
-    forEach(topLevels, (currRule) => {
-        const currRuleName = currRule.name;
-        if (includes(tokenNames, currRuleName)) {
-            const errMsg = errMsgProvider.buildNamespaceConflictError(currRule);
-            errors.push({
-                message: errMsg,
-                type: parser.ParserDefinitionErrorType.CONFLICT_TOKENS_RULES_NAMESPACE,
-                ruleName: currRuleName,
-            });
-        }
-    });
-    return errors;
-}
-
-exports.OccurrenceValidationCollector = OccurrenceValidationCollector;
-exports.RepetitionCollector = RepetitionCollector;
-exports.checkPrefixAlternativesAmbiguities = checkPrefixAlternativesAmbiguities;
-exports.getFirstNoneTerminal = getFirstNoneTerminal;
-exports.identifyProductionForDuplicates = identifyProductionForDuplicates;
-exports.validateAmbiguousAlternationAlternatives = validateAmbiguousAlternationAlternatives;
-exports.validateEmptyOrAlternative = validateEmptyOrAlternative;
-exports.validateGrammar = validateGrammar;
-exports.validateLookahead = validateLookahead;
-exports.validateNoLeftRecursion = validateNoLeftRecursion;
-exports.validateRuleDoesNotAlreadyExist = validateRuleDoesNotAlreadyExist;
-exports.validateRuleIsOverridden = validateRuleIsOverridden;
-exports.validateSomeNonEmptyLookaheadPath = validateSomeNonEmptyLookaheadPath;
-exports.validateTooManyAlts = validateTooManyAlts;