@zenstackhq/language 3.0.0-beta.6 → 3.0.0-beta.7

package/dist/index.cjs

@@ -40,7 +40,7 @@ __export(src_exports, {
   loadDocument: () => loadDocument
 });
 module.exports = __toCommonJS(src_exports);
-var import_langium11 = require("langium");
+var import_langium12 = require("langium");
 var import_node = require("langium/node");
 var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
@@ -1074,7 +1074,7 @@ var ExpressionContext = /* @__PURE__ */ function(ExpressionContext2) {
 }({});
 
 // src/module.ts
-var import_langium10 = require("langium");
+var import_langium11 = require("langium");
 var import_lsp = require("langium/lsp");
 
 // src/generated/grammar.ts
@@ -5141,7 +5141,6 @@ var import_langium3 = require("langium");
 var import_pluralize = __toESM(require("pluralize"), 1);
 
 // src/utils.ts
-var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_langium2 = require("langium");
 var import_node_fs = __toESM(require("fs"), 1);
 var import_path = __toESM(require("path"), 1);
@@ -5246,7 +5245,7 @@ function getRecursiveBases(decl, includeDelegate = true, seen = /* @__PURE__ */
   }
   seen.add(decl);
   decl.mixins.forEach((mixin) => {
-    const baseDecl = mixin.ref;
+    const baseDecl = decl.$container.declarations.find((d) => isTypeDef(d) && d.name === mixin.$refText);
     if (baseDecl) {
       if (!includeDelegate && isDelegateModel(baseDecl)) {
         return;
@@ -5521,12 +5520,14 @@ function getAllFields(decl, includeIgnored = false, seen = /* @__PURE__ */ new S
   seen.add(decl);
   const fields = [];
   for (const mixin of decl.mixins) {
-    (0, import_common_helpers.invariant)(mixin.ref, `Mixin ${mixin.$refText} is not resolved`);
-    fields.push(...getAllFields(mixin.ref, includeIgnored, seen));
+    if (mixin.ref) {
+      fields.push(...getAllFields(mixin.ref, includeIgnored, seen));
+    }
   }
   if (isDataModel(decl) && decl.baseModel) {
-    (0, import_common_helpers.invariant)(decl.baseModel.ref, `Base model ${decl.baseModel.$refText} is not resolved`);
-    fields.push(...getAllFields(decl.baseModel.ref, includeIgnored, seen));
+    if (decl.baseModel.ref) {
+      fields.push(...getAllFields(decl.baseModel.ref, includeIgnored, seen));
+    }
   }
   fields.push(...decl.fields.filter((f) => includeIgnored || !hasAttribute(f, "@ignore")));
   return fields;
@@ -5539,12 +5540,14 @@ function getAllAttributes(decl, seen = /* @__PURE__ */ new Set()) {
   seen.add(decl);
   const attributes = [];
   for (const mixin of decl.mixins) {
-    (0, import_common_helpers.invariant)(mixin.ref, `Mixin ${mixin.$refText} is not resolved`);
-    attributes.push(...getAllAttributes(mixin.ref, seen));
+    if (mixin.ref) {
+      attributes.push(...getAllAttributes(mixin.ref, seen));
+    }
   }
   if (isDataModel(decl) && decl.baseModel) {
-    (0, import_common_helpers.invariant)(decl.baseModel.ref, `Base model ${decl.baseModel.$refText} is not resolved`);
-    attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+    if (decl.baseModel.ref) {
+      attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+    }
   }
   attributes.push(...decl.attributes);
   return attributes;
@@ -5993,7 +5996,7 @@ var AttributeValidator = class {
 };
 
 // src/validators/datamodel-validator.ts
-var import_common_helpers2 = require("@zenstackhq/common-helpers");
+var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_langium4 = require("langium");
 
 // src/validators/common.ts
@@ -6364,7 +6367,7 @@ var DataModelValidator = class {
     if (!model.baseModel) {
       return;
     }
-    (0, import_common_helpers2.invariant)(model.baseModel.ref, "baseModel must be resolved");
+    (0, import_common_helpers.invariant)(model.baseModel.ref, "baseModel must be resolved");
     if (!isDelegateModel(model.baseModel.ref)) {
       accept("error", `Model ${model.baseModel.$refText} cannot be extended because it's not a delegate model`, {
         node: model,
@@ -6386,7 +6389,7 @@ var DataModelValidator = class {
       }
       seen.push(current);
       if (current.baseModel) {
-        (0, import_common_helpers2.invariant)(current.baseModel.ref, "baseModel must be resolved");
+        (0, import_common_helpers.invariant)(current.baseModel.ref, "baseModel must be resolved");
         todo.push(current.baseModel.ref);
       }
     }
@@ -7008,51 +7011,60 @@ var ZModelValidator = class {
   constructor(services) {
     this.services = services;
   }
-  shouldCheck(node) {
-    let doc;
-    let currNode = node;
-    while (currNode) {
-      if (currNode.$document) {
-        doc = currNode.$document;
-        break;
-      }
-      currNode = currNode.$container;
-    }
-    return doc?.parseResult.lexerErrors.length === 0 && doc?.parseResult.parserErrors.length === 0;
-  }
   checkModel(node, accept) {
-    this.shouldCheck(node) && new SchemaValidator(this.services.shared.workspace.LangiumDocuments).validate(node, accept);
+    new SchemaValidator(this.services.shared.workspace.LangiumDocuments).validate(node, accept);
   }
   checkDataSource(node, accept) {
-    this.shouldCheck(node) && new DataSourceValidator().validate(node, accept);
+    new DataSourceValidator().validate(node, accept);
   }
   checkDataModel(node, accept) {
-    this.shouldCheck(node) && new DataModelValidator().validate(node, accept);
+    new DataModelValidator().validate(node, accept);
   }
   checkTypeDef(node, accept) {
-    this.shouldCheck(node) && new TypeDefValidator().validate(node, accept);
+    new TypeDefValidator().validate(node, accept);
   }
   checkEnum(node, accept) {
-    this.shouldCheck(node) && new EnumValidator().validate(node, accept);
+    new EnumValidator().validate(node, accept);
   }
   checkAttribute(node, accept) {
-    this.shouldCheck(node) && new AttributeValidator().validate(node, accept);
+    new AttributeValidator().validate(node, accept);
   }
   checkExpression(node, accept) {
-    this.shouldCheck(node) && new ExpressionValidator().validate(node, accept);
+    new ExpressionValidator().validate(node, accept);
   }
   checkFunctionInvocation(node, accept) {
-    this.shouldCheck(node) && new FunctionInvocationValidator().validate(node, accept);
+    new FunctionInvocationValidator().validate(node, accept);
   }
   checkFunctionDecl(node, accept) {
-    this.shouldCheck(node) && new FunctionDeclValidator().validate(node, accept);
+    new FunctionDeclValidator().validate(node, accept);
   }
 };
 
-// src/zmodel-linker.ts
+// src/zmodel-document-builder.ts
 var import_langium7 = require("langium");
+var ZModelDocumentBuilder = class extends import_langium7.DefaultDocumentBuilder {
+  static {
+    __name(this, "ZModelDocumentBuilder");
+  }
+  buildDocuments(documents, options, cancelToken) {
+    return super.buildDocuments(documents, {
+      ...options,
+      validation: (
+        // force overriding validation options
+        options.validation === false || options.validation === void 0 ? options.validation : {
+          stopAfterLexingErrors: true,
+          stopAfterParsingErrors: true,
+          stopAfterLinkingErrors: true
+        }
+      )
+    }, cancelToken);
+  }
+};
+
+// src/zmodel-linker.ts
+var import_langium8 = require("langium");
 var import_ts_pattern2 = require("ts-pattern");
-var ZModelLinker = class extends import_langium7.DefaultLinker {
+var ZModelLinker = class extends import_langium8.DefaultLinker {
   static {
     __name(this, "ZModelLinker");
   }
@@ -7062,15 +7074,15 @@ var ZModelLinker = class extends import_langium7.DefaultLinker {
     this.descriptions = services.workspace.AstNodeDescriptionProvider;
   }
   //#region Reference linking
-  async link(document, cancelToken = import_langium7.Cancellation.CancellationToken.None) {
+  async link(document, cancelToken = import_langium8.Cancellation.CancellationToken.None) {
     if (document.parseResult.lexerErrors?.length > 0 || document.parseResult.parserErrors?.length > 0) {
       return;
     }
-    for (const node of import_langium7.AstUtils.streamContents(document.parseResult.value)) {
-      await (0, import_langium7.interruptAndCheck)(cancelToken);
+    for (const node of import_langium8.AstUtils.streamContents(document.parseResult.value)) {
+      await (0, import_langium8.interruptAndCheck)(cancelToken);
       this.resolve(node, document);
     }
-    document.state = import_langium7.DocumentState.Linked;
+    document.state = import_langium8.DocumentState.Linked;
   }
   linkReference(container, property, document, extraScopes) {
     if (this.resolveFromScopeProviders(container, property, document, extraScopes)) {
@@ -7220,7 +7232,7 @@ var ZModelLinker = class extends import_langium7.DefaultLinker {
     if (node.function.ref) {
       const funcDecl = node.function.ref;
       if (isAuthInvocation(node)) {
-        const allDecls = getAllLoadedAndReachableDataModelsAndTypeDefs(this.langiumDocuments(), import_langium7.AstUtils.getContainerOfType(node, isDataModel));
+        const allDecls = getAllLoadedAndReachableDataModelsAndTypeDefs(this.langiumDocuments(), import_langium8.AstUtils.getContainerOfType(node, isDataModel));
         const authDecl = getAuthDecl(allDecls);
         if (authDecl) {
           node.$resolvedType = {
@@ -7360,12 +7372,12 @@ var ZModelLinker = class extends import_langium7.DefaultLinker {
   resolveDefault(node, document, extraScopes) {
     for (const [property, value] of Object.entries(node)) {
       if (!property.startsWith("$")) {
-        if ((0, import_langium7.isReference)(value)) {
+        if ((0, import_langium8.isReference)(value)) {
           this.linkReference(node, property, document, extraScopes);
         }
       }
     }
-    for (const child of import_langium7.AstUtils.streamContents(node)) {
+    for (const child of import_langium8.AstUtils.streamContents(node)) {
       this.resolve(child, document, extraScopes);
     }
   }
@@ -7409,9 +7421,9 @@ var ZModelLinker = class extends import_langium7.DefaultLinker {
 };
 
 // src/zmodel-scope.ts
-var import_langium8 = require("langium");
+var import_langium9 = require("langium");
 var import_ts_pattern3 = require("ts-pattern");
-var ZModelScopeComputation = class extends import_langium8.DefaultScopeComputation {
+var ZModelScopeComputation = class extends import_langium9.DefaultScopeComputation {
   static {
     __name(this, "ZModelScopeComputation");
   }
@@ -7421,9 +7433,9 @@ var ZModelScopeComputation = class extends import_langium8.DefaultScopeComputati
   }
   async computeExports(document, cancelToken) {
     const result = await super.computeExports(document, cancelToken);
-    for (const node of import_langium8.AstUtils.streamAllContents(document.parseResult.value)) {
+    for (const node of import_langium9.AstUtils.streamAllContents(document.parseResult.value)) {
       if (cancelToken) {
-        await (0, import_langium8.interruptAndCheck)(cancelToken);
+        await (0, import_langium9.interruptAndCheck)(cancelToken);
       }
       if (isEnumField(node)) {
         const desc = this.services.workspace.AstNodeDescriptionProvider.createDescription(node, node.name, document);
@@ -7444,7 +7456,7 @@ var ZModelScopeComputation = class extends import_langium8.DefaultScopeComputati
     }
   }
 };
-var ZModelScopeProvider = class extends import_langium8.DefaultScopeProvider {
+var ZModelScopeProvider = class extends import_langium9.DefaultScopeProvider {
   static {
     __name(this, "ZModelScopeProvider");
   }
@@ -7453,19 +7465,19 @@ var ZModelScopeProvider = class extends import_langium8.DefaultScopeProvider {
     super(services), this.services = services;
   }
   getGlobalScope(referenceType, context) {
-    const model = import_langium8.AstUtils.getContainerOfType(context.container, isModel);
+    const model = import_langium9.AstUtils.getContainerOfType(context.container, isModel);
     if (!model) {
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium9.EMPTY_SCOPE;
     }
     const importedUris = model.imports.map(resolveImportUri).filter((url) => !!url);
     const importedElements = this.indexManager.allElements(referenceType).filter((des) => (
       // allow current document
-      import_langium8.UriUtils.equals(des.documentUri, model.$document?.uri) || // allow stdlib
+      import_langium9.UriUtils.equals(des.documentUri, model.$document?.uri) || // allow stdlib
       des.documentUri.path.endsWith(STD_LIB_MODULE_NAME) || // allow plugin models
       des.documentUri.path.endsWith(PLUGIN_MODULE_NAME) || // allow imported documents
-      importedUris.some((importedUri) => import_langium8.UriUtils.equals(des.documentUri, importedUri))
+      importedUris.some((importedUri) => import_langium9.UriUtils.equals(des.documentUri, importedUri))
     ));
-    return new import_langium8.StreamScope(importedElements);
+    return new import_langium9.StreamScope(importedElements);
   }
   getScope(context) {
     if (isMemberAccessExpr(context.container) && context.container.operand && context.property === "member") {
@@ -7485,20 +7497,20 @@ var ZModelScopeProvider = class extends import_langium8.DefaultScopeProvider {
     const node = context.container;
     const allowTypeDefScope = (
       // isAuthOrAuthMemberAccess(node.operand) ||
-      !!import_langium8.AstUtils.getContainerOfType(node, isTypeDef)
+      !!import_langium9.AstUtils.getContainerOfType(node, isTypeDef)
     );
     return (0, import_ts_pattern3.match)(node.operand).when(isReferenceExpr, (operand) => {
       const ref = operand.target.ref;
       if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium9.EMPTY_SCOPE;
     }).when(isMemberAccessExpr, (operand) => {
       const ref = operand.member.ref;
       if (isDataField(ref) && !ref.type.array) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium9.EMPTY_SCOPE;
     }).when(isThisExpr, () => {
       return this.createScopeForContainingModel(node, globalScope);
     }).when(isInvocationExpr, (operand) => {
@@ -7508,8 +7520,8 @@ var ZModelScopeProvider = class extends import_langium8.DefaultScopeProvider {
       if (isFutureInvocation(operand)) {
         return this.createScopeForContainingModel(node, globalScope);
       }
-      return import_langium8.EMPTY_SCOPE;
-    }).otherwise(() => import_langium8.EMPTY_SCOPE);
+      return import_langium9.EMPTY_SCOPE;
+    }).otherwise(() => import_langium9.EMPTY_SCOPE);
   }
   getCollectionPredicateScope(context, collectionPredicate) {
     const referenceType = this.reflection.getReferenceType(context);
@@ -7521,30 +7533,30 @@ var ZModelScopeProvider = class extends import_langium8.DefaultScopeProvider {
       if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium9.EMPTY_SCOPE;
     }).when(isMemberAccessExpr, (expr) => {
       const ref = expr.member.ref;
       if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium9.EMPTY_SCOPE;
     }).when(isInvocationExpr, (expr) => {
       const returnTypeDecl = expr.function.ref?.returnType.reference?.ref;
       if (isDataModel(returnTypeDecl)) {
         return this.createScopeForContainer(returnTypeDecl, globalScope, allowTypeDefScope);
       } else {
-        return import_langium8.EMPTY_SCOPE;
+        return import_langium9.EMPTY_SCOPE;
       }
     }).when(isAuthInvocation, (expr) => {
       return this.createScopeForAuth(expr, globalScope);
-    }).otherwise(() => import_langium8.EMPTY_SCOPE);
+    }).otherwise(() => import_langium9.EMPTY_SCOPE);
   }
   createScopeForContainingModel(node, globalScope) {
-    const model = import_langium8.AstUtils.getContainerOfType(node, isDataModel);
+    const model = import_langium9.AstUtils.getContainerOfType(node, isDataModel);
     if (model) {
       return this.createScopeForContainer(model, globalScope);
     } else {
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium9.EMPTY_SCOPE;
     }
   }
   createScopeForContainer(node, globalScope, includeTypeDefScope = false) {
@@ -7553,16 +7565,16 @@ var ZModelScopeProvider = class extends import_langium8.DefaultScopeProvider {
     } else if (includeTypeDefScope && isTypeDef(node)) {
       return this.createScopeForNodes(node.fields, globalScope);
     } else {
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium9.EMPTY_SCOPE;
     }
   }
   createScopeForAuth(node, globalScope) {
-    const decls = getAllLoadedAndReachableDataModelsAndTypeDefs(this.services.shared.workspace.LangiumDocuments, import_langium8.AstUtils.getContainerOfType(node, isDataModel));
+    const decls = getAllLoadedAndReachableDataModelsAndTypeDefs(this.services.shared.workspace.LangiumDocuments, import_langium9.AstUtils.getContainerOfType(node, isDataModel));
     const authDecl = getAuthDecl(decls);
     if (authDecl) {
       return this.createScopeForContainer(authDecl, globalScope, true);
     } else {
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium9.EMPTY_SCOPE;
     }
   }
 };
@@ -7579,12 +7591,12 @@ function getCollectionPredicateContext(node) {
 __name(getCollectionPredicateContext, "getCollectionPredicateContext");
 
 // src/zmodel-workspace-manager.ts
-var import_langium9 = require("langium");
+var import_langium10 = require("langium");
 var import_node_fs2 = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
 var import_node_url = require("url");
 var import_meta = {};
-var ZModelWorkspaceManager = class extends import_langium9.DefaultWorkspaceManager {
+var ZModelWorkspaceManager = class extends import_langium10.DefaultWorkspaceManager {
   static {
     __name(this, "ZModelWorkspaceManager");
   }
@@ -7623,7 +7635,7 @@ var ZModelWorkspaceManager = class extends import_langium9.DefaultWorkspaceManag
       stdLibPath = import_node_path.default.join(_dirname, "../res", STD_LIB_MODULE_NAME);
       console.log(`Using bundled stdlib in extension:`, stdLibPath);
     }
-    const stdlib = await this.documentFactory.fromUri(import_langium9.URI.file(stdLibPath));
+    const stdlib = await this.documentFactory.fromUri(import_langium10.URI.file(stdLibPath));
     collector(stdlib);
     const documents = this.langiumDocuments.all;
     const pluginModels = /* @__PURE__ */ new Set();
@@ -7653,7 +7665,7 @@ var ZModelWorkspaceManager = class extends import_langium9.DefaultWorkspaceManag
   async loadPluginModels(workspaceFolder, folderPath, pendingPluginModels, collector) {
     const content = (await this.fileSystemProvider.readDirectory(folderPath)).sort((a, b) => {
       if (a.isDirectory && b.isDirectory) {
-        const aName = import_langium9.UriUtils.basename(a.uri);
+        const aName = import_langium10.UriUtils.basename(a.uri);
         if (aName === "node_modules") {
           return -1;
         } else {
@@ -7665,10 +7677,10 @@ var ZModelWorkspaceManager = class extends import_langium9.DefaultWorkspaceManag
     });
     for (const entry of content) {
       if (entry.isDirectory) {
-        const name = import_langium9.UriUtils.basename(entry.uri);
+        const name = import_langium10.UriUtils.basename(entry.uri);
         if (name === "node_modules") {
           for (const plugin of Array.from(pendingPluginModels)) {
-            const path4 = import_langium9.UriUtils.joinPath(entry.uri, plugin, PLUGIN_MODULE_NAME);
+            const path4 = import_langium10.UriUtils.joinPath(entry.uri, plugin, PLUGIN_MODULE_NAME);
             try {
               await this.fileSystemProvider.readFile(path4);
               const document = await this.langiumDocuments.getOrCreateDocument(path4);
@@ -7702,12 +7714,13 @@ var ZModelLanguageModule = {
 };
 var ZModelSharedModule = {
   workspace: {
+    DocumentBuilder: /* @__PURE__ */ __name((services) => new ZModelDocumentBuilder(services), "DocumentBuilder"),
     WorkspaceManager: /* @__PURE__ */ __name((services) => new ZModelWorkspaceManager(services), "WorkspaceManager")
   }
 };
 function createZModelLanguageServices(context) {
-  const shared = (0, import_langium10.inject)((0, import_lsp.createDefaultSharedModule)(context), ZModelGeneratedSharedModule, ZModelSharedModule);
-  const ZModelLanguage = (0, import_langium10.inject)((0, import_lsp.createDefaultModule)({
+  const shared = (0, import_langium11.inject)((0, import_lsp.createDefaultSharedModule)(context), ZModelGeneratedSharedModule, ZModelSharedModule);
+  const ZModelLanguage = (0, import_langium11.inject)((0, import_lsp.createDefaultModule)({
     shared
   }), ZModelGeneratedModule, ZModelLanguageModule);
   shared.ServiceRegistry.register(ZModelLanguage);
@@ -7758,10 +7771,10 @@ async function loadDocument(fileName, pluginModelFiles = []) {
     };
   }
   const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path2.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
-  const stdLib = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium11.URI.file(import_node_path2.default.resolve(import_node_path2.default.join(_dirname, "../res", STD_LIB_MODULE_NAME))));
-  const pluginDocs = await Promise.all(pluginModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium11.URI.file(import_node_path2.default.resolve(file)))));
+  const stdLib = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium12.URI.file(import_node_path2.default.resolve(import_node_path2.default.join(_dirname, "../res", STD_LIB_MODULE_NAME))));
+  const pluginDocs = await Promise.all(pluginModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium12.URI.file(import_node_path2.default.resolve(file)))));
   const langiumDocuments = services.shared.workspace.LangiumDocuments;
-  const document = await langiumDocuments.getOrCreateDocument(import_langium11.URI.file(import_node_path2.default.resolve(fileName)));
+  const document = await langiumDocuments.getOrCreateDocument(import_langium12.URI.file(import_node_path2.default.resolve(fileName)));
   const importedURIs = await loadImports(document, langiumDocuments);
   const importedDocuments = [];
   for (const uri of importedURIs) {
@@ -7832,7 +7845,7 @@ async function loadImports(document, documents, uris = /* @__PURE__ */ new Set()
       }
     }
   }
-  return Array.from(uris).filter((x) => uriString != x).map((e) => import_langium11.URI.parse(e));
+  return Array.from(uris).filter((x) => uriString != x).map((e) => import_langium12.URI.parse(e));
 }
 __name(loadImports, "loadImports");
 function mergeImportsDeclarations(documents, model) {
@@ -7849,13 +7862,13 @@ function linkContentToContainer(node) {
     if (!name.startsWith("$")) {
       if (Array.isArray(value)) {
         value.forEach((item, index) => {
-          if ((0, import_langium11.isAstNode)(item)) {
+          if ((0, import_langium12.isAstNode)(item)) {
             item.$container = node;
             item.$containerProperty = name;
             item.$containerIndex = index;
           }
         });
-      } else if ((0, import_langium11.isAstNode)(value)) {
+      } else if ((0, import_langium12.isAstNode)(value)) {
         value.$container = node;
         value.$containerProperty = name;
       }