@plumile/ui 0.1.113 → 0.1.114

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

@@ -1,900 +0,0 @@
-import { AbstractAstReflection as e } from "../../syntax-tree.js";
-//#region ../../node_modules/langium/lib/languages/generated/ast.js
-var t = {
-	$type: "AbstractElement",
-	cardinality: "cardinality"
-};
-function ee(e) {
-	return $.isInstance(e, t.$type);
-}
-var n = { $type: "AbstractParserRule" };
-function te(e) {
-	return $.isInstance(e, n.$type);
-}
-var r = { $type: "AbstractRule" }, i = { $type: "AbstractType" }, a = {
-	$type: "Action",
-	cardinality: "cardinality",
-	feature: "feature",
-	inferredType: "inferredType",
-	operator: "operator",
-	type: "type"
-};
-function ne(e) {
-	return $.isInstance(e, a.$type);
-}
-var o = {
-	$type: "Alternatives",
-	cardinality: "cardinality",
-	elements: "elements"
-};
-function re(e) {
-	return $.isInstance(e, o.$type);
-}
-var s = {
-	$type: "ArrayLiteral",
-	elements: "elements"
-}, c = {
-	$type: "ArrayType",
-	elementType: "elementType"
-}, l = {
-	$type: "Assignment",
-	cardinality: "cardinality",
-	feature: "feature",
-	operator: "operator",
-	predicate: "predicate",
-	terminal: "terminal"
-};
-function ie(e) {
-	return $.isInstance(e, l.$type);
-}
-var u = {
-	$type: "BooleanLiteral",
-	true: "true"
-};
-function ae(e) {
-	return $.isInstance(e, u.$type);
-}
-var d = {
-	$type: "CharacterRange",
-	cardinality: "cardinality",
-	left: "left",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized",
-	right: "right"
-};
-function oe(e) {
-	return $.isInstance(e, d.$type);
-}
-var f = { $type: "Condition" }, p = {
-	$type: "Conjunction",
-	left: "left",
-	right: "right"
-};
-function se(e) {
-	return $.isInstance(e, p.$type);
-}
-var m = {
-	$type: "CrossReference",
-	cardinality: "cardinality",
-	deprecatedSyntax: "deprecatedSyntax",
-	isMulti: "isMulti",
-	terminal: "terminal",
-	type: "type"
-};
-function ce(e) {
-	return $.isInstance(e, m.$type);
-}
-var h = {
-	$type: "Disjunction",
-	left: "left",
-	right: "right"
-};
-function le(e) {
-	return $.isInstance(e, h.$type);
-}
-var g = {
-	$type: "EndOfFile",
-	cardinality: "cardinality"
-};
-function ue(e) {
-	return $.isInstance(e, g.$type);
-}
-var _ = {
-	$type: "Grammar",
-	imports: "imports",
-	interfaces: "interfaces",
-	isDeclared: "isDeclared",
-	name: "name",
-	rules: "rules",
-	types: "types"
-}, v = {
-	$type: "GrammarImport",
-	path: "path"
-}, y = {
-	$type: "Group",
-	cardinality: "cardinality",
-	elements: "elements",
-	guardCondition: "guardCondition",
-	predicate: "predicate"
-};
-function de(e) {
-	return $.isInstance(e, y.$type);
-}
-var b = {
-	$type: "InferredType",
-	name: "name"
-};
-function fe(e) {
-	return $.isInstance(e, b.$type);
-}
-var x = {
-	$type: "InfixRule",
-	call: "call",
-	dataType: "dataType",
-	inferredType: "inferredType",
-	name: "name",
-	operators: "operators",
-	parameters: "parameters",
-	returnType: "returnType"
-};
-function pe(e) {
-	return $.isInstance(e, x.$type);
-}
-var S = {
-	$type: "InfixRuleOperatorList",
-	associativity: "associativity",
-	operators: "operators"
-}, C = {
-	$type: "InfixRuleOperators",
-	precedences: "precedences"
-}, w = {
-	$type: "Interface",
-	attributes: "attributes",
-	name: "name",
-	superTypes: "superTypes"
-};
-function me(e) {
-	return $.isInstance(e, w.$type);
-}
-var T = {
-	$type: "Keyword",
-	cardinality: "cardinality",
-	predicate: "predicate",
-	value: "value"
-};
-function he(e) {
-	return $.isInstance(e, T.$type);
-}
-var E = {
-	$type: "NamedArgument",
-	calledByName: "calledByName",
-	parameter: "parameter",
-	value: "value"
-}, D = {
-	$type: "NegatedToken",
-	cardinality: "cardinality",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized",
-	terminal: "terminal"
-};
-function ge(e) {
-	return $.isInstance(e, D.$type);
-}
-var O = {
-	$type: "Negation",
-	value: "value"
-};
-function _e(e) {
-	return $.isInstance(e, O.$type);
-}
-var k = {
-	$type: "NumberLiteral",
-	value: "value"
-}, A = {
-	$type: "Parameter",
-	name: "name"
-}, j = {
-	$type: "ParameterReference",
-	parameter: "parameter"
-};
-function ve(e) {
-	return $.isInstance(e, j.$type);
-}
-var M = {
-	$type: "ParserRule",
-	dataType: "dataType",
-	definition: "definition",
-	entry: "entry",
-	fragment: "fragment",
-	inferredType: "inferredType",
-	name: "name",
-	parameters: "parameters",
-	returnType: "returnType"
-};
-function ye(e) {
-	return $.isInstance(e, M.$type);
-}
-var N = {
-	$type: "ReferenceType",
-	isMulti: "isMulti",
-	referenceType: "referenceType"
-}, P = {
-	$type: "RegexToken",
-	cardinality: "cardinality",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized",
-	regex: "regex"
-};
-function be(e) {
-	return $.isInstance(e, P.$type);
-}
-var F = {
-	$type: "ReturnType",
-	name: "name"
-};
-function xe(e) {
-	return $.isInstance(e, F.$type);
-}
-var I = {
-	$type: "RuleCall",
-	arguments: "arguments",
-	cardinality: "cardinality",
-	predicate: "predicate",
-	rule: "rule"
-};
-function Se(e) {
-	return $.isInstance(e, I.$type);
-}
-var L = {
-	$type: "SimpleType",
-	primitiveType: "primitiveType",
-	stringType: "stringType",
-	typeRef: "typeRef"
-};
-function Ce(e) {
-	return $.isInstance(e, L.$type);
-}
-var R = {
-	$type: "StringLiteral",
-	value: "value"
-}, z = {
-	$type: "TerminalAlternatives",
-	cardinality: "cardinality",
-	elements: "elements",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized"
-};
-function we(e) {
-	return $.isInstance(e, z.$type);
-}
-var B = {
-	$type: "TerminalElement",
-	cardinality: "cardinality",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized"
-}, V = {
-	$type: "TerminalGroup",
-	cardinality: "cardinality",
-	elements: "elements",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized"
-};
-function Te(e) {
-	return $.isInstance(e, V.$type);
-}
-var H = {
-	$type: "TerminalRule",
-	definition: "definition",
-	fragment: "fragment",
-	hidden: "hidden",
-	name: "name",
-	type: "type"
-};
-function Ee(e) {
-	return $.isInstance(e, H.$type);
-}
-var U = {
-	$type: "TerminalRuleCall",
-	cardinality: "cardinality",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized",
-	rule: "rule"
-};
-function De(e) {
-	return $.isInstance(e, U.$type);
-}
-var W = {
-	$type: "Type",
-	name: "name",
-	type: "type"
-};
-function Oe(e) {
-	return $.isInstance(e, W.$type);
-}
-var G = {
-	$type: "TypeAttribute",
-	defaultValue: "defaultValue",
-	isOptional: "isOptional",
-	name: "name",
-	type: "type"
-}, K = { $type: "TypeDefinition" }, q = {
-	$type: "UnionType",
-	types: "types"
-}, J = {
-	$type: "UnorderedGroup",
-	cardinality: "cardinality",
-	elements: "elements"
-};
-function ke(e) {
-	return $.isInstance(e, J.$type);
-}
-var Y = {
-	$type: "UntilToken",
-	cardinality: "cardinality",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized",
-	terminal: "terminal"
-};
-function Ae(e) {
-	return $.isInstance(e, Y.$type);
-}
-var X = { $type: "ValueLiteral" }, Z = {
-	$type: "Wildcard",
-	cardinality: "cardinality",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized"
-};
-function je(e) {
-	return $.isInstance(e, Z.$type);
-}
-var Q = class extends e {
-	constructor() {
-		super(...arguments), this.types = {
-			AbstractElement: {
-				name: t.$type,
-				properties: { cardinality: { name: t.cardinality } },
-				superTypes: []
-			},
-			AbstractParserRule: {
-				name: n.$type,
-				properties: {},
-				superTypes: [r.$type, i.$type]
-			},
-			AbstractRule: {
-				name: r.$type,
-				properties: {},
-				superTypes: []
-			},
-			AbstractType: {
-				name: i.$type,
-				properties: {},
-				superTypes: []
-			},
-			Action: {
-				name: a.$type,
-				properties: {
-					cardinality: { name: a.cardinality },
-					feature: { name: a.feature },
-					inferredType: { name: a.inferredType },
-					operator: { name: a.operator },
-					type: {
-						name: a.type,
-						referenceType: i.$type
-					}
-				},
-				superTypes: [t.$type]
-			},
-			Alternatives: {
-				name: o.$type,
-				properties: {
-					cardinality: { name: o.cardinality },
-					elements: {
-						name: o.elements,
-						defaultValue: []
-					}
-				},
-				superTypes: [t.$type]
-			},
-			ArrayLiteral: {
-				name: s.$type,
-				properties: { elements: {
-					name: s.elements,
-					defaultValue: []
-				} },
-				superTypes: [X.$type]
-			},
-			ArrayType: {
-				name: c.$type,
-				properties: { elementType: { name: c.elementType } },
-				superTypes: [K.$type]
-			},
-			Assignment: {
-				name: l.$type,
-				properties: {
-					cardinality: { name: l.cardinality },
-					feature: { name: l.feature },
-					operator: { name: l.operator },
-					predicate: { name: l.predicate },
-					terminal: { name: l.terminal }
-				},
-				superTypes: [t.$type]
-			},
-			BooleanLiteral: {
-				name: u.$type,
-				properties: { true: {
-					name: u.true,
-					defaultValue: !1
-				} },
-				superTypes: [f.$type, X.$type]
-			},
-			CharacterRange: {
-				name: d.$type,
-				properties: {
-					cardinality: { name: d.cardinality },
-					left: { name: d.left },
-					lookahead: { name: d.lookahead },
-					parenthesized: {
-						name: d.parenthesized,
-						defaultValue: !1
-					},
-					right: { name: d.right }
-				},
-				superTypes: [B.$type]
-			},
-			Condition: {
-				name: f.$type,
-				properties: {},
-				superTypes: []
-			},
-			Conjunction: {
-				name: p.$type,
-				properties: {
-					left: { name: p.left },
-					right: { name: p.right }
-				},
-				superTypes: [f.$type]
-			},
-			CrossReference: {
-				name: m.$type,
-				properties: {
-					cardinality: { name: m.cardinality },
-					deprecatedSyntax: {
-						name: m.deprecatedSyntax,
-						defaultValue: !1
-					},
-					isMulti: {
-						name: m.isMulti,
-						defaultValue: !1
-					},
-					terminal: { name: m.terminal },
-					type: {
-						name: m.type,
-						referenceType: i.$type
-					}
-				},
-				superTypes: [t.$type]
-			},
-			Disjunction: {
-				name: h.$type,
-				properties: {
-					left: { name: h.left },
-					right: { name: h.right }
-				},
-				superTypes: [f.$type]
-			},
-			EndOfFile: {
-				name: g.$type,
-				properties: { cardinality: { name: g.cardinality } },
-				superTypes: [t.$type]
-			},
-			Grammar: {
-				name: _.$type,
-				properties: {
-					imports: {
-						name: _.imports,
-						defaultValue: []
-					},
-					interfaces: {
-						name: _.interfaces,
-						defaultValue: []
-					},
-					isDeclared: {
-						name: _.isDeclared,
-						defaultValue: !1
-					},
-					name: { name: _.name },
-					rules: {
-						name: _.rules,
-						defaultValue: []
-					},
-					types: {
-						name: _.types,
-						defaultValue: []
-					}
-				},
-				superTypes: []
-			},
-			GrammarImport: {
-				name: v.$type,
-				properties: { path: { name: v.path } },
-				superTypes: []
-			},
-			Group: {
-				name: y.$type,
-				properties: {
-					cardinality: { name: y.cardinality },
-					elements: {
-						name: y.elements,
-						defaultValue: []
-					},
-					guardCondition: { name: y.guardCondition },
-					predicate: { name: y.predicate }
-				},
-				superTypes: [t.$type]
-			},
-			InferredType: {
-				name: b.$type,
-				properties: { name: { name: b.name } },
-				superTypes: [i.$type]
-			},
-			InfixRule: {
-				name: x.$type,
-				properties: {
-					call: { name: x.call },
-					dataType: { name: x.dataType },
-					inferredType: { name: x.inferredType },
-					name: { name: x.name },
-					operators: { name: x.operators },
-					parameters: {
-						name: x.parameters,
-						defaultValue: []
-					},
-					returnType: {
-						name: x.returnType,
-						referenceType: i.$type
-					}
-				},
-				superTypes: [n.$type]
-			},
-			InfixRuleOperatorList: {
-				name: S.$type,
-				properties: {
-					associativity: { name: S.associativity },
-					operators: {
-						name: S.operators,
-						defaultValue: []
-					}
-				},
-				superTypes: []
-			},
-			InfixRuleOperators: {
-				name: C.$type,
-				properties: { precedences: {
-					name: C.precedences,
-					defaultValue: []
-				} },
-				superTypes: []
-			},
-			Interface: {
-				name: w.$type,
-				properties: {
-					attributes: {
-						name: w.attributes,
-						defaultValue: []
-					},
-					name: { name: w.name },
-					superTypes: {
-						name: w.superTypes,
-						defaultValue: [],
-						referenceType: i.$type
-					}
-				},
-				superTypes: [i.$type]
-			},
-			Keyword: {
-				name: T.$type,
-				properties: {
-					cardinality: { name: T.cardinality },
-					predicate: { name: T.predicate },
-					value: { name: T.value }
-				},
-				superTypes: [t.$type]
-			},
-			NamedArgument: {
-				name: E.$type,
-				properties: {
-					calledByName: {
-						name: E.calledByName,
-						defaultValue: !1
-					},
-					parameter: {
-						name: E.parameter,
-						referenceType: A.$type
-					},
-					value: { name: E.value }
-				},
-				superTypes: []
-			},
-			NegatedToken: {
-				name: D.$type,
-				properties: {
-					cardinality: { name: D.cardinality },
-					lookahead: { name: D.lookahead },
-					parenthesized: {
-						name: D.parenthesized,
-						defaultValue: !1
-					},
-					terminal: { name: D.terminal }
-				},
-				superTypes: [B.$type]
-			},
-			Negation: {
-				name: O.$type,
-				properties: { value: { name: O.value } },
-				superTypes: [f.$type]
-			},
-			NumberLiteral: {
-				name: k.$type,
-				properties: { value: { name: k.value } },
-				superTypes: [X.$type]
-			},
-			Parameter: {
-				name: A.$type,
-				properties: { name: { name: A.name } },
-				superTypes: []
-			},
-			ParameterReference: {
-				name: j.$type,
-				properties: { parameter: {
-					name: j.parameter,
-					referenceType: A.$type
-				} },
-				superTypes: [f.$type]
-			},
-			ParserRule: {
-				name: M.$type,
-				properties: {
-					dataType: { name: M.dataType },
-					definition: { name: M.definition },
-					entry: {
-						name: M.entry,
-						defaultValue: !1
-					},
-					fragment: {
-						name: M.fragment,
-						defaultValue: !1
-					},
-					inferredType: { name: M.inferredType },
-					name: { name: M.name },
-					parameters: {
-						name: M.parameters,
-						defaultValue: []
-					},
-					returnType: {
-						name: M.returnType,
-						referenceType: i.$type
-					}
-				},
-				superTypes: [n.$type]
-			},
-			ReferenceType: {
-				name: N.$type,
-				properties: {
-					isMulti: {
-						name: N.isMulti,
-						defaultValue: !1
-					},
-					referenceType: { name: N.referenceType }
-				},
-				superTypes: [K.$type]
-			},
-			RegexToken: {
-				name: P.$type,
-				properties: {
-					cardinality: { name: P.cardinality },
-					lookahead: { name: P.lookahead },
-					parenthesized: {
-						name: P.parenthesized,
-						defaultValue: !1
-					},
-					regex: { name: P.regex }
-				},
-				superTypes: [B.$type]
-			},
-			ReturnType: {
-				name: F.$type,
-				properties: { name: { name: F.name } },
-				superTypes: []
-			},
-			RuleCall: {
-				name: I.$type,
-				properties: {
-					arguments: {
-						name: I.arguments,
-						defaultValue: []
-					},
-					cardinality: { name: I.cardinality },
-					predicate: { name: I.predicate },
-					rule: {
-						name: I.rule,
-						referenceType: r.$type
-					}
-				},
-				superTypes: [t.$type]
-			},
-			SimpleType: {
-				name: L.$type,
-				properties: {
-					primitiveType: { name: L.primitiveType },
-					stringType: { name: L.stringType },
-					typeRef: {
-						name: L.typeRef,
-						referenceType: i.$type
-					}
-				},
-				superTypes: [K.$type]
-			},
-			StringLiteral: {
-				name: R.$type,
-				properties: { value: { name: R.value } },
-				superTypes: [X.$type]
-			},
-			TerminalAlternatives: {
-				name: z.$type,
-				properties: {
-					cardinality: { name: z.cardinality },
-					elements: {
-						name: z.elements,
-						defaultValue: []
-					},
-					lookahead: { name: z.lookahead },
-					parenthesized: {
-						name: z.parenthesized,
-						defaultValue: !1
-					}
-				},
-				superTypes: [B.$type]
-			},
-			TerminalElement: {
-				name: B.$type,
-				properties: {
-					cardinality: { name: B.cardinality },
-					lookahead: { name: B.lookahead },
-					parenthesized: {
-						name: B.parenthesized,
-						defaultValue: !1
-					}
-				},
-				superTypes: [t.$type]
-			},
-			TerminalGroup: {
-				name: V.$type,
-				properties: {
-					cardinality: { name: V.cardinality },
-					elements: {
-						name: V.elements,
-						defaultValue: []
-					},
-					lookahead: { name: V.lookahead },
-					parenthesized: {
-						name: V.parenthesized,
-						defaultValue: !1
-					}
-				},
-				superTypes: [B.$type]
-			},
-			TerminalRule: {
-				name: H.$type,
-				properties: {
-					definition: { name: H.definition },
-					fragment: {
-						name: H.fragment,
-						defaultValue: !1
-					},
-					hidden: {
-						name: H.hidden,
-						defaultValue: !1
-					},
-					name: { name: H.name },
-					type: { name: H.type }
-				},
-				superTypes: [r.$type]
-			},
-			TerminalRuleCall: {
-				name: U.$type,
-				properties: {
-					cardinality: { name: U.cardinality },
-					lookahead: { name: U.lookahead },
-					parenthesized: {
-						name: U.parenthesized,
-						defaultValue: !1
-					},
-					rule: {
-						name: U.rule,
-						referenceType: H.$type
-					}
-				},
-				superTypes: [B.$type]
-			},
-			Type: {
-				name: W.$type,
-				properties: {
-					name: { name: W.name },
-					type: { name: W.type }
-				},
-				superTypes: [i.$type]
-			},
-			TypeAttribute: {
-				name: G.$type,
-				properties: {
-					defaultValue: { name: G.defaultValue },
-					isOptional: {
-						name: G.isOptional,
-						defaultValue: !1
-					},
-					name: { name: G.name },
-					type: { name: G.type }
-				},
-				superTypes: []
-			},
-			TypeDefinition: {
-				name: K.$type,
-				properties: {},
-				superTypes: []
-			},
-			UnionType: {
-				name: q.$type,
-				properties: { types: {
-					name: q.types,
-					defaultValue: []
-				} },
-				superTypes: [K.$type]
-			},
-			UnorderedGroup: {
-				name: J.$type,
-				properties: {
-					cardinality: { name: J.cardinality },
-					elements: {
-						name: J.elements,
-						defaultValue: []
-					}
-				},
-				superTypes: [t.$type]
-			},
-			UntilToken: {
-				name: Y.$type,
-				properties: {
-					cardinality: { name: Y.cardinality },
-					lookahead: { name: Y.lookahead },
-					parenthesized: {
-						name: Y.parenthesized,
-						defaultValue: !1
-					},
-					terminal: { name: Y.terminal }
-				},
-				superTypes: [B.$type]
-			},
-			ValueLiteral: {
-				name: X.$type,
-				properties: {},
-				superTypes: []
-			},
-			Wildcard: {
-				name: Z.$type,
-				properties: {
-					cardinality: { name: Z.cardinality },
-					lookahead: { name: Z.lookahead },
-					parenthesized: {
-						name: Z.parenthesized,
-						defaultValue: !1
-					}
-				},
-				superTypes: [B.$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 };
-
-//# sourceMappingURL=ast.js.map