@zenstackhq/language 3.5.6 → 3.6.1

package/dist/ast.cjs

@@ -1,1435 +1,133 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_ast = require("./ast-Clidp86c.cjs");
+//#region src/ast.ts
+const BinaryExprOperatorPriority = {
+	"||": 1,
+	"&&": 1,
+	"==": 2,
+	"!=": 2,
+	">": 3,
+	"<": 3,
+	">=": 3,
+	"<=": 3,
+	in: 4,
+	"^": 5,
+	"?": 5,
+	"!": 5
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/ast.ts
-var ast_exports = {};
-__export(ast_exports, {
-  AbstractDeclaration: () => AbstractDeclaration,
-  Argument: () => Argument,
-  ArrayExpr: () => ArrayExpr,
-  Attribute: () => Attribute,
-  AttributeArg: () => AttributeArg,
-  AttributeParam: () => AttributeParam,
-  AttributeParamType: () => AttributeParamType,
-  BinaryExpr: () => BinaryExpr,
-  BinaryExprOperatorPriority: () => BinaryExprOperatorPriority,
-  BooleanLiteral: () => BooleanLiteral,
-  CollectionPredicateBinding: () => CollectionPredicateBinding,
-  ConfigArrayExpr: () => ConfigArrayExpr,
-  ConfigExpr: () => ConfigExpr,
-  ConfigField: () => ConfigField,
-  ConfigInvocationArg: () => ConfigInvocationArg,
-  ConfigInvocationExpr: () => ConfigInvocationExpr,
-  DataField: () => DataField,
-  DataFieldAttribute: () => DataFieldAttribute,
-  DataFieldType: () => DataFieldType,
-  DataModel: () => DataModel,
-  DataModelAttribute: () => DataModelAttribute,
-  DataSource: () => DataSource,
-  Enum: () => Enum,
-  EnumField: () => EnumField,
-  Expression: () => Expression,
-  FieldInitializer: () => FieldInitializer,
-  FunctionDecl: () => FunctionDecl,
-  FunctionParam: () => FunctionParam,
-  FunctionParamType: () => FunctionParamType,
-  GeneratorDecl: () => GeneratorDecl,
-  InternalAttribute: () => InternalAttribute,
-  InvocationExpr: () => InvocationExpr,
-  LiteralExpr: () => LiteralExpr,
-  MemberAccessExpr: () => MemberAccessExpr,
-  MemberAccessTarget: () => MemberAccessTarget,
-  Model: () => Model,
-  ModelImport: () => ModelImport,
-  NullExpr: () => NullExpr,
-  NumberLiteral: () => NumberLiteral,
-  ObjectExpr: () => ObjectExpr,
-  Plugin: () => Plugin,
-  PluginField: () => PluginField,
-  Procedure: () => Procedure,
-  ProcedureParam: () => ProcedureParam,
-  ReferenceArg: () => ReferenceArg,
-  ReferenceExpr: () => ReferenceExpr,
-  ReferenceTarget: () => ReferenceTarget,
-  StringLiteral: () => StringLiteral,
-  ThisExpr: () => ThisExpr,
-  TypeDeclaration: () => TypeDeclaration,
-  TypeDef: () => TypeDef,
-  UnaryExpr: () => UnaryExpr,
-  UnsupportedFieldType: () => UnsupportedFieldType,
-  ZModelAstReflection: () => ZModelAstReflection,
-  ZModelTerminals: () => ZModelTerminals,
-  isAbstractDeclaration: () => isAbstractDeclaration,
-  isArgument: () => isArgument,
-  isArrayExpr: () => isArrayExpr,
-  isAttribute: () => isAttribute,
-  isAttributeArg: () => isAttributeArg,
-  isAttributeParam: () => isAttributeParam,
-  isAttributeParamType: () => isAttributeParamType,
-  isBinaryExpr: () => isBinaryExpr,
-  isBoolean: () => isBoolean,
-  isBooleanLiteral: () => isBooleanLiteral,
-  isBuiltinType: () => isBuiltinType,
-  isCollectionPredicateBinding: () => isCollectionPredicateBinding,
-  isConfigArrayExpr: () => isConfigArrayExpr,
-  isConfigExpr: () => isConfigExpr,
-  isConfigField: () => isConfigField,
-  isConfigInvocationArg: () => isConfigInvocationArg,
-  isConfigInvocationExpr: () => isConfigInvocationExpr,
-  isDataField: () => isDataField,
-  isDataFieldAttribute: () => isDataFieldAttribute,
-  isDataFieldType: () => isDataFieldType,
-  isDataModel: () => isDataModel,
-  isDataModelAttribute: () => isDataModelAttribute,
-  isDataSource: () => isDataSource,
-  isEnum: () => isEnum,
-  isEnumField: () => isEnumField,
-  isExpression: () => isExpression,
-  isExpressionType: () => isExpressionType,
-  isFieldInitializer: () => isFieldInitializer,
-  isFunctionDecl: () => isFunctionDecl,
-  isFunctionParam: () => isFunctionParam,
-  isFunctionParamType: () => isFunctionParamType,
-  isGeneratorDecl: () => isGeneratorDecl,
-  isInternalAttribute: () => isInternalAttribute,
-  isInvocationExpr: () => isInvocationExpr,
-  isLiteralExpr: () => isLiteralExpr,
-  isMemberAccessExpr: () => isMemberAccessExpr,
-  isMemberAccessTarget: () => isMemberAccessTarget,
-  isModel: () => isModel,
-  isModelImport: () => isModelImport,
-  isNullExpr: () => isNullExpr,
-  isNumberLiteral: () => isNumberLiteral,
-  isObjectExpr: () => isObjectExpr,
-  isPlugin: () => isPlugin,
-  isPluginField: () => isPluginField,
-  isProcedure: () => isProcedure,
-  isProcedureParam: () => isProcedureParam,
-  isReferenceArg: () => isReferenceArg,
-  isReferenceExpr: () => isReferenceExpr,
-  isReferenceTarget: () => isReferenceTarget,
-  isRegularID: () => isRegularID,
-  isRegularIDWithTypeNames: () => isRegularIDWithTypeNames,
-  isStringLiteral: () => isStringLiteral,
-  isThisExpr: () => isThisExpr,
-  isTypeDeclaration: () => isTypeDeclaration,
-  isTypeDef: () => isTypeDef,
-  isUnaryExpr: () => isUnaryExpr,
-  isUnsupportedFieldType: () => isUnsupportedFieldType,
-  reflection: () => reflection
-});
-module.exports = __toCommonJS(ast_exports);
-
-// src/generated/ast.ts
-var langium = __toESM(require("langium"), 1);
-var ZModelTerminals = {
-  WS: /\s+/,
-  INTERNAL_ATTRIBUTE_NAME: /@@@([_a-zA-Z][\w_]*\.)*[_a-zA-Z][\w_]*/,
-  MODEL_ATTRIBUTE_NAME: /@@([_a-zA-Z][\w_]*\.)*[_a-zA-Z][\w_]*/,
-  FIELD_ATTRIBUTE_NAME: /@([_a-zA-Z][\w_]*\.)*[_a-zA-Z][\w_]*/,
-  ID: /[_a-zA-Z][\w_]*/,
-  STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,
-  NUMBER: /[+-]?[0-9]+(\.[0-9]+)?/,
-  TRIPLE_SLASH_COMMENT: /\/\/\/[^\n\r]*/,
-  ML_COMMENT: /\/\*[\s\S]*?\*\//,
-  SL_COMMENT: /\/\/[^\n\r]*/
-};
-var AbstractDeclaration = "AbstractDeclaration";
-function isAbstractDeclaration(item) {
-  return reflection.isInstance(item, AbstractDeclaration);
-}
-__name(isAbstractDeclaration, "isAbstractDeclaration");
-function isBoolean(item) {
-  return typeof item === "boolean";
-}
-__name(isBoolean, "isBoolean");
-function isBuiltinType(item) {
-  return item === "String" || item === "Boolean" || item === "Int" || item === "BigInt" || item === "Float" || item === "Decimal" || item === "DateTime" || item === "Json" || item === "Bytes";
-}
-__name(isBuiltinType, "isBuiltinType");
-var ConfigExpr = "ConfigExpr";
-function isConfigExpr(item) {
-  return reflection.isInstance(item, ConfigExpr);
-}
-__name(isConfigExpr, "isConfigExpr");
-var Expression = "Expression";
-function isExpression(item) {
-  return reflection.isInstance(item, Expression);
-}
-__name(isExpression, "isExpression");
-function isExpressionType(item) {
-  return item === "String" || item === "Int" || item === "Float" || item === "Boolean" || item === "BigInt" || item === "Decimal" || item === "DateTime" || item === "Json" || item === "Bytes" || item === "Null" || item === "Object" || item === "Any" || item === "Void" || item === "Undefined" || item === "Unsupported";
-}
-__name(isExpressionType, "isExpressionType");
-var LiteralExpr = "LiteralExpr";
-function isLiteralExpr(item) {
-  return reflection.isInstance(item, LiteralExpr);
-}
-__name(isLiteralExpr, "isLiteralExpr");
-var MemberAccessTarget = "MemberAccessTarget";
-function isMemberAccessTarget(item) {
-  return reflection.isInstance(item, MemberAccessTarget);
-}
-__name(isMemberAccessTarget, "isMemberAccessTarget");
-var ReferenceTarget = "ReferenceTarget";
-function isReferenceTarget(item) {
-  return reflection.isInstance(item, ReferenceTarget);
-}
-__name(isReferenceTarget, "isReferenceTarget");
-function isRegularID(item) {
-  return item === "model" || item === "enum" || item === "attribute" || item === "datasource" || item === "plugin" || item === "abstract" || item === "in" || item === "view" || item === "import" || item === "type" || typeof item === "string" && /[_a-zA-Z][\w_]*/.test(item);
-}
-__name(isRegularID, "isRegularID");
-function isRegularIDWithTypeNames(item) {
-  return isRegularID(item) || item === "String" || item === "Boolean" || item === "Int" || item === "BigInt" || item === "Float" || item === "Decimal" || item === "DateTime" || item === "Json" || item === "Bytes" || item === "Null" || item === "Object" || item === "Any" || item === "Void" || item === "Unsupported";
-}
-__name(isRegularIDWithTypeNames, "isRegularIDWithTypeNames");
-var TypeDeclaration = "TypeDeclaration";
-function isTypeDeclaration(item) {
-  return reflection.isInstance(item, TypeDeclaration);
-}
-__name(isTypeDeclaration, "isTypeDeclaration");
-var Argument = "Argument";
-function isArgument(item) {
-  return reflection.isInstance(item, Argument);
-}
-__name(isArgument, "isArgument");
-var ArrayExpr = "ArrayExpr";
-function isArrayExpr(item) {
-  return reflection.isInstance(item, ArrayExpr);
-}
-__name(isArrayExpr, "isArrayExpr");
-var Attribute = "Attribute";
-function isAttribute(item) {
-  return reflection.isInstance(item, Attribute);
-}
-__name(isAttribute, "isAttribute");
-var AttributeArg = "AttributeArg";
-function isAttributeArg(item) {
-  return reflection.isInstance(item, AttributeArg);
-}
-__name(isAttributeArg, "isAttributeArg");
-var AttributeParam = "AttributeParam";
-function isAttributeParam(item) {
-  return reflection.isInstance(item, AttributeParam);
-}
-__name(isAttributeParam, "isAttributeParam");
-var AttributeParamType = "AttributeParamType";
-function isAttributeParamType(item) {
-  return reflection.isInstance(item, AttributeParamType);
-}
-__name(isAttributeParamType, "isAttributeParamType");
-var BinaryExpr = "BinaryExpr";
-function isBinaryExpr(item) {
-  return reflection.isInstance(item, BinaryExpr);
-}
-__name(isBinaryExpr, "isBinaryExpr");
-var BooleanLiteral = "BooleanLiteral";
-function isBooleanLiteral(item) {
-  return reflection.isInstance(item, BooleanLiteral);
-}
-__name(isBooleanLiteral, "isBooleanLiteral");
-var CollectionPredicateBinding = "CollectionPredicateBinding";
-function isCollectionPredicateBinding(item) {
-  return reflection.isInstance(item, CollectionPredicateBinding);
-}
-__name(isCollectionPredicateBinding, "isCollectionPredicateBinding");
-var ConfigArrayExpr = "ConfigArrayExpr";
-function isConfigArrayExpr(item) {
-  return reflection.isInstance(item, ConfigArrayExpr);
-}
-__name(isConfigArrayExpr, "isConfigArrayExpr");
-var ConfigField = "ConfigField";
-function isConfigField(item) {
-  return reflection.isInstance(item, ConfigField);
-}
-__name(isConfigField, "isConfigField");
-var ConfigInvocationArg = "ConfigInvocationArg";
-function isConfigInvocationArg(item) {
-  return reflection.isInstance(item, ConfigInvocationArg);
-}
-__name(isConfigInvocationArg, "isConfigInvocationArg");
-var ConfigInvocationExpr = "ConfigInvocationExpr";
-function isConfigInvocationExpr(item) {
-  return reflection.isInstance(item, ConfigInvocationExpr);
-}
-__name(isConfigInvocationExpr, "isConfigInvocationExpr");
-var DataField = "DataField";
-function isDataField(item) {
-  return reflection.isInstance(item, DataField);
-}
-__name(isDataField, "isDataField");
-var DataFieldAttribute = "DataFieldAttribute";
-function isDataFieldAttribute(item) {
-  return reflection.isInstance(item, DataFieldAttribute);
-}
-__name(isDataFieldAttribute, "isDataFieldAttribute");
-var DataFieldType = "DataFieldType";
-function isDataFieldType(item) {
-  return reflection.isInstance(item, DataFieldType);
-}
-__name(isDataFieldType, "isDataFieldType");
-var DataModel = "DataModel";
-function isDataModel(item) {
-  return reflection.isInstance(item, DataModel);
-}
-__name(isDataModel, "isDataModel");
-var DataModelAttribute = "DataModelAttribute";
-function isDataModelAttribute(item) {
-  return reflection.isInstance(item, DataModelAttribute);
-}
-__name(isDataModelAttribute, "isDataModelAttribute");
-var DataSource = "DataSource";
-function isDataSource(item) {
-  return reflection.isInstance(item, DataSource);
-}
-__name(isDataSource, "isDataSource");
-var Enum = "Enum";
-function isEnum(item) {
-  return reflection.isInstance(item, Enum);
-}
-__name(isEnum, "isEnum");
-var EnumField = "EnumField";
-function isEnumField(item) {
-  return reflection.isInstance(item, EnumField);
-}
-__name(isEnumField, "isEnumField");
-var FieldInitializer = "FieldInitializer";
-function isFieldInitializer(item) {
-  return reflection.isInstance(item, FieldInitializer);
-}
-__name(isFieldInitializer, "isFieldInitializer");
-var FunctionDecl = "FunctionDecl";
-function isFunctionDecl(item) {
-  return reflection.isInstance(item, FunctionDecl);
-}
-__name(isFunctionDecl, "isFunctionDecl");
-var FunctionParam = "FunctionParam";
-function isFunctionParam(item) {
-  return reflection.isInstance(item, FunctionParam);
-}
-__name(isFunctionParam, "isFunctionParam");
-var FunctionParamType = "FunctionParamType";
-function isFunctionParamType(item) {
-  return reflection.isInstance(item, FunctionParamType);
-}
-__name(isFunctionParamType, "isFunctionParamType");
-var GeneratorDecl = "GeneratorDecl";
-function isGeneratorDecl(item) {
-  return reflection.isInstance(item, GeneratorDecl);
-}
-__name(isGeneratorDecl, "isGeneratorDecl");
-var InternalAttribute = "InternalAttribute";
-function isInternalAttribute(item) {
-  return reflection.isInstance(item, InternalAttribute);
-}
-__name(isInternalAttribute, "isInternalAttribute");
-var InvocationExpr = "InvocationExpr";
-function isInvocationExpr(item) {
-  return reflection.isInstance(item, InvocationExpr);
-}
-__name(isInvocationExpr, "isInvocationExpr");
-var MemberAccessExpr = "MemberAccessExpr";
-function isMemberAccessExpr(item) {
-  return reflection.isInstance(item, MemberAccessExpr);
-}
-__name(isMemberAccessExpr, "isMemberAccessExpr");
-var Model = "Model";
-function isModel(item) {
-  return reflection.isInstance(item, Model);
-}
-__name(isModel, "isModel");
-var ModelImport = "ModelImport";
-function isModelImport(item) {
-  return reflection.isInstance(item, ModelImport);
-}
-__name(isModelImport, "isModelImport");
-var NullExpr = "NullExpr";
-function isNullExpr(item) {
-  return reflection.isInstance(item, NullExpr);
-}
-__name(isNullExpr, "isNullExpr");
-var NumberLiteral = "NumberLiteral";
-function isNumberLiteral(item) {
-  return reflection.isInstance(item, NumberLiteral);
-}
-__name(isNumberLiteral, "isNumberLiteral");
-var ObjectExpr = "ObjectExpr";
-function isObjectExpr(item) {
-  return reflection.isInstance(item, ObjectExpr);
-}
-__name(isObjectExpr, "isObjectExpr");
-var Plugin = "Plugin";
-function isPlugin(item) {
-  return reflection.isInstance(item, Plugin);
-}
-__name(isPlugin, "isPlugin");
-var PluginField = "PluginField";
-function isPluginField(item) {
-  return reflection.isInstance(item, PluginField);
-}
-__name(isPluginField, "isPluginField");
-var Procedure = "Procedure";
-function isProcedure(item) {
-  return reflection.isInstance(item, Procedure);
-}
-__name(isProcedure, "isProcedure");
-var ProcedureParam = "ProcedureParam";
-function isProcedureParam(item) {
-  return reflection.isInstance(item, ProcedureParam);
-}
-__name(isProcedureParam, "isProcedureParam");
-var ReferenceArg = "ReferenceArg";
-function isReferenceArg(item) {
-  return reflection.isInstance(item, ReferenceArg);
-}
-__name(isReferenceArg, "isReferenceArg");
-var ReferenceExpr = "ReferenceExpr";
-function isReferenceExpr(item) {
-  return reflection.isInstance(item, ReferenceExpr);
-}
-__name(isReferenceExpr, "isReferenceExpr");
-var StringLiteral = "StringLiteral";
-function isStringLiteral(item) {
-  return reflection.isInstance(item, StringLiteral);
-}
-__name(isStringLiteral, "isStringLiteral");
-var ThisExpr = "ThisExpr";
-function isThisExpr(item) {
-  return reflection.isInstance(item, ThisExpr);
-}
-__name(isThisExpr, "isThisExpr");
-var TypeDef = "TypeDef";
-function isTypeDef(item) {
-  return reflection.isInstance(item, TypeDef);
-}
-__name(isTypeDef, "isTypeDef");
-var UnaryExpr = "UnaryExpr";
-function isUnaryExpr(item) {
-  return reflection.isInstance(item, UnaryExpr);
-}
-__name(isUnaryExpr, "isUnaryExpr");
-var UnsupportedFieldType = "UnsupportedFieldType";
-function isUnsupportedFieldType(item) {
-  return reflection.isInstance(item, UnsupportedFieldType);
-}
-__name(isUnsupportedFieldType, "isUnsupportedFieldType");
-var ZModelAstReflection = class extends langium.AbstractAstReflection {
-  static {
-    __name(this, "ZModelAstReflection");
-  }
-  getAllTypes() {
-    return [
-      AbstractDeclaration,
-      Argument,
-      ArrayExpr,
-      Attribute,
-      AttributeArg,
-      AttributeParam,
-      AttributeParamType,
-      BinaryExpr,
-      BooleanLiteral,
-      CollectionPredicateBinding,
-      ConfigArrayExpr,
-      ConfigExpr,
-      ConfigField,
-      ConfigInvocationArg,
-      ConfigInvocationExpr,
-      DataField,
-      DataFieldAttribute,
-      DataFieldType,
-      DataModel,
-      DataModelAttribute,
-      DataSource,
-      Enum,
-      EnumField,
-      Expression,
-      FieldInitializer,
-      FunctionDecl,
-      FunctionParam,
-      FunctionParamType,
-      GeneratorDecl,
-      InternalAttribute,
-      InvocationExpr,
-      LiteralExpr,
-      MemberAccessExpr,
-      MemberAccessTarget,
-      Model,
-      ModelImport,
-      NullExpr,
-      NumberLiteral,
-      ObjectExpr,
-      Plugin,
-      PluginField,
-      Procedure,
-      ProcedureParam,
-      ReferenceArg,
-      ReferenceExpr,
-      ReferenceTarget,
-      StringLiteral,
-      ThisExpr,
-      TypeDeclaration,
-      TypeDef,
-      UnaryExpr,
-      UnsupportedFieldType
-    ];
-  }
-  computeIsSubtype(subtype, supertype) {
-    switch (subtype) {
-      case ArrayExpr:
-      case BinaryExpr:
-      case MemberAccessExpr:
-      case NullExpr:
-      case ObjectExpr:
-      case ReferenceExpr:
-      case ThisExpr:
-      case UnaryExpr: {
-        return this.isSubtype(Expression, supertype);
-      }
-      case Attribute:
-      case DataSource:
-      case FunctionDecl:
-      case GeneratorDecl:
-      case Plugin:
-      case Procedure: {
-        return this.isSubtype(AbstractDeclaration, supertype);
-      }
-      case BooleanLiteral:
-      case NumberLiteral:
-      case StringLiteral: {
-        return this.isSubtype(LiteralExpr, supertype);
-      }
-      case CollectionPredicateBinding:
-      case EnumField:
-      case FunctionParam: {
-        return this.isSubtype(ReferenceTarget, supertype);
-      }
-      case ConfigArrayExpr: {
-        return this.isSubtype(ConfigExpr, supertype);
-      }
-      case DataField: {
-        return this.isSubtype(MemberAccessTarget, supertype) || this.isSubtype(ReferenceTarget, supertype);
-      }
-      case DataModel:
-      case Enum:
-      case TypeDef: {
-        return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, supertype);
-      }
-      case InvocationExpr:
-      case LiteralExpr: {
-        return this.isSubtype(ConfigExpr, supertype) || this.isSubtype(Expression, supertype);
-      }
-      default: {
-        return false;
-      }
-    }
-  }
-  getReferenceType(refInfo) {
-    const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
-    switch (referenceId) {
-      case "AttributeParamType:reference":
-      case "DataFieldType:reference":
-      case "FunctionParamType:reference": {
-        return TypeDeclaration;
-      }
-      case "DataFieldAttribute:decl":
-      case "DataModelAttribute:decl":
-      case "InternalAttribute:decl": {
-        return Attribute;
-      }
-      case "DataModel:baseModel": {
-        return DataModel;
-      }
-      case "DataModel:mixins":
-      case "TypeDef:mixins": {
-        return TypeDef;
-      }
-      case "InvocationExpr:function": {
-        return FunctionDecl;
-      }
-      case "MemberAccessExpr:member": {
-        return MemberAccessTarget;
-      }
-      case "ReferenceExpr:target": {
-        return ReferenceTarget;
-      }
-      default: {
-        throw new Error(`${referenceId} is not a valid reference id.`);
-      }
-    }
-  }
-  getTypeMetaData(type) {
-    switch (type) {
-      case Argument: {
-        return {
-          name: Argument,
-          properties: [
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      case ArrayExpr: {
-        return {
-          name: ArrayExpr,
-          properties: [
-            {
-              name: "items",
-              defaultValue: []
-            }
-          ]
-        };
-      }
-      case Attribute: {
-        return {
-          name: Attribute,
-          properties: [
-            {
-              name: "attributes",
-              defaultValue: []
-            },
-            {
-              name: "comments",
-              defaultValue: []
-            },
-            {
-              name: "name"
-            },
-            {
-              name: "params",
-              defaultValue: []
-            }
-          ]
-        };
-      }
-      case AttributeArg: {
-        return {
-          name: AttributeArg,
-          properties: [
-            {
-              name: "name"
-            },
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      case AttributeParam: {
-        return {
-          name: AttributeParam,
-          properties: [
-            {
-              name: "attributes",
-              defaultValue: []
-            },
-            {
-              name: "comments",
-              defaultValue: []
-            },
-            {
-              name: "default",
-              defaultValue: false
-            },
-            {
-              name: "name"
-            },
-            {
-              name: "type"
-            }
-          ]
-        };
-      }
-      case AttributeParamType: {
-        return {
-          name: AttributeParamType,
-          properties: [
-            {
-              name: "array",
-              defaultValue: false
-            },
-            {
-              name: "optional",
-              defaultValue: false
-            },
-            {
-              name: "reference"
-            },
-            {
-              name: "type"
-            }
-          ]
-        };
-      }
-      case BinaryExpr: {
-        return {
-          name: BinaryExpr,
-          properties: [
-            {
-              name: "binding"
-            },
-            {
-              name: "left"
-            },
-            {
-              name: "operator"
-            },
-            {
-              name: "right"
-            }
-          ]
-        };
-      }
-      case BooleanLiteral: {
-        return {
-          name: BooleanLiteral,
-          properties: [
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      case CollectionPredicateBinding: {
-        return {
-          name: CollectionPredicateBinding,
-          properties: [
-            {
-              name: "name"
-            }
-          ]
-        };
-      }
-      case ConfigArrayExpr: {
-        return {
-          name: ConfigArrayExpr,
-          properties: [
-            {
-              name: "items",
-              defaultValue: []
-            }
-          ]
-        };
-      }
-      case ConfigField: {
-        return {
-          name: ConfigField,
-          properties: [
-            {
-              name: "name"
-            },
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      case ConfigInvocationArg: {
-        return {
-          name: ConfigInvocationArg,
-          properties: [
-            {
-              name: "name"
-            },
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      case ConfigInvocationExpr: {
-        return {
-          name: ConfigInvocationExpr,
-          properties: [
-            {
-              name: "args",
-              defaultValue: []
-            },
-            {
-              name: "name"
-            }
-          ]
-        };
-      }
-      case DataField: {
-        return {
-          name: DataField,
-          properties: [
-            {
-              name: "attributes",
-              defaultValue: []
-            },
-            {
-              name: "comments",
-              defaultValue: []
-            },
-            {
-              name: "name"
-            },
-            {
-              name: "type"
-            }
-          ]
-        };
-      }
-      case DataFieldAttribute: {
-        return {
-          name: DataFieldAttribute,
-          properties: [
-            {
-              name: "args",
-              defaultValue: []
-            },
-            {
-              name: "decl"
-            }
-          ]
-        };
-      }
-      case DataFieldType: {
-        return {
-          name: DataFieldType,
-          properties: [
-            {
-              name: "array",
-              defaultValue: false
-            },
-            {
-              name: "optional",
-              defaultValue: false
-            },
-            {
-              name: "reference"
-            },
-            {
-              name: "type"
-            },
-            {
-              name: "unsupported"
-            }
-          ]
-        };
-      }
-      case DataModel: {
-        return {
-          name: DataModel,
-          properties: [
-            {
-              name: "attributes",
-              defaultValue: []
-            },
-            {
-              name: "baseModel"
-            },
-            {
-              name: "comments",
-              defaultValue: []
-            },
-            {
-              name: "fields",
-              defaultValue: []
-            },
-            {
-              name: "isView",
-              defaultValue: false
-            },
-            {
-              name: "mixins",
-              defaultValue: []
-            },
-            {
-              name: "name"
-            }
-          ]
-        };
-      }
-      case DataModelAttribute: {
-        return {
-          name: DataModelAttribute,
-          properties: [
-            {
-              name: "args",
-              defaultValue: []
-            },
-            {
-              name: "decl"
-            }
-          ]
-        };
-      }
-      case DataSource: {
-        return {
-          name: DataSource,
-          properties: [
-            {
-              name: "fields",
-              defaultValue: []
-            },
-            {
-              name: "name"
-            }
-          ]
-        };
-      }
-      case Enum: {
-        return {
-          name: Enum,
-          properties: [
-            {
-              name: "attributes",
-              defaultValue: []
-            },
-            {
-              name: "comments",
-              defaultValue: []
-            },
-            {
-              name: "fields",
-              defaultValue: []
-            },
-            {
-              name: "name"
-            }
-          ]
-        };
-      }
-      case EnumField: {
-        return {
-          name: EnumField,
-          properties: [
-            {
-              name: "attributes",
-              defaultValue: []
-            },
-            {
-              name: "comments",
-              defaultValue: []
-            },
-            {
-              name: "name"
-            }
-          ]
-        };
-      }
-      case FieldInitializer: {
-        return {
-          name: FieldInitializer,
-          properties: [
-            {
-              name: "name"
-            },
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      case FunctionDecl: {
-        return {
-          name: FunctionDecl,
-          properties: [
-            {
-              name: "attributes",
-              defaultValue: []
-            },
-            {
-              name: "expression"
-            },
-            {
-              name: "name"
-            },
-            {
-              name: "params",
-              defaultValue: []
-            },
-            {
-              name: "returnType"
-            }
-          ]
-        };
-      }
-      case FunctionParam: {
-        return {
-          name: FunctionParam,
-          properties: [
-            {
-              name: "name"
-            },
-            {
-              name: "optional",
-              defaultValue: false
-            },
-            {
-              name: "type"
-            }
-          ]
-        };
-      }
-      case FunctionParamType: {
-        return {
-          name: FunctionParamType,
-          properties: [
-            {
-              name: "array",
-              defaultValue: false
-            },
-            {
-              name: "reference"
-            },
-            {
-              name: "type"
-            }
-          ]
-        };
-      }
-      case GeneratorDecl: {
-        return {
-          name: GeneratorDecl,
-          properties: [
-            {
-              name: "fields",
-              defaultValue: []
-            },
-            {
-              name: "name"
-            }
-          ]
-        };
-      }
-      case InternalAttribute: {
-        return {
-          name: InternalAttribute,
-          properties: [
-            {
-              name: "args",
-              defaultValue: []
-            },
-            {
-              name: "decl"
-            }
-          ]
-        };
-      }
-      case InvocationExpr: {
-        return {
-          name: InvocationExpr,
-          properties: [
-            {
-              name: "args",
-              defaultValue: []
-            },
-            {
-              name: "function"
-            }
-          ]
-        };
-      }
-      case MemberAccessExpr: {
-        return {
-          name: MemberAccessExpr,
-          properties: [
-            {
-              name: "member"
-            },
-            {
-              name: "operand"
-            }
-          ]
-        };
-      }
-      case Model: {
-        return {
-          name: Model,
-          properties: [
-            {
-              name: "declarations",
-              defaultValue: []
-            },
-            {
-              name: "imports",
-              defaultValue: []
-            }
-          ]
-        };
-      }
-      case ModelImport: {
-        return {
-          name: ModelImport,
-          properties: [
-            {
-              name: "path"
-            }
-          ]
-        };
-      }
-      case NullExpr: {
-        return {
-          name: NullExpr,
-          properties: [
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      case NumberLiteral: {
-        return {
-          name: NumberLiteral,
-          properties: [
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      case ObjectExpr: {
-        return {
-          name: ObjectExpr,
-          properties: [
-            {
-              name: "fields",
-              defaultValue: []
-            }
-          ]
-        };
-      }
-      case Plugin: {
-        return {
-          name: Plugin,
-          properties: [
-            {
-              name: "fields",
-              defaultValue: []
-            },
-            {
-              name: "name"
-            }
-          ]
-        };
-      }
-      case PluginField: {
-        return {
-          name: PluginField,
-          properties: [
-            {
-              name: "name"
-            },
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      case Procedure: {
-        return {
-          name: Procedure,
-          properties: [
-            {
-              name: "attributes",
-              defaultValue: []
-            },
-            {
-              name: "mutation",
-              defaultValue: false
-            },
-            {
-              name: "name"
-            },
-            {
-              name: "params",
-              defaultValue: []
-            },
-            {
-              name: "returnType"
-            }
-          ]
-        };
-      }
-      case ProcedureParam: {
-        return {
-          name: ProcedureParam,
-          properties: [
-            {
-              name: "name"
-            },
-            {
-              name: "optional",
-              defaultValue: false
-            },
-            {
-              name: "type"
-            }
-          ]
-        };
-      }
-      case ReferenceArg: {
-        return {
-          name: ReferenceArg,
-          properties: [
-            {
-              name: "name"
-            },
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      case ReferenceExpr: {
-        return {
-          name: ReferenceExpr,
-          properties: [
-            {
-              name: "args",
-              defaultValue: []
-            },
-            {
-              name: "target"
-            }
-          ]
-        };
-      }
-      case StringLiteral: {
-        return {
-          name: StringLiteral,
-          properties: [
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      case ThisExpr: {
-        return {
-          name: ThisExpr,
-          properties: [
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      case TypeDef: {
-        return {
-          name: TypeDef,
-          properties: [
-            {
-              name: "attributes",
-              defaultValue: []
-            },
-            {
-              name: "comments",
-              defaultValue: []
-            },
-            {
-              name: "fields",
-              defaultValue: []
-            },
-            {
-              name: "mixins",
-              defaultValue: []
-            },
-            {
-              name: "name"
-            }
-          ]
-        };
-      }
-      case UnaryExpr: {
-        return {
-          name: UnaryExpr,
-          properties: [
-            {
-              name: "operand"
-            },
-            {
-              name: "operator"
-            }
-          ]
-        };
-      }
-      case UnsupportedFieldType: {
-        return {
-          name: UnsupportedFieldType,
-          properties: [
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      default: {
-        return {
-          name: type,
-          properties: []
-        };
-      }
-    }
-  }
-};
-var reflection = new ZModelAstReflection();
+//#endregion
+exports.AbstractDeclaration = require_ast.AbstractDeclaration;
+exports.Argument = require_ast.Argument;
+exports.ArrayExpr = require_ast.ArrayExpr;
+exports.Attribute = require_ast.Attribute;
+exports.AttributeArg = require_ast.AttributeArg;
+exports.AttributeParam = require_ast.AttributeParam;
+exports.AttributeParamType = require_ast.AttributeParamType;
+exports.BinaryExpr = require_ast.BinaryExpr;
+exports.BinaryExprOperatorPriority = BinaryExprOperatorPriority;
+exports.BooleanLiteral = require_ast.BooleanLiteral;
+exports.CollectionPredicateBinding = require_ast.CollectionPredicateBinding;
+exports.ConfigArrayExpr = require_ast.ConfigArrayExpr;
+exports.ConfigExpr = require_ast.ConfigExpr;
+exports.ConfigField = require_ast.ConfigField;
+exports.ConfigInvocationArg = require_ast.ConfigInvocationArg;
+exports.ConfigInvocationExpr = require_ast.ConfigInvocationExpr;
+exports.DataField = require_ast.DataField;
+exports.DataFieldAttribute = require_ast.DataFieldAttribute;
+exports.DataFieldType = require_ast.DataFieldType;
+exports.DataModel = require_ast.DataModel;
+exports.DataModelAttribute = require_ast.DataModelAttribute;
+exports.DataSource = require_ast.DataSource;
+exports.Enum = require_ast.Enum;
+exports.EnumField = require_ast.EnumField;
+exports.Expression = require_ast.Expression;
+exports.FieldInitializer = require_ast.FieldInitializer;
+exports.FunctionDecl = require_ast.FunctionDecl;
+exports.FunctionParam = require_ast.FunctionParam;
+exports.FunctionParamType = require_ast.FunctionParamType;
+exports.GeneratorDecl = require_ast.GeneratorDecl;
+exports.InternalAttribute = require_ast.InternalAttribute;
+exports.InvocationExpr = require_ast.InvocationExpr;
+exports.LiteralExpr = require_ast.LiteralExpr;
+exports.MemberAccessExpr = require_ast.MemberAccessExpr;
+exports.MemberAccessTarget = require_ast.MemberAccessTarget;
+exports.Model = require_ast.Model;
+exports.ModelImport = require_ast.ModelImport;
+exports.NullExpr = require_ast.NullExpr;
+exports.NumberLiteral = require_ast.NumberLiteral;
+exports.ObjectExpr = require_ast.ObjectExpr;
+exports.Plugin = require_ast.Plugin;
+exports.PluginField = require_ast.PluginField;
+exports.Procedure = require_ast.Procedure;
+exports.ProcedureParam = require_ast.ProcedureParam;
+exports.ReferenceArg = require_ast.ReferenceArg;
+exports.ReferenceExpr = require_ast.ReferenceExpr;
+exports.ReferenceTarget = require_ast.ReferenceTarget;
+exports.StringLiteral = require_ast.StringLiteral;
+exports.ThisExpr = require_ast.ThisExpr;
+exports.TypeDeclaration = require_ast.TypeDeclaration;
+exports.TypeDef = require_ast.TypeDef;
+exports.UnaryExpr = require_ast.UnaryExpr;
+exports.UnsupportedFieldType = require_ast.UnsupportedFieldType;
+exports.ZModelAstReflection = require_ast.ZModelAstReflection;
+exports.ZModelTerminals = require_ast.ZModelTerminals;
+exports.isAbstractDeclaration = require_ast.isAbstractDeclaration;
+exports.isArgument = require_ast.isArgument;
+exports.isArrayExpr = require_ast.isArrayExpr;
+exports.isAttribute = require_ast.isAttribute;
+exports.isAttributeArg = require_ast.isAttributeArg;
+exports.isAttributeParam = require_ast.isAttributeParam;
+exports.isAttributeParamType = require_ast.isAttributeParamType;
+exports.isBinaryExpr = require_ast.isBinaryExpr;
+exports.isBoolean = require_ast.isBoolean;
+exports.isBooleanLiteral = require_ast.isBooleanLiteral;
+exports.isBuiltinType = require_ast.isBuiltinType;
+exports.isCollectionPredicateBinding = require_ast.isCollectionPredicateBinding;
+exports.isConfigArrayExpr = require_ast.isConfigArrayExpr;
+exports.isConfigExpr = require_ast.isConfigExpr;
+exports.isConfigField = require_ast.isConfigField;
+exports.isConfigInvocationArg = require_ast.isConfigInvocationArg;
+exports.isConfigInvocationExpr = require_ast.isConfigInvocationExpr;
+exports.isDataField = require_ast.isDataField;
+exports.isDataFieldAttribute = require_ast.isDataFieldAttribute;
+exports.isDataFieldType = require_ast.isDataFieldType;
+exports.isDataModel = require_ast.isDataModel;
+exports.isDataModelAttribute = require_ast.isDataModelAttribute;
+exports.isDataSource = require_ast.isDataSource;
+exports.isEnum = require_ast.isEnum;
+exports.isEnumField = require_ast.isEnumField;
+exports.isExpression = require_ast.isExpression;
+exports.isExpressionType = require_ast.isExpressionType;
+exports.isFieldInitializer = require_ast.isFieldInitializer;
+exports.isFunctionDecl = require_ast.isFunctionDecl;
+exports.isFunctionParam = require_ast.isFunctionParam;
+exports.isFunctionParamType = require_ast.isFunctionParamType;
+exports.isGeneratorDecl = require_ast.isGeneratorDecl;
+exports.isInternalAttribute = require_ast.isInternalAttribute;
+exports.isInvocationExpr = require_ast.isInvocationExpr;
+exports.isLiteralExpr = require_ast.isLiteralExpr;
+exports.isMemberAccessExpr = require_ast.isMemberAccessExpr;
+exports.isMemberAccessTarget = require_ast.isMemberAccessTarget;
+exports.isModel = require_ast.isModel;
+exports.isModelImport = require_ast.isModelImport;
+exports.isNullExpr = require_ast.isNullExpr;
+exports.isNumberLiteral = require_ast.isNumberLiteral;
+exports.isObjectExpr = require_ast.isObjectExpr;
+exports.isPlugin = require_ast.isPlugin;
+exports.isPluginField = require_ast.isPluginField;
+exports.isProcedure = require_ast.isProcedure;
+exports.isProcedureParam = require_ast.isProcedureParam;
+exports.isReferenceArg = require_ast.isReferenceArg;
+exports.isReferenceExpr = require_ast.isReferenceExpr;
+exports.isReferenceTarget = require_ast.isReferenceTarget;
+exports.isRegularID = require_ast.isRegularID;
+exports.isRegularIDWithTypeNames = require_ast.isRegularIDWithTypeNames;
+exports.isStringLiteral = require_ast.isStringLiteral;
+exports.isThisExpr = require_ast.isThisExpr;
+exports.isTypeDeclaration = require_ast.isTypeDeclaration;
+exports.isTypeDef = require_ast.isTypeDef;
+exports.isUnaryExpr = require_ast.isUnaryExpr;
+exports.isUnsupportedFieldType = require_ast.isUnsupportedFieldType;
+exports.reflection = require_ast.reflection;
 
-// src/ast.ts
-var BinaryExprOperatorPriority = {
-  //LogicalExpr
-  "||": 1,
-  "&&": 1,
-  //EqualityExpr
-  "==": 2,
-  "!=": 2,
-  //ComparisonExpr
-  ">": 3,
-  "<": 3,
-  ">=": 3,
-  "<=": 3,
-  in: 4,
-  //CollectionPredicateExpr
-  "^": 5,
-  "?": 5,
-  "!": 5
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AbstractDeclaration,
-  Argument,
-  ArrayExpr,
-  Attribute,
-  AttributeArg,
-  AttributeParam,
-  AttributeParamType,
-  BinaryExpr,
-  BinaryExprOperatorPriority,
-  BooleanLiteral,
-  CollectionPredicateBinding,
-  ConfigArrayExpr,
-  ConfigExpr,
-  ConfigField,
-  ConfigInvocationArg,
-  ConfigInvocationExpr,
-  DataField,
-  DataFieldAttribute,
-  DataFieldType,
-  DataModel,
-  DataModelAttribute,
-  DataSource,
-  Enum,
-  EnumField,
-  Expression,
-  FieldInitializer,
-  FunctionDecl,
-  FunctionParam,
-  FunctionParamType,
-  GeneratorDecl,
-  InternalAttribute,
-  InvocationExpr,
-  LiteralExpr,
-  MemberAccessExpr,
-  MemberAccessTarget,
-  Model,
-  ModelImport,
-  NullExpr,
-  NumberLiteral,
-  ObjectExpr,
-  Plugin,
-  PluginField,
-  Procedure,
-  ProcedureParam,
-  ReferenceArg,
-  ReferenceExpr,
-  ReferenceTarget,
-  StringLiteral,
-  ThisExpr,
-  TypeDeclaration,
-  TypeDef,
-  UnaryExpr,
-  UnsupportedFieldType,
-  ZModelAstReflection,
-  ZModelTerminals,
-  isAbstractDeclaration,
-  isArgument,
-  isArrayExpr,
-  isAttribute,
-  isAttributeArg,
-  isAttributeParam,
-  isAttributeParamType,
-  isBinaryExpr,
-  isBoolean,
-  isBooleanLiteral,
-  isBuiltinType,
-  isCollectionPredicateBinding,
-  isConfigArrayExpr,
-  isConfigExpr,
-  isConfigField,
-  isConfigInvocationArg,
-  isConfigInvocationExpr,
-  isDataField,
-  isDataFieldAttribute,
-  isDataFieldType,
-  isDataModel,
-  isDataModelAttribute,
-  isDataSource,
-  isEnum,
-  isEnumField,
-  isExpression,
-  isExpressionType,
-  isFieldInitializer,
-  isFunctionDecl,
-  isFunctionParam,
-  isFunctionParamType,
-  isGeneratorDecl,
-  isInternalAttribute,
-  isInvocationExpr,
-  isLiteralExpr,
-  isMemberAccessExpr,
-  isMemberAccessTarget,
-  isModel,
-  isModelImport,
-  isNullExpr,
-  isNumberLiteral,
-  isObjectExpr,
-  isPlugin,
-  isPluginField,
-  isProcedure,
-  isProcedureParam,
-  isReferenceArg,
-  isReferenceExpr,
-  isReferenceTarget,
-  isRegularID,
-  isRegularIDWithTypeNames,
-  isStringLiteral,
-  isThisExpr,
-  isTypeDeclaration,
-  isTypeDef,
-  isUnaryExpr,
-  isUnsupportedFieldType,
-  reflection
-});
 //# sourceMappingURL=ast.cjs.map