@elmethis/core 1.0.0-alpha.146 → 1.0.0-alpha.148

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

@@ -0,0 +1,725 @@
+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
+};