@artel/artc 0.6.26039 → 0.9.26001

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

@@ -0,0 +1,9 @@
+import { Node } from './Nodes.js';
+/**
+ * Проверяет, что тип узла совместим с типом родительского узла всех дочерних узлов.
+ */
+export type IsCorrectParent<Parent, Children> = Children extends readonly [infer FirstChild, ...infer RemainingChildren] ? (FirstChild extends Node ? (IsAssignableTo<Parent, FirstChild['parent']> extends true ? IsCorrectParent<Parent, RemainingChildren> : IsAssignableTo<Parent, FirstChild['parent']>) : FirstChild extends undefined ? true : 'Ожидалось, что типом FirstChild будет Node или undefined.') : Children extends readonly (infer ListElement)[] ? (ListElement extends Node ? IsAssignableTo<Parent, ListElement['parent']> : ListElement extends undefined ? true : 'Ожидалось, что типом ListElement будет Node или undefined.') : Children extends readonly [] ? true : 'Ожидался пустой кортеж.';
+export type IsAssignableTo<Source, Target> = Source extends Target ? true : ['Тип', Source, 'не совместим с типом', Target];
+export type NodesWithChild<Child, Nodes = Node> = Nodes extends {
+    children: readonly (infer C)[];
+} ? Child extends C ? Nodes : never : never;

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

@@ -0,0 +1,39 @@
+import { KeywordKind } from './KeywordKind.js';
+import { TokenKind } from './TokenKind.js';
+export declare enum OperatorKind {
+    Plus = 0,// Одноместный или двухместный.
+    Minus = 1,// Одноместный или двухместный.
+    Not = 2,
+    Multiply = 3,
+    Divide = 4,
+    Modulo = 5,
+    LessThan = 6,
+    GreaterThan = 7,
+    LessThanOrEqual = 8,
+    GreaterThanOrEqual = 9,
+    Or = 10,
+    And = 11
+}
+export declare const operatorKinds: readonly [OperatorKind.Plus, OperatorKind.Minus, OperatorKind.Not, OperatorKind.Multiply, OperatorKind.Divide, OperatorKind.Modulo, OperatorKind.LessThan, OperatorKind.GreaterThan, OperatorKind.LessThanOrEqual, OperatorKind.GreaterThanOrEqual, OperatorKind.Or, OperatorKind.And];
+/**
+ * Виды операторов, задаваемых токенами (`+`, `-`, `*=` и др.).
+ */
+export type KindOfOperatorDefinedByToken = OperatorKind.Plus | OperatorKind.Minus | OperatorKind.Multiply | OperatorKind.Divide | OperatorKind.Modulo | OperatorKind.LessThan | OperatorKind.GreaterThan | OperatorKind.LessThanOrEqual | OperatorKind.GreaterThanOrEqual;
+export declare function isOperatorDefinedByToken(kind: OperatorKind): kind is KindOfOperatorDefinedByToken;
+/**
+ * Виды операторов, задаваемых ключевыми словами (`и`, `или`, `не` и др.)
+ */
+export type KindOfOperatorDefinedByKeyword = OperatorKind.Not | OperatorKind.Or | OperatorKind.And;
+export declare function isOperatorDefinedByKeyword(kind: OperatorKind): kind is KindOfOperatorDefinedByKeyword;
+export declare const tokenTextByOperatorKind: {
+    [T in KindOfOperatorDefinedByToken]: string;
+};
+export declare const operatorKindByTokenText: Record<string, KindOfOperatorDefinedByToken | undefined>;
+export declare const keywordKindByOperatorKind: {
+    [T in KindOfOperatorDefinedByKeyword]: KeywordKind;
+};
+export declare const operatorKindByKeywordKind: Record<number, KindOfOperatorDefinedByKeyword | undefined>;
+export declare const tokenKindByOperatorKind: {
+    [T in KindOfOperatorDefinedByToken]: TokenKind;
+};
+export declare const operatorKindByTokenKind: Record<number, KindOfOperatorDefinedByToken | undefined>;

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

@@ -0,0 +1,107 @@
+import { PackageLocale } from '../../common/index.js';
+import type * as tree from './Nodes.js';
+export declare class SyntaxToCode {
+    private static writeFunctions_;
+    private readonly node;
+    private readonly newLine;
+    private readonly indentationStep;
+    private readonly keywordsLocale;
+    private readonly singleWordKeywordValues;
+    private code;
+    private indentation;
+    private isIndentationWritten;
+    private isSingleLineMode;
+    private static get writeFunctions();
+    constructor(node: tree.Node, options?: SyntaxToCodeOptions);
+    convert(): string;
+    private writeSourceFile;
+    private writePackageImportDirectiveList;
+    private writePackageImport;
+    private writePackageName;
+    private writePackageMemberDeclarationList;
+    private writePackageVariableDeclaration;
+    private writePackageVariableGetterDeclaration;
+    private writePackageVariableSetterDeclaration;
+    private writePackageFunctionDeclaration;
+    private writePackageTypeDeclaration;
+    private writePackageAliasTypeDeclaration;
+    private writePackageMemberGroupDeclaration;
+    private writeExtendsClause;
+    private writeBaseTypeList;
+    private writeTypeMemberDeclarationBlock;
+    private writeFieldDeclaration;
+    private writeFieldGetterDeclaration;
+    private writeFieldSetterDeclaration;
+    private writeMethodDeclaration;
+    private writeIndexedElementGetterDeclaration;
+    private writeIndexedElementSetterDeclaration;
+    private writeVariantValueDeclaration;
+    private writeTypeMemberGroupDeclaration;
+    private writeTypeParameterClause;
+    private writeTypeParameterDeclaration;
+    private writeParameterClause;
+    private writeParameterList;
+    private writeParameterDeclaration;
+    private writeDeclarationTags;
+    private writeTag;
+    private writeTypeAnnotation;
+    private writeTypeSpecifier;
+    private writeNamedTypeSpecifier;
+    private writeLocalTypeSpecifier;
+    private writeLocalFunctionTypeDeclaration;
+    private writeLocalStructuredTypeDeclaration;
+    private writeUnionTypeSpecifier;
+    private writeParenthesizedTypeSpecifier;
+    private writeNullableTypeSpecifier;
+    private doesUnionTypeElementRequireParenthesis;
+    private doesTypeMadeNullableRequireParenthesis;
+    private writeQualifiedName;
+    private writeTypeArgumentClause;
+    private writeArgument;
+    private writeExpression;
+    private writeDeclarationBody;
+    private writeStatementBlock;
+    private writeFunctionBlock;
+    private writeTranslationsDeclaration;
+    private writePackageVariableTranslation;
+    private writePackageFunctionTranslation;
+    private writeTypeTranslation;
+    private writeFunctionTypeTranslation;
+    private writeFieldOrVariantTranslation;
+    private writeMethodTranslation;
+    private writeIndexerTranslation;
+    private writeTranslationTypeParameterClause;
+    private writeTranslationParameterClause;
+    private writeIndexParameterTranslationClause;
+    private writeStaticFieldDeclaration;
+    private writeStaticFieldGetterDeclaration;
+    private writeStaticFieldSetterDeclaration;
+    private writeStaticMethodDeclaration;
+    private writeStaticNameClause;
+    private writeTypeParameterReference;
+    private writeVariableInitializer;
+    private writeNodeDefault;
+    private writeWhitespaceSeparatedList;
+    private writeSemicolonSeparatedList;
+    private writeCommaSeparatedList;
+    private writePlusSeparatedList;
+    private writeKeyword;
+    private writeToken;
+    private writeNode;
+    private writeNewLineOrWhitespace;
+    private writeWhitespace;
+    private writeNewLine;
+    private writeCode;
+    private writeIndentation;
+    private increaseIndentation;
+    private decreaseIndentation;
+    private static createWriteFunctions;
+    private escapeLiteralIdentifier;
+}
+export interface SyntaxToCodeOptions {
+    newLine?: '\n' | '\r\n';
+    indentationStep?: string;
+    initialIndentation?: string;
+    modifiersOnSeparateLine?: boolean;
+    keywordsLocale?: PackageLocale;
+}

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

@@ -0,0 +1,46 @@
+import { Range } from '../../common/index.js';
+import { BaseNode } from './BaseNode.js';
+import { NodeKind } from './NodeKind.js';
+import { Node } from './Nodes.js';
+import { OperatorKind } from './OperatorKind.js';
+import { TokenFlags } from './TokenFlags.js';
+import { TokenKind } from './TokenKind.js';
+import { TriviaKind } from './TriviaKind.js';
+export declare class Token<TKind extends TokenKind = TokenKind> extends BaseNode {
+    readonly kind = NodeKind.Token;
+    readonly tokenKind: TKind;
+    readonly value: string;
+    readonly leadingTrivia: readonly Trivia[];
+    readonly trailingTrivia: readonly Trivia[];
+    readonly flags: TokenFlags;
+    readonly operatorKind: OperatorKind | undefined;
+    get children(): readonly [];
+    get parent(): Node;
+    get isMissing(): boolean;
+    protected get thisAsNode(): Node;
+    constructor(tokenKind: TKind, value: string, leadingTrivia: readonly Trivia[], trailingTrivia: readonly Trivia[], flags: TokenFlags, operatorKind: OperatorKind | undefined, rangeWithTrivia: Range | undefined);
+    get rangeWithoutTrivia(): Range;
+    getTextWithTrivia(): string;
+    hasLeadingLineBreak(): boolean;
+    hasTrailingLineBreak(): boolean;
+    getTriviaAt(position: number): TokenTrivia | undefined;
+    selectLeadingTrivia(condition: (trivia: Trivia, rangeStart: number, rangeEnd: number) => boolean): TokenTrivia[];
+    selectTrailingTrivia(condition: (trivia: Trivia, rangeStart: number, rangeEnd: number) => boolean): TokenTrivia[];
+    protected getLengthWithTrivia(): number;
+}
+export declare class Trivia {
+    readonly kind: TriviaKind;
+    readonly value: string;
+    get rangeLength(): number;
+    constructor(kind: TriviaKind, value: string);
+}
+export declare class TokenTrivia {
+    readonly trivia: Trivia;
+    readonly token: Token<TokenKind>;
+    readonly isTrailing: boolean;
+    readonly index: number;
+    readonly range: Range;
+    get kind(): TriviaKind;
+    get value(): string;
+    constructor(token: Token<TokenKind>, trivia: Trivia, isTrailing: boolean, index: number, range: Range);
+}

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

@@ -0,0 +1,12 @@
+export declare const enum TokenFlags {
+    None = 0,// обычная лексема
+    Missing = 1,// лексема отсутствует в исходном тексте, но требуется по грамматике.
+    CompoundAngle = 2,// составная лексема с угловой скобкой: <<, <<=, >>, >>>, >>=
+    QuotedName = 4,// 'имя', 'имя с пробелами', '+'
+    RequiresQuotes = 8,// 'имя с пробелами', '+'
+    EscapedKeyword = 16,// 'выполнить'
+    SingleCharText = 64,// текст из одного символа: "а", "\/", "ю000А"
+    EndsWithExclamation = 256,// переводимый текст: "текст"!, }текст"!
+    ObjectParameterName = 512,// имя особого параметра "объект"
+    LocalizableText = 256
+}

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

@@ -1,73 +1,74 @@
 export declare enum TokenKind {
     Unknown = 1000,
-    EndOfFile = 1001,
-    IntegerLiteral = 1002,
-    RealLiteral = 1003,
-    MeasureLiteral = 1004,
-    TextLiteral = 1005,
-    TextTemplateHead = 1006,
-    TextTemplatePart = 1007,
-    TextTemplateTail = 1008,
-    Identifier = 1009,
-    Ampersand = 1010,
-    AmpersandAmpersand = 1011,
-    AmpersandEquals = 1012,
-    Asterisk = 1013,
-    AsteriskAsterisk = 1014,
-    AsteriskEquals = 1015,
-    BackQuote = 1016,
-    Bar = 1017,
-    BarBar = 1018,
-    BarEquals = 1019,
-    BarBarEquals = 1020,
-    Caret = 1021,
-    CloseBrace = 1022,
-    CloseParenthesis = 1023,
-    CloseSquareBracket = 1024,
-    Colon = 1025,
-    Comma = 1026,
-    CommercialAt = 1027,
-    Dot = 1028,
-    DoublePeriod = 1029,
-    Ellipsis = 1030,
+    Ampersand = 1001,
+    AmpersandAmpersand = 1002,
+    AmpersandEquals = 1003,
+    Asterisk = 1004,
+    AsteriskAsterisk = 1005,
+    AsteriskEquals = 1006,
+    BackQuote = 1007,
+    Backslash = 1008,
+    Bar = 1009,
+    BarBar = 1010,
+    BarBarEquals = 1011,
+    BarEquals = 1012,
+    BarGreaterThan = 1013,
+    BarGreaterThanEquals = 1014,
+    BarGreaterThanGreaterThan = 1015,
+    BarGreaterThanGreaterThanEquals = 1016,
+    BarLessThan = 1017,
+    BarLessThanEquals = 1018,
+    Caret = 1019,
+    CloseBrace = 1020,
+    CloseParenthesis = 1021,
+    CloseSquareBracket = 1022,
+    Colon = 1023,
+    Comma = 1024,
+    CommercialAt = 1025,
+    Dot = 1026,
+    DoublePeriod = 1027,
+    Ellipsis = 1028,
+    EndOfFile = 1029,
+    Equals = 1030,
     EqualsEquals = 1031,
     Exclamation = 1032,
     ExclamationEquals = 1033,
     GreaterThan = 1034,
     GreaterThanOrEqual = 1035,
     HashSign = 1036,
-    LessThan = 1037,
-    LessThanOrEqual = 1038,
-    LessThanMinus = 1039,
-    LessThanLessThan = 1040,
-    LessThanLessThanEquals = 1041,
-    Minus = 1042,
-    MinusMinus = 1043,
+    Identifier = 1037,
+    IntegerLiteral = 1038,
+    LessThan = 1039,
+    LessThanMinus = 1040,
+    LessThanOrEqual = 1041,
+    MeasureLiteral = 1042,
+    Minus = 1043,
     MinusEquals = 1044,
     MinusGreaterThan = 1045,
-    OpenBrace = 1046,
-    OpenParenthesis = 1047,
-    OpenSquareBracket = 1048,
-    Plus = 1049,
-    PlusPlus = 1050,
-    PlusEquals = 1051,
-    Question = 1052,
-    QuestionQuestion = 1053,
-    GreaterThanGreaterThan = 1054,
-    GreaterThanGreaterThanEquals = 1055,
-    GreaterThanGreaterThanGreaterThan = 1056,
-    GreaterThanGreaterThanGreaterThanEquals = 1057,
-    Semicolon = 1058,
-    Slash = 1059,
-    SlashEquals = 1060,
-    Tilde = 1061,
-    TildeTilde = 1062,
-    Underscore = 1063,
-    Equals = 1064,
-    Percent = 1065,
-    PercentEquals = 1066,
-    PercentPercent = 1067,
-    Backslash = 1068
+    MinusMinus = 1046,
+    OpenBrace = 1047,
+    OpenParenthesis = 1048,
+    OpenSquareBracket = 1049,
+    Percent = 1050,
+    PercentEquals = 1051,
+    PercentPercent = 1052,
+    Plus = 1053,
+    PlusEquals = 1054,
+    PlusPlus = 1055,
+    Question = 1056,
+    QuestionQuestion = 1057,
+    RealLiteral = 1058,
+    Semicolon = 1059,
+    Slash = 1060,
+    SlashEquals = 1061,
+    TextLiteral = 1062,
+    TextLiteralSuffix = 1063,
+    TextTemplateHead = 1064,
+    TextTemplatePart = 1065,
+    TextTemplateTail = 1066,
+    Tilde = 1067,
+    TildeTilde = 1068,
+    Underscore = 1069
 }
 export declare const tokenKindValues: {
     [T in TokenKind]: string;

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

@@ -0,0 +1,18 @@
+import { TaskController } from '../../common/index.js';
+import { Node } from './Nodes.js';
+type ChildNodeVisitor = (node: Node) => void;
+export declare function forEachChild(node: Node, visitTokens: boolean, nodeVisitor: ChildNodeVisitor): void;
+export declare function traverseTree(node: Node, visitTokens: boolean, nodeVisitor: ChildNodeVisitor): void;
+export declare function traverseTreeAsync(root: Node, visitTokens: boolean, taskController: TaskController, nodeVisitor: (node: Node, controller: TraversalController) => Promise<void> | undefined): Promise<void>;
+export declare class TraversalController {
+    private shouldStopTraverse_;
+    private shouldSkipChildrenTraverse_;
+    readonly task: TaskController;
+    constructor(task: TaskController);
+    shouldStopTraverse(): boolean;
+    shouldSkipChildrenTraverse(): boolean;
+    stopTraverse(): void;
+    skipChildrenTraverse(): void;
+    resetSkipChildrenTraverse(): void;
+}
+export {};

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

@@ -0,0 +1,46 @@
+import { KeywordKind } from './KeywordKind.js';
+import { LocalFunctionTypeDeclaration, Expression, FieldDeclaration, FieldGetterDeclaration, FieldSetterDeclaration, ForStatementVariableDeclaration, FunctionBlockLiteral, FunctionBlockParent, FunctionLiteral, Identifier, IdentifierParent, IndexedElementGetterDeclaration, IndexedElementSetterDeclaration, Keyword, LocalStructuredTypeDeclaration, LocalVariableDeclaration, MethodDeclaration, NestedFunctionDeclaration, Node, PackageAliasTypeDeclaration, PackageFunctionDeclaration, PackageMemberDeclaration, PackageStatement, PackageTypeDeclaration, PackageVariableDeclaration, PackageVariableGetterDeclaration, PackageVariableSetterDeclaration, ParameterDeclaration, Statement, StaticDeclaration, StaticFieldDeclaration, StaticFieldGetterDeclaration, StaticFieldSetterDeclaration, StaticMethodDeclaration, TagListParent, TypeMemberDeclaration, TypeParameterDeclaration, TypeSpecifier, VariantValueDeclaration } from './Nodes.js';
+import { Token } from './Token.js';
+import { TokenKind } from './TokenKind.js';
+export declare function isIdentifier(node: Node): node is Identifier;
+export declare function isToken<T extends TokenKind>(node: Node, kind?: T): node is Token<T>;
+export declare function isKeyword<T extends KeywordKind>(node: Node, kind?: T): node is Keyword<T>;
+export declare function isTypeMemberDeclaration(node: Node): node is TypeMemberDeclaration;
+export declare function isPackageMemberDeclaration(node: Node): node is PackageMemberDeclaration;
+export declare function isExpression(node: Node): node is Expression;
+export declare function isNullLiteral(node: Node): boolean;
+export declare function isStatement(node: Node): node is Statement;
+export declare function isTypeSpecifier(node: Node): node is TypeSpecifier;
+export type TypeDeclaration = LocalStructuredTypeDeclaration | LocalFunctionTypeDeclaration | PackageAliasTypeDeclaration | TypeParameterDeclaration | PackageTypeDeclaration;
+export declare function isTypeDeclaration(node: Node): node is TypeDeclaration;
+export type TypeOrExtensionDeclaration = TypeDeclaration;
+export declare function isTypeOrExtensionDeclaration(node: Node): node is TypeOrExtensionDeclaration;
+export type TypeWithMembersDeclaration = LocalStructuredTypeDeclaration | PackageAliasTypeDeclaration | PackageTypeDeclaration;
+export declare function isTypeWithMembersDeclaration(node: Node): node is TypeWithMembersDeclaration;
+export type TypeWithMembersOrExtensionDeclaration = TypeWithMembersDeclaration;
+export declare function isTypeWithMembersOrExtensionDeclaration(node: Node): node is TypeWithMembersOrExtensionDeclaration;
+export type NamedTypeDeclaration = TypeDeclaration & IdentifierParent;
+export declare function isNamedTypeDeclaration(node: Node): node is NamedTypeDeclaration;
+export declare function isPackageTypeDeclaration(node: Node): node is TypeDeclaration & PackageMemberDeclaration;
+export type FunctionDeclaration = PackageFunctionDeclaration | NestedFunctionDeclaration | MethodDeclaration | StaticMethodDeclaration;
+export declare function isFunctionDeclaration(node: Node): node is FunctionDeclaration;
+export type VariableAccessorDeclaration = FieldGetterDeclaration | FieldSetterDeclaration | StaticFieldGetterDeclaration | StaticFieldSetterDeclaration | PackageVariableGetterDeclaration | PackageVariableSetterDeclaration;
+export declare function isVariableAccessorDeclaration(node: Node): node is VariableAccessorDeclaration;
+export type VariableDeclaration = ForStatementVariableDeclaration | PackageVariableDeclaration | LocalVariableDeclaration | ParameterDeclaration | FieldDeclaration | VariantValueDeclaration | FieldDeclaration | StaticFieldDeclaration;
+export declare function isVariableDeclaration(node: Node): node is VariableDeclaration;
+export type SubprogramDeclarationOrLiteral = FunctionBlockParent;
+export declare function isSubprogramDeclarationOrLiteral(node: Node): node is SubprogramDeclarationOrLiteral;
+export type RegularOrBlockFunctionLiteral = FunctionLiteral | FunctionBlockLiteral;
+export declare function isRegularOrBlockFunctionLiteral(node: Node): node is RegularOrBlockFunctionLiteral;
+export declare function isLocalStructuredTypeDeclaration(node: Node): node is LocalStructuredTypeDeclaration;
+export declare function isStaticDeclaration(node: Node): node is StaticDeclaration;
+export type GetterDeclaration = PackageVariableGetterDeclaration | FieldGetterDeclaration | IndexedElementGetterDeclaration | StaticFieldGetterDeclaration;
+export type SetterDeclaration = PackageVariableSetterDeclaration | FieldSetterDeclaration | IndexedElementSetterDeclaration | StaticFieldSetterDeclaration;
+export type PackageVariableAccessorDeclaration = PackageVariableGetterDeclaration | PackageVariableSetterDeclaration;
+export type PackageVariableOrAccessorDeclaration = PackageVariableDeclaration | PackageVariableGetterDeclaration | PackageVariableSetterDeclaration;
+export type FieldAccessorDeclaration = FieldGetterDeclaration | FieldSetterDeclaration;
+export type FieldOrAccessorDeclaration = FieldDeclaration | FieldGetterDeclaration | FieldSetterDeclaration;
+export type StaticFieldAccessorDeclaration = StaticFieldGetterDeclaration | StaticFieldSetterDeclaration;
+export type StaticFieldOrAccessorDeclaration = StaticFieldDeclaration | StaticFieldGetterDeclaration | StaticFieldSetterDeclaration;
+export type IndexedElementAccessorDeclaration = IndexedElementGetterDeclaration | IndexedElementSetterDeclaration;
+export type NodeWithTags = Exclude<TagListParent, PackageStatement>;

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

@@ -0,0 +1,7 @@
+import { Expression, FunctionBlock, GenericSpecializationExpression, PackageTypeDeclaration, TypeSingleMemberDeclaration } from './Nodes.js';
+import { TypeWithMembersOrExtensionDeclaration } from './Types.js';
+export declare function getParentGenericSpecializationExpression(expression: Expression): GenericSpecializationExpression | undefined;
+export declare function getGenericSpecializationExpressionOfCallee(callee: Expression): GenericSpecializationExpression | undefined;
+export declare function hasAnyVariantValueDeclaration(node: PackageTypeDeclaration): boolean;
+export declare function getMemberDeclarationsOfTypeOrExtension(node: TypeWithMembersOrExtensionDeclaration): Iterable<TypeSingleMemberDeclaration>;
+export declare function isEmptyFunctionBlock(node: FunctionBlock | undefined): boolean;

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

@@ -1,5 +1,14 @@
 export * from './BaseNode.js';
+export * from './KeywordFlags.js';
+export * from './KeywordKind.js';
 export * from './NodeKind.js';
 export * from './Nodes.js';
+export * from './OperatorKind.js';
+export * from './SyntaxToCode.js';
+export * from './Token.js';
+export * from './TokenFlags.js';
 export * from './TokenKind.js';
+export * from './TreeTraversal.js';
 export * from './TriviaKind.js';
+export * from './Types.js';
+export * from './Utils.js';

package/build/types/types/StandardTypes.d.ts

@@ -24,6 +24,7 @@ export declare class StandardTypes {
     private task_;
     private error_;
     private func_;
+    private typeDesignator_;
     constructor(analyzer: Analyzer, wellKnownDeclarations: WellKnownDeclarations);
     get object(): StructuredType;
     get structure(): StructuredType;
@@ -44,4 +45,5 @@ export declare class StandardTypes {
     get task(): StructuredType;
     get error(): StructuredType;
     get func(): StructuredType;
+    get typeDesignator(): StructuredType;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artel/artc",
-  "version": "0.6.26039",
+  "version": "0.9.26001",
   "description": "Артель Компилятор | Artel Compiler",
   "author": "Nezaboodka Team <contact@nezaboodka.com>",
   "license": "Apache-2.0",
@@ -44,7 +44,7 @@
     "@babel/types": "7.27.3",
     "@vscode/l10n": "0.0.18",
     "jsonc-parser": "3.3.1",
-    "reactronic": "^0.96.26027",
+    "reactronic": "^0.96.26029",
     "typescript": "5.9.3",
     "vscode-json-languageservice": "5.4.2",
     "vscode-languageserver": "9.0.1",