@elmethis/core 1.0.0-alpha.149 → 1.0.0-alpha.150

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

@@ -1,725 +0,0 @@
-import { AbstractAstReflection } from "../../syntax-tree.mjs";
-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
-};