@artel/artc 0.6.25210 → 0.6.25212

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

@@ -31,32 +31,26 @@ export declare class AssertionExpression {
 }
 export declare class AssignmentExpression {
     left: LValueExpression;
-    operator: AssignmentOperator;
+    operatorKind: AssignmentOperatorKind;
     right: Expression;
+    operator: AccessedMethod | undefined;
     sourceLocation: SourceLocation | undefined;
     loweringOptions: AssignmentLoweringOptions;
     readonly kind = NodeKind.AssignmentExpression;
-    constructor(left: LValueExpression, operator: AssignmentOperator, right: Expression, sourceLocation: SourceLocation | undefined, loweringOptions?: AssignmentLoweringOptions);
+    constructor(left: LValueExpression, operatorKind: AssignmentOperatorKind, right: Expression, operator: AccessedMethod | undefined, sourceLocation: SourceLocation | undefined, loweringOptions?: AssignmentLoweringOptions);
     clone(): AssignmentExpression;
 }
 export declare class AssignmentStatement {
     left: LValueExpression;
-    operator: AssignmentOperator;
+    operatorKind: AssignmentOperatorKind;
     right: Expression;
+    operator: AccessedMethod | undefined;
     sourceLocation: SourceLocation | undefined;
     loweringOptions: AssignmentLoweringOptions;
     readonly kind = NodeKind.AssignmentStatement;
-    constructor(left: LValueExpression, operator: AssignmentOperator, right: Expression, sourceLocation: SourceLocation | undefined, loweringOptions?: AssignmentLoweringOptions);
+    constructor(left: LValueExpression, operatorKind: AssignmentOperatorKind, right: Expression, operator: AccessedMethod | undefined, sourceLocation: SourceLocation | undefined, loweringOptions?: AssignmentLoweringOptions);
     clone(): AssignmentStatement;
 }
-export declare const enum AssignmentOperator {
-    Equals = 0,
-    AddEquals = 1,
-    SubtractEquals = 2,
-    MultiplyEquals = 3,
-    DivideEquals = 4,
-    IntegerDivideEquals = 5
-}
 export declare class AssumptionExpression {
     expression: Expression;
     sourceLocation: SourceLocation | undefined;
@@ -81,12 +75,13 @@ export declare class BaseExpression {
 }
 export declare class BinaryExpression {
     left: Expression;
-    operator: BinaryExpressionOperator;
+    operatorKind: BinaryExpressionOperatorKind;
     right: Expression;
     type: Type;
+    operator: AccessedMethod | undefined;
     sourceLocation: SourceLocation | undefined;
     readonly kind = NodeKind.BinaryExpression;
-    constructor(left: Expression, operator: BinaryExpressionOperator, right: Expression, type: Type, sourceLocation: SourceLocation | undefined);
+    constructor(left: Expression, operatorKind: BinaryExpressionOperatorKind, right: Expression, type: Type, operator: AccessedMethod | undefined, sourceLocation: SourceLocation | undefined);
     clone(): BinaryExpression;
 }
 export declare class BlockStatement {
@@ -256,9 +251,6 @@ export declare class IfStatement {
     constructor(condition: Expression, thenStatement: BlockStatement, elseStatement: BlockStatement | undefined, sourceLocation: SourceLocation | undefined);
     clone(): IfStatement;
 }
-export declare const enum ImplicitConversionKind {
-    TextTemplateToText = 0
-}
 export declare class IndexedAccessExpression {
     expression: Expression;
     isOptionalChaining: boolean;
@@ -490,9 +482,10 @@ export declare class NoneLiteral {
 }
 export declare class NotExpression {
     expression: Expression;
+    operator: AccessedMethod | undefined;
     sourceLocation: SourceLocation | undefined;
     readonly kind = NodeKind.NotExpression;
-    constructor(expression: Expression, sourceLocation: SourceLocation | undefined);
+    constructor(expression: Expression, operator: AccessedMethod | undefined, sourceLocation: SourceLocation | undefined);
     clone(): NotExpression;
 }
 export declare class NumericLiteral {
@@ -592,11 +585,12 @@ export declare class VariantDeclaration {
     clone(): VariantDeclaration;
 }
 export declare class PrefixUnaryExpression {
-    operator: PrefixUnaryExpressionOperator;
+    operatorKind: PrefixUnaryExpressionOperatorKind;
     expression: Expression;
+    operator: AccessedMethod | undefined;
     sourceLocation: SourceLocation | undefined;
     readonly kind = NodeKind.PrefixUnaryExpression;
-    constructor(operator: PrefixUnaryExpressionOperator, expression: Expression, sourceLocation: SourceLocation | undefined);
+    constructor(operatorKind: PrefixUnaryExpressionOperatorKind, expression: Expression, operator: AccessedMethod | undefined, sourceLocation: SourceLocation | undefined);
     clone(): PrefixUnaryExpression;
 }
 export declare class ReferenceExpression {
@@ -973,21 +967,28 @@ 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
-}
-export declare const enum PrefixUnaryExpressionOperator {
+    JsIdentifierExpression = 88,
+    DereferenceExpression = 89,
+    BaseExpression = 90,
+    OwnConstructorCallExpression = 91,
+    TypeDereferencedVariableGetterDeclaration = 92,
+    TypeDereferencedVariableSetterDeclaration = 93,
+    JsNamespaceDestructuringStatement = 94
+}
+export declare const enum AssignmentOperatorKind {
+    Equals = 0,
+    AddEquals = 1,
+    SubtractEquals = 2,
+    MultiplyEquals = 3,
+    DivideEquals = 4,
+    IntegerDivideEquals = 5
+}
+export declare const enum PrefixUnaryExpressionOperatorKind {
     Plus = 0,
-    Minus = 1
+    Minus = 1,
+    BitwiseNot = 2
 }
-export declare const enum BinaryExpressionOperator {
+export declare const enum BinaryExpressionOperatorKind {
     Add = 0,
     Subtract = 1,
     Multiply = 2,
@@ -1003,5 +1004,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/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,43 @@
+import { Analyzer } from '../analysis/index.js';
+import { Tag } from '../analysis/Tags.js';
+import * as tree 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;
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): 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: tree.OperatorDeclaration;
+};
+export declare class OperatorDeclarationEntity implements OperatorEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Operator;
+    private readonly _operatorKind;
+    private readonly _valueParameters;
+    constructor(_analyzer: Analyzer, _node: tree.OperatorDeclaration);
+    getOperatorKind(): OperatorKind;
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): OperatorDefinition;
+    getContainer(): TypeMemberEntityContainer;
+    isStatic(): boolean;
+    isRedefinable(): boolean;
+    isRedefined(): boolean;
+    isAbstract(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    private convertSyntaxOperatorKind;
+}

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

@@ -0,0 +1,56 @@
+import * as tree from '../tree/index.js';
+export declare enum OperatorKind {
+    UnaryPlus = 0,
+    UnaryMinus = 1,
+    Not = 2,
+    BitwiseNot = 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,
+    BitwiseAnd = 17,
+    BitwiseOr = 18,
+    BitwiseXor = 19
+}
+/**
+ * Виды операторов, задаваемых токенами (`+`, `-`, `*=` и др.).
+ */
+export type KindOfOperatorDefinedByToken = OperatorKind.BitwiseNot | OperatorKind.UnaryPlus | OperatorKind.UnaryMinus | OperatorKind.Add | OperatorKind.Subtract | OperatorKind.Multiply | OperatorKind.Divide | OperatorKind.IntegerDivide | OperatorKind.Modulo | OperatorKind.LessThan | OperatorKind.GreaterThan | OperatorKind.LessThanEquals | OperatorKind.GreaterThanEquals | OperatorKind.BitwiseAnd | OperatorKind.BitwiseOr | OperatorKind.BitwiseXor;
+export declare function isOperatorDefinedByToken(kind: OperatorKind): kind is KindOfOperatorDefinedByToken;
+/**
+ * Виды операторов, задаваемых ключевыми словами (`и`, `или`, `не` и др.)
+ */
+export type KindOfOperatorDefinedByKeyword = OperatorKind.Not | OperatorKind.Or | OperatorKind.And | OperatorKind.Xor;
+export declare function isOperatorDefinedByKeyword(kind: OperatorKind): kind is KindOfOperatorDefinedByKeyword;
+/**
+ * Виды одноместных операторов. Объявление одноместного оператора не должно содержать ни одного параметра.
+ */
+export type UnaryOperatorKind = OperatorKind.UnaryPlus | OperatorKind.UnaryMinus | OperatorKind.Not | OperatorKind.BitwiseNot;
+export declare function isUnaryOperator(kind: OperatorKind): kind is UnaryOperatorKind;
+/**
+* Виды двухместных операторов. Объявление двухместного оператора должно содержать один параметр.
+*/
+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.BitwiseAnd | OperatorKind.BitwiseOr | OperatorKind.BitwiseXor;
+export declare function isBinaryOperator(kind: OperatorKind): kind is BinaryOperatorKind;
+export type KindOfUnaryOperatorDefinedByToken = UnaryOperatorKind & KindOfOperatorDefinedByToken;
+export type KindOfUnaryOperatorDefinedByKeyword = UnaryOperatorKind & KindOfOperatorDefinedByKeyword;
+export type KindOfBinaryOperatorDefinedByToken = BinaryOperatorKind & KindOfOperatorDefinedByToken;
+export type KindOfBinaryOperatorDefinedByKeyword = BinaryOperatorKind & KindOfOperatorDefinedByKeyword;
+export declare const tokenTextByOperatorKind: {
+    [T in KindOfOperatorDefinedByToken]: string;
+};
+export declare const keywordKindByOperatorKind: {
+    [T in KindOfOperatorDefinedByKeyword]: tree.KeywordKind;
+};
+export declare const operatorKindsBySyntacticalOperatorKind: {
+    [T in tree.OperatorKind]: readonly OperatorKind[];
+};

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

@@ -5,7 +5,7 @@ import { AnonymousStructuredTypeDeclaration, PackageStructuredTypeDeclaration }
 import * as types from '../types/index.js';
 import { EntityNaming } from './EntityNaming.js';
 import { NamedTypeMemberEntity, OriginalTypeEntityMembers } from './TypeEntityMembers.js';
-import type { DereferenceOperatorEntity, PackageEntity } from './index.js';
+import type { DereferenceOperatorEntity, OperatorEntity, PackageEntity } from './index.js';
 import { ConstructorEntity, DefinitionKind, DestructorEntity, EntityHidingLevel, EntityKind, IndexerEntity, SubstitutionApplicationMode, TypeParameterEntity } from './index.js';
 export type StructuredTypeEntity = PackageStructuredTypeEntity | AnonymousStructuredTypeEntity;
 export interface PackageStructuredTypeEntity extends IStructuredTypeEntity {
@@ -188,12 +188,12 @@ export declare class UnfinishedIntrinsicPackageStructuredTypeEntity {
     private readonly _unfinishedValue;
     get unfinishedValue(): PackageStructuredTypeEntity;
     constructor(analyzer: Analyzer, name: Name, containingPackage: PackageEntity, typeParameters: readonly TypeParameterEntity[], isAspect: boolean, isRefObject: boolean, baseObjectType: types.StructuredType | undefined, baseAspectTypes: readonly types.StructuredType[], isHidden: EntityHidingLevel | undefined, substitutionApplicationMode: SubstitutionApplicationMode);
-    finish(ownNamedMembers: readonly NamedTypeMemberEntity[], ownConstructors: readonly ConstructorEntity[], ownDestructors: readonly DestructorEntity[], ownIndexers: readonly IndexerEntity[], ownDereferenceOperators: readonly DereferenceOperatorEntity[]): PackageStructuredTypeEntity;
+    finish(ownNamedMembers: readonly NamedTypeMemberEntity[], ownOperators: readonly OperatorEntity[], ownConstructors: readonly ConstructorEntity[], ownDestructors: readonly DestructorEntity[], ownIndexers: readonly IndexerEntity[], ownDereferenceOperators: readonly DereferenceOperatorEntity[]): PackageStructuredTypeEntity;
 }
 export declare class UnfinishedIntrinsicAnonymousStructuredTypeEntity {
     private readonly _unfinishedValue;
     get unfinishedValue(): AnonymousStructuredTypeEntity;
     constructor(analyzer: Analyzer, typeParameters: readonly TypeParameterEntity[], isAspect: boolean, isRefObject: boolean, baseObjectType: types.StructuredType | undefined, baseAspectTypes: readonly types.StructuredType[], isHidden: EntityHidingLevel | undefined, substitutionApplicationMode: SubstitutionApplicationMode, containingPackage: PackageEntity);
-    finish(ownNamedMembers: readonly NamedTypeMemberEntity[], ownConstructors: readonly ConstructorEntity[], ownDestructors: readonly DestructorEntity[], ownIndexers: readonly IndexerEntity[], ownDereferenceOperators: readonly DereferenceOperatorEntity[]): AnonymousStructuredTypeEntity;
+    finish(ownNamedMembers: readonly NamedTypeMemberEntity[], ownOperators: readonly OperatorEntity[], ownConstructors: readonly ConstructorEntity[], ownDestructors: readonly DestructorEntity[], ownIndexers: readonly IndexerEntity[], ownDereferenceOperators: readonly DereferenceOperatorEntity[]): AnonymousStructuredTypeEntity;
 }
 export {};

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

@@ -1,36 +1,31 @@
 import { Name } from '../common/index.js';
-import { BinaryOperatorEntity, BinaryOperatorKind } from './BinaryOperatorEntity.js';
 import { ConstructorEntity } from './ConstructorEntity.js';
+import { DereferenceOperatorEntity } from './DereferenceOperatorEntity.js';
 import { DestructorEntity } from './DestructorEntity.js';
 import { IndexerEntity } from './IndexerEntity.js';
 import { TypeMethodEntity } from './MethodEntity.js';
-import { DereferenceOperatorEntity } from './DereferenceOperatorEntity.js';
-import { UnaryOperatorEntity, UnaryOperatorKind } from './UnaryOperatorEntity.js';
+import { OperatorEntity } from './OperatorEntity.js';
+import { OperatorKind } from './OperatorKind.js';
 import { TypeVariableEntity } from './VariableEntity.js';
 export declare class OriginalTypeEntityMembers {
     private readonly _namedMembers;
+    private readonly _operators;
     private readonly _constructors;
     private readonly _destructors;
     private readonly _indexers;
     private readonly _referenceOperators;
-    private readonly _unaryOperators;
-    private readonly _binaryOperators;
     private readonly _membersByNameKey;
-    private readonly _unaryOperatorsByKind;
-    private readonly _binaryOperatorsByKind;
+    private readonly _operatorsByKind;
     private get membersByNameKey();
-    private get unaryOperatorByKind();
-    private get binaryOperatorByKind();
-    constructor(_namedMembers: readonly NamedTypeMemberEntity[], _constructors: readonly ConstructorEntity[], _destructors: readonly DestructorEntity[], _indexers: readonly IndexerEntity[], _referenceOperators: readonly DereferenceOperatorEntity[], _unaryOperators: readonly UnaryOperatorEntity[], _binaryOperators: readonly BinaryOperatorEntity[]);
+    private get operatorByKind();
+    constructor(_namedMembers: readonly NamedTypeMemberEntity[], _operators: readonly OperatorEntity[], _constructors: readonly ConstructorEntity[], _destructors: readonly DestructorEntity[], _indexers: readonly IndexerEntity[], _referenceOperators: readonly DereferenceOperatorEntity[]);
     getNamedMembers(): readonly NamedTypeMemberEntity[];
     getNamedMembersByName(name: Name): readonly NamedTypeMemberEntity[];
+    getOperators(): readonly OperatorEntity[];
+    getOperatorsByKind(kind: OperatorKind): readonly OperatorEntity[];
     getIndexers(): readonly IndexerEntity[];
     getDereferenceOperators(): readonly DereferenceOperatorEntity[];
     getConstructors(): readonly ConstructorEntity[];
     getDestructors(): readonly DestructorEntity[];
-    getUnaryOperators(): readonly UnaryOperatorEntity[];
-    getUnaryOperatorsByKind(kind: UnaryOperatorKind): readonly UnaryOperatorEntity[];
-    getBinaryOperators(): readonly BinaryOperatorEntity[];
-    getBinaryOperatorsByKind(kind: BinaryOperatorKind): readonly BinaryOperatorEntity[];
 }
 export type NamedTypeMemberEntity = TypeVariableEntity | TypeMethodEntity;

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

@@ -28,6 +28,5 @@ export declare class SourceTypeExtensionEntity implements TypeExtensionEntity {
     getDefinition(): TypeExtensionEntityDefinition;
     isHidden(): EntityHidingLevel | undefined;
     getTags(): readonly Tag[];
-    private enumerateOwnMembers;
 }
 export {};

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

@@ -3,7 +3,7 @@ import { Analyzer } from '../analysis/index.js';
 import { Lazy, Name } from '../common/index.js';
 import { EnumerationVariableDeclaration, ErrorVariableDeclaration, LocalVariableDeclaration, MethodLiteral, PackageVariableDeclaration, PackageVariableGetterDeclaration, PackageVariableSetterDeclaration, ParameterDeclaration, SetterParameterDeclaration, TypeVariableDeclaration, TypeVariableGetterDeclaration, TypeVariableSetterDeclaration } from '../tree/index.js';
 import * as types from '../types/index.js';
-import type { Entity, IndexerEntity, PackageEntity } from './index.js';
+import type { Entity, IndexerEntity, OperatorEntity, PackageEntity } from './index.js';
 import { Entity as ActualEntity, ConstructorEntity, DefinitionKind, DestructorEntity, EntityHidingLevel, EntityKind, GetterEntity, MethodEntity, MethodTypeEntity, SetterEntity, TypeMemberEntityContainer } from './index.js';
 export type VariableEntity = PackageVariableEntity | TypeVariableEntity | ParameterVariableEntity | LocalVariableEntity;
 export interface PackageVariableEntity extends IVariableEntity {
@@ -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';
@@ -55,7 +53,7 @@ export declare namespace ParameterVariableEntityContainer {
         constructor(entityContainingMethod: ActualEntity);
     }
 }
-export type EntityContainingValueParameter = MethodEntity | IndexerEntity | ConstructorEntity | DestructorEntity | MethodTypeEntity | SetterEntity;
+export type EntityContainingValueParameter = MethodEntity | IndexerEntity | ConstructorEntity | DestructorEntity | MethodTypeEntity | SetterEntity | OperatorEntity;
 export declare function isEntityContainingValueParameter(entity: Entity): entity is EntityContainingValueParameter;
 export type VariableEntityDefinition = {
     kind: DefinitionKind.Source;
@@ -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,33 +1,33 @@
 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 { OperatorEntity } from './OperatorEntity.js';
 import { PackageAliasEntity } from './PackageAliasEntity.js';
 import { PackageEntity } from './PackageEntity.js';
 import { SetterEntity } from './SetterEntity.js';
 import { AnonymousStructuredTypeEntity, PackageStructuredTypeEntity, StructuredTypeEntity } from './StructuredTypeEntity.js';
 import { TypeExtensionEntity } from './TypeExtensionEntity.js';
 import { TypeParameterEntity } from './TypeParameterEntity.js';
-import { UnaryOperatorEntity } from './UnaryOperatorEntity.js';
 import { PackageVariableEntity, TypeVariableEntity, VariableEntity } from './VariableEntity.js';
 import { VariantEntity } from './VariantEntity.js';
 import { AnonymousVariantTypeEntity, PackageVariantTypeEntity, VariantTypeEntity } from './VariantTypeEntity.js';
-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 * from './OperatorKind.js';
 export * from './PackageAliasEntity.js';
 export * from './PackageEntity.js';
 export * from './SetterEntity.js';
@@ -36,7 +36,6 @@ export * from './SubstitutionApplicationMode.js';
 export * from './TypeExtensionEntity.js';
 export * from './TypeMemberContainer.js';
 export * from './TypeParameterEntity.js';
-export * from './UnaryOperatorEntity.js';
 export * from './VariableEntity.js';
 export * from './VariantEntity.js';
 export * from './VariantTypeEntity.js';
@@ -61,12 +60,11 @@ export declare const enum EntityKind {
     StructuredType = 12,
     PackageAlias = 13,
     AliasType = 14,
-    UnaryOperator = 15,
-    BinaryOperator = 16,
-    Package = 17,
-    TypeExtension = 18
+    Operator = 15,
+    Package = 16,
+    TypeExtension = 17
 }
-export type Entity = PackageEntity | VariableEntity | VariantEntity | VariantTypeEntity | GetterEntity | SetterEntity | MethodEntity | TypeParameterEntity | IndexerEntity | DereferenceOperatorEntity | ConstructorEntity | DestructorEntity | MethodTypeEntity | StructuredTypeEntity | PackageAliasEntity | AliasTypeEntity | TypeExtensionEntity | UnaryOperatorEntity | BinaryOperatorEntity;
+export type Entity = PackageEntity | VariableEntity | VariantEntity | VariantTypeEntity | GetterEntity | SetterEntity | MethodEntity | TypeParameterEntity | OperatorEntity | IndexerEntity | DereferenceOperatorEntity | ConstructorEntity | DestructorEntity | MethodTypeEntity | StructuredTypeEntity | PackageAliasEntity | AliasTypeEntity | TypeExtensionEntity;
 export type TypeEntity = MethodTypeEntity | StructuredTypeEntity | TypeParameterEntity | VariantTypeEntity | AliasTypeEntity;
 export type PackageTypeEntity = PackageMethodTypeEntity | PackageStructuredTypeEntity | PackageVariantTypeEntity | AliasTypeEntity;
 export declare function isPackageTypeEntity(entity: TypeEntity): entity is PackageTypeEntity;
@@ -80,7 +78,7 @@ export declare function isPackageMemberEntity(entity: Entity): entity is Package
 export type NamedPackageMemberEntity = PackageVariableEntity | PackageMethodEntity | PackageTypeEntity;
 export type EntityWithTags = AliasTypeEntity | ConstructorEntity | DestructorEntity | IndexerEntity | DereferenceOperatorEntity | MethodEntity | MethodTypeEntity | StructuredTypeEntity | VariableEntity | VariantEntity | VariantTypeEntity | GetterEntity | SetterEntity;
 export declare function isEntityWithTags(entity: Entity): entity is EntityWithTags;
-export type TypeMemberEntity = TypeVariableEntity | TypeMethodEntity | ConstructorEntity | DestructorEntity | IndexerEntity | DereferenceOperatorEntity | UnaryOperatorEntity | BinaryOperatorEntity;
+export type TypeMemberEntity = TypeVariableEntity | TypeMethodEntity | OperatorEntity | ConstructorEntity | DestructorEntity | IndexerEntity | DereferenceOperatorEntity;
 export declare function isTypeMemberEntity(entity: Entity): entity is TypeMemberEntity;
 export type AnonymousTypeEntity = AnonymousStructuredTypeEntity | AnonymousMethodTypeEntity | AnonymousVariantTypeEntity;
 export declare function isAnonymousTypeEntity(entity: Entity): entity is AnonymousTypeEntity;

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

@@ -1,7 +1,7 @@
-import { PackageLocale } from '../common/index.js';
+import { PackageDialect, PackageLocale } from '../common/index.js';
 import * as tree from '../tree/green/index.js';
 export declare class Parser {
     private readonly _parser;
-    constructor(text: string, locale?: PackageLocale);
+    constructor(text: string, locale?: PackageLocale, dialect?: PackageDialect);
     parse(): tree.SourceFile;
 }

package/build/types/project/FileSystemTree.d.ts

@@ -3,7 +3,7 @@ import { Uri } from '../common/index.js';
 export declare class FileSystemTree extends ObservableObject implements ReadonlyFileSystemTree {
     private readonly _handleInconsistentRequestsWithoutErrors;
     private readonly _deleteEmptyDirectories;
-    private readonly _rootByScheme;
+    private readonly _rootsByScheme;
     private _version;
     private _createdDirectoriesVersion;
     private _deletedDirectoriesVersion;

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

@@ -1,4 +1,5 @@
 import { Analyzer } from '../analysis/index.js';
+import { Range } from '../common/index.js';
 import { SourceFile } from '../project/index.js';
 export declare class CompletionService {
     private readonly _cache;
@@ -45,6 +46,7 @@ export declare class CompletionService {
     private getPackageImportCompletionItemInfos;
     private getTopLevelAliasListCompletionItemInfos;
     private getTypeAliasMemberListItemInfos;
+    private getOperatorNameItemInfos;
     private mergeOverloadedMethods;
     private removeCompletionItemsWithDuplicateLabels;
     private convertCompletionItemInfos;
@@ -55,40 +57,44 @@ export declare class CompletionItem {
     readonly kind: CompletionItemKind;
     readonly details: string | undefined;
     readonly insertText: string | undefined;
+    readonly editRange: Range | undefined;
     readonly sortText: string | undefined;
     readonly cacheId: number;
     readonly indexInCache: number;
-    constructor(label: string, kind: CompletionItemKind, details: string | undefined, insertText: string | undefined, sortText: string | undefined, cacheId: number, indexInCache: number);
+    constructor(label: string, kind: CompletionItemKind, details: string | undefined, insertText: string | undefined, editRange: Range | undefined, sortText: string | undefined, cacheId: number, indexInCache: number);
 }
 export declare const enum CompletionItemKind {
     PackageNameSegment = 0,
     PackageAlias = 1,
     TypeVariable = 2,
     TypeMethod = 3,
-    TypeIndexer = 4,
-    TypeConstructor = 5,
-    PackageVariable = 6,
-    PackageMethod = 7,
-    LocalVariable = 8,
-    ParameterVariable = 9,
-    NestedMethod = 10,
-    Variant = 11,
-    RefObjectType = 12,
-    PlainObjectType = 13,
-    AspectType = 14,
-    VariantType = 15,
-    TypeParameter = 16,
-    MethodType = 17,
-    AliasType = 18,
-    InvalidType = 19,
-    Keyword = 20,
-    TargetSignatureParameter = 21
+    Operator = 4,
+    TypeIndexer = 5,
+    TypeConstructor = 6,
+    PackageVariable = 7,
+    PackageMethod = 8,
+    LocalVariable = 9,
+    ParameterVariable = 10,
+    NestedMethod = 11,
+    Variant = 12,
+    RefObjectType = 13,
+    PlainObjectType = 14,
+    AspectType = 15,
+    VariantType = 16,
+    TypeParameter = 17,
+    MethodType = 18,
+    AliasType = 19,
+    InvalidType = 20,
+    Keyword = 21,
+    TargetSignatureParameter = 22,
+    OperatorName = 23
 }
 export type ResolutionResult = ResolutionResult_item | ResolutionResult_notInCache;
 export declare class ResolutionResult_item {
     readonly value: CompletionItem;
+    readonly sourceFile: SourceFile;
     readonly kind = "item";
-    constructor(value: CompletionItem);
+    constructor(value: CompletionItem, sourceFile: SourceFile);
 }
 export declare class ResolutionResult_notInCache {
     readonly kind = "not-in-cache";