@windrun-huaiin/third-ui 7.0.0 → 7.1.0

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

@@ -0,0 +1,652 @@
+import { AbstractAstReflection } from '../../syntax-tree.mjs';
+
+/******************************************************************************
+ * 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 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();
+
+export { AbstractElement, AbstractRule, AbstractType, Action, Alternatives, ArrayLiteral, ArrayType, Assignment, BooleanLiteral, CharacterRange, Condition, Conjunction, CrossReference, Disjunction, EndOfFile, Grammar, GrammarImport, Group, InferredType, Interface, Keyword, LangiumGrammarAstReflection, 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, isAbstractElement, isAction, isAlternatives, isAssignment, isBooleanLiteral, isCharacterRange, isConjunction, isCrossReference, isDisjunction, isEndOfFile, isGroup, isInferredType, isInterface, isKeyword, isNegatedToken, isNegation, isParameterReference, isParserRule, isRegexToken, isReturnType, isRuleCall, isSimpleType, isTerminalAlternatives, isTerminalGroup, isTerminalRule, isTerminalRuleCall, isType, isUnorderedGroup, isUntilToken, isWildcard, reflection };

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/languages/grammar-config.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var cstUtils = require('../utils/cst-utils.js');
+var grammarUtils = require('../utils/grammar-utils.js');
+var regexpUtils = require('../utils/regexp-utils.js');
+var ast = require('./generated/ast.js');
+
+/******************************************************************************
+ * Copyright 2021 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.
+ ******************************************************************************/
+/**
+ * Create the default grammar configuration (used by `createDefaultModule`). This can be overridden in a
+ * language-specific module.
+ */
+function createGrammarConfig(services) {
+    const rules = [];
+    const grammar = services.Grammar;
+    for (const rule of grammar.rules) {
+        if (ast.isTerminalRule(rule) && grammarUtils.isCommentTerminal(rule) && regexpUtils.isMultilineComment(grammarUtils.terminalRegex(rule))) {
+            rules.push(rule.name);
+        }
+    }
+    return {
+        multilineCommentRules: rules,
+        nameRegexp: cstUtils.DefaultNameRegexp
+    };
+}
+
+exports.createGrammarConfig = createGrammarConfig;