@windrun-huaiin/third-ui 13.1.3 → 13.1.5

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/parser/lexer.js

@@ -1,86 +0,0 @@
-'use strict';
-
-require('../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/parser/parser.js');
-var lexer_public = require('../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/lexer_public.js');
-require('../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/tokens_public.js');
-require('../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/grammar/lookahead.js');
-require('../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/errors_public.js');
-require('../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/exceptions_public.js');
-var lexer_errors_public = require('../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/lexer_errors_public.js');
-
-/******************************************************************************
- * Copyright 2022 TypeFox GmbH
- * This program and the accompanying materials are made available under the
- * terms of the MIT License, which is available in the project root.
- ******************************************************************************/
-class DefaultLexerErrorMessageProvider {
-    buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column) {
-        return lexer_errors_public.defaultLexerErrorProvider.buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column);
-    }
-    buildUnableToPopLexerModeMessage(token) {
-        return lexer_errors_public.defaultLexerErrorProvider.buildUnableToPopLexerModeMessage(token);
-    }
-}
-const DEFAULT_TOKENIZE_OPTIONS = { mode: 'full' };
-class DefaultLexer {
-    constructor(services) {
-        this.errorMessageProvider = services.parser.LexerErrorMessageProvider;
-        this.tokenBuilder = services.parser.TokenBuilder;
-        const tokens = this.tokenBuilder.buildTokens(services.Grammar, {
-            caseInsensitive: services.LanguageMetaData.caseInsensitive
-        });
-        this.tokenTypes = this.toTokenTypeDictionary(tokens);
-        const lexerTokens = isTokenTypeDictionary(tokens) ? Object.values(tokens) : tokens;
-        const production = services.LanguageMetaData.mode === 'production';
-        this.chevrotainLexer = new lexer_public.Lexer(lexerTokens, {
-            positionTracking: 'full',
-            skipValidations: production,
-            errorMessageProvider: this.errorMessageProvider
-        });
-    }
-    get definition() {
-        return this.tokenTypes;
-    }
-    tokenize(text, _options = DEFAULT_TOKENIZE_OPTIONS) {
-        const chevrotainResult = this.chevrotainLexer.tokenize(text);
-        return {
-            tokens: chevrotainResult.tokens,
-            errors: chevrotainResult.errors,
-            hidden: chevrotainResult.groups.hidden ?? [],
-            report: this.tokenBuilder.flushLexingReport?.(text)
-        };
-    }
-    toTokenTypeDictionary(buildTokens) {
-        if (isTokenTypeDictionary(buildTokens))
-            return buildTokens;
-        const tokens = isIMultiModeLexerDefinition(buildTokens) ? Object.values(buildTokens.modes).flat() : buildTokens;
-        const res = {};
-        tokens.forEach(token => res[token.name] = token);
-        return res;
-    }
-}
-/**
- * Returns a check whether the given TokenVocabulary is TokenType array
- */
-function isTokenTypeArray(tokenVocabulary) {
-    return Array.isArray(tokenVocabulary) && (tokenVocabulary.length === 0 || 'name' in tokenVocabulary[0]);
-}
-/**
- * Returns a check whether the given TokenVocabulary is IMultiModeLexerDefinition
- */
-function isIMultiModeLexerDefinition(tokenVocabulary) {
-    return tokenVocabulary && 'modes' in tokenVocabulary && 'defaultMode' in tokenVocabulary;
-}
-/**
- * Returns a check whether the given TokenVocabulary is TokenTypeDictionary
- */
-function isTokenTypeDictionary(tokenVocabulary) {
-    return !isTokenTypeArray(tokenVocabulary) && !isIMultiModeLexerDefinition(tokenVocabulary);
-}
-
-exports.DEFAULT_TOKENIZE_OPTIONS = DEFAULT_TOKENIZE_OPTIONS;
-exports.DefaultLexer = DefaultLexer;
-exports.DefaultLexerErrorMessageProvider = DefaultLexerErrorMessageProvider;
-exports.isIMultiModeLexerDefinition = isIMultiModeLexerDefinition;
-exports.isTokenTypeArray = isTokenTypeArray;
-exports.isTokenTypeDictionary = isTokenTypeDictionary;

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/parser/lexer.mjs

@@ -1,79 +0,0 @@
-import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/parser/parser.mjs';
-import { Lexer } from '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/lexer_public.mjs';
-import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/tokens_public.mjs';
-import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/grammar/lookahead.mjs';
-import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/errors_public.mjs';
-import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/exceptions_public.mjs';
-import { defaultLexerErrorProvider } from '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/lexer_errors_public.mjs';
-
-/******************************************************************************
- * Copyright 2022 TypeFox GmbH
- * This program and the accompanying materials are made available under the
- * terms of the MIT License, which is available in the project root.
- ******************************************************************************/
-class DefaultLexerErrorMessageProvider {
-    buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column) {
-        return defaultLexerErrorProvider.buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column);
-    }
-    buildUnableToPopLexerModeMessage(token) {
-        return defaultLexerErrorProvider.buildUnableToPopLexerModeMessage(token);
-    }
-}
-const DEFAULT_TOKENIZE_OPTIONS = { mode: 'full' };
-class DefaultLexer {
-    constructor(services) {
-        this.errorMessageProvider = services.parser.LexerErrorMessageProvider;
-        this.tokenBuilder = services.parser.TokenBuilder;
-        const tokens = this.tokenBuilder.buildTokens(services.Grammar, {
-            caseInsensitive: services.LanguageMetaData.caseInsensitive
-        });
-        this.tokenTypes = this.toTokenTypeDictionary(tokens);
-        const lexerTokens = isTokenTypeDictionary(tokens) ? Object.values(tokens) : tokens;
-        const production = services.LanguageMetaData.mode === 'production';
-        this.chevrotainLexer = new Lexer(lexerTokens, {
-            positionTracking: 'full',
-            skipValidations: production,
-            errorMessageProvider: this.errorMessageProvider
-        });
-    }
-    get definition() {
-        return this.tokenTypes;
-    }
-    tokenize(text, _options = DEFAULT_TOKENIZE_OPTIONS) {
-        const chevrotainResult = this.chevrotainLexer.tokenize(text);
-        return {
-            tokens: chevrotainResult.tokens,
-            errors: chevrotainResult.errors,
-            hidden: chevrotainResult.groups.hidden ?? [],
-            report: this.tokenBuilder.flushLexingReport?.(text)
-        };
-    }
-    toTokenTypeDictionary(buildTokens) {
-        if (isTokenTypeDictionary(buildTokens))
-            return buildTokens;
-        const tokens = isIMultiModeLexerDefinition(buildTokens) ? Object.values(buildTokens.modes).flat() : buildTokens;
-        const res = {};
-        tokens.forEach(token => res[token.name] = token);
-        return res;
-    }
-}
-/**
- * Returns a check whether the given TokenVocabulary is TokenType array
- */
-function isTokenTypeArray(tokenVocabulary) {
-    return Array.isArray(tokenVocabulary) && (tokenVocabulary.length === 0 || 'name' in tokenVocabulary[0]);
-}
-/**
- * Returns a check whether the given TokenVocabulary is IMultiModeLexerDefinition
- */
-function isIMultiModeLexerDefinition(tokenVocabulary) {
-    return tokenVocabulary && 'modes' in tokenVocabulary && 'defaultMode' in tokenVocabulary;
-}
-/**
- * Returns a check whether the given TokenVocabulary is TokenTypeDictionary
- */
-function isTokenTypeDictionary(tokenVocabulary) {
-    return !isTokenTypeArray(tokenVocabulary) && !isIMultiModeLexerDefinition(tokenVocabulary);
-}
-
-export { DEFAULT_TOKENIZE_OPTIONS, DefaultLexer, DefaultLexerErrorMessageProvider, isIMultiModeLexerDefinition, isTokenTypeArray, isTokenTypeDictionary };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/parser/parser-builder-base.js

@@ -1,483 +0,0 @@
-'use strict';
-
-var parser = require('../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/parser/parser.js');
-require('../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/lexer_public.js');
-var tokens_public = require('../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/tokens_public.js');
-require('../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/grammar/lookahead.js');
-require('../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/errors_public.js');
-require('../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/exceptions_public.js');
-var ast = require('../languages/generated/ast.js');
-var errors = require('../utils/errors.js');
-var stream = require('../utils/stream.js');
-var grammarUtils = require('../utils/grammar-utils.js');
-
-/******************************************************************************
- * Copyright 2022 TypeFox GmbH
- * This program and the accompanying materials are made available under the
- * terms of the MIT License, which is available in the project root.
- ******************************************************************************/
-function createParser(grammar, parser, tokens) {
-    const parserContext = {
-        parser,
-        tokens,
-        ruleNames: new Map()
-    };
-    buildRules(parserContext, grammar);
-    return parser;
-}
-function buildRules(parserContext, grammar) {
-    const reachable = grammarUtils.getAllReachableRules(grammar, false);
-    const parserRules = stream.stream(grammar.rules).filter(ast.isParserRule).filter(rule => reachable.has(rule));
-    for (const rule of parserRules) {
-        const ctx = {
-            ...parserContext,
-            consume: 1,
-            optional: 1,
-            subrule: 1,
-            many: 1,
-            or: 1
-        };
-        parserContext.parser.rule(rule, buildElement(ctx, rule.definition));
-    }
-    const infixRules = stream.stream(grammar.rules).filter(ast.isInfixRule).filter(rule => reachable.has(rule));
-    for (const rule of infixRules) {
-        parserContext.parser.rule(rule, buildInfixRule(parserContext, rule));
-    }
-}
-function buildInfixRule(ctx, rule) {
-    const expressionRule = rule.call.rule.ref;
-    if (!expressionRule) {
-        throw new Error('Could not resolve reference to infix operator rule: ' + rule.call.rule.$refText);
-    }
-    if (ast.isTerminalRule(expressionRule)) {
-        throw new Error('Cannot use terminal rule in infix expression');
-    }
-    // We need to construct a bunch of synthetic grammar AST nodes here
-    // This ensures that the CST and completion engine get populated as expected
-    const allKeywords = rule.operators.precedences.flatMap(e => e.operators);
-    // The outer group represents the first expression call and the whole (optional) loop
-    const outerGroup = {
-        $type: 'Group',
-        elements: []
-    };
-    const part1Assignment = {
-        $container: outerGroup,
-        $type: 'Assignment',
-        feature: 'parts',
-        operator: '+=',
-        terminal: rule.call
-    };
-    // The inner group represents the loop that contains the operator and expression call
-    // It can be infinitely repeated
-    const innerGroup = {
-        $container: outerGroup,
-        $type: 'Group',
-        elements: [],
-        cardinality: '*'
-    };
-    outerGroup.elements.push(part1Assignment, innerGroup);
-    // Store all operator keywords in one alternative/assignment
-    const alternatives = {
-        $type: 'Alternatives',
-        elements: allKeywords
-    };
-    const operatorAssignment = {
-        $container: innerGroup,
-        $type: 'Assignment',
-        feature: 'operators',
-        operator: '+=',
-        terminal: alternatives
-    };
-    // We need a second assignment of the called expression here
-    const part2Assignment = {
-        ...part1Assignment,
-        $container: innerGroup
-    };
-    innerGroup.elements.push(operatorAssignment, part2Assignment);
-    const tokens = allKeywords.map(e => ctx.tokens[e.value]);
-    const orAlts = tokens.map((token, index) => ({
-        ALT: () => ctx.parser.consume(index, token, operatorAssignment)
-    }));
-    let subrule;
-    return (args) => {
-        subrule ?? (subrule = getRule(ctx, expressionRule));
-        ctx.parser.subrule(0, subrule, false, part1Assignment, args);
-        ctx.parser.many(0, {
-            DEF: () => {
-                ctx.parser.alternatives(0, orAlts);
-                ctx.parser.subrule(1, subrule, false, part2Assignment, args);
-            }
-        });
-    };
-}
-function buildElement(ctx, element, ignoreGuard = false) {
-    let method;
-    if (ast.isKeyword(element)) {
-        method = buildKeyword(ctx, element);
-    }
-    else if (ast.isAction(element)) {
-        method = buildAction(ctx, element);
-    }
-    else if (ast.isAssignment(element)) {
-        method = buildElement(ctx, element.terminal);
-    }
-    else if (ast.isCrossReference(element)) {
-        method = buildCrossReference(ctx, element);
-    }
-    else if (ast.isRuleCall(element)) {
-        method = buildRuleCall(ctx, element);
-    }
-    else if (ast.isAlternatives(element)) {
-        method = buildAlternatives(ctx, element);
-    }
-    else if (ast.isUnorderedGroup(element)) {
-        method = buildUnorderedGroup(ctx, element);
-    }
-    else if (ast.isGroup(element)) {
-        method = buildGroup(ctx, element);
-    }
-    else if (ast.isEndOfFile(element)) {
-        const idx = ctx.consume++;
-        method = () => ctx.parser.consume(idx, tokens_public.EOF, element);
-    }
-    else {
-        throw new errors.ErrorWithLocation(element.$cstNode, `Unexpected element type: ${element.$type}`);
-    }
-    return wrap(ctx, ignoreGuard ? undefined : getGuardCondition(element), method, element.cardinality);
-}
-function buildAction(ctx, action) {
-    const actionType = grammarUtils.getTypeName(action);
-    return () => ctx.parser.action(actionType, action);
-}
-function buildRuleCall(ctx, ruleCall) {
-    const rule = ruleCall.rule.ref;
-    if (ast.isAbstractParserRule(rule)) {
-        const idx = ctx.subrule++;
-        const fragment = ast.isParserRule(rule) && rule.fragment;
-        const predicate = ruleCall.arguments.length > 0 ? buildRuleCallPredicate(rule, ruleCall.arguments) : () => ({});
-        let subrule;
-        return (args) => {
-            subrule ?? (subrule = getRule(ctx, rule));
-            ctx.parser.subrule(idx, subrule, fragment, ruleCall, predicate(args));
-        };
-    }
-    else if (ast.isTerminalRule(rule)) {
-        const idx = ctx.consume++;
-        const method = getToken(ctx, rule.name);
-        return () => ctx.parser.consume(idx, method, ruleCall);
-    }
-    else if (!rule) {
-        throw new errors.ErrorWithLocation(ruleCall.$cstNode, `Undefined rule: ${ruleCall.rule.$refText}`);
-    }
-    else {
-        errors.assertUnreachable();
-    }
-}
-function buildRuleCallPredicate(rule, namedArgs) {
-    const hasNamedArguments = namedArgs.some(arg => arg.calledByName);
-    if (hasNamedArguments) {
-        const namedPredicates = namedArgs.map(arg => ({
-            parameterName: arg.parameter?.ref?.name,
-            predicate: buildPredicate(arg.value)
-        }));
-        return (args) => {
-            const ruleArgs = {};
-            for (const { parameterName, predicate } of namedPredicates) {
-                if (parameterName) {
-                    ruleArgs[parameterName] = predicate(args);
-                }
-            }
-            return ruleArgs;
-        };
-    }
-    else {
-        const predicates = namedArgs.map(arg => buildPredicate(arg.value));
-        return (args) => {
-            const ruleArgs = {};
-            for (let i = 0; i < predicates.length; i++) {
-                if (i < rule.parameters.length) {
-                    const parameterName = rule.parameters[i].name;
-                    const predicate = predicates[i];
-                    ruleArgs[parameterName] = predicate(args);
-                }
-            }
-            return ruleArgs;
-        };
-    }
-}
-function buildPredicate(condition) {
-    if (ast.isDisjunction(condition)) {
-        const left = buildPredicate(condition.left);
-        const right = buildPredicate(condition.right);
-        return (args) => (left(args) || right(args));
-    }
-    else if (ast.isConjunction(condition)) {
-        const left = buildPredicate(condition.left);
-        const right = buildPredicate(condition.right);
-        return (args) => (left(args) && right(args));
-    }
-    else if (ast.isNegation(condition)) {
-        const value = buildPredicate(condition.value);
-        return (args) => !value(args);
-    }
-    else if (ast.isParameterReference(condition)) {
-        const name = condition.parameter.ref.name;
-        return (args) => args !== undefined && args[name] === true;
-    }
-    else if (ast.isBooleanLiteral(condition)) {
-        const value = Boolean(condition.true);
-        return () => value;
-    }
-    errors.assertUnreachable();
-}
-function buildAlternatives(ctx, alternatives) {
-    if (alternatives.elements.length === 1) {
-        return buildElement(ctx, alternatives.elements[0]);
-    }
-    else {
-        const methods = [];
-        for (const element of alternatives.elements) {
-            const predicatedMethod = {
-                // Since we handle the guard condition in the alternative already
-                // We can ignore the group guard condition inside
-                ALT: buildElement(ctx, element, true)
-            };
-            const guard = getGuardCondition(element);
-            if (guard) {
-                predicatedMethod.GATE = buildPredicate(guard);
-            }
-            methods.push(predicatedMethod);
-        }
-        const idx = ctx.or++;
-        return (args) => ctx.parser.alternatives(idx, methods.map(method => {
-            const alt = {
-                ALT: () => method.ALT(args)
-            };
-            const gate = method.GATE;
-            if (gate) {
-                alt.GATE = () => gate(args);
-            }
-            return alt;
-        }));
-    }
-}
-function buildUnorderedGroup(ctx, group) {
-    if (group.elements.length === 1) {
-        return buildElement(ctx, group.elements[0]);
-    }
-    const methods = [];
-    for (const element of group.elements) {
-        const predicatedMethod = {
-            // Since we handle the guard condition in the alternative already
-            // We can ignore the group guard condition inside
-            ALT: buildElement(ctx, element, true)
-        };
-        const guard = getGuardCondition(element);
-        if (guard) {
-            predicatedMethod.GATE = buildPredicate(guard);
-        }
-        methods.push(predicatedMethod);
-    }
-    const orIdx = ctx.or++;
-    const idFunc = (groupIdx, lParser) => {
-        const stackId = lParser.getRuleStack().join('-');
-        return `uGroup_${groupIdx}_${stackId}`;
-    };
-    const alternatives = (args) => ctx.parser.alternatives(orIdx, methods.map((method, idx) => {
-        const alt = { ALT: () => true };
-        const parser = ctx.parser;
-        alt.ALT = () => {
-            method.ALT(args);
-            if (!parser.isRecording()) {
-                const key = idFunc(orIdx, parser);
-                if (!parser.unorderedGroups.get(key)) {
-                    // init after clear state
-                    parser.unorderedGroups.set(key, []);
-                }
-                const groupState = parser.unorderedGroups.get(key);
-                if (typeof groupState?.[idx] === 'undefined') {
-                    // Not accessed yet
-                    groupState[idx] = true;
-                }
-            }
-        };
-        const gate = method.GATE;
-        if (gate) {
-            alt.GATE = () => gate(args);
-        }
-        else {
-            alt.GATE = () => {
-                const trackedAlternatives = parser.unorderedGroups.get(idFunc(orIdx, parser));
-                const allow = !trackedAlternatives?.[idx];
-                return allow;
-            };
-        }
-        return alt;
-    }));
-    const wrapped = wrap(ctx, getGuardCondition(group), alternatives, '*');
-    return (args) => {
-        wrapped(args);
-        if (!ctx.parser.isRecording()) {
-            ctx.parser.unorderedGroups.delete(idFunc(orIdx, ctx.parser));
-        }
-    };
-}
-function buildGroup(ctx, group) {
-    const methods = group.elements.map(e => buildElement(ctx, e));
-    return (args) => methods.forEach(method => method(args));
-}
-function getGuardCondition(element) {
-    if (ast.isGroup(element)) {
-        return element.guardCondition;
-    }
-    return undefined;
-}
-function buildCrossReference(ctx, crossRef, terminal = crossRef.terminal) {
-    if (!terminal) {
-        if (!crossRef.type.ref) {
-            throw new Error('Could not resolve reference to type: ' + crossRef.type.$refText);
-        }
-        const assignment = grammarUtils.findNameAssignment(crossRef.type.ref);
-        const assignTerminal = assignment?.terminal;
-        if (!assignTerminal) {
-            throw new Error('Could not find name assignment for type: ' + grammarUtils.getTypeName(crossRef.type.ref));
-        }
-        return buildCrossReference(ctx, crossRef, assignTerminal);
-    }
-    else if (ast.isRuleCall(terminal) && ast.isParserRule(terminal.rule.ref)) {
-        // The terminal is a data type rule here. Everything else will result in a validation error.
-        const rule = terminal.rule.ref;
-        const idx = ctx.subrule++;
-        let subrule;
-        return (args) => {
-            subrule ?? (subrule = getRule(ctx, rule));
-            ctx.parser.subrule(idx, subrule, false, crossRef, args);
-        };
-    }
-    else if (ast.isRuleCall(terminal) && ast.isTerminalRule(terminal.rule.ref)) {
-        const idx = ctx.consume++;
-        const terminalRule = getToken(ctx, terminal.rule.ref.name);
-        return () => ctx.parser.consume(idx, terminalRule, crossRef);
-    }
-    else if (ast.isKeyword(terminal)) {
-        const idx = ctx.consume++;
-        const keyword = getToken(ctx, terminal.value);
-        return () => ctx.parser.consume(idx, keyword, crossRef);
-    }
-    else {
-        throw new Error('Could not build cross reference parser');
-    }
-}
-function buildKeyword(ctx, keyword) {
-    const idx = ctx.consume++;
-    const token = ctx.tokens[keyword.value];
-    if (!token) {
-        throw new Error('Could not find token for keyword: ' + keyword.value);
-    }
-    return () => ctx.parser.consume(idx, token, keyword);
-}
-function wrap(ctx, guard, method, cardinality) {
-    const gate = guard && buildPredicate(guard);
-    if (!cardinality) {
-        if (gate) {
-            const idx = ctx.or++;
-            return (args) => ctx.parser.alternatives(idx, [
-                {
-                    ALT: () => method(args),
-                    GATE: () => gate(args)
-                },
-                {
-                    ALT: parser.EMPTY_ALT(),
-                    GATE: () => !gate(args)
-                }
-            ]);
-        }
-        else {
-            return method;
-        }
-    }
-    if (cardinality === '*') {
-        const idx = ctx.many++;
-        return (args) => ctx.parser.many(idx, {
-            DEF: () => method(args),
-            GATE: gate ? () => gate(args) : undefined
-        });
-    }
-    else if (cardinality === '+') {
-        const idx = ctx.many++;
-        if (gate) {
-            const orIdx = ctx.or++;
-            // In the case of a guard condition for the `+` group
-            // We combine it with an empty alternative
-            // If the condition returns true, it needs to parse at least a single iteration
-            // If its false, it is not allowed to parse anything
-            return (args) => ctx.parser.alternatives(orIdx, [
-                {
-                    ALT: () => ctx.parser.atLeastOne(idx, {
-                        DEF: () => method(args)
-                    }),
-                    GATE: () => gate(args)
-                },
-                {
-                    ALT: parser.EMPTY_ALT(),
-                    GATE: () => !gate(args)
-                }
-            ]);
-        }
-        else {
-            return (args) => ctx.parser.atLeastOne(idx, {
-                DEF: () => method(args),
-            });
-        }
-    }
-    else if (cardinality === '?') {
-        const idx = ctx.optional++;
-        return (args) => ctx.parser.optional(idx, {
-            DEF: () => method(args),
-            GATE: gate ? () => gate(args) : undefined
-        });
-    }
-    else {
-        errors.assertUnreachable();
-    }
-}
-function getRule(ctx, element) {
-    const name = getRuleName(ctx, element);
-    const rule = ctx.parser.getRule(name);
-    if (!rule)
-        throw new Error(`Rule "${name}" not found."`);
-    return rule;
-}
-function getRuleName(ctx, element) {
-    if (ast.isAbstractParserRule(element)) {
-        return element.name;
-    }
-    else if (ctx.ruleNames.has(element)) {
-        return ctx.ruleNames.get(element);
-    }
-    else {
-        let item = element;
-        let parent = item.$container;
-        let ruleName = element.$type;
-        while (!ast.isParserRule(parent)) {
-            if (ast.isGroup(parent) || ast.isAlternatives(parent) || ast.isUnorderedGroup(parent)) {
-                const index = parent.elements.indexOf(item);
-                ruleName = index.toString() + ':' + ruleName;
-            }
-            item = parent;
-            parent = parent.$container;
-        }
-        const rule = parent;
-        ruleName = rule.name + ':' + ruleName;
-        ctx.ruleNames.set(element, ruleName);
-        return ruleName;
-    }
-}
-function getToken(ctx, name) {
-    const token = ctx.tokens[name];
-    if (!token)
-        throw new Error(`Token "${name}" not found."`);
-    return token;
-}
-
-exports.createParser = createParser;