@artel/artc 0.9.26036-pre-release → 0.9.26038-pre-release

package/build/Cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   CommandLineCompiler
-} from "./chunk-D247ZQ57.js";
-import "./chunk-AUCAONLF.js";
+} from "./chunk-NRZEWWTT.js";
+import "./chunk-3I4SQIYG.js";
 import {
   __async
-} from "./chunk-JTOL3VLA.js";
+} from "./chunk-62UH22KS.js";
 
 // source/Cli.ts
 function main() {

package/build/api/Api.js

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "../chunk-AUCAONLF.js";
+} from "../chunk-3I4SQIYG.js";
 import {
   AccessKind,
   AccessedFunction_entity,
@@ -197,7 +197,7 @@ import {
   TagArgument_boolean,
   TagArgument_invalid,
   TagArgument_numeric,
-  TagArgument_string,
+  TagArgument_text,
   TagArgument_variableExpression,
   TagFunction,
   TagType,
@@ -311,7 +311,7 @@ import {
   withoutQuotes,
   withoutTemplateQuotes,
   yieldTask
-} from "../chunk-JTOL3VLA.js";
+} from "../chunk-62UH22KS.js";
 export {
   AccessKind,
   AccessedFunction_entity,
@@ -506,7 +506,7 @@ export {
   TagArgument_boolean,
   TagArgument_invalid,
   TagArgument_numeric,
-  TagArgument_string,
+  TagArgument_text,
   TagArgument_variableExpression,
   TagFunction,
   TagType,

package/build/api/ApiNodeJS.js

@@ -6,9 +6,9 @@ import {
   PhysicalFileSystem,
   PhysicalTypeScriptLibrariesProvider,
   PrintingDiagnosticAcceptor
-} from "../chunk-D247ZQ57.js";
-import "../chunk-AUCAONLF.js";
-import "../chunk-JTOL3VLA.js";
+} from "../chunk-NRZEWWTT.js";
+import "../chunk-3I4SQIYG.js";
+import "../chunk-62UH22KS.js";
 export {
   CommandLineCompiler,
   FileSystemUri,

package/build/api/ApiServices.js

@@ -102,6 +102,7 @@ import {
   isIdentifier2,
   isKeyword,
   isKeyword2,
+  isNamedFunctionEntity,
   isNamedTypeEntity,
   isNarrowableReferenceExpression,
   isNarrowableReferenceExpression2,
@@ -140,7 +141,7 @@ import {
   traverseTreeAsync,
   traverseTreeAsync2,
   yieldTask
-} from "../chunk-JTOL3VLA.js";
+} from "../chunk-62UH22KS.js";
 
 // source/services/common/Types.ts
 import * as ls from "vscode-languageserver";
@@ -9870,7 +9871,89 @@ var EntityToSyntax = class {
     return SyntaxFactory.modifier(41 /* Hidden */, levelKeyword);
   }
   convertTags(entityTags) {
-    return [];
+    return entityTags.map((t) => this.convertTag(t)).filter((t) => t !== void 0);
+  }
+  convertTag(tag) {
+    let name;
+    let typeArguments;
+    let parameterEntities;
+    switch (tag.kind) {
+      case "function": {
+        const func = tag.func;
+        if (!isNamedFunctionEntity(func.entity)) {
+          return void 0;
+        }
+        name = this.getEntityName(func.entity);
+        typeArguments = func.kind === "substituted-function" ? Query.from(func.value.getSubstitutions().getTypes()).map((t) => this.convertType(t)).toArray() : void 0;
+        parameterEntities = func.entity.getParameters();
+        break;
+      }
+      case "type": {
+        const typeEntity = tag.typeEntity;
+        if (!isNamedTypeEntity(typeEntity)) {
+          return void 0;
+        }
+        name = this.getEntityName(typeEntity);
+        const substitutions = tag.constructor_.substitutions;
+        typeArguments = substitutions.size > 0 ? Query.from(substitutions.getTypes()).map((t) => this.convertType(t)).toArray() : void 0;
+        parameterEntities = tag.constructor_.entity.getParameters();
+        break;
+      }
+      default:
+        Debug.never(tag);
+    }
+    let args;
+    if (tag.argumentByOriginalParameter.size > 0) {
+      args = [];
+      for (const parameterEntity of parameterEntities) {
+        const argument = tag.argumentByOriginalParameter.get(parameterEntity.originalEntity);
+        if (argument !== void 0) {
+          let argumentExpression;
+          switch (argument.kind) {
+            case "text":
+              argumentExpression = SyntaxFactory.textLiteral(argument.value);
+              break;
+            case "boolean":
+              argumentExpression = SyntaxFactory.booleanLiteral(argument.value);
+              break;
+            case "numeric":
+              argumentExpression = SyntaxFactory.numericLiteral(argument.value);
+              break;
+            case "variable-expression": {
+              const firstSegmentEntity = argument.segments[0];
+              if (firstSegmentEntity.subkind === "field") {
+                const containingType = firstSegmentEntity.getContainingType();
+                if (!isNamedTypeEntity(containingType)) {
+                  return void 0;
+                }
+                argumentExpression = SyntaxFactory.memberAccessExpression(
+                  SyntaxFactory.identifierExpression(this.getEntityName(containingType)),
+                  this.getEntityName(firstSegmentEntity)
+                );
+              } else {
+                argumentExpression = SyntaxFactory.identifierExpression(this.getEntityName(firstSegmentEntity));
+              }
+              for (let i = 1; i < argument.segments.length; i++) {
+                argumentExpression = SyntaxFactory.memberAccessExpression(
+                  argumentExpression,
+                  this.getEntityName(argument.segments[i])
+                );
+              }
+              break;
+            }
+            case "invalid":
+              argumentExpression = SyntaxFactory.missingExpression();
+              break;
+            default:
+              Debug.never(argument);
+          }
+          args.push(SyntaxFactory.argument(argumentExpression));
+        } else {
+          args.push(SyntaxFactory.argument(SyntaxFactory.missingExpression()));
+        }
+      }
+    }
+    return SyntaxFactory.tag(name, typeArguments, args);
   }
   getEntityName(entity) {
     return entity.getName().unescapedOriginal;
@@ -10103,12 +10186,14 @@ var EntityToSyntax2 = class {
       const getterEntity = entity.getGetter();
       if (getterEntity !== void 0) {
         const parameters = this.convertParameters(getterEntity.getParameters());
-        result.push(SyntaxFactory2.packageVariableGetterDeclaration(tags, name, parameters, type, void 0));
+        const body = SyntaxFactory2.emptyFunctionBlock();
+        result.push(SyntaxFactory2.packageVariableGetterDeclaration(tags, name, parameters, type, body));
       }
       const setterEntity = entity.getSetter();
       if (setterEntity !== void 0) {
         const parameters = this.convertParameters(setterEntity.getParameters());
-        result.push(SyntaxFactory2.packageVariableSetterDeclaration(tags, name, parameters, void 0));
+        const body = SyntaxFactory2.emptyFunctionBlock();
+        result.push(SyntaxFactory2.packageVariableSetterDeclaration(tags, name, parameters, body));
       }
     } else {
       result = SyntaxFactory2.packageVariableDeclaration(tags, name, type, void 0);
@@ -10121,14 +10206,8 @@ var EntityToSyntax2 = class {
     const typeParameters = this.convertTypeParameters(entity.getTypeParameters());
     const parameters = this.convertParameters(entity.getParameters());
     const returnType = this.convertTypeIfNotNullType(entity.getReturnType());
-    return SyntaxFactory2.packageFunctionDeclaration(
-      tags,
-      name,
-      typeParameters,
-      parameters,
-      returnType,
-      void 0
-    );
+    const body = SyntaxFactory2.emptyFunctionBlock();
+    return SyntaxFactory2.packageFunctionDeclaration(tags, name, typeParameters, parameters, returnType, body);
   }
   convertPackageType(entity) {
     switch (entity.typeEntityKind) {
@@ -10250,7 +10329,8 @@ var EntityToSyntax2 = class {
         const typeParameters = this.convertTypeParameters(entity.getTypeParameters());
         const parameters = this.convertParameters(entity.getParameters());
         const returnType = this.convertTypeIfNotNullType(entity.getReturnType());
-        return SyntaxFactory2.methodDeclaration(tags, name, typeParameters, parameters, returnType, void 0);
+        const body = SyntaxFactory2.emptyFunctionBlock();
+        return SyntaxFactory2.methodDeclaration(tags, name, typeParameters, parameters, returnType, body);
       }
       case 5 /* Accessor */:
         return this.convertTypeMemberAccessor(entity);
@@ -10297,7 +10377,8 @@ var EntityToSyntax2 = class {
         const name = this.getEntityName(owningEntity);
         const type = this.convertType(entity.getReturnType());
         const parameters = this.convertParameters(entity.getParameters());
-        return SyntaxFactory2.fieldGetterDeclaration(tags, name, parameters, type, void 0);
+        const body = SyntaxFactory2.emptyFunctionBlock();
+        return SyntaxFactory2.fieldGetterDeclaration(tags, name, parameters, type, body);
       }
       case 3 /* FieldSetter */: {
         const owningEntity = entity.getAccessorOwner();
@@ -10306,12 +10387,14 @@ var EntityToSyntax2 = class {
         }
         const name = this.getEntityName(owningEntity);
         const parameters = this.convertParameters(entity.getParameters());
-        return SyntaxFactory2.fieldSetterDeclaration(tags, name, parameters, void 0);
+        const body = SyntaxFactory2.emptyFunctionBlock();
+        return SyntaxFactory2.fieldSetterDeclaration(tags, name, parameters, body);
       }
       case 4 /* IndexedElementGetter */: {
         const parameters = this.convertParameters(entity.getParameters());
         const type = this.convertType(entity.getReturnType());
-        return SyntaxFactory2.indexedElementGetterDeclaration(tags, parameters, type, void 0);
+        const body = SyntaxFactory2.emptyFunctionBlock();
+        return SyntaxFactory2.indexedElementGetterDeclaration(tags, parameters, type, body);
       }
       case 5 /* IndexedElementSetter */: {
         const owningEntity = entity.getAccessorOwner();
@@ -10320,7 +10403,8 @@ var EntityToSyntax2 = class {
         }
         const parameterEntities = entity.getParameters();
         const parameters = this.convertParameters(parameterEntities);
-        return SyntaxFactory2.indexedElementSetterDeclaration(tags, parameters, void 0);
+        const body = SyntaxFactory2.emptyFunctionBlock();
+        return SyntaxFactory2.indexedElementSetterDeclaration(tags, parameters, body);
       }
       case 6 /* DereferencedVariableGetter */:
       case 7 /* DereferencedVariableSetter */:
@@ -10436,11 +10520,96 @@ var EntityToSyntax2 = class {
         break;
       }
     }
-    return Array.from(wkTagFlags).map((it) => {
+    const result = Array.from(wkTagFlags).map((it) => {
       const name = getWellKnownTagFlagName(it, entity.locale);
       Debug.assert(name !== void 0);
       return SyntaxFactory2.tag(name.unescapedOriginal);
     });
+    const entityTags = entity.getTags();
+    result.push(...entityTags.filter((t) => !(t.kind === "type" && isPackageTypeEntity(t.typeEntity) && this.analyzer.tags.getWellKnownTagFlagByTagEntity(t.typeEntity) !== void 0)).map((t) => this.convertUserTag(t)).filter((t) => t !== void 0));
+    return result;
+  }
+  convertUserTag(tag) {
+    let name;
+    let typeArguments;
+    let parameterEntities;
+    switch (tag.kind) {
+      case "function": {
+        const func = tag.func;
+        if (!isNamedFunctionEntity(func.entity)) {
+          return void 0;
+        }
+        name = this.getEntityName(func.entity);
+        typeArguments = func.kind === "substituted-function" ? Query.from(func.value.getSubstitutions().getTypes()).map((t) => this.convertType(t)).toArray() : void 0;
+        parameterEntities = func.entity.getParameters();
+        break;
+      }
+      case "type": {
+        const typeEntity = tag.typeEntity;
+        if (!isNamedTypeEntity(typeEntity)) {
+          return void 0;
+        }
+        name = this.getEntityName(typeEntity);
+        const substitutions = tag.constructor_.substitutions;
+        typeArguments = substitutions.size > 0 ? Query.from(substitutions.getTypes()).map((t) => this.convertType(t)).toArray() : void 0;
+        parameterEntities = tag.constructor_.entity.getParameters();
+        break;
+      }
+      default:
+        Debug.never(tag);
+    }
+    let args;
+    if (tag.argumentByOriginalParameter.size > 0) {
+      args = [];
+      for (const parameterEntity of parameterEntities) {
+        const argument = tag.argumentByOriginalParameter.get(parameterEntity.originalEntity);
+        if (argument !== void 0) {
+          let argumentExpression;
+          switch (argument.kind) {
+            case "text":
+              argumentExpression = SyntaxFactory2.textLiteral(argument.value);
+              break;
+            case "boolean":
+              argumentExpression = SyntaxFactory2.booleanLiteral(argument.value);
+              break;
+            case "numeric":
+              argumentExpression = SyntaxFactory2.numericLiteral(argument.value);
+              break;
+            case "variable-expression": {
+              const firstSegmentEntity = argument.segments[0];
+              if (firstSegmentEntity.subkind === "field") {
+                const containingType = firstSegmentEntity.getContainingType();
+                if (!isNamedTypeEntity(containingType)) {
+                  return void 0;
+                }
+                argumentExpression = SyntaxFactory2.memberAccessExpression(
+                  SyntaxFactory2.identifierExpression(this.getEntityName(containingType)),
+                  this.getEntityName(firstSegmentEntity)
+                );
+              } else {
+                argumentExpression = SyntaxFactory2.identifierExpression(this.getEntityName(firstSegmentEntity));
+              }
+              for (let i = 1; i < argument.segments.length; i++) {
+                argumentExpression = SyntaxFactory2.memberAccessExpression(
+                  argumentExpression,
+                  this.getEntityName(argument.segments[i])
+                );
+              }
+              break;
+            }
+            case "invalid":
+              argumentExpression = SyntaxFactory2.missingExpression();
+              break;
+            default:
+              Debug.never(argument);
+          }
+          args.push(SyntaxFactory2.argument(argumentExpression));
+        } else {
+          args.push(SyntaxFactory2.argument(SyntaxFactory2.missingExpression()));
+        }
+      }
+    }
+    return SyntaxFactory2.tag(name, typeArguments, args);
   }
   getEntityName(entity) {
     return entity.getName().unescapedOriginal;
@@ -10787,6 +10956,18 @@ var CompilationController = class extends RxObject2 {
   reloadMainCompilation() {
     return __async(this, null, function* () {
       subscribeToFileSystemRecursively(this.rootDirectory);
+      if (this.config.standardPackagesUri !== void 0 && this.config.standardPackagesUri.checkIfRelativeTo(this.rootDirectory.uri) === 2 /* NotRelativeOrEqual */) {
+        const standardPackagesDirectory = this.fileSystemTree.getDirectory(this.config.standardPackagesUri);
+        if (standardPackagesDirectory !== void 0) {
+          subscribeToFileSystemRecursively(standardPackagesDirectory);
+        }
+      }
+      if (this.config.builtInStandardPackagesUri !== void 0 && this.config.builtInStandardPackagesUri.checkIfRelativeTo(this.rootDirectory.uri) === 2 /* NotRelativeOrEqual */) {
+        const standardPackagesDirectory = this.fileSystemTree.getDirectory(this.config.builtInStandardPackagesUri);
+        if (standardPackagesDirectory !== void 0) {
+          subscribeToFileSystemRecursively(standardPackagesDirectory);
+        }
+      }
       const configurationByPackageOrGroupUri = /* @__PURE__ */ new Map();
       for (const [packageUri, controller] of this.configurationControllerByPackageUri_) {
         if (!controller.hasConvertedConfiguration) {
@@ -12865,7 +13046,7 @@ var SourceGenerationService = class extends RxObject7 {
             break;
           }
           case 1 /* ArtelM */: {
-            const node = new EntityToSyntax2(analyzer, packageEntity).convert();
+            const node = new EntityToSyntax2(analyzer.dialectM, packageEntity).convert();
             code = new SyntaxToCode2(node, { keywordsLocale: packageLocale }).convert();
             break;
           }

package/build/{chunk-AUCAONLF.js → chunk-3I4SQIYG.js}

@@ -10,7 +10,7 @@ import {
   WellKnownDeclarationsLoadError,
   __async,
   createTsInteropInputsForCompilation
-} from "./chunk-JTOL3VLA.js";
+} from "./chunk-62UH22KS.js";
 
 // source/executor/Compiler.ts
 var Compiler = class {

package/build/{chunk-JTOL3VLA.js → chunk-62UH22KS.js}

@@ -780,7 +780,7 @@ var UniqueWithComparatorQuery = class extends Query {
 };
 
 // source/common/Constants.ts
-var ArtelVersion = true ? "0.9.26036-pre-release" : "";
+var ArtelVersion = true ? "0.9.26038-pre-release" : "";
 var ArtelSourceFileExtensions = [".\u0430\u0440\u0442", ".\u0430\u0440\u0442\u0435\u043B\u044C", ".art", ".artel", ".\u0430\u0440\u0442\u043C", ".\u0430\u0440\u0442\u0435\u043B\u044C\u043C", ".artm", ".artelm"];
 var ArtelSourceFileExtensionSet = new Set(ArtelSourceFileExtensions);
 var ArtelSourceAndConfigurationFileExtensionSet = new Set(ArtelSourceFileExtensionSet).add(".json");
@@ -11211,6 +11211,44 @@ var SyntaxFactory = class {
         Debug.never(node);
     }
   }
+  static argument(value, name) {
+    let equalsToken;
+    let nameIdentifier;
+    if (name !== void 0) {
+      equalsToken = this.token(64 /* Equals */);
+      nameIdentifier = this.identifier(name);
+    }
+    return new Argument(nameIdentifier, equalsToken, value, void 0);
+  }
+  static missingExpression() {
+    return new MissingExpression(void 0);
+  }
+  static booleanLiteral(value) {
+    const keyword = value ? this.keyword(57 /* Yes */) : this.keyword(58 /* No */);
+    return new KeywordExpression(keyword, void 0);
+  }
+  static textLiteral(valueWithoutQuotes) {
+    const token = this.token(5 /* TextLiteral */, `"${valueWithoutQuotes}"`);
+    return new TextLiteral(token, void 0);
+  }
+  static numericLiteral(value) {
+    let token;
+    if (Number.isInteger(value)) {
+      token = this.token(2 /* IntegerLiteral */, value.toString());
+    } else {
+      token = this.token(3 /* RealLiteral */, value.toString());
+    }
+    return new TokenExpression(token, void 0);
+  }
+  static identifierExpression(value) {
+    const valueIdentifier = this.identifier(value);
+    return new IdentifierExpression(valueIdentifier, void 0);
+  }
+  static memberAccessExpression(expression, memberName) {
+    const dotToken = this.token(34 /* Dot */);
+    const memberNameIdentifier = this.identifier(memberName);
+    return new MemberAccessExpression(expression, dotToken, memberNameIdentifier, void 0);
+  }
   static identifier(value, flags = 0 /* None */) {
     if (typeof value === "string") {
       return this.createToken(9 /* Identifier */, value, flags);
@@ -17682,6 +17720,10 @@ var SyntaxFactory2 = class {
       void 0
     );
   }
+  static emptyFunctionBlock() {
+    const endKeyword = this.keyword(1011 /* End */);
+    return new FunctionBlock2(void 0, new StatementList2([], void 0), void 0, endKeyword, void 0);
+  }
   static localStructuredTypeDeclaration(name, baseTypes, members) {
     const typeKeyword = this.keyword(1033 /* Type */);
     const nameIdentifier = this.identifier(name);
@@ -17771,14 +17813,13 @@ var SyntaxFactory2 = class {
     return new ParameterDeclaration2(tagList, nameIdentifier, typeAnnotation, initializer, void 0);
   }
   static typeMemberDeclarationBlock(members) {
-    const openBraceToken = this.token(1046 /* OpenBrace */);
     const memberList = members instanceof Array ? new TypeMemberDeclarationList2(members, void 0) : members;
-    const closeBraceToken = this.token(1020 /* CloseBrace */);
+    const endKeyword = this.keyword(1011 /* End */);
     return new TypeMemberDeclarationBlock2(
-      openBraceToken,
+      void 0,
       memberList,
-      closeBraceToken,
       void 0,
+      endKeyword,
       void 0
     );
   }
@@ -18116,6 +18157,44 @@ var SyntaxFactory2 = class {
     }
     return this.translationTypeParameterClause(typeParameters);
   }
+  static argument(value, name) {
+    let equalsToken;
+    let nameIdentifier;
+    if (name !== void 0) {
+      equalsToken = this.token(1030 /* Equals */);
+      nameIdentifier = this.identifier(name);
+    }
+    return new Argument2(nameIdentifier, equalsToken, value, void 0);
+  }
+  static missingExpression() {
+    return new MissingExpression2(void 0);
+  }
+  static booleanLiteral(value) {
+    const keyword = value ? this.keyword(1036 /* Yes */) : this.keyword(1022 /* No */);
+    return new KeywordExpression2(keyword, void 0);
+  }
+  static textLiteral(valueWithoutQuotes) {
+    const token = this.token(1062 /* TextLiteral */, `"${valueWithoutQuotes}"`);
+    return new TextLiteral2(token, void 0);
+  }
+  static numericLiteral(value) {
+    let token;
+    if (Number.isInteger(value)) {
+      token = this.token(1038 /* IntegerLiteral */, value.toString());
+    } else {
+      token = this.token(1057 /* RealLiteral */, value.toString());
+    }
+    return new TokenExpression2(token, void 0);
+  }
+  static identifierExpression(value) {
+    const valueIdentifier = this.identifier(value);
+    return new IdentifierExpression2(valueIdentifier, void 0);
+  }
+  static memberAccessExpression(expression, memberName) {
+    const dotToken = this.token(1026 /* Dot */);
+    const memberNameIdentifier = this.identifier(memberName);
+    return new MemberAccessExpression2(expression, dotToken, memberNameIdentifier, void 0);
+  }
   static identifier(value, flags = 0 /* None */) {
     if (typeof value === "string") {
       return this.createToken(1037 /* Identifier */, value, flags);
@@ -19185,8 +19264,8 @@ var SyntaxToCode2 = class _SyntaxToCode {
     if (node.openBraceToken !== void 0) {
       Debug.assert(node.endKeyword === void 0);
       this.writeToken(node.openBraceToken);
+      this.writeNewLineOrWhitespace();
     }
-    this.writeNewLineOrWhitespace();
     if (node.memberList.elements.length > 0) {
       this.increaseIndentation();
       const addSemicolonsIfMissing = this.isSingleLineMode;
@@ -19520,7 +19599,16 @@ var SyntaxToCode2 = class _SyntaxToCode {
     if (addLeadingNewLineOrWhitespace) {
       this.writeNewLineOrWhitespace();
     }
-    this.writeNodeDefault(node);
+    if (node.openBraceToken !== void 0) {
+      this.writeToken(node.openBraceToken);
+      this.writeNewLineOrWhitespace();
+    }
+    this.writeNodeDefault(node.statementList);
+    if (node.closeBraceToken !== void 0) {
+      this.writeToken(node.closeBraceToken);
+    } else if (node.endKeyword !== void 0) {
+      this.writeKeyword(node.endKeyword);
+    }
   }
   writeVariableInitializer(node) {
     this.writeWhitespace();
@@ -33535,10 +33623,10 @@ var TagFunction = class extends TagBase {
     return this.func.entity;
   }
 };
-var TagArgument_string = class {
+var TagArgument_text = class {
   constructor(value) {
     this.value = value;
-    this.kind = "string";
+    this.kind = "text";
   }
 };
 var TagArgument_numeric = class {
@@ -43334,7 +43422,7 @@ var EntityMap = class _EntityMap {
       const realNameTag = findTag(this.analyzer.originalWellKnownDeclarationsA.realName, tags);
       if (realNameTag !== void 0) {
         const nameArgument = realNameTag.argumentByNameKey.get("\u0438\u043C\u044F");
-        if (nameArgument?.kind === "string") {
+        if (nameArgument?.kind === "text") {
           result = nameArgument.value;
         }
       }
@@ -106375,7 +106463,7 @@ var Tags = class {
       const value = argument2.value;
       switch (value.kind) {
         case 1108 /* TextLiteral */:
-          result = new TagArgument_string(unescapeText(withoutQuotes(value.text.value)));
+          result = new TagArgument_text(unescapeText(withoutQuotes(value.text.value)));
           break;
         case 1114 /* TokenExpression */:
           switch (value.token.tokenKind) {
@@ -117426,7 +117514,7 @@ var Tags2 = class {
       const value = argument2.value;
       switch (value.kind) {
         case 78 /* TextLiteral */:
-          result = new TagArgument_string(unescapeText(withoutQuotes(value.text.value)));
+          result = new TagArgument_text(unescapeText(withoutQuotes(value.text.value)));
           break;
         case 77 /* TokenExpression */:
           switch (value.token.tokenKind) {
@@ -117955,7 +118043,7 @@ export {
   entityToStringDecorator,
   TagType,
   TagFunction,
-  TagArgument_string,
+  TagArgument_text,
   TagArgument_numeric,
   TagArgument_boolean,
   TagArgument_variableExpression,

package/build/{chunk-D247ZQ57.js → chunk-NRZEWWTT.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-AUCAONLF.js";
+} from "./chunk-3I4SQIYG.js";
 import {
   ArtelVersion,
   Cached,
@@ -16,7 +16,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-JTOL3VLA.js";
+} from "./chunk-62UH22KS.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";

package/build/types/analysis/m/Analyzer.d.ts

@@ -385,7 +385,7 @@ declare class Tags {
     private createTagFromNode;
     private argumentToTagArgument;
     getWellKnownTagFlagsOfNodeWithTags(node: tree.NodeWithTags): tree.WellKnownTagFlags;
-    getWellKnownTagFlagByTagEntity(entity: e.PackageStructuredTypeEntity): tree.WellKnownTagFlags | undefined;
+    getWellKnownTagFlagByTagEntity(entity: e.PackageTypeEntity): tree.WellKnownTagFlags | undefined;
     getTagEntityByWellKnownTagFlag(flag: tree.WellKnownTagFlags, locale: PackageLocale): e.PackageTypeEntity | undefined;
     private getFlagByOriginalEntityMap;
     private getLocalizedEntityByFlagMap;

package/build/types/entities/Tag.d.ts

@@ -25,10 +25,10 @@ export declare class TagFunction extends TagBase {
     get entity(): TypeEntity | FunctionEntity;
     constructor(func: AccessedFunction, argumentByParameter: ReadonlyMap<ParameterEntity, TagArgument>);
 }
-export type TagArgument = TagArgument_string | TagArgument_numeric | TagArgument_boolean | TagArgument_variableExpression | TagArgument_invalid;
-export declare class TagArgument_string {
+export type TagArgument = TagArgument_text | TagArgument_numeric | TagArgument_boolean | TagArgument_variableExpression | TagArgument_invalid;
+export declare class TagArgument_text {
     readonly value: string;
-    readonly kind = "string";
+    readonly kind = "text";
     constructor(value: string);
 }
 export declare class TagArgument_numeric {

package/build/types/services/a/source-generation/EntityToSyntax.d.ts

@@ -41,6 +41,7 @@ export declare class EntityToSyntax {
     private convertParameter;
     private createHidingModifier;
     private convertTags;
+    private convertTag;
     private getEntityName;
     private groupTypeMemberDeclarations;
     private groupTypeMemberDeclarationsRecursively;

package/build/types/services/m/source-generation/EntityToSyntax.d.ts

@@ -1,4 +1,4 @@
-import { Analyzer } from '../../../analysis/Analyzer.js';
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
 import { PackageEntity } from '../../../entities/index.js';
 import * as tree from '../../../tree/m/index.js';
 export declare class EntityToSyntax {
@@ -27,6 +27,7 @@ export declare class EntityToSyntax {
     private convertParameters;
     private convertParameter;
     private convertTags;
+    private convertUserTag;
     private getEntityName;
     private convertType;
     private convertStructuredType;

package/build/types/tree/a/SyntaxFactory.d.ts

@@ -65,6 +65,13 @@ export declare class SyntaxFactory {
     static translationParameterClause(parameters: readonly (tree.Identifier | string)[]): tree.TranslationParameterClause;
     static indexParameterTranslationClause(parameters: readonly (tree.Identifier | string)[]): tree.IndexParameterTranslationClause;
     static typeMemberDeclarationWithModifiers(node: tree.TypeMemberDeclaration, modifiers: readonly tree.Modifier[] | tree.ModifierList): tree.TypeMemberDeclaration;
+    static argument(value: tree.Expression, name?: tree.Identifier | string): tree.Argument;
+    static missingExpression(): tree.MissingExpression;
+    static booleanLiteral(value: boolean): tree.KeywordExpression;
+    static textLiteral(valueWithoutQuotes: string): tree.TextLiteral;
+    static numericLiteral(value: number): tree.TokenExpression;
+    static identifierExpression(value: tree.Identifier | string): tree.IdentifierExpression;
+    static memberAccessExpression(expression: tree.Expression, memberName: tree.Identifier | string): tree.MemberAccessExpression;
     static identifier(value: tree.Identifier | string, flags?: TokenFlags): tree.Identifier;
     static token<T extends TokenKind>(kind: T, value?: string): Token<T>;
     static keyword<T extends KeywordKind>(kind: T): tree.Keyword<T>;

package/build/types/tree/m/SyntaxFactory.d.ts

@@ -18,6 +18,7 @@ export declare class SyntaxFactory {
     static methodDeclaration(tags: readonly tree.Tag[] | tree.TagList, name: tree.Identifier | string, typeParameters: readonly tree.TypeParameterDeclaration[] | tree.TypeParameterDeclarationList | undefined, parameters: readonly tree.ParameterDeclaration[] | tree.ParameterList, returnTypeSpecifier: tree.TypeSpecifier | undefined, body: tree.FunctionBlock | undefined): tree.MethodDeclaration;
     static indexedElementGetterDeclaration(tags: readonly tree.Tag[] | tree.TagList, parameters: readonly tree.ParameterDeclaration[] | tree.ParameterList, typeSpecifier: tree.TypeSpecifier, body: tree.FunctionBlock | undefined): tree.IndexedElementGetterDeclaration;
     static indexedElementSetterDeclaration(tags: readonly tree.Tag[] | tree.TagList, parameters: readonly tree.ParameterDeclaration[] | tree.ParameterList, body: tree.FunctionBlock | undefined): tree.IndexedElementSetterDeclaration;
+    static emptyFunctionBlock(): tree.FunctionBlock;
     static localStructuredTypeDeclaration(name: tree.Identifier | string, baseTypes: readonly tree.NamedTypeSpecifier[] | undefined, members: readonly tree.TypeMemberDeclaration[] | tree.TypeMemberDeclarationList): tree.LocalStructuredTypeDeclaration;
     static localFunctionTypeDeclaration(parameters: readonly tree.ParameterDeclaration[] | tree.ParameterList, returnTypeSpecifier: tree.TypeSpecifier | undefined): tree.LocalFunctionTypeDeclaration;
     static namedTypeSpecifier(name: tree.Identifier | string | readonly (tree.Identifier | string)[], typeArguments?: readonly tree.TypeSpecifier[]): tree.NamedTypeSpecifier;
@@ -53,6 +54,13 @@ export declare class SyntaxFactory {
     private static translationTypeParameterClause;
     private static translationParameterClause;
     private static createTranslationTypeParameterClause;
+    static argument(value: tree.Expression, name?: tree.Identifier | string): tree.Argument;
+    static missingExpression(): tree.MissingExpression;
+    static booleanLiteral(value: boolean): tree.KeywordExpression;
+    static textLiteral(valueWithoutQuotes: string): tree.TextLiteral;
+    static numericLiteral(value: number): tree.TokenExpression;
+    static identifierExpression(value: tree.Identifier | string): tree.IdentifierExpression;
+    static memberAccessExpression(expression: tree.Expression, memberName: tree.Identifier | string): tree.MemberAccessExpression;
     static identifier(value: tree.Identifier | string, flags?: TokenFlags): tree.Identifier;
     static token<T extends TokenKind>(kind: T, value?: string): Token<T>;
     static keyword<T extends KeywordKind>(kind: T): tree.Keyword<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artel/artc",
-  "version": "0.9.26036-pre-release",
+  "version": "0.9.26038-pre-release",
   "description": "Артель Компилятор | Artel Compiler",
   "author": "Nezaboodka Team <contact@nezaboodka.com>",
   "license": "Apache-2.0",