@artel/artc 0.6.25210 → 0.6.25211

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

@@ -234,6 +234,7 @@ export declare class Analyzer {
     checkBodyOfRedefinableAliasTypeMethod(node: tree.TypeMethodDeclaration, diagnostics?: DiagnosticAcceptor): {
         redefinableMethodOfOriginalType: TypeMethodEntity;
     } | undefined;
+    determineOperatorKind(name: Name, parameterCount: number, locale: PackageLocale): entities.OperatorKind | undefined;
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -276,7 +277,6 @@ declare class Type {
     private ofIndexedAccessExpression;
     private ofInvalidExpression;
     private ofIsExpression;
-    private ofUnobservableExpression;
     private ofNotExpression;
     private ofParenthesizedExpression;
     private ofPrefixUnaryExpression;
@@ -285,7 +285,6 @@ declare class Type {
     private ofDereferenceExpression;
     private ofWhenTernaryExpression;
     private ofTextTemplateLiteral;
-    private ofTransactionalExpression;
     private ofIdentifierExpression;
     private ofTokenExpression;
     private ofKeywordExpression;

package/build/types/common/Debug.d.ts

@@ -8,3 +8,6 @@ export declare class Debug {
     static cast<T>(_value: unknown): asserts _value is T;
     static internalError(message?: string): never;
 }
+export type AreEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+export type IsTrue<_T extends true> = never;
+export type IsNever<_T extends never> = never;

package/build/types/common/Logger.d.ts

@@ -1,4 +1,4 @@
-import { EmitterError } from '../emitter/error-boundary.js';
+import { EmitterError } from '../emitter/ErrorBoundary.js';
 import { Node } from '../tree/index.js';
 export declare class Logger {
     static info(message: string): void;

package/build/types/emitter/Transformer.d.ts

@@ -1,7 +1,7 @@
 import { DebugStack } from './DebugStack.js';
 import { blockStatementTransformationResult, expressionTransformationResult, packageMemberDeclarationTransformationResult, simpleTransformationResult, statementTransformationResult, typeAccessExpressionTransformationResult, typeMemberDeclarationTransformationResult } from './Internal.js';
-import { TransformationContinuationAction } from './TransformationContinuationAction.js';
 import * as ir from './ir/index.js';
+import { TransformationContinuationAction } from './TransformationContinuationAction.js';
 export declare class Transformer {
     readonly config: TransformationConfig;
     protected readonly _debugStack: DebugStack;

package/build/types/emitter/ir/Nodes.d.ts

@@ -973,19 +973,18 @@ export declare const enum NodeKind {
     JsFunctionLiteral = 85,
     JsTypeOfExpression = 86,
     JsInstanceOfExpression = 87,
-    TransactionalExpression = 88,
-    UnobservableExpression = 89,
-    JsIdentifierExpression = 90,
-    DereferenceExpression = 91,
-    BaseExpression = 92,
-    OwnConstructorCallExpression = 93,
-    TypeDereferencedVariableGetterDeclaration = 94,
-    TypeDereferencedVariableSetterDeclaration = 95,
-    JsNamespaceDestructuringStatement = 96
+    JsIdentifierExpression = 88,
+    DereferenceExpression = 89,
+    BaseExpression = 90,
+    OwnConstructorCallExpression = 91,
+    TypeDereferencedVariableGetterDeclaration = 92,
+    TypeDereferencedVariableSetterDeclaration = 93,
+    JsNamespaceDestructuringStatement = 94
 }
 export declare const enum PrefixUnaryExpressionOperator {
     Plus = 0,
-    Minus = 1
+    Minus = 1,
+    BitwiseNot = 2
 }
 export declare const enum BinaryExpressionOperator {
     Add = 0,
@@ -1003,5 +1002,8 @@ export declare const enum BinaryExpressionOperator {
     And = 12,
     Xor = 13,
     QuestionQuestion = 14,
-    Modulo = 15
+    Modulo = 15,
+    BitwiseAnd = 16,
+    BitwiseOr = 17,
+    BitwiseXor = 18
 }

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

@@ -30,7 +30,10 @@ export declare enum BinaryOperatorKind {
     GreaterThanEquals = 11,
     Or = 12,
     And = 13,
-    Xor = 14
+    Xor = 14,
+    BitwiseAnd = 15,
+    BitwiseOr = 16,
+    BitwiseXor = 17
 }
 export declare class IntrinsicBinaryOperatorEntity implements BinaryOperatorEntity {
     private readonly _operatorKind;

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

@@ -1,13 +1,13 @@
 import { SourceFile } from '../project/index.js';
 import { PackageEntity } from './PackageEntity.js';
 import { TypeEntity } from './index.js';
-export type EntityHidingLevel = EntityHidingLevel_type | EntityHidingLevel_typeFamily | EntityHidingLevel_file | EntityHidingLevel_package;
+export type EntityHidingLevel = EntityHidingLevel_type | EntityHidingLevel_typeHierarchy | EntityHidingLevel_file | EntityHidingLevel_package;
 export declare class EntityHidingLevel_type {
     readonly typeEntity: TypeEntity;
     readonly kind = "type";
     constructor(typeEntity: TypeEntity);
 }
-export declare class EntityHidingLevel_typeFamily {
+export declare class EntityHidingLevel_typeHierarchy {
     readonly baseTypeEntity: TypeEntity;
     readonly kind = "type-hierarchy";
     constructor(baseTypeEntity: TypeEntity);

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

@@ -0,0 +1,45 @@
+import { Analyzer } from '../analysis/index.js';
+import { Tag } from '../analysis/Tags.js';
+import { Name } from '../common/index.js';
+import { TypeMethodDeclaration } from '../tree/index.js';
+import * as types from '../types/index.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, OperatorKind, ParameterVariableEntity, TypeMemberEntityContainer } from './index.js';
+export interface OperatorEntity {
+    readonly kind: EntityKind.Operator;
+    getOperatorKind(): OperatorKind;
+    getName(): Name;
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getResultType(): types.Type;
+    getDefinition(): OperatorDefinition;
+    getContainer(): TypeMemberEntityContainer;
+    isStatic(): boolean;
+    isRedefinable(): boolean;
+    isRedefined(): boolean;
+    isAbstract(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+}
+export type OperatorDefinition = {
+    kind: DefinitionKind.Source;
+    node: TypeMethodDeclaration;
+};
+export declare class OperatorDeclarationEntity implements OperatorEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _operatorKind;
+    readonly kind = EntityKind.Operator;
+    private readonly _valueParameters;
+    constructor(_analyzer: Analyzer, _node: TypeMethodDeclaration, _operatorKind: OperatorKind);
+    getOperatorKind(): OperatorKind;
+    getName(): Name;
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getResultType(): types.Type;
+    getDefinition(): OperatorDefinition;
+    getContainer(): TypeMemberEntityContainer;
+    isStatic(): boolean;
+    isRedefinable(): boolean;
+    isRedefined(): boolean;
+    isAbstract(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+}

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

@@ -0,0 +1,63 @@
+import { PackageLocale } from '../common/PackageLocale.js';
+export declare enum OperatorKind {
+    UnaryPlus = 0,
+    UnaryMinus = 1,
+    Not = 2,
+    ImplicitConversion = 3,
+    Add = 4,
+    Subtract = 5,
+    Multiply = 6,
+    Divide = 7,
+    IntegerDivide = 8,
+    Modulo = 9,
+    LessThan = 10,
+    GreaterThan = 11,
+    LessThanEquals = 12,
+    GreaterThanEquals = 13,
+    Or = 14,
+    And = 15,
+    Xor = 16,
+    AddEquals = 17,
+    SubtractEquals = 18,
+    MultiplyEquals = 19,
+    DivideEquals = 20,
+    IntegerDivideEquals = 21,
+    ModuloEquals = 22
+}
+/**
+ * Виды операторов, задаваемых токенами (`+`, `-`, `*=` и др.).
+ */
+export type KindOfOperatorDefinedByToken = OperatorKind.UnaryPlus | OperatorKind.UnaryMinus | OperatorKind.ImplicitConversion | OperatorKind.Add | OperatorKind.Subtract | OperatorKind.Multiply | OperatorKind.Divide | OperatorKind.IntegerDivide | OperatorKind.Modulo | OperatorKind.LessThan | OperatorKind.GreaterThan | OperatorKind.LessThanEquals | OperatorKind.GreaterThanEquals | OperatorKind.AddEquals | OperatorKind.SubtractEquals | OperatorKind.MultiplyEquals | OperatorKind.DivideEquals | OperatorKind.IntegerDivideEquals | OperatorKind.ModuloEquals;
+/**
+ * Виды операторов, задаваемых ключевыми словами (`и`, `или`, `не` и др.)
+ */
+export type KindOfOperatorDefinedByKeyword = OperatorKind.Not | OperatorKind.Or | OperatorKind.And | OperatorKind.Xor;
+/**
+ * Виды одноместных операторов. Объявление одноместного оператора не должно содержать ни одного параметра.
+ */
+export type UnaryOperatorKind = OperatorKind.UnaryPlus | OperatorKind.UnaryMinus | OperatorKind.Not | OperatorKind.ImplicitConversion;
+/**
+* Виды двухместных операторов, в том числе составных. Объявление двухместного оператора должно содержать один параметр.
+*/
+export type BinaryOperatorKind = OperatorKind.Add | OperatorKind.Subtract | OperatorKind.Multiply | OperatorKind.Divide | OperatorKind.IntegerDivide | OperatorKind.Modulo | OperatorKind.LessThan | OperatorKind.GreaterThan | OperatorKind.LessThanEquals | OperatorKind.GreaterThanEquals | OperatorKind.Or | OperatorKind.And | OperatorKind.Xor | OperatorKind.AddEquals | OperatorKind.SubtractEquals | OperatorKind.MultiplyEquals | OperatorKind.DivideEquals | OperatorKind.IntegerDivideEquals | OperatorKind.ModuloEquals;
+export type KindOfUnaryOperatorDefinedByToken = UnaryOperatorKind & KindOfOperatorDefinedByToken;
+export type KindOfUnaryOperatorDefinedByKeyword = UnaryOperatorKind & KindOfOperatorDefinedByKeyword;
+export type KindOfBinaryOperatorDefinedByToken = BinaryOperatorKind & KindOfOperatorDefinedByToken;
+export type KindOfBinaryOperatorDefinedByKeyword = BinaryOperatorKind & KindOfOperatorDefinedByKeyword;
+export declare const unaryOperatorKindByTokenText: Record<string, KindOfUnaryOperatorDefinedByToken | undefined>;
+export declare const binaryOperatorKindByTokenText: Record<string, KindOfBinaryOperatorDefinedByToken | undefined>;
+export declare const operatorKindByRussianKeywordText: {
+    readonly не: OperatorKind.Not;
+    readonly или: OperatorKind.Or;
+    readonly и: OperatorKind.And;
+    readonly искл: OperatorKind.Xor;
+};
+export declare const operatorKindByEnglishKeywordText: {
+    readonly not: OperatorKind.Not;
+    readonly or: OperatorKind.Or;
+    readonly and: OperatorKind.And;
+    readonly xor: OperatorKind.Xor;
+};
+export declare const operatorKindByKeywordTextByPackageLocale: {
+    [T in PackageLocale]: Record<string, KindOfOperatorDefinedByKeyword>;
+};

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

@@ -17,7 +17,8 @@ export type UnaryOperatorDefinition = {
 export declare enum UnaryOperatorKind {
     Plus = 0,
     Minus = 1,
-    Not = 2
+    Not = 2,
+    BitwiseNot = 3
 }
 export declare class IntrinsicUnaryOperatorEntity implements UnaryOperatorEntity {
     readonly _operatorKind: UnaryOperatorKind;

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

@@ -17,8 +17,6 @@ export interface TypeVariableEntity extends IVariableEntity {
     isRedefinable(): boolean;
     isRedefined(): boolean;
     isAbstract(): boolean;
-    isConsistent(): boolean;
-    isObservable(): boolean;
 }
 export interface ParameterVariableEntity extends IVariableEntity {
     readonly subkind: 'parameter';
@@ -157,8 +155,6 @@ export declare class TypeVariableDeclarationEntity implements TypeVariableEntity
     isRedefinable(): boolean;
     isRedefined(): boolean;
     isAbstract(): boolean;
-    isConsistent(): boolean;
-    isObservable(): boolean;
 }
 export declare class ComputedTypeVariableDeclarationEntity implements TypeVariableEntity {
     readonly kind = EntityKind.Variable;
@@ -177,8 +173,6 @@ export declare class ComputedTypeVariableDeclarationEntity implements TypeVariab
     isRedefinable(): boolean;
     isRedefined(): boolean;
     isAbstract(): boolean;
-    isConsistent(): boolean;
-    isObservable(): boolean;
     getDefinition(): VariableEntityDefinition;
     getGetter(): GetterEntity | undefined;
     getSetter(): SetterEntity | undefined;
@@ -351,15 +345,13 @@ export declare class IntrinsicTypeVariableEntity implements TypeVariableEntity {
     private readonly _isRedefinable;
     private readonly _isRedefined;
     private readonly _isAbstract;
-    private readonly _isConsistent;
-    private readonly _isObservable;
     private readonly _isSpecial;
     private readonly _isHidden;
     private readonly _getter;
     private readonly _setter;
     readonly kind = EntityKind.Variable;
     readonly subkind = "type";
-    constructor(_name: Name, _type: types.Type, _container: TypeMemberEntityContainer, _isStatic: boolean, _isRedefinable: boolean, _isRedefined: boolean, _isAbstract: boolean, _isConsistent: boolean, _isObservable: boolean, _isSpecial: SpecialVariableEntityInfo | undefined, _isHidden: EntityHidingLevel | undefined, _getter: GetterEntity | undefined, _setter: SetterEntity | undefined);
+    constructor(_name: Name, _type: types.Type, _container: TypeMemberEntityContainer, _isStatic: boolean, _isRedefinable: boolean, _isRedefined: boolean, _isAbstract: boolean, _isSpecial: SpecialVariableEntityInfo | undefined, _isHidden: EntityHidingLevel | undefined, _getter: GetterEntity | undefined, _setter: SetterEntity | undefined);
     getName(): Name;
     getType(): types.Type;
     getDefinition(): VariableEntityDefinition;
@@ -374,8 +366,6 @@ export declare class IntrinsicTypeVariableEntity implements TypeVariableEntity {
     isRedefinable(): boolean;
     isRedefined(): boolean;
     isAbstract(): boolean;
-    isConsistent(): boolean;
-    isObservable(): boolean;
 }
 export declare class IntrinsicParameterVariableEntity implements ParameterVariableEntity {
     private readonly _name;

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

@@ -1,9 +1,9 @@
 import { AliasTypeEntity } from './AliasTypeEntity.js';
 import { ConstructorEntity } from './ConstructorEntity.js';
+import { DereferenceOperatorEntity } from './DereferenceOperatorEntity.js';
 import { DestructorEntity } from './DestructorEntity.js';
 import { GetterEntity } from './GetterEntity.js';
 import { IndexerEntity } from './IndexerEntity.js';
-import { DereferenceOperatorEntity } from './DereferenceOperatorEntity.js';
 import { MethodEntity, PackageMethodEntity, TypeMethodEntity } from './MethodEntity.js';
 import { AnonymousMethodTypeEntity, MethodTypeEntity, PackageMethodTypeEntity } from './MethodTypeEntity.js';
 import { PackageAliasEntity } from './PackageAliasEntity.js';
@@ -20,14 +20,16 @@ import { BinaryOperatorEntity } from './index.js';
 export * from './AliasTypeEntity.js';
 export * from './BinaryOperatorEntity.js';
 export * from './ConstructorEntity.js';
+export * from './DereferenceOperatorEntity.js';
 export * from './DestructorEntity.js';
 export * from './EntityHiding.js';
 export * from './EntityNaming.js';
 export * from './GetterEntity.js';
 export * from './IndexerEntity.js';
-export * from './DereferenceOperatorEntity.js';
 export * from './MethodEntity.js';
 export * from './MethodTypeEntity.js';
+export * from './OperatorEntity.js';
+export { binaryOperatorKindByTokenText, OperatorKind, operatorKindByKeywordTextByPackageLocale, unaryOperatorKindByTokenText } from './OperatorKind.js';
 export * from './PackageAliasEntity.js';
 export * from './PackageEntity.js';
 export * from './SetterEntity.js';
@@ -63,8 +65,9 @@ export declare const enum EntityKind {
     AliasType = 14,
     UnaryOperator = 15,
     BinaryOperator = 16,
-    Package = 17,
-    TypeExtension = 18
+    Operator = 17,
+    Package = 18,
+    TypeExtension = 19
 }
 export type Entity = PackageEntity | VariableEntity | VariantEntity | VariantTypeEntity | GetterEntity | SetterEntity | MethodEntity | TypeParameterEntity | IndexerEntity | DereferenceOperatorEntity | ConstructorEntity | DestructorEntity | MethodTypeEntity | StructuredTypeEntity | PackageAliasEntity | AliasTypeEntity | TypeExtensionEntity | UnaryOperatorEntity | BinaryOperatorEntity;
 export type TypeEntity = MethodTypeEntity | StructuredTypeEntity | TypeParameterEntity | VariantTypeEntity | AliasTypeEntity;

package/build/types/parser/OperatorDictionary.d.ts

@@ -0,0 +1,11 @@
+import { OperatorKind } from '../tree/OperatorKind.js';
+/**
+ * Виды операторов, задаваемых токенами (`+`, `-`, `*=` и др.).
+ */
+export type KindOfOperatorDefinedByToken = OperatorKind.Plus | OperatorKind.Minus | OperatorKind.ImplicitConversion | OperatorKind.Multiply | OperatorKind.Divide | OperatorKind.IntegerDivide | OperatorKind.Modulo | OperatorKind.LessThan | OperatorKind.GreaterThan | OperatorKind.LessThanEquals | OperatorKind.GreaterThanEquals | OperatorKind.AddEquals | OperatorKind.SubtractEquals | OperatorKind.MultiplyEquals | OperatorKind.DivideEquals | OperatorKind.IntegerDivideEquals | OperatorKind.ModuloEquals;
+/**
+ * Виды операторов, задаваемых ключевыми словами (`и`, `или`, `не` и др.)
+ */
+export type KindOfOperatorDefinedByKeyword = OperatorKind.Not | OperatorKind.Or | OperatorKind.And | OperatorKind.Xor;
+export declare const operatorKindByTokenText: Record<string, KindOfOperatorDefinedByToken | undefined>;
+export declare const operatorKindByKeywordKind: Record<number, KindOfOperatorDefinedByKeyword | undefined>;

package/build/types/services/DisplayService.d.ts

@@ -741,8 +741,8 @@ declare class TypeMemberContainer {
 }
 export declare class MethodDeclarationDisplayParts {
     readonly asyncKeywordWithWhitespace: string;
-    readonly operationKeyword: string;
-    readonly whitespaceAfterOperationKeyword: string;
+    readonly functionKeyword: string;
+    readonly whitespaceAfterFunctionKeyword: string;
     readonly container: string;
     readonly name: string;
     readonly typeParametersStart: string;
@@ -755,7 +755,7 @@ export declare class MethodDeclarationDisplayParts {
     readonly valueParametersEnd: string;
     readonly returnTypeAnnotationColon: string;
     readonly returnType: string;
-    constructor(asyncKeywordWithWhitespace: string, operationKeyword: string, whitespaceAfterOperationKeyword: string, container: string, name: string, typeParametersStart: string, typeParameters: readonly string[], typeParameterSeparator: string, typeParametersEnd: string, valueParametersStart: string, valueParameters: readonly ValueParameterDeclarationDisplayParts[], valueParameterSeparator: string, valueParametersEnd: string, returnTypeAnnotationColon: string, returnType: string);
+    constructor(asyncKeywordWithWhitespace: string, functionKeyword: string, whitespaceAfterFunctionKeyword: string, container: string, name: string, typeParametersStart: string, typeParameters: readonly string[], typeParameterSeparator: string, typeParametersEnd: string, valueParametersStart: string, valueParameters: readonly ValueParameterDeclarationDisplayParts[], valueParameterSeparator: string, valueParametersEnd: string, returnTypeAnnotationColon: string, returnType: string);
     toString(): string;
 }
 export declare class ValueParameterDeclarationDisplayParts {
@@ -817,14 +817,14 @@ export declare class NamedTypeDisplayParts {
 }
 export declare class MethodTypeBodyDisplayParts {
     readonly asyncKeywordWithWhitespace: string;
-    readonly operationKeyword: string;
+    readonly functionKeyword: string;
     readonly valueParametersStart: string;
     readonly valueParameters: readonly ValueParameterDeclarationDisplayParts[];
     readonly valueParameterSeparator: string;
     readonly valueParametersEnd: string;
     readonly returnTypeAnnotationColon: string;
     readonly returnType: string;
-    constructor(asyncKeywordWithWhitespace: string, operationKeyword: string, valueParametersStart: string, valueParameters: readonly ValueParameterDeclarationDisplayParts[], valueParameterSeparator: string, valueParametersEnd: string, returnTypeAnnotationColon: string, returnType: string);
+    constructor(asyncKeywordWithWhitespace: string, functionKeyword: string, valueParametersStart: string, valueParameters: readonly ValueParameterDeclarationDisplayParts[], valueParameterSeparator: string, valueParametersEnd: string, returnTypeAnnotationColon: string, returnType: string);
     toString(): string;
 }
 export {};

package/build/types/tree/KeywordKind.d.ts

@@ -10,7 +10,7 @@ export declare enum KeywordKind {
     From = 8,
     Else = 9,
     ElseIf = 10,
-    Operation = 11,
+    Function = 11,
     If = 12,
     Is = 13,
     Return = 14,
@@ -34,32 +34,28 @@ export declare enum KeywordKind {
     For = 32,
     Const = 33,
     Hidden = 34,
-    Observable = 35,
-    Consistent = 36,
-    Abstract = 37,
-    Redefinable = 38,
-    Redefined = 39,
-    Transactional = 40,
-    Unobservable = 41,
-    Async = 42,
-    Static = 43,
-    As = 44,
-    Not = 45,
-    Switch = 46,
-    Case = 47,
-    Await = 48,
-    Dispose = 49,
-    Destruction = 50,
-    InHierarchy = 51,
-    InFile = 52,
-    InPackage = 53,
-    InType = 54,
-    Yes = 55,
-    No = 56,
-    Reference = 57,
-    Translations = 58,
-    Base = 59,
-    None = 60,
-    Get = 61,
-    Set = 62
+    Abstract = 35,
+    Redefinable = 36,
+    Redefined = 37,
+    Async = 38,
+    Static = 39,
+    As = 40,
+    Not = 41,
+    Switch = 42,
+    Case = 43,
+    Await = 44,
+    Dispose = 45,
+    Destruction = 46,
+    InHierarchy = 47,
+    InFile = 48,
+    InPackage = 49,
+    InType = 50,
+    Yes = 51,
+    No = 52,
+    Reference = 53,
+    Translations = 54,
+    Base = 55,
+    None = 56,
+    Get = 57,
+    Set = 58
 }

package/build/types/tree/NodeKind.d.ts

@@ -73,91 +73,87 @@ export declare enum NodeKind {
     IndexedAccessExpression = 71,
     InvalidExpression = 72,
     IsExpression = 73,
-    UnobservableExpression = 74,
-    NotExpression = 75,
-    MethodLiteral = 76,
-    ParenthesizedExpression = 77,
-    WhenTernaryExpression = 78,
-    PrefixUnaryExpression = 79,
-    PropertyAccessExpression = 80,
-    ReferenceExpression = 81,
-    DereferenceExpression = 82,
-    TextTemplateLiteral = 83,
-    TextTemplateSpanList = 84,
-    TextTemplateSpan = 85,
-    TokenExpression = 86,
-    KeywordExpression = 87,
-    ObjectExpression = 88,
-    BaseExpression = 89,
-    IdentifierExpression = 90,
-    TransactionalExpression = 91,
-    GenericSpecializationExpression = 92,
-    DefaultMatchExpression = 93,
-    AssignmentStatement = 94,
-    StatementList = 95,
-    StatementBlock = 96,
-    BreakLoopStatement = 97,
-    ContinueLoopStatement = 98,
-    DisposeStatement = 99,
-    RunStatementClauseList = 100,
-    RunStatement = 101,
-    OnErrorClause = 102,
-    ErrorVariableDeclaration = 103,
-    FinallyClause = 104,
-    EmptyStatement = 105,
-    ErrorStatement = 106,
-    ExpressionStatement = 107,
-    EnumerationVariableList = 108,
-    ForStatement = 109,
-    IfStatement = 110,
-    ElseIfClauseList = 111,
-    ElseIfClause = 112,
-    InvalidStatement = 113,
-    NestedMethodDeclarationStatement = 114,
-    LocalVariableDeclarationStatement = 115,
-    UnobservableStatement = 116,
-    LoopStatement = 117,
-    ReturnStatement = 118,
-    CaseClauseList = 119,
-    SwitchStatement = 120,
-    MatchExpressionList = 121,
-    SwitchStatementCaseClause = 122,
-    TransactionalStatement = 123,
-    WhileStatement = 124,
-    YieldStatement = 125,
-    TranslationParameterList = 126,
-    TranslationParameterClause = 127,
-    ConstructorTranslation = 128,
-    IndexerTranslationParameterClause = 129,
-    IndexerTranslation = 130,
-    TranslationTypeParameterList = 131,
-    TranslationTypeParameterClause = 132,
-    PackageMethodTranslation = 133,
-    TypeMethodTranslation = 134,
-    MethodTypeTranslation = 135,
-    PackageImportTranslation = 136,
-    QualifiedName = 137,
-    PackageVariableTranslation = 138,
-    TypeVariableOrVariantTranslation = 139,
-    TypeMemberTranslationList = 140,
-    TypeTranslation = 141,
-    TextLiteralTranslation = 142,
-    TextTemplateLiteralTranslation = 143,
-    VariantDeclaration = 144,
-    TypeParameterDeclaration = 145,
-    ParameterDeclaration = 146,
-    CallArgument = 147,
-    TagList = 148,
-    Tag = 149,
-    ModifierList = 150,
-    Modifier = 151,
-    ParameterClause = 152,
-    ParameterList = 153,
-    SetterParameterClause = 154,
-    SetterParameterDeclaration = 155,
-    TypeArgumentClause = 156,
-    TypeArgumentList = 157,
-    TypeParameterClause = 158,
-    TypeParameterList = 159,
-    TypeAnnotation = 160
+    NotExpression = 74,
+    MethodLiteral = 75,
+    ParenthesizedExpression = 76,
+    WhenTernaryExpression = 77,
+    PrefixUnaryExpression = 78,
+    PropertyAccessExpression = 79,
+    ReferenceExpression = 80,
+    DereferenceExpression = 81,
+    TextTemplateLiteral = 82,
+    TextTemplateSpanList = 83,
+    TextTemplateSpan = 84,
+    TokenExpression = 85,
+    KeywordExpression = 86,
+    ObjectExpression = 87,
+    BaseExpression = 88,
+    IdentifierExpression = 89,
+    GenericSpecializationExpression = 90,
+    DefaultMatchExpression = 91,
+    AssignmentStatement = 92,
+    StatementList = 93,
+    StatementBlock = 94,
+    BreakLoopStatement = 95,
+    ContinueLoopStatement = 96,
+    DisposeStatement = 97,
+    RunStatementClauseList = 98,
+    RunStatement = 99,
+    OnErrorClause = 100,
+    ErrorVariableDeclaration = 101,
+    FinallyClause = 102,
+    EmptyStatement = 103,
+    ErrorStatement = 104,
+    ExpressionStatement = 105,
+    EnumerationVariableList = 106,
+    ForStatement = 107,
+    IfStatement = 108,
+    ElseIfClauseList = 109,
+    ElseIfClause = 110,
+    InvalidStatement = 111,
+    NestedMethodDeclarationStatement = 112,
+    LocalVariableDeclarationStatement = 113,
+    LoopStatement = 114,
+    ReturnStatement = 115,
+    CaseClauseList = 116,
+    SwitchStatement = 117,
+    MatchExpressionList = 118,
+    SwitchStatementCaseClause = 119,
+    WhileStatement = 120,
+    YieldStatement = 121,
+    TranslationParameterList = 122,
+    TranslationParameterClause = 123,
+    ConstructorTranslation = 124,
+    IndexerTranslationParameterClause = 125,
+    IndexerTranslation = 126,
+    TranslationTypeParameterList = 127,
+    TranslationTypeParameterClause = 128,
+    PackageMethodTranslation = 129,
+    TypeMethodTranslation = 130,
+    MethodTypeTranslation = 131,
+    PackageImportTranslation = 132,
+    QualifiedName = 133,
+    PackageVariableTranslation = 134,
+    TypeVariableOrVariantTranslation = 135,
+    TypeMemberTranslationList = 136,
+    TypeTranslation = 137,
+    TextLiteralTranslation = 138,
+    TextTemplateLiteralTranslation = 139,
+    VariantDeclaration = 140,
+    TypeParameterDeclaration = 141,
+    ParameterDeclaration = 142,
+    CallArgument = 143,
+    TagList = 144,
+    Tag = 145,
+    ModifierList = 146,
+    Modifier = 147,
+    ParameterClause = 148,
+    ParameterList = 149,
+    SetterParameterClause = 150,
+    SetterParameterDeclaration = 151,
+    TypeArgumentClause = 152,
+    TypeArgumentList = 153,
+    TypeParameterClause = 154,
+    TypeParameterList = 155,
+    TypeAnnotation = 156
 }

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

@@ -0,0 +1,23 @@
+export declare enum OperatorKind {
+    Plus = 0,// Одноместный или двухместный.
+    Minus = 1,// Одноместный или двухместный.
+    Not = 2,
+    ImplicitConversion = 3,
+    Multiply = 4,
+    Divide = 5,
+    IntegerDivide = 6,
+    Modulo = 7,
+    LessThan = 8,
+    GreaterThan = 9,
+    LessThanEquals = 10,
+    GreaterThanEquals = 11,
+    Or = 12,
+    And = 13,
+    Xor = 14,
+    AddEquals = 15,
+    SubtractEquals = 16,
+    MultiplyEquals = 17,
+    DivideEquals = 18,
+    IntegerDivideEquals = 19,
+    ModuloEquals = 20
+}