@loopstack/loopstack-studio 0.25.1 → 0.25.2

package/dist/node_modules/langium/lib/languages/generated/ast.js

@@ -1,17 +1,140 @@
-import { AbstractAstReflection as e } from "../../syntax-tree.js";
-//#region ../../node_modules/langium/lib/languages/generated/ast.js
-var t = {
+import { __export } from "../../../../../_virtual/rolldown_runtime.js";
+import { AbstractAstReflection } from "../../syntax-tree.js";
+var ast_exports = /* @__PURE__ */ __export({
+	AbstractElement: () => AbstractElement,
+	AbstractParserRule: () => AbstractParserRule,
+	AbstractRule: () => AbstractRule,
+	AbstractType: () => AbstractType,
+	Action: () => Action,
+	Alternatives: () => Alternatives,
+	ArrayLiteral: () => ArrayLiteral,
+	ArrayType: () => ArrayType,
+	Assignment: () => Assignment,
+	BooleanLiteral: () => BooleanLiteral,
+	CharacterRange: () => CharacterRange,
+	Condition: () => Condition,
+	Conjunction: () => Conjunction,
+	CrossReference: () => CrossReference,
+	Disjunction: () => Disjunction,
+	EndOfFile: () => EndOfFile,
+	Grammar: () => Grammar,
+	GrammarImport: () => GrammarImport,
+	Group: () => Group,
+	InferredType: () => InferredType,
+	InfixRule: () => InfixRule,
+	InfixRuleOperatorList: () => InfixRuleOperatorList,
+	InfixRuleOperators: () => InfixRuleOperators,
+	Interface: () => Interface,
+	Keyword: () => Keyword,
+	LangiumGrammarAstReflection: () => LangiumGrammarAstReflection,
+	LangiumGrammarTerminals: () => LangiumGrammarTerminals,
+	NamedArgument: () => NamedArgument,
+	NegatedToken: () => NegatedToken,
+	Negation: () => Negation,
+	NumberLiteral: () => NumberLiteral,
+	Parameter: () => Parameter,
+	ParameterReference: () => ParameterReference,
+	ParserRule: () => ParserRule,
+	ReferenceType: () => ReferenceType,
+	RegexToken: () => RegexToken,
+	ReturnType: () => ReturnType,
+	RuleCall: () => RuleCall,
+	SimpleType: () => SimpleType,
+	StringLiteral: () => StringLiteral,
+	TerminalAlternatives: () => TerminalAlternatives,
+	TerminalElement: () => TerminalElement,
+	TerminalGroup: () => TerminalGroup,
+	TerminalRule: () => TerminalRule,
+	TerminalRuleCall: () => TerminalRuleCall,
+	Type: () => Type,
+	TypeAttribute: () => TypeAttribute,
+	TypeDefinition: () => TypeDefinition,
+	UnionType: () => UnionType,
+	UnorderedGroup: () => UnorderedGroup,
+	UntilToken: () => UntilToken,
+	ValueLiteral: () => ValueLiteral,
+	Wildcard: () => Wildcard,
+	isAbstractElement: () => isAbstractElement,
+	isAbstractParserRule: () => isAbstractParserRule,
+	isAbstractRule: () => isAbstractRule,
+	isAbstractType: () => isAbstractType,
+	isAction: () => isAction,
+	isAlternatives: () => isAlternatives,
+	isArrayLiteral: () => isArrayLiteral,
+	isArrayType: () => isArrayType,
+	isAssignment: () => isAssignment,
+	isBooleanLiteral: () => isBooleanLiteral,
+	isCharacterRange: () => isCharacterRange,
+	isCondition: () => isCondition,
+	isConjunction: () => isConjunction,
+	isCrossReference: () => isCrossReference,
+	isDisjunction: () => isDisjunction,
+	isEndOfFile: () => isEndOfFile,
+	isGrammar: () => isGrammar,
+	isGrammarImport: () => isGrammarImport,
+	isGroup: () => isGroup,
+	isInferredType: () => isInferredType,
+	isInfixRule: () => isInfixRule,
+	isInfixRuleOperatorList: () => isInfixRuleOperatorList,
+	isInfixRuleOperators: () => isInfixRuleOperators,
+	isInterface: () => isInterface,
+	isKeyword: () => isKeyword,
+	isNamedArgument: () => isNamedArgument,
+	isNegatedToken: () => isNegatedToken,
+	isNegation: () => isNegation,
+	isNumberLiteral: () => isNumberLiteral,
+	isParameter: () => isParameter,
+	isParameterReference: () => isParameterReference,
+	isParserRule: () => isParserRule,
+	isReferenceType: () => isReferenceType,
+	isRegexToken: () => isRegexToken,
+	isReturnType: () => isReturnType,
+	isRuleCall: () => isRuleCall,
+	isSimpleType: () => isSimpleType,
+	isStringLiteral: () => isStringLiteral,
+	isTerminalAlternatives: () => isTerminalAlternatives,
+	isTerminalElement: () => isTerminalElement,
+	isTerminalGroup: () => isTerminalGroup,
+	isTerminalRule: () => isTerminalRule,
+	isTerminalRuleCall: () => isTerminalRuleCall,
+	isType: () => isType,
+	isTypeAttribute: () => isTypeAttribute,
+	isTypeDefinition: () => isTypeDefinition,
+	isUnionType: () => isUnionType,
+	isUnorderedGroup: () => isUnorderedGroup,
+	isUntilToken: () => isUntilToken,
+	isValueLiteral: () => isValueLiteral,
+	isWildcard: () => isWildcard,
+	reflection: () => reflection
+}, 1);
+const LangiumGrammarTerminals = {
+	ID: /\^?[_a-zA-Z][\w_]*/,
+	STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,
+	NUMBER: /NaN|-?((\d*\.\d+|\d+)([Ee][+-]?\d+)?|Infinity)/,
+	RegexLiteral: /\/(?![*+?])(?:[^\r\n\[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*\])+\/[a-z]*/,
+	WS: /\s+/,
+	ML_COMMENT: /\/\*[\s\S]*?\*\//,
+	SL_COMMENT: /\/\/[^\n\r]*/
+}, AbstractElement = {
 	$type: "AbstractElement",
 	cardinality: "cardinality"
 };
-function ee(e) {
-	return $.isInstance(e, t.$type);
+function isAbstractElement(e) {
+	return reflection.isInstance(e, AbstractElement.$type);
 }
-var n = { $type: "AbstractParserRule" };
-function te(e) {
-	return $.isInstance(e, n.$type);
+const AbstractParserRule = { $type: "AbstractParserRule" };
+function isAbstractParserRule(e) {
+	return reflection.isInstance(e, AbstractParserRule.$type);
 }
-var r = { $type: "AbstractRule" }, i = { $type: "AbstractType" }, a = {
+const AbstractRule = { $type: "AbstractRule" };
+function isAbstractRule(e) {
+	return reflection.isInstance(e, AbstractRule.$type);
+}
+const AbstractType = { $type: "AbstractType" };
+function isAbstractType(e) {
+	return reflection.isInstance(e, AbstractType.$type);
+}
+const Action = {
 	$type: "Action",
 	cardinality: "cardinality",
 	feature: "feature",
@@ -19,24 +142,32 @@ var r = { $type: "AbstractRule" }, i = { $type: "AbstractType" }, a = {
 	operator: "operator",
 	type: "type"
 };
-function ne(e) {
-	return $.isInstance(e, a.$type);
+function isAction(e) {
+	return reflection.isInstance(e, Action.$type);
 }
-var o = {
+const Alternatives = {
 	$type: "Alternatives",
 	cardinality: "cardinality",
 	elements: "elements"
 };
-function re(e) {
-	return $.isInstance(e, o.$type);
+function isAlternatives(e) {
+	return reflection.isInstance(e, Alternatives.$type);
 }
-var s = {
+const ArrayLiteral = {
 	$type: "ArrayLiteral",
 	elements: "elements"
-}, c = {
+};
+function isArrayLiteral(e) {
+	return reflection.isInstance(e, ArrayLiteral.$type);
+}
+const ArrayType = {
 	$type: "ArrayType",
 	elementType: "elementType"
-}, l = {
+};
+function isArrayType(e) {
+	return reflection.isInstance(e, ArrayType.$type);
+}
+const Assignment = {
 	$type: "Assignment",
 	cardinality: "cardinality",
 	feature: "feature",
@@ -44,17 +175,17 @@ var s = {
 	predicate: "predicate",
 	terminal: "terminal"
 };
-function ie(e) {
-	return $.isInstance(e, l.$type);
+function isAssignment(e) {
+	return reflection.isInstance(e, Assignment.$type);
 }
-var u = {
+const BooleanLiteral = {
 	$type: "BooleanLiteral",
 	true: "true"
 };
-function ae(e) {
-	return $.isInstance(e, u.$type);
+function isBooleanLiteral(e) {
+	return reflection.isInstance(e, BooleanLiteral.$type);
 }
-var d = {
+const CharacterRange = {
 	$type: "CharacterRange",
 	cardinality: "cardinality",
 	left: "left",
@@ -62,18 +193,22 @@ var d = {
 	parenthesized: "parenthesized",
 	right: "right"
 };
-function oe(e) {
-	return $.isInstance(e, d.$type);
+function isCharacterRange(e) {
+	return reflection.isInstance(e, CharacterRange.$type);
+}
+const Condition = { $type: "Condition" };
+function isCondition(e) {
+	return reflection.isInstance(e, Condition.$type);
 }
-var f = { $type: "Condition" }, p = {
+const Conjunction = {
 	$type: "Conjunction",
 	left: "left",
 	right: "right"
 };
-function se(e) {
-	return $.isInstance(e, p.$type);
+function isConjunction(e) {
+	return reflection.isInstance(e, Conjunction.$type);
 }
-var m = {
+const CrossReference = {
 	$type: "CrossReference",
 	cardinality: "cardinality",
 	deprecatedSyntax: "deprecatedSyntax",
@@ -81,25 +216,25 @@ var m = {
 	terminal: "terminal",
 	type: "type"
 };
-function ce(e) {
-	return $.isInstance(e, m.$type);
+function isCrossReference(e) {
+	return reflection.isInstance(e, CrossReference.$type);
 }
-var h = {
+const Disjunction = {
 	$type: "Disjunction",
 	left: "left",
 	right: "right"
 };
-function le(e) {
-	return $.isInstance(e, h.$type);
+function isDisjunction(e) {
+	return reflection.isInstance(e, Disjunction.$type);
 }
-var g = {
+const EndOfFile = {
 	$type: "EndOfFile",
 	cardinality: "cardinality"
 };
-function ue(e) {
-	return $.isInstance(e, g.$type);
+function isEndOfFile(e) {
+	return reflection.isInstance(e, EndOfFile.$type);
 }
-var _ = {
+const Grammar = {
 	$type: "Grammar",
 	imports: "imports",
 	interfaces: "interfaces",
@@ -107,27 +242,35 @@ var _ = {
 	name: "name",
 	rules: "rules",
 	types: "types"
-}, v = {
+};
+function isGrammar(e) {
+	return reflection.isInstance(e, Grammar.$type);
+}
+const GrammarImport = {
 	$type: "GrammarImport",
 	path: "path"
-}, y = {
+};
+function isGrammarImport(e) {
+	return reflection.isInstance(e, GrammarImport.$type);
+}
+const Group = {
 	$type: "Group",
 	cardinality: "cardinality",
 	elements: "elements",
 	guardCondition: "guardCondition",
 	predicate: "predicate"
 };
-function de(e) {
-	return $.isInstance(e, y.$type);
+function isGroup(e) {
+	return reflection.isInstance(e, Group.$type);
 }
-var b = {
+const InferredType = {
 	$type: "InferredType",
 	name: "name"
 };
-function fe(e) {
-	return $.isInstance(e, b.$type);
+function isInferredType(e) {
+	return reflection.isInstance(e, InferredType.$type);
 }
-var x = {
+const InfixRule = {
 	$type: "InfixRule",
 	call: "call",
 	dataType: "dataType",
@@ -137,70 +280,90 @@ var x = {
 	parameters: "parameters",
 	returnType: "returnType"
 };
-function pe(e) {
-	return $.isInstance(e, x.$type);
+function isInfixRule(e) {
+	return reflection.isInstance(e, InfixRule.$type);
 }
-var S = {
+const InfixRuleOperatorList = {
 	$type: "InfixRuleOperatorList",
 	associativity: "associativity",
 	operators: "operators"
-}, C = {
+};
+function isInfixRuleOperatorList(e) {
+	return reflection.isInstance(e, InfixRuleOperatorList.$type);
+}
+const InfixRuleOperators = {
 	$type: "InfixRuleOperators",
 	precedences: "precedences"
-}, w = {
+};
+function isInfixRuleOperators(e) {
+	return reflection.isInstance(e, InfixRuleOperators.$type);
+}
+const Interface = {
 	$type: "Interface",
 	attributes: "attributes",
 	name: "name",
 	superTypes: "superTypes"
 };
-function me(e) {
-	return $.isInstance(e, w.$type);
+function isInterface(e) {
+	return reflection.isInstance(e, Interface.$type);
 }
-var T = {
+const Keyword = {
 	$type: "Keyword",
 	cardinality: "cardinality",
 	predicate: "predicate",
 	value: "value"
 };
-function he(e) {
-	return $.isInstance(e, T.$type);
+function isKeyword(e) {
+	return reflection.isInstance(e, Keyword.$type);
 }
-var E = {
+const NamedArgument = {
 	$type: "NamedArgument",
 	calledByName: "calledByName",
 	parameter: "parameter",
 	value: "value"
-}, D = {
+};
+function isNamedArgument(e) {
+	return reflection.isInstance(e, NamedArgument.$type);
+}
+const NegatedToken = {
 	$type: "NegatedToken",
 	cardinality: "cardinality",
 	lookahead: "lookahead",
 	parenthesized: "parenthesized",
 	terminal: "terminal"
 };
-function ge(e) {
-	return $.isInstance(e, D.$type);
+function isNegatedToken(e) {
+	return reflection.isInstance(e, NegatedToken.$type);
 }
-var O = {
+const Negation = {
 	$type: "Negation",
 	value: "value"
 };
-function _e(e) {
-	return $.isInstance(e, O.$type);
+function isNegation(e) {
+	return reflection.isInstance(e, Negation.$type);
 }
-var k = {
+const NumberLiteral = {
 	$type: "NumberLiteral",
 	value: "value"
-}, A = {
+};
+function isNumberLiteral(e) {
+	return reflection.isInstance(e, NumberLiteral.$type);
+}
+const Parameter = {
 	$type: "Parameter",
 	name: "name"
-}, j = {
+};
+function isParameter(e) {
+	return reflection.isInstance(e, Parameter.$type);
+}
+const ParameterReference = {
 	$type: "ParameterReference",
 	parameter: "parameter"
 };
-function ve(e) {
-	return $.isInstance(e, j.$type);
+function isParameterReference(e) {
+	return reflection.isInstance(e, ParameterReference.$type);
 }
-var M = {
+const ParserRule = {
 	$type: "ParserRule",
 	dataType: "dataType",
 	definition: "definition",
@@ -211,78 +374,90 @@ var M = {
 	parameters: "parameters",
 	returnType: "returnType"
 };
-function ye(e) {
-	return $.isInstance(e, M.$type);
+function isParserRule(e) {
+	return reflection.isInstance(e, ParserRule.$type);
 }
-var N = {
+const ReferenceType = {
 	$type: "ReferenceType",
 	isMulti: "isMulti",
 	referenceType: "referenceType"
-}, P = {
+};
+function isReferenceType(e) {
+	return reflection.isInstance(e, ReferenceType.$type);
+}
+const RegexToken = {
 	$type: "RegexToken",
 	cardinality: "cardinality",
 	lookahead: "lookahead",
 	parenthesized: "parenthesized",
 	regex: "regex"
 };
-function be(e) {
-	return $.isInstance(e, P.$type);
+function isRegexToken(e) {
+	return reflection.isInstance(e, RegexToken.$type);
 }
-var F = {
+const ReturnType = {
 	$type: "ReturnType",
 	name: "name"
 };
-function xe(e) {
-	return $.isInstance(e, F.$type);
+function isReturnType(e) {
+	return reflection.isInstance(e, ReturnType.$type);
 }
-var I = {
+const RuleCall = {
 	$type: "RuleCall",
 	arguments: "arguments",
 	cardinality: "cardinality",
 	predicate: "predicate",
 	rule: "rule"
 };
-function Se(e) {
-	return $.isInstance(e, I.$type);
+function isRuleCall(e) {
+	return reflection.isInstance(e, RuleCall.$type);
 }
-var L = {
+const SimpleType = {
 	$type: "SimpleType",
 	primitiveType: "primitiveType",
 	stringType: "stringType",
 	typeRef: "typeRef"
 };
-function Ce(e) {
-	return $.isInstance(e, L.$type);
+function isSimpleType(e) {
+	return reflection.isInstance(e, SimpleType.$type);
 }
-var R = {
+const StringLiteral = {
 	$type: "StringLiteral",
 	value: "value"
-}, z = {
+};
+function isStringLiteral(e) {
+	return reflection.isInstance(e, StringLiteral.$type);
+}
+const TerminalAlternatives = {
 	$type: "TerminalAlternatives",
 	cardinality: "cardinality",
 	elements: "elements",
 	lookahead: "lookahead",
 	parenthesized: "parenthesized"
 };
-function we(e) {
-	return $.isInstance(e, z.$type);
+function isTerminalAlternatives(e) {
+	return reflection.isInstance(e, TerminalAlternatives.$type);
 }
-var B = {
+const TerminalElement = {
 	$type: "TerminalElement",
 	cardinality: "cardinality",
 	lookahead: "lookahead",
 	parenthesized: "parenthesized"
-}, V = {
+};
+function isTerminalElement(e) {
+	return reflection.isInstance(e, TerminalElement.$type);
+}
+const TerminalGroup = {
 	$type: "TerminalGroup",
 	cardinality: "cardinality",
 	elements: "elements",
 	lookahead: "lookahead",
 	parenthesized: "parenthesized"
 };
-function Te(e) {
-	return $.isInstance(e, V.$type);
+function isTerminalGroup(e) {
+	return reflection.isInstance(e, TerminalGroup.$type);
 }
-var H = {
+const TerminalRule = {
 	$type: "TerminalRule",
 	definition: "definition",
 	fragment: "fragment",
@@ -290,609 +465,625 @@ var H = {
 	name: "name",
 	type: "type"
 };
-function Ee(e) {
-	return $.isInstance(e, H.$type);
+function isTerminalRule(e) {
+	return reflection.isInstance(e, TerminalRule.$type);
 }
-var U = {
+const TerminalRuleCall = {
 	$type: "TerminalRuleCall",
 	cardinality: "cardinality",
 	lookahead: "lookahead",
 	parenthesized: "parenthesized",
 	rule: "rule"
 };
-function De(e) {
-	return $.isInstance(e, U.$type);
+function isTerminalRuleCall(e) {
+	return reflection.isInstance(e, TerminalRuleCall.$type);
 }
-var W = {
+const Type = {
 	$type: "Type",
 	name: "name",
 	type: "type"
 };
-function Oe(e) {
-	return $.isInstance(e, W.$type);
+function isType(e) {
+	return reflection.isInstance(e, Type.$type);
 }
-var G = {
+const TypeAttribute = {
 	$type: "TypeAttribute",
 	defaultValue: "defaultValue",
 	isOptional: "isOptional",
 	name: "name",
 	type: "type"
-}, K = { $type: "TypeDefinition" }, q = {
+};
+function isTypeAttribute(e) {
+	return reflection.isInstance(e, TypeAttribute.$type);
+}
+const TypeDefinition = { $type: "TypeDefinition" };
+function isTypeDefinition(e) {
+	return reflection.isInstance(e, TypeDefinition.$type);
+}
+const UnionType = {
 	$type: "UnionType",
 	types: "types"
-}, J = {
+};
+function isUnionType(e) {
+	return reflection.isInstance(e, UnionType.$type);
+}
+const UnorderedGroup = {
 	$type: "UnorderedGroup",
 	cardinality: "cardinality",
 	elements: "elements"
 };
-function ke(e) {
-	return $.isInstance(e, J.$type);
+function isUnorderedGroup(e) {
+	return reflection.isInstance(e, UnorderedGroup.$type);
 }
-var Y = {
+const UntilToken = {
 	$type: "UntilToken",
 	cardinality: "cardinality",
 	lookahead: "lookahead",
 	parenthesized: "parenthesized",
 	terminal: "terminal"
 };
-function Ae(e) {
-	return $.isInstance(e, Y.$type);
+function isUntilToken(e) {
+	return reflection.isInstance(e, UntilToken.$type);
 }
-var X = { $type: "ValueLiteral" }, Z = {
+const ValueLiteral = { $type: "ValueLiteral" };
+function isValueLiteral(e) {
+	return reflection.isInstance(e, ValueLiteral.$type);
+}
+const Wildcard = {
 	$type: "Wildcard",
 	cardinality: "cardinality",
 	lookahead: "lookahead",
 	parenthesized: "parenthesized"
 };
-function je(e) {
-	return $.isInstance(e, Z.$type);
+function isWildcard(e) {
+	return reflection.isInstance(e, Wildcard.$type);
 }
-var Q = class extends e {
+var LangiumGrammarAstReflection = class extends AbstractAstReflection {
 	constructor() {
 		super(...arguments), this.types = {
 			AbstractElement: {
-				name: t.$type,
-				properties: { cardinality: { name: t.cardinality } },
+				name: AbstractElement.$type,
+				properties: { cardinality: { name: AbstractElement.cardinality } },
 				superTypes: []
 			},
 			AbstractParserRule: {
-				name: n.$type,
+				name: AbstractParserRule.$type,
 				properties: {},
-				superTypes: [r.$type, i.$type]
+				superTypes: [AbstractRule.$type, AbstractType.$type]
 			},
 			AbstractRule: {
-				name: r.$type,
+				name: AbstractRule.$type,
 				properties: {},
 				superTypes: []
 			},
 			AbstractType: {
-				name: i.$type,
+				name: AbstractType.$type,
 				properties: {},
 				superTypes: []
 			},
 			Action: {
-				name: a.$type,
+				name: Action.$type,
 				properties: {
-					cardinality: { name: a.cardinality },
-					feature: { name: a.feature },
-					inferredType: { name: a.inferredType },
-					operator: { name: a.operator },
+					cardinality: { name: Action.cardinality },
+					feature: { name: Action.feature },
+					inferredType: { name: Action.inferredType },
+					operator: { name: Action.operator },
 					type: {
-						name: a.type,
-						referenceType: i.$type
+						name: Action.type,
+						referenceType: AbstractType.$type
 					}
 				},
-				superTypes: [t.$type]
+				superTypes: [AbstractElement.$type]
 			},
 			Alternatives: {
-				name: o.$type,
+				name: Alternatives.$type,
 				properties: {
-					cardinality: { name: o.cardinality },
+					cardinality: { name: Alternatives.cardinality },
 					elements: {
-						name: o.elements,
+						name: Alternatives.elements,
 						defaultValue: []
 					}
 				},
-				superTypes: [t.$type]
+				superTypes: [AbstractElement.$type]
 			},
 			ArrayLiteral: {
-				name: s.$type,
+				name: ArrayLiteral.$type,
 				properties: { elements: {
-					name: s.elements,
+					name: ArrayLiteral.elements,
 					defaultValue: []
 				} },
-				superTypes: [X.$type]
+				superTypes: [ValueLiteral.$type]
 			},
 			ArrayType: {
-				name: c.$type,
-				properties: { elementType: { name: c.elementType } },
-				superTypes: [K.$type]
+				name: ArrayType.$type,
+				properties: { elementType: { name: ArrayType.elementType } },
+				superTypes: [TypeDefinition.$type]
 			},
 			Assignment: {
-				name: l.$type,
+				name: Assignment.$type,
 				properties: {
-					cardinality: { name: l.cardinality },
-					feature: { name: l.feature },
-					operator: { name: l.operator },
-					predicate: { name: l.predicate },
-					terminal: { name: l.terminal }
+					cardinality: { name: Assignment.cardinality },
+					feature: { name: Assignment.feature },
+					operator: { name: Assignment.operator },
+					predicate: { name: Assignment.predicate },
+					terminal: { name: Assignment.terminal }
 				},
-				superTypes: [t.$type]
+				superTypes: [AbstractElement.$type]
 			},
 			BooleanLiteral: {
-				name: u.$type,
+				name: BooleanLiteral.$type,
 				properties: { true: {
-					name: u.true,
+					name: BooleanLiteral.true,
 					defaultValue: !1
 				} },
-				superTypes: [f.$type, X.$type]
+				superTypes: [Condition.$type, ValueLiteral.$type]
 			},
 			CharacterRange: {
-				name: d.$type,
+				name: CharacterRange.$type,
 				properties: {
-					cardinality: { name: d.cardinality },
-					left: { name: d.left },
-					lookahead: { name: d.lookahead },
+					cardinality: { name: CharacterRange.cardinality },
+					left: { name: CharacterRange.left },
+					lookahead: { name: CharacterRange.lookahead },
 					parenthesized: {
-						name: d.parenthesized,
+						name: CharacterRange.parenthesized,
 						defaultValue: !1
 					},
-					right: { name: d.right }
+					right: { name: CharacterRange.right }
 				},
-				superTypes: [B.$type]
+				superTypes: [TerminalElement.$type]
 			},
 			Condition: {
-				name: f.$type,
+				name: Condition.$type,
 				properties: {},
 				superTypes: []
 			},
 			Conjunction: {
-				name: p.$type,
+				name: Conjunction.$type,
 				properties: {
-					left: { name: p.left },
-					right: { name: p.right }
+					left: { name: Conjunction.left },
+					right: { name: Conjunction.right }
 				},
-				superTypes: [f.$type]
+				superTypes: [Condition.$type]
 			},
 			CrossReference: {
-				name: m.$type,
+				name: CrossReference.$type,
 				properties: {
-					cardinality: { name: m.cardinality },
+					cardinality: { name: CrossReference.cardinality },
 					deprecatedSyntax: {
-						name: m.deprecatedSyntax,
+						name: CrossReference.deprecatedSyntax,
 						defaultValue: !1
 					},
 					isMulti: {
-						name: m.isMulti,
+						name: CrossReference.isMulti,
 						defaultValue: !1
 					},
-					terminal: { name: m.terminal },
+					terminal: { name: CrossReference.terminal },
 					type: {
-						name: m.type,
-						referenceType: i.$type
+						name: CrossReference.type,
+						referenceType: AbstractType.$type
 					}
 				},
-				superTypes: [t.$type]
+				superTypes: [AbstractElement.$type]
 			},
 			Disjunction: {
-				name: h.$type,
+				name: Disjunction.$type,
 				properties: {
-					left: { name: h.left },
-					right: { name: h.right }
+					left: { name: Disjunction.left },
+					right: { name: Disjunction.right }
 				},
-				superTypes: [f.$type]
+				superTypes: [Condition.$type]
 			},
 			EndOfFile: {
-				name: g.$type,
-				properties: { cardinality: { name: g.cardinality } },
-				superTypes: [t.$type]
+				name: EndOfFile.$type,
+				properties: { cardinality: { name: EndOfFile.cardinality } },
+				superTypes: [AbstractElement.$type]
 			},
 			Grammar: {
-				name: _.$type,
+				name: Grammar.$type,
 				properties: {
 					imports: {
-						name: _.imports,
+						name: Grammar.imports,
 						defaultValue: []
 					},
 					interfaces: {
-						name: _.interfaces,
+						name: Grammar.interfaces,
 						defaultValue: []
 					},
 					isDeclared: {
-						name: _.isDeclared,
+						name: Grammar.isDeclared,
 						defaultValue: !1
 					},
-					name: { name: _.name },
+					name: { name: Grammar.name },
 					rules: {
-						name: _.rules,
+						name: Grammar.rules,
 						defaultValue: []
 					},
 					types: {
-						name: _.types,
+						name: Grammar.types,
 						defaultValue: []
 					}
 				},
 				superTypes: []
 			},
 			GrammarImport: {
-				name: v.$type,
-				properties: { path: { name: v.path } },
+				name: GrammarImport.$type,
+				properties: { path: { name: GrammarImport.path } },
 				superTypes: []
 			},
 			Group: {
-				name: y.$type,
+				name: Group.$type,
 				properties: {
-					cardinality: { name: y.cardinality },
+					cardinality: { name: Group.cardinality },
 					elements: {
-						name: y.elements,
+						name: Group.elements,
 						defaultValue: []
 					},
-					guardCondition: { name: y.guardCondition },
-					predicate: { name: y.predicate }
+					guardCondition: { name: Group.guardCondition },
+					predicate: { name: Group.predicate }
 				},
-				superTypes: [t.$type]
+				superTypes: [AbstractElement.$type]
 			},
 			InferredType: {
-				name: b.$type,
-				properties: { name: { name: b.name } },
-				superTypes: [i.$type]
+				name: InferredType.$type,
+				properties: { name: { name: InferredType.name } },
+				superTypes: [AbstractType.$type]
 			},
 			InfixRule: {
-				name: x.$type,
+				name: InfixRule.$type,
 				properties: {
-					call: { name: x.call },
-					dataType: { name: x.dataType },
-					inferredType: { name: x.inferredType },
-					name: { name: x.name },
-					operators: { name: x.operators },
+					call: { name: InfixRule.call },
+					dataType: { name: InfixRule.dataType },
+					inferredType: { name: InfixRule.inferredType },
+					name: { name: InfixRule.name },
+					operators: { name: InfixRule.operators },
 					parameters: {
-						name: x.parameters,
+						name: InfixRule.parameters,
 						defaultValue: []
 					},
 					returnType: {
-						name: x.returnType,
-						referenceType: i.$type
+						name: InfixRule.returnType,
+						referenceType: AbstractType.$type
 					}
 				},
-				superTypes: [n.$type]
+				superTypes: [AbstractParserRule.$type]
 			},
 			InfixRuleOperatorList: {
-				name: S.$type,
+				name: InfixRuleOperatorList.$type,
 				properties: {
-					associativity: { name: S.associativity },
+					associativity: { name: InfixRuleOperatorList.associativity },
 					operators: {
-						name: S.operators,
+						name: InfixRuleOperatorList.operators,
 						defaultValue: []
 					}
 				},
 				superTypes: []
 			},
 			InfixRuleOperators: {
-				name: C.$type,
+				name: InfixRuleOperators.$type,
 				properties: { precedences: {
-					name: C.precedences,
+					name: InfixRuleOperators.precedences,
 					defaultValue: []
 				} },
 				superTypes: []
 			},
 			Interface: {
-				name: w.$type,
+				name: Interface.$type,
 				properties: {
 					attributes: {
-						name: w.attributes,
+						name: Interface.attributes,
 						defaultValue: []
 					},
-					name: { name: w.name },
+					name: { name: Interface.name },
 					superTypes: {
-						name: w.superTypes,
+						name: Interface.superTypes,
 						defaultValue: [],
-						referenceType: i.$type
+						referenceType: AbstractType.$type
 					}
 				},
-				superTypes: [i.$type]
+				superTypes: [AbstractType.$type]
 			},
 			Keyword: {
-				name: T.$type,
+				name: Keyword.$type,
 				properties: {
-					cardinality: { name: T.cardinality },
-					predicate: { name: T.predicate },
-					value: { name: T.value }
+					cardinality: { name: Keyword.cardinality },
+					predicate: { name: Keyword.predicate },
+					value: { name: Keyword.value }
 				},
-				superTypes: [t.$type]
+				superTypes: [AbstractElement.$type]
 			},
 			NamedArgument: {
-				name: E.$type,
+				name: NamedArgument.$type,
 				properties: {
 					calledByName: {
-						name: E.calledByName,
+						name: NamedArgument.calledByName,
 						defaultValue: !1
 					},
 					parameter: {
-						name: E.parameter,
-						referenceType: A.$type
+						name: NamedArgument.parameter,
+						referenceType: Parameter.$type
 					},
-					value: { name: E.value }
+					value: { name: NamedArgument.value }
 				},
 				superTypes: []
 			},
 			NegatedToken: {
-				name: D.$type,
+				name: NegatedToken.$type,
 				properties: {
-					cardinality: { name: D.cardinality },
-					lookahead: { name: D.lookahead },
+					cardinality: { name: NegatedToken.cardinality },
+					lookahead: { name: NegatedToken.lookahead },
 					parenthesized: {
-						name: D.parenthesized,
+						name: NegatedToken.parenthesized,
 						defaultValue: !1
 					},
-					terminal: { name: D.terminal }
+					terminal: { name: NegatedToken.terminal }
 				},
-				superTypes: [B.$type]
+				superTypes: [TerminalElement.$type]
 			},
 			Negation: {
-				name: O.$type,
-				properties: { value: { name: O.value } },
-				superTypes: [f.$type]
+				name: Negation.$type,
+				properties: { value: { name: Negation.value } },
+				superTypes: [Condition.$type]
 			},
 			NumberLiteral: {
-				name: k.$type,
-				properties: { value: { name: k.value } },
-				superTypes: [X.$type]
+				name: NumberLiteral.$type,
+				properties: { value: { name: NumberLiteral.value } },
+				superTypes: [ValueLiteral.$type]
 			},
 			Parameter: {
-				name: A.$type,
-				properties: { name: { name: A.name } },
+				name: Parameter.$type,
+				properties: { name: { name: Parameter.name } },
 				superTypes: []
 			},
 			ParameterReference: {
-				name: j.$type,
+				name: ParameterReference.$type,
 				properties: { parameter: {
-					name: j.parameter,
-					referenceType: A.$type
+					name: ParameterReference.parameter,
+					referenceType: Parameter.$type
 				} },
-				superTypes: [f.$type]
+				superTypes: [Condition.$type]
 			},
 			ParserRule: {
-				name: M.$type,
+				name: ParserRule.$type,
 				properties: {
-					dataType: { name: M.dataType },
-					definition: { name: M.definition },
+					dataType: { name: ParserRule.dataType },
+					definition: { name: ParserRule.definition },
 					entry: {
-						name: M.entry,
+						name: ParserRule.entry,
 						defaultValue: !1
 					},
 					fragment: {
-						name: M.fragment,
+						name: ParserRule.fragment,
 						defaultValue: !1
 					},
-					inferredType: { name: M.inferredType },
-					name: { name: M.name },
+					inferredType: { name: ParserRule.inferredType },
+					name: { name: ParserRule.name },
 					parameters: {
-						name: M.parameters,
+						name: ParserRule.parameters,
 						defaultValue: []
 					},
 					returnType: {
-						name: M.returnType,
-						referenceType: i.$type
+						name: ParserRule.returnType,
+						referenceType: AbstractType.$type
 					}
 				},
-				superTypes: [n.$type]
+				superTypes: [AbstractParserRule.$type]
 			},
 			ReferenceType: {
-				name: N.$type,
+				name: ReferenceType.$type,
 				properties: {
 					isMulti: {
-						name: N.isMulti,
+						name: ReferenceType.isMulti,
 						defaultValue: !1
 					},
-					referenceType: { name: N.referenceType }
+					referenceType: { name: ReferenceType.referenceType }
 				},
-				superTypes: [K.$type]
+				superTypes: [TypeDefinition.$type]
 			},
 			RegexToken: {
-				name: P.$type,
+				name: RegexToken.$type,
 				properties: {
-					cardinality: { name: P.cardinality },
-					lookahead: { name: P.lookahead },
+					cardinality: { name: RegexToken.cardinality },
+					lookahead: { name: RegexToken.lookahead },
 					parenthesized: {
-						name: P.parenthesized,
+						name: RegexToken.parenthesized,
 						defaultValue: !1
 					},
-					regex: { name: P.regex }
+					regex: { name: RegexToken.regex }
 				},
-				superTypes: [B.$type]
+				superTypes: [TerminalElement.$type]
 			},
 			ReturnType: {
-				name: F.$type,
-				properties: { name: { name: F.name } },
+				name: ReturnType.$type,
+				properties: { name: { name: ReturnType.name } },
 				superTypes: []
 			},
 			RuleCall: {
-				name: I.$type,
+				name: RuleCall.$type,
 				properties: {
 					arguments: {
-						name: I.arguments,
+						name: RuleCall.arguments,
 						defaultValue: []
 					},
-					cardinality: { name: I.cardinality },
-					predicate: { name: I.predicate },
+					cardinality: { name: RuleCall.cardinality },
+					predicate: { name: RuleCall.predicate },
 					rule: {
-						name: I.rule,
-						referenceType: r.$type
+						name: RuleCall.rule,
+						referenceType: AbstractRule.$type
 					}
 				},
-				superTypes: [t.$type]
+				superTypes: [AbstractElement.$type]
 			},
 			SimpleType: {
-				name: L.$type,
+				name: SimpleType.$type,
 				properties: {
-					primitiveType: { name: L.primitiveType },
-					stringType: { name: L.stringType },
+					primitiveType: { name: SimpleType.primitiveType },
+					stringType: { name: SimpleType.stringType },
 					typeRef: {
-						name: L.typeRef,
-						referenceType: i.$type
+						name: SimpleType.typeRef,
+						referenceType: AbstractType.$type
 					}
 				},
-				superTypes: [K.$type]
+				superTypes: [TypeDefinition.$type]
 			},
 			StringLiteral: {
-				name: R.$type,
-				properties: { value: { name: R.value } },
-				superTypes: [X.$type]
+				name: StringLiteral.$type,
+				properties: { value: { name: StringLiteral.value } },
+				superTypes: [ValueLiteral.$type]
 			},
 			TerminalAlternatives: {
-				name: z.$type,
+				name: TerminalAlternatives.$type,
 				properties: {
-					cardinality: { name: z.cardinality },
+					cardinality: { name: TerminalAlternatives.cardinality },
 					elements: {
-						name: z.elements,
+						name: TerminalAlternatives.elements,
 						defaultValue: []
 					},
-					lookahead: { name: z.lookahead },
+					lookahead: { name: TerminalAlternatives.lookahead },
 					parenthesized: {
-						name: z.parenthesized,
+						name: TerminalAlternatives.parenthesized,
 						defaultValue: !1
 					}
 				},
-				superTypes: [B.$type]
+				superTypes: [TerminalElement.$type]
 			},
 			TerminalElement: {
-				name: B.$type,
+				name: TerminalElement.$type,
 				properties: {
-					cardinality: { name: B.cardinality },
-					lookahead: { name: B.lookahead },
+					cardinality: { name: TerminalElement.cardinality },
+					lookahead: { name: TerminalElement.lookahead },
 					parenthesized: {
-						name: B.parenthesized,
+						name: TerminalElement.parenthesized,
 						defaultValue: !1
 					}
 				},
-				superTypes: [t.$type]
+				superTypes: [AbstractElement.$type]
 			},
 			TerminalGroup: {
-				name: V.$type,
+				name: TerminalGroup.$type,
 				properties: {
-					cardinality: { name: V.cardinality },
+					cardinality: { name: TerminalGroup.cardinality },
 					elements: {
-						name: V.elements,
+						name: TerminalGroup.elements,
 						defaultValue: []
 					},
-					lookahead: { name: V.lookahead },
+					lookahead: { name: TerminalGroup.lookahead },
 					parenthesized: {
-						name: V.parenthesized,
+						name: TerminalGroup.parenthesized,
 						defaultValue: !1
 					}
 				},
-				superTypes: [B.$type]
+				superTypes: [TerminalElement.$type]
 			},
 			TerminalRule: {
-				name: H.$type,
+				name: TerminalRule.$type,
 				properties: {
-					definition: { name: H.definition },
+					definition: { name: TerminalRule.definition },
 					fragment: {
-						name: H.fragment,
+						name: TerminalRule.fragment,
 						defaultValue: !1
 					},
 					hidden: {
-						name: H.hidden,
+						name: TerminalRule.hidden,
 						defaultValue: !1
 					},
-					name: { name: H.name },
-					type: { name: H.type }
+					name: { name: TerminalRule.name },
+					type: { name: TerminalRule.type }
 				},
-				superTypes: [r.$type]
+				superTypes: [AbstractRule.$type]
 			},
 			TerminalRuleCall: {
-				name: U.$type,
+				name: TerminalRuleCall.$type,
 				properties: {
-					cardinality: { name: U.cardinality },
-					lookahead: { name: U.lookahead },
+					cardinality: { name: TerminalRuleCall.cardinality },
+					lookahead: { name: TerminalRuleCall.lookahead },
 					parenthesized: {
-						name: U.parenthesized,
+						name: TerminalRuleCall.parenthesized,
 						defaultValue: !1
 					},
 					rule: {
-						name: U.rule,
-						referenceType: H.$type
+						name: TerminalRuleCall.rule,
+						referenceType: TerminalRule.$type
 					}
 				},
-				superTypes: [B.$type]
+				superTypes: [TerminalElement.$type]
 			},
 			Type: {
-				name: W.$type,
+				name: Type.$type,
 				properties: {
-					name: { name: W.name },
-					type: { name: W.type }
+					name: { name: Type.name },
+					type: { name: Type.type }
 				},
-				superTypes: [i.$type]
+				superTypes: [AbstractType.$type]
 			},
 			TypeAttribute: {
-				name: G.$type,
+				name: TypeAttribute.$type,
 				properties: {
-					defaultValue: { name: G.defaultValue },
+					defaultValue: { name: TypeAttribute.defaultValue },
 					isOptional: {
-						name: G.isOptional,
+						name: TypeAttribute.isOptional,
 						defaultValue: !1
 					},
-					name: { name: G.name },
-					type: { name: G.type }
+					name: { name: TypeAttribute.name },
+					type: { name: TypeAttribute.type }
 				},
 				superTypes: []
 			},
 			TypeDefinition: {
-				name: K.$type,
+				name: TypeDefinition.$type,
 				properties: {},
 				superTypes: []
 			},
 			UnionType: {
-				name: q.$type,
+				name: UnionType.$type,
 				properties: { types: {
-					name: q.types,
+					name: UnionType.types,
 					defaultValue: []
 				} },
-				superTypes: [K.$type]
+				superTypes: [TypeDefinition.$type]
 			},
 			UnorderedGroup: {
-				name: J.$type,
+				name: UnorderedGroup.$type,
 				properties: {
-					cardinality: { name: J.cardinality },
+					cardinality: { name: UnorderedGroup.cardinality },
 					elements: {
-						name: J.elements,
+						name: UnorderedGroup.elements,
 						defaultValue: []
 					}
 				},
-				superTypes: [t.$type]
+				superTypes: [AbstractElement.$type]
 			},
 			UntilToken: {
-				name: Y.$type,
+				name: UntilToken.$type,
 				properties: {
-					cardinality: { name: Y.cardinality },
-					lookahead: { name: Y.lookahead },
+					cardinality: { name: UntilToken.cardinality },
+					lookahead: { name: UntilToken.lookahead },
 					parenthesized: {
-						name: Y.parenthesized,
+						name: UntilToken.parenthesized,
 						defaultValue: !1
 					},
-					terminal: { name: Y.terminal }
+					terminal: { name: UntilToken.terminal }
 				},
-				superTypes: [B.$type]
+				superTypes: [TerminalElement.$type]
 			},
 			ValueLiteral: {
-				name: X.$type,
+				name: ValueLiteral.$type,
 				properties: {},
 				superTypes: []
 			},
 			Wildcard: {
-				name: Z.$type,
+				name: Wildcard.$type,
 				properties: {
-					cardinality: { name: Z.cardinality },
-					lookahead: { name: Z.lookahead },
+					cardinality: { name: Wildcard.cardinality },
+					lookahead: { name: Wildcard.lookahead },
 					parenthesized: {
-						name: Z.parenthesized,
+						name: Wildcard.parenthesized,
 						defaultValue: !1
 					}
 				},
-				superTypes: [B.$type]
+				superTypes: [TerminalElement.$type]
 			}
 		};
 	}
-}, $ = new Q();
-//#endregion
-export { Q as LangiumGrammarAstReflection, ee as isAbstractElement, te as isAbstractParserRule, ne as isAction, re as isAlternatives, ie as isAssignment, ae as isBooleanLiteral, oe as isCharacterRange, se as isConjunction, ce as isCrossReference, le as isDisjunction, ue as isEndOfFile, de as isGroup, fe as isInferredType, pe as isInfixRule, me as isInterface, he as isKeyword, ge as isNegatedToken, _e as isNegation, ve as isParameterReference, ye as isParserRule, be as isRegexToken, xe as isReturnType, Se as isRuleCall, Ce as isSimpleType, we as isTerminalAlternatives, Te as isTerminalGroup, Ee as isTerminalRule, De as isTerminalRuleCall, Oe as isType, ke as isUnorderedGroup, Ae as isUntilToken, je as isWildcard };
+};
+const reflection = new LangiumGrammarAstReflection();
+export { LangiumGrammarAstReflection, ast_exports, isAbstractElement, isAbstractParserRule, isAction, isAlternatives, isArrayType, isAssignment, isBooleanLiteral, isCharacterRange, isConjunction, isCrossReference, isDisjunction, isEndOfFile, isGroup, isInferredType, isInfixRule, isInterface, isKeyword, isNegatedToken, isNegation, isParameterReference, isParserRule, isReferenceType, isRegexToken, isReturnType, isRuleCall, isSimpleType, isTerminalAlternatives, isTerminalGroup, isTerminalRule, isTerminalRuleCall, isType, isUnionType, isUnorderedGroup, isUntilToken, isWildcard };