@windrun-huaiin/third-ui 15.0.0 → 15.1.0

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/languages/generated/ast.js

@@ -1,731 +0,0 @@
-'use strict';
-
-var syntaxTree = require('../../syntax-tree.js');
-
-/******************************************************************************
- * This file was generated by langium-cli 3.3.0.
- * DO NOT EDIT MANUALLY!
- ******************************************************************************/
-const AbstractRule = 'AbstractRule';
-const AbstractType = 'AbstractType';
-const Condition = 'Condition';
-const TypeDefinition = 'TypeDefinition';
-const ValueLiteral = 'ValueLiteral';
-const AbstractElement = 'AbstractElement';
-function isAbstractElement(item) {
-    return reflection.isInstance(item, AbstractElement);
-}
-const ArrayLiteral = 'ArrayLiteral';
-const ArrayType = 'ArrayType';
-const BooleanLiteral = 'BooleanLiteral';
-function isBooleanLiteral(item) {
-    return reflection.isInstance(item, BooleanLiteral);
-}
-const Conjunction = 'Conjunction';
-function isConjunction(item) {
-    return reflection.isInstance(item, Conjunction);
-}
-const Disjunction = 'Disjunction';
-function isDisjunction(item) {
-    return reflection.isInstance(item, Disjunction);
-}
-const Grammar = 'Grammar';
-const GrammarImport = 'GrammarImport';
-const InferredType = 'InferredType';
-function isInferredType(item) {
-    return reflection.isInstance(item, InferredType);
-}
-const Interface = 'Interface';
-function isInterface(item) {
-    return reflection.isInstance(item, Interface);
-}
-const NamedArgument = 'NamedArgument';
-const Negation = 'Negation';
-function isNegation(item) {
-    return reflection.isInstance(item, Negation);
-}
-const NumberLiteral = 'NumberLiteral';
-const Parameter = 'Parameter';
-const ParameterReference = 'ParameterReference';
-function isParameterReference(item) {
-    return reflection.isInstance(item, ParameterReference);
-}
-const ParserRule = 'ParserRule';
-function isParserRule(item) {
-    return reflection.isInstance(item, ParserRule);
-}
-const ReferenceType = 'ReferenceType';
-const ReturnType = 'ReturnType';
-function isReturnType(item) {
-    return reflection.isInstance(item, ReturnType);
-}
-const SimpleType = 'SimpleType';
-function isSimpleType(item) {
-    return reflection.isInstance(item, SimpleType);
-}
-const StringLiteral = 'StringLiteral';
-const TerminalRule = 'TerminalRule';
-function isTerminalRule(item) {
-    return reflection.isInstance(item, TerminalRule);
-}
-const Type = 'Type';
-function isType(item) {
-    return reflection.isInstance(item, Type);
-}
-const TypeAttribute = 'TypeAttribute';
-const UnionType = 'UnionType';
-const Action = 'Action';
-function isAction(item) {
-    return reflection.isInstance(item, Action);
-}
-const Alternatives = 'Alternatives';
-function isAlternatives(item) {
-    return reflection.isInstance(item, Alternatives);
-}
-const Assignment = 'Assignment';
-function isAssignment(item) {
-    return reflection.isInstance(item, Assignment);
-}
-const CharacterRange = 'CharacterRange';
-function isCharacterRange(item) {
-    return reflection.isInstance(item, CharacterRange);
-}
-const CrossReference = 'CrossReference';
-function isCrossReference(item) {
-    return reflection.isInstance(item, CrossReference);
-}
-const EndOfFile = 'EndOfFile';
-function isEndOfFile(item) {
-    return reflection.isInstance(item, EndOfFile);
-}
-const Group = 'Group';
-function isGroup(item) {
-    return reflection.isInstance(item, Group);
-}
-const Keyword = 'Keyword';
-function isKeyword(item) {
-    return reflection.isInstance(item, Keyword);
-}
-const NegatedToken = 'NegatedToken';
-function isNegatedToken(item) {
-    return reflection.isInstance(item, NegatedToken);
-}
-const RegexToken = 'RegexToken';
-function isRegexToken(item) {
-    return reflection.isInstance(item, RegexToken);
-}
-const RuleCall = 'RuleCall';
-function isRuleCall(item) {
-    return reflection.isInstance(item, RuleCall);
-}
-const TerminalAlternatives = 'TerminalAlternatives';
-function isTerminalAlternatives(item) {
-    return reflection.isInstance(item, TerminalAlternatives);
-}
-const TerminalGroup = 'TerminalGroup';
-function isTerminalGroup(item) {
-    return reflection.isInstance(item, TerminalGroup);
-}
-const TerminalRuleCall = 'TerminalRuleCall';
-function isTerminalRuleCall(item) {
-    return reflection.isInstance(item, TerminalRuleCall);
-}
-const UnorderedGroup = 'UnorderedGroup';
-function isUnorderedGroup(item) {
-    return reflection.isInstance(item, UnorderedGroup);
-}
-const UntilToken = 'UntilToken';
-function isUntilToken(item) {
-    return reflection.isInstance(item, UntilToken);
-}
-const Wildcard = 'Wildcard';
-function isWildcard(item) {
-    return reflection.isInstance(item, Wildcard);
-}
-class LangiumGrammarAstReflection extends syntaxTree.AbstractAstReflection {
-    getAllTypes() {
-        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];
-    }
-    computeIsSubtype(subtype, supertype) {
-        switch (subtype) {
-            case Action:
-            case Alternatives:
-            case Assignment:
-            case CharacterRange:
-            case CrossReference:
-            case EndOfFile:
-            case Group:
-            case Keyword:
-            case NegatedToken:
-            case RegexToken:
-            case RuleCall:
-            case TerminalAlternatives:
-            case TerminalGroup:
-            case TerminalRuleCall:
-            case UnorderedGroup:
-            case UntilToken:
-            case Wildcard: {
-                return this.isSubtype(AbstractElement, supertype);
-            }
-            case ArrayLiteral:
-            case NumberLiteral:
-            case StringLiteral: {
-                return this.isSubtype(ValueLiteral, supertype);
-            }
-            case ArrayType:
-            case ReferenceType:
-            case SimpleType:
-            case UnionType: {
-                return this.isSubtype(TypeDefinition, supertype);
-            }
-            case BooleanLiteral: {
-                return this.isSubtype(Condition, supertype) || this.isSubtype(ValueLiteral, supertype);
-            }
-            case Conjunction:
-            case Disjunction:
-            case Negation:
-            case ParameterReference: {
-                return this.isSubtype(Condition, supertype);
-            }
-            case InferredType:
-            case Interface:
-            case Type: {
-                return this.isSubtype(AbstractType, supertype);
-            }
-            case ParserRule: {
-                return this.isSubtype(AbstractRule, supertype) || this.isSubtype(AbstractType, supertype);
-            }
-            case TerminalRule: {
-                return this.isSubtype(AbstractRule, supertype);
-            }
-            default: {
-                return false;
-            }
-        }
-    }
-    getReferenceType(refInfo) {
-        const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
-        switch (referenceId) {
-            case 'Action:type':
-            case 'CrossReference:type':
-            case 'Interface:superTypes':
-            case 'ParserRule:returnType':
-            case 'SimpleType:typeRef': {
-                return AbstractType;
-            }
-            case 'Grammar:hiddenTokens':
-            case 'ParserRule:hiddenTokens':
-            case 'RuleCall:rule': {
-                return AbstractRule;
-            }
-            case 'Grammar:usedGrammars': {
-                return Grammar;
-            }
-            case 'NamedArgument:parameter':
-            case 'ParameterReference:parameter': {
-                return Parameter;
-            }
-            case 'TerminalRuleCall:rule': {
-                return TerminalRule;
-            }
-            default: {
-                throw new Error(`${referenceId} is not a valid reference id.`);
-            }
-        }
-    }
-    getTypeMetaData(type) {
-        switch (type) {
-            case AbstractElement: {
-                return {
-                    name: AbstractElement,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'lookahead' }
-                    ]
-                };
-            }
-            case ArrayLiteral: {
-                return {
-                    name: ArrayLiteral,
-                    properties: [
-                        { name: 'elements', defaultValue: [] }
-                    ]
-                };
-            }
-            case ArrayType: {
-                return {
-                    name: ArrayType,
-                    properties: [
-                        { name: 'elementType' }
-                    ]
-                };
-            }
-            case BooleanLiteral: {
-                return {
-                    name: BooleanLiteral,
-                    properties: [
-                        { name: 'true', defaultValue: false }
-                    ]
-                };
-            }
-            case Conjunction: {
-                return {
-                    name: Conjunction,
-                    properties: [
-                        { name: 'left' },
-                        { name: 'right' }
-                    ]
-                };
-            }
-            case Disjunction: {
-                return {
-                    name: Disjunction,
-                    properties: [
-                        { name: 'left' },
-                        { name: 'right' }
-                    ]
-                };
-            }
-            case Grammar: {
-                return {
-                    name: Grammar,
-                    properties: [
-                        { name: 'definesHiddenTokens', defaultValue: false },
-                        { name: 'hiddenTokens', defaultValue: [] },
-                        { name: 'imports', defaultValue: [] },
-                        { name: 'interfaces', defaultValue: [] },
-                        { name: 'isDeclared', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'rules', defaultValue: [] },
-                        { name: 'types', defaultValue: [] },
-                        { name: 'usedGrammars', defaultValue: [] }
-                    ]
-                };
-            }
-            case GrammarImport: {
-                return {
-                    name: GrammarImport,
-                    properties: [
-                        { name: 'path' }
-                    ]
-                };
-            }
-            case InferredType: {
-                return {
-                    name: InferredType,
-                    properties: [
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case Interface: {
-                return {
-                    name: Interface,
-                    properties: [
-                        { name: 'attributes', defaultValue: [] },
-                        { name: 'name' },
-                        { name: 'superTypes', defaultValue: [] }
-                    ]
-                };
-            }
-            case NamedArgument: {
-                return {
-                    name: NamedArgument,
-                    properties: [
-                        { name: 'calledByName', defaultValue: false },
-                        { name: 'parameter' },
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case Negation: {
-                return {
-                    name: Negation,
-                    properties: [
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case NumberLiteral: {
-                return {
-                    name: NumberLiteral,
-                    properties: [
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case Parameter: {
-                return {
-                    name: Parameter,
-                    properties: [
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case ParameterReference: {
-                return {
-                    name: ParameterReference,
-                    properties: [
-                        { name: 'parameter' }
-                    ]
-                };
-            }
-            case ParserRule: {
-                return {
-                    name: ParserRule,
-                    properties: [
-                        { name: 'dataType' },
-                        { name: 'definesHiddenTokens', defaultValue: false },
-                        { name: 'definition' },
-                        { name: 'entry', defaultValue: false },
-                        { name: 'fragment', defaultValue: false },
-                        { name: 'hiddenTokens', defaultValue: [] },
-                        { name: 'inferredType' },
-                        { name: 'name' },
-                        { name: 'parameters', defaultValue: [] },
-                        { name: 'returnType' },
-                        { name: 'wildcard', defaultValue: false }
-                    ]
-                };
-            }
-            case ReferenceType: {
-                return {
-                    name: ReferenceType,
-                    properties: [
-                        { name: 'referenceType' }
-                    ]
-                };
-            }
-            case ReturnType: {
-                return {
-                    name: ReturnType,
-                    properties: [
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case SimpleType: {
-                return {
-                    name: SimpleType,
-                    properties: [
-                        { name: 'primitiveType' },
-                        { name: 'stringType' },
-                        { name: 'typeRef' }
-                    ]
-                };
-            }
-            case StringLiteral: {
-                return {
-                    name: StringLiteral,
-                    properties: [
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case TerminalRule: {
-                return {
-                    name: TerminalRule,
-                    properties: [
-                        { name: 'definition' },
-                        { name: 'fragment', defaultValue: false },
-                        { name: 'hidden', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case Type: {
-                return {
-                    name: Type,
-                    properties: [
-                        { name: 'name' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case TypeAttribute: {
-                return {
-                    name: TypeAttribute,
-                    properties: [
-                        { name: 'defaultValue' },
-                        { name: 'isOptional', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case UnionType: {
-                return {
-                    name: UnionType,
-                    properties: [
-                        { name: 'types', defaultValue: [] }
-                    ]
-                };
-            }
-            case Action: {
-                return {
-                    name: Action,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'feature' },
-                        { name: 'inferredType' },
-                        { name: 'lookahead' },
-                        { name: 'operator' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case Alternatives: {
-                return {
-                    name: Alternatives,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'elements', defaultValue: [] },
-                        { name: 'lookahead' }
-                    ]
-                };
-            }
-            case Assignment: {
-                return {
-                    name: Assignment,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'feature' },
-                        { name: 'lookahead' },
-                        { name: 'operator' },
-                        { name: 'terminal' }
-                    ]
-                };
-            }
-            case CharacterRange: {
-                return {
-                    name: CharacterRange,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'left' },
-                        { name: 'lookahead' },
-                        { name: 'right' }
-                    ]
-                };
-            }
-            case CrossReference: {
-                return {
-                    name: CrossReference,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'deprecatedSyntax', defaultValue: false },
-                        { name: 'lookahead' },
-                        { name: 'terminal' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case EndOfFile: {
-                return {
-                    name: EndOfFile,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'lookahead' }
-                    ]
-                };
-            }
-            case Group: {
-                return {
-                    name: Group,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'elements', defaultValue: [] },
-                        { name: 'guardCondition' },
-                        { name: 'lookahead' }
-                    ]
-                };
-            }
-            case Keyword: {
-                return {
-                    name: Keyword,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'lookahead' },
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case NegatedToken: {
-                return {
-                    name: NegatedToken,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'lookahead' },
-                        { name: 'terminal' }
-                    ]
-                };
-            }
-            case RegexToken: {
-                return {
-                    name: RegexToken,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'lookahead' },
-                        { name: 'regex' }
-                    ]
-                };
-            }
-            case RuleCall: {
-                return {
-                    name: RuleCall,
-                    properties: [
-                        { name: 'arguments', defaultValue: [] },
-                        { name: 'cardinality' },
-                        { name: 'lookahead' },
-                        { name: 'rule' }
-                    ]
-                };
-            }
-            case TerminalAlternatives: {
-                return {
-                    name: TerminalAlternatives,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'elements', defaultValue: [] },
-                        { name: 'lookahead' }
-                    ]
-                };
-            }
-            case TerminalGroup: {
-                return {
-                    name: TerminalGroup,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'elements', defaultValue: [] },
-                        { name: 'lookahead' }
-                    ]
-                };
-            }
-            case TerminalRuleCall: {
-                return {
-                    name: TerminalRuleCall,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'lookahead' },
-                        { name: 'rule' }
-                    ]
-                };
-            }
-            case UnorderedGroup: {
-                return {
-                    name: UnorderedGroup,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'elements', defaultValue: [] },
-                        { name: 'lookahead' }
-                    ]
-                };
-            }
-            case UntilToken: {
-                return {
-                    name: UntilToken,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'lookahead' },
-                        { name: 'terminal' }
-                    ]
-                };
-            }
-            case Wildcard: {
-                return {
-                    name: Wildcard,
-                    properties: [
-                        { name: 'cardinality' },
-                        { name: 'lookahead' }
-                    ]
-                };
-            }
-            default: {
-                return {
-                    name: type,
-                    properties: []
-                };
-            }
-        }
-    }
-}
-const reflection = new LangiumGrammarAstReflection();
-
-exports.AbstractElement = AbstractElement;
-exports.AbstractRule = AbstractRule;
-exports.AbstractType = AbstractType;
-exports.Action = Action;
-exports.Alternatives = Alternatives;
-exports.ArrayLiteral = ArrayLiteral;
-exports.ArrayType = ArrayType;
-exports.Assignment = Assignment;
-exports.BooleanLiteral = BooleanLiteral;
-exports.CharacterRange = CharacterRange;
-exports.Condition = Condition;
-exports.Conjunction = Conjunction;
-exports.CrossReference = CrossReference;
-exports.Disjunction = Disjunction;
-exports.EndOfFile = EndOfFile;
-exports.Grammar = Grammar;
-exports.GrammarImport = GrammarImport;
-exports.Group = Group;
-exports.InferredType = InferredType;
-exports.Interface = Interface;
-exports.Keyword = Keyword;
-exports.LangiumGrammarAstReflection = LangiumGrammarAstReflection;
-exports.NamedArgument = NamedArgument;
-exports.NegatedToken = NegatedToken;
-exports.Negation = Negation;
-exports.NumberLiteral = NumberLiteral;
-exports.Parameter = Parameter;
-exports.ParameterReference = ParameterReference;
-exports.ParserRule = ParserRule;
-exports.ReferenceType = ReferenceType;
-exports.RegexToken = RegexToken;
-exports.ReturnType = ReturnType;
-exports.RuleCall = RuleCall;
-exports.SimpleType = SimpleType;
-exports.StringLiteral = StringLiteral;
-exports.TerminalAlternatives = TerminalAlternatives;
-exports.TerminalGroup = TerminalGroup;
-exports.TerminalRule = TerminalRule;
-exports.TerminalRuleCall = TerminalRuleCall;
-exports.Type = Type;
-exports.TypeAttribute = TypeAttribute;
-exports.TypeDefinition = TypeDefinition;
-exports.UnionType = UnionType;
-exports.UnorderedGroup = UnorderedGroup;
-exports.UntilToken = UntilToken;
-exports.ValueLiteral = ValueLiteral;
-exports.Wildcard = Wildcard;
-exports.isAbstractElement = isAbstractElement;
-exports.isAction = isAction;
-exports.isAlternatives = isAlternatives;
-exports.isAssignment = isAssignment;
-exports.isBooleanLiteral = isBooleanLiteral;
-exports.isCharacterRange = isCharacterRange;
-exports.isConjunction = isConjunction;
-exports.isCrossReference = isCrossReference;
-exports.isDisjunction = isDisjunction;
-exports.isEndOfFile = isEndOfFile;
-exports.isGroup = isGroup;
-exports.isInferredType = isInferredType;
-exports.isInterface = isInterface;
-exports.isKeyword = isKeyword;
-exports.isNegatedToken = isNegatedToken;
-exports.isNegation = isNegation;
-exports.isParameterReference = isParameterReference;
-exports.isParserRule = isParserRule;
-exports.isRegexToken = isRegexToken;
-exports.isReturnType = isReturnType;
-exports.isRuleCall = isRuleCall;
-exports.isSimpleType = isSimpleType;
-exports.isTerminalAlternatives = isTerminalAlternatives;
-exports.isTerminalGroup = isTerminalGroup;
-exports.isTerminalRule = isTerminalRule;
-exports.isTerminalRuleCall = isTerminalRuleCall;
-exports.isType = isType;
-exports.isUnorderedGroup = isUnorderedGroup;
-exports.isUntilToken = isUntilToken;
-exports.isWildcard = isWildcard;
-exports.reflection = reflection;