@loopstack/loopstack-studio 0.25.0 → 0.25.1

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

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