@artel/artc 0.6.25211 → 0.6.25212

package/build/{chunk-5BGDYCRQ.js → chunk-MRSDFDBD.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-EYLAO2SF.js";
+} from "./chunk-XGS3PSIF.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-Y3KGPV3L.js";
+} from "./chunk-DYVLHEXS.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";
@@ -22,13 +22,14 @@ import { normalize, sep } from "path";
 var FileSystemUri = class {
   static pathToUri(path) {
     path = normalize(path);
-    if (path.startsWith(sep)) {
-      path = path.substring(sep.length);
+    const segments = path.split(sep);
+    if (segments.length > 0 && segments[0].length === 0) {
+      segments.shift();
     }
-    if (path.endsWith(sep)) {
-      path = path.substring(0, path.length - sep.length);
+    if (segments.length > 0 && segments[segments.length - 1].length === 0) {
+      segments.pop();
     }
-    return new Uri("file", path.split(sep));
+    return new Uri("file", "", segments);
   }
   static toPath(uri) {
     if (platform() === "win32") {
@@ -215,7 +216,7 @@ var NodeCompiler = class {
       const standardLibraryUri = yield this.findStandardTypeScriptLibrary(nodeModulesSearchPaths, defaultTsLibraryPath);
       if (standardLibraryUri === void 0) {
         const diagnostic = new Diagnostic(DiagnosticData.withCode(
-          137 /* CanNotFindTsLibDirectoryBaseSearchPaths0 */,
+          148 /* CanNotFindTsLibDirectoryBaseSearchPaths0 */,
           [nodeModulesSearchPaths.map((p) => `'${p}'`).join(", ")]
         ), void 0);
         diagnostics?.addDiagnostic(diagnostic);

package/build/{chunk-EYLAO2SF.js → chunk-XGS3PSIF.js}

@@ -10,7 +10,7 @@ import {
   WellKnownDeclarationsLoadError,
   __async,
   createTsInteropInputsForCompilation
-} from "./chunk-Y3KGPV3L.js";
+} from "./chunk-DYVLHEXS.js";
 
 // source/executor/Compiler.ts
 var Compiler = class {
@@ -68,7 +68,7 @@ var Compiler = class {
     return __async(this, null, function* () {
       if (analyzer.compilation.mainPackage === void 0) {
         _diagnostics?.addDiagnostic(new Diagnostic(DiagnosticData.withCode(
-          140 /* ProgramWithoutMainPackageCanNotBeCompiled */
+          151 /* ProgramWithoutMainPackageCanNotBeCompiled */
         ), void 0));
         return void 0;
       }
@@ -82,7 +82,7 @@ var Compiler = class {
     return __async(this, null, function* () {
       if (analyzer.compilation.mainPackage === void 0) {
         _diagnostics?.addDiagnostic(new Diagnostic(DiagnosticData.withCode(
-          140 /* ProgramWithoutMainPackageCanNotBeCompiled */
+          151 /* ProgramWithoutMainPackageCanNotBeCompiled */
         ), void 0));
         return "";
       }

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

@@ -5,7 +5,7 @@ import { NamedMember, NamedPackageMemberEntity } from '../entities/PackageMember
 import { NamedTypeMemberEntity } from '../entities/TypeEntityMembers.js';
 import { PackageVariableEntity, ParameterVariableEntity, TypeVariableEntity } from '../entities/VariableEntity.js';
 import { VariantEntity } from '../entities/VariantEntity.js';
-import { AliasTypeEntity, ConstructorEntity, DestructorEntity, IndexerEntity, MethodEntity, MethodTypeEntity, PackageMethodEntity, PackageMethodTypeEntity, PackageTypeEntity, PackageVariantTypeEntity, StructuredTypeEntity, TypeMethodEntity, TypeParameterEntity, VariantTypeEntity } from '../entities/index.js';
+import { AliasTypeEntity, ConstructorEntity, DestructorEntity, IndexerEntity, MethodEntity, MethodTypeEntity, OperatorEntity, PackageMethodEntity, PackageMethodTypeEntity, PackageTypeEntity, PackageVariantTypeEntity, StructuredTypeEntity, TypeMethodEntity, TypeParameterEntity, VariantTypeEntity } from '../entities/index.js';
 import { PackageName, TranslationPackage } from '../project/index.js';
 import * as tree from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -19,6 +19,7 @@ export declare class AnalyzedTranslationPackage {
     private readonly _translatedTypeEntityMembers;
     private readonly _translatedVariants;
     private readonly _methodSignatureTranslations;
+    private readonly _operatorSignatureTranslations;
     private readonly _methodTypeSignatureTranslations;
     private readonly _constructorSignatureTranslations;
     private readonly _indexerSignatureTranslations;
@@ -43,6 +44,7 @@ export declare class AnalyzedTranslationPackage {
     getConstructorTranslationTargets(node: tree.ConstructorTranslation): GetMultipleTranslationTargetsResult<ConstructorEntity>;
     getIndexerTranslationTargets(node: tree.IndexerTranslation): GetMultipleTranslationTargetsResult<IndexerEntity>;
     getMethodSignature(entity: MethodEntity): LocalizedSubprogramSignature.Translated | undefined;
+    getOperatorSignature(entity: OperatorEntity): LocalizedSubprogramSignature.Translated | undefined;
     getPackageMethodSignature(entity: PackageMethodEntity): LocalizedSubprogramSignature.Translated | undefined;
     getTypeMethodSignature(entity: TypeMethodEntity): LocalizedSubprogramSignature.Translated | undefined;
     getMethodTypeSignature(entity: MethodTypeEntity): LocalizedSubprogramSignature.Translated | undefined;

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

@@ -3,10 +3,11 @@ import { CancellationToken, Name, PackageLocale, Range, SearchName, WithDiagnost
 import { Diagnostic, DiagnosticAcceptor, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
 import { DiagnosticCode } from '../diagnostic/DiagnosticCode.js';
 import { DiagnosticFlags, DiagnosticKind } from '../diagnostic/DiagnosticData.js';
+import { BinaryOperatorKind } from '../entities/OperatorKind.js';
 import * as packageMembers from '../entities/PackageMembers.js';
 import { NamedTypeMemberEntity } from '../entities/TypeEntityMembers.js';
 import * as entities from '../entities/index.js';
-import { AliasTypeEntity, AnonymousMethodTypeEntity, AnonymousStructuredTypeEntity, AnonymousVariantTypeEntity, BinaryOperatorEntity, BinaryOperatorKind, ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, GetterEntity, IEntityHidingMatcher, LocalVariableEntity, MethodEntity, MethodTypeEntity, NamedTypeEntity, NestedMethodEntity, PackageAliasEntity, PackageEntity, PackageMethodEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariableEntity, PackageVariantTypeEntity, SetterEntity, SourceIndexerEntity, StructuredTypeEntity, TypeEntity, TypeExtensionEntity, TypeMemberEntityContainer, TypeMethodEntity, TypeParameterEntity, TypeVariableEntity, UnaryOperatorEntity, VariableEntity, VariantEntity, VariantTypeEntity } from '../entities/index.js';
+import { AliasTypeEntity, AnonymousMethodTypeEntity, AnonymousStructuredTypeEntity, AnonymousVariantTypeEntity, ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, GetterEntity, IEntityHidingMatcher, LocalVariableEntity, MethodEntity, MethodTypeEntity, NamedTypeEntity, NestedMethodEntity, OperatorEntity, PackageAliasEntity, PackageEntity, PackageMethodEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariableEntity, PackageVariantTypeEntity, SetterEntity, SourceIndexerEntity, StructuredTypeEntity, TypeEntity, TypeExtensionEntity, TypeMemberEntityContainer, TypeMethodEntity, TypeParameterEntity, TypeVariableEntity, VariableEntity, VariantEntity, VariantTypeEntity } from '../entities/index.js';
 import { ReservedIdentifierKind } from '../parser/ReservedIdentifierDictionary.js';
 import * as project from '../project/index.js';
 import { PackageName, PlatformKind, SourcePackage } from '../project/index.js';
@@ -18,7 +19,6 @@ import { AccessedMethod } from './AccessedMethod.js';
 import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
 import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.js';
 import * as baseExpressionMeaning from './BaseExpressionMeaning.js';
-import { BuiltInOperators } from './BuiltInOperators.js';
 import { CallArgumentToParameterMatchResult, MatchResultValueParameter } from './CallArgumentToParameterMatchResult.js';
 import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import * as constructorOverloadResolver from './ConstructorOverloadResolver.js';
@@ -69,7 +69,6 @@ export declare class Analyzer {
     readonly tags: Tags;
     readonly linkedEntity: LinkedEntity;
     readonly owningPlainObjectModificationCheck: OwningPlainObjectModificationCheck;
-    readonly builtInOperators: BuiltInOperators;
     readonly packageImports: PackageImports;
     private readonly _tsInteropInputs;
     private readonly _targetType;
@@ -153,16 +152,17 @@ export declare class Analyzer {
         packageAlias: PackageAliasEntity;
     } | undefined;
     checkExpressionDenotesMethod(expression: tree.Expression): ExpressionDenotesMethodCheckResult | undefined;
+    checkExpressionDenotesOperator(expression: tree.Expression): ExpressionDenotesOperatorCheckResult | undefined;
     checkExpressionDenotesPackageNameSegment(expression: tree.Expression): {
         packageTreeNode: PackageNameTreeNode;
     } | undefined;
     checkMethodBodyUsesYieldStatement(node: tree.StatementBlock): boolean;
     enumerateAspects(type: types.Type): Iterable<types.StructuredType>;
     checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: StructuredTypeEntity): boolean;
-    resolvePrefixUnaryExpressionOperator(node: tree.PrefixUnaryExpression): WithDiagnostics<FoundAnonymousDeclaration<types.UnaryOperator>>;
-    resolveNotExpressionOperator(node: tree.NotExpression): WithDiagnostics<FoundAnonymousDeclaration<types.UnaryOperator>>;
-    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): WithDiagnostics<FoundAnonymousDeclaration<types.BinaryOperator>>;
-    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): WithDiagnostics<FoundAnonymousDeclaration<types.BinaryOperator>>;
+    resolvePrefixUnaryExpressionOperator(node: tree.PrefixUnaryExpression): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
+    resolveNotExpressionOperator(node: tree.NotExpression): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
+    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
+    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
     classifyBinaryExpressionOperator(operator: tree.BinaryExpressionOperator): BinaryExpressionOperatorClassificationResult;
     getBinaryOperatorKindIfCompoundAssignmentOperator(operator: tree.AssignmentStatementOperator): BinaryOperatorKind | undefined;
     getPackageEntities(): readonly PackageEntity[];
@@ -234,7 +234,6 @@ 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 {
@@ -249,6 +248,10 @@ export type BinaryExpressionOperatorClassificationResult = {
     operatorKind: BinaryOperatorKind;
 } | {
     kind: 'question-question';
+} | {
+    kind: 'equals';
+} | {
+    kind: 'not-equals';
 };
 export declare const enum SyntacticAccessKind {
     Get = 0,
@@ -265,6 +268,7 @@ declare class Type {
     ofExpression(node: tree.Expression, targetTypeHint?: TargetTypeHint): types.Type;
     ofTypeSpecifier(node: tree.TypeSpecifier): types.Type;
     ofAccessedMethod(accessedMethod: WithLocalization<AccessedMethod>): types.Type;
+    ofAccessedOperator(operator: WithLocalization<types.Operator>): types.Type;
     ofMethodBlockLiteral(node: tree.MethodBlockLiteral, targetTypeHint?: TargetTypeHint): types.MethodType;
     ofMethodLiteral(node: tree.MethodLiteral, targetTypeHint?: TargetTypeHint): types.MethodType;
     private ofArrayLiteral;
@@ -312,6 +316,7 @@ declare class ReturnType {
     ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): types.Type;
     ofMethodLiteral(node: tree.MethodLiteral): types.Type;
     ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): types.Type;
+    ofOperatorDeclaration(node: tree.OperatorDeclaration): types.Type;
 }
 declare class Entity {
     private readonly _analyzer;
@@ -334,6 +339,7 @@ declare class Entity {
     private readonly _typeMethodEntities;
     private readonly _nestedMethodEntities;
     private readonly _constructorEntities;
+    private readonly _operatorEntities;
     private readonly _destructorEntities;
     private readonly _getterEntities;
     private readonly _setterEntities;
@@ -367,6 +373,7 @@ declare class Entity {
     ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): PackageMethodEntity;
     ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): TypeMethodEntity;
     ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): NestedMethodEntity;
+    ofOperatorDeclaration(node: tree.OperatorDeclaration): OperatorEntity;
     ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): GetterEntity;
     ofTypeVariableGetterDeclaration(node: tree.TypeVariableGetterDeclaration): GetterEntity;
     ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration): GetterEntity;
@@ -397,6 +404,7 @@ declare class ResultLocalVariableEntity {
     ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): LocalVariableEntity;
     ofMethodLiteral(node: tree.MethodLiteral): LocalVariableEntity;
     ofMethodBlockLiteral(node: tree.MethodBlockLiteral): LocalVariableEntity;
+    ofOperatorDeclaration(node: tree.OperatorDeclaration): LocalVariableEntity;
     ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): LocalVariableEntity;
     ofTypeVariableGetterDeclaration(node: tree.TypeVariableGetterDeclaration): LocalVariableEntity;
     ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration): LocalVariableEntity;
@@ -418,6 +426,7 @@ declare class ParamLocalVariableEntity {
     ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): VariableEntity | undefined;
     ofMethodLiteral(node: tree.MethodLiteral): VariableEntity | undefined;
     ofMethodBlockLiteral(node: tree.MethodBlockLiteral): VariableEntity | undefined;
+    ofOperatorDeclaration(node: tree.OperatorDeclaration): VariableEntity | undefined;
     ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): VariableEntity | undefined;
     private createParamLocalVariableEntity;
     private createAccessorParamLocalVariableEntity;
@@ -438,6 +447,7 @@ declare class DestructuredParameterLocalVariableEntities {
     ofMethodBlockLiteral(node: tree.MethodBlockLiteral): readonly VariableEntity[];
     ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): readonly VariableEntity[];
     ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): readonly VariableEntity[];
+    ofOperatorDeclaration(node: tree.OperatorDeclaration): readonly VariableEntity[];
     ofMethodLiteral(node: tree.MethodLiteral): readonly VariableEntity[];
     ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): readonly VariableEntity[];
     ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): readonly VariableEntity[];
@@ -465,6 +475,7 @@ declare class Scope {
     private readonly _variantTypeDeclarationBodyScopes;
     private readonly _aliasTypeDeclarationBodyScopes;
     private readonly _packageAliasTypeDeclarationTypeParametersScopes;
+    private readonly _operatorDeclarationScopes;
     private readonly _structuredTypeConstructorDeclarationScopes;
     private readonly _structuredTypeDestructorDeclarationScopes;
     private readonly _typeIndexedAccessorDeclarationParametersScopes;
@@ -491,6 +502,7 @@ declare class Scope {
     ofVariantTypeDeclarationBody(node: tree.VariantTypeDeclarationBody): scope.IScope;
     ofAliasTypeDeclarationBody(node: tree.AliasTypeDeclarationBody): scope.IScope;
     ofPackageAliasTypeDeclarationTypeParameters(node: tree.PackageAliasTypeDeclaration): scope.IScope;
+    ofOperatorDeclaration(node: tree.OperatorDeclaration): scope.IScope;
     ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): scope.IScope;
     ofTypeDestructorDeclaration(node: tree.TypeDestructorDeclaration): scope.IScope;
     ofTypeIndexedAccessorDeclarationParameters(node: TypeIndexedAccessorDeclaration): scope.IScope;
@@ -510,13 +522,16 @@ declare class OverriddenMember {
     constructor(_analyzer: Analyzer);
     getOverriddenMethod(method: TypeMethodEntity): types.Method | undefined;
     getTheMostBaseOverriddenMethod(method: TypeMethodEntity): types.Method | undefined;
+    getOverriddenOperator(operator: OperatorEntity): types.Operator | undefined;
     getOverriddenVariable(variable: entities.TypeVariableEntity): types.Variable | undefined;
     getTheMostBaseOverriddenVariable(variable: entities.TypeVariableEntity): types.Variable | undefined;
     checkMethodOverridesMethod(methodInDerivedType: TypeMethodEntity, methodInBaseType: types.Method): boolean;
     checkVariableOverridesVariable(variableInDerivedType: entities.TypeVariableEntity, variableInBaseType: types.Variable): boolean;
+    checkOperatorOverridesOperator(operatorInDerivedType: OperatorEntity, operatorInBaseType: types.Operator): boolean;
     private findOverriddenVariableInType;
     private findOverriddenMethodInType;
     private methodSignatureTypesAreEqual;
+    private findOverriddenOperatorInType;
 }
 declare class Tags {
     readonly _analyzer: Analyzer;
@@ -537,11 +552,10 @@ declare class LinkedEntity {
     ofPackageMethod(entity: PackageMethodEntity, platform: PlatformKind): PackageMethodEntity | undefined;
     ofTypeVariable(entity: entities.TypeVariableEntity, platform: PlatformKind): entities.TypeVariableEntity | undefined;
     ofTypeMethod(entity: entities.TypeMethodEntity, platform: PlatformKind): entities.TypeMethodEntity | undefined;
+    ofOperator(entity: entities.OperatorEntity, platform: PlatformKind): entities.OperatorEntity | undefined;
     ofConstructor(entity: entities.ConstructorEntity, platform: PlatformKind): entities.ConstructorEntity | undefined;
     ofIndexer(entity: entities.IndexerEntity, platform: PlatformKind): entities.IndexerEntity | undefined;
     ofDereferenceOperator(entity: entities.DereferenceOperatorEntity, platform: PlatformKind): entities.DereferenceOperatorEntity | undefined;
-    ofUnaryOperator(entity: entities.UnaryOperatorEntity, platform: PlatformKind): entities.UnaryOperatorEntity | undefined;
-    ofBinaryOperator(entity: entities.BinaryOperatorEntity, platform: PlatformKind): entities.BinaryOperatorEntity | undefined;
     ofVariant(entity: VariantEntity, platform: PlatformKind): VariantEntity | undefined;
     ofGetter(entity: entities.GetterEntity, platform: PlatformKind): entities.GetterEntity | undefined;
     ofSetter(entity: entities.SetterEntity, platform: PlatformKind): entities.SetterEntity | undefined;
@@ -581,11 +595,10 @@ export declare class LinkedTypeWithMembers {
     constructor(analyzer: Analyzer, externalType: entities.TypeEntityWithMembers, targetType: entities.TypeEntityWithMembers, linkedPackage: LinkedMultiPlatformPackage);
     getLinkedVariable(entity: entities.TypeVariableEntity): entities.TypeVariableEntity | undefined;
     getLinkedMethod(entity: entities.TypeMethodEntity): entities.TypeMethodEntity | undefined;
+    getLinkedOperator(entity: entities.OperatorEntity): entities.OperatorEntity | undefined;
     getLinkedConstructor(entity: entities.ConstructorEntity): entities.ConstructorEntity | undefined;
     getLinkedIndexer(entity: entities.IndexerEntity): entities.IndexerEntity | undefined;
     getLinkedDereferenceOperator(entity: entities.DereferenceOperatorEntity): entities.DereferenceOperatorEntity | undefined;
-    getLinkedUnaryOperator(entity: UnaryOperatorEntity): UnaryOperatorEntity | undefined;
-    getLinkedBinaryOperator(entity: BinaryOperatorEntity): BinaryOperatorEntity | undefined;
     getLinkedVariant(entity: VariantEntity): VariantEntity | undefined;
 }
 declare class OwningPlainObjectModificationCheck {
@@ -634,6 +647,12 @@ export declare class ExpressionDenotesMethodCheckResult {
     get singleSuitableMethod(): WithLocalization<AccessedMethod> | undefined;
     constructor(candidates: readonly WithLocalization<AccessedMethod>[], suitableMethods: readonly WithLocalization<AccessedMethod>[]);
 }
+export declare class ExpressionDenotesOperatorCheckResult {
+    readonly candidates: readonly WithLocalization<types.Operator>[];
+    readonly suitableOperators: readonly WithLocalization<types.Operator>[];
+    get singleSuitableOperator(): WithLocalization<types.Operator> | undefined;
+    constructor(candidates: readonly WithLocalization<types.Operator>[], suitableOperators: readonly WithLocalization<types.Operator>[]);
+}
 export declare class NonHiddenEntityHidingMatcher implements IEntityHidingMatcher {
     matches(_hiding: entities.EntityHidingLevel): boolean;
 }
@@ -668,13 +687,12 @@ declare namespace AvailablePackage {
 export declare class DeclaredTypeMemberEntities {
     readonly variables: readonly TypeVariableEntity[];
     readonly methods: readonly TypeMethodEntity[];
+    readonly operators: readonly OperatorEntity[];
     readonly constructors: readonly ConstructorEntity[];
     readonly destructors: readonly DestructorEntity[];
     readonly indexers: readonly SourceIndexerEntity[];
     readonly dereferenceOperators: readonly DereferenceOperatorEntity[];
-    readonly unaryOperators: readonly UnaryOperatorEntity[];
-    readonly binaryOperators: readonly BinaryOperatorEntity[];
     get namedMembers(): NamedTypeMemberEntity[];
-    constructor(variables: readonly TypeVariableEntity[], methods: readonly TypeMethodEntity[], constructors: readonly ConstructorEntity[], destructors: readonly DestructorEntity[], indexers: readonly SourceIndexerEntity[], dereferenceOperators: readonly DereferenceOperatorEntity[], unaryOperators: readonly UnaryOperatorEntity[], binaryOperators: readonly BinaryOperatorEntity[]);
+    constructor(variables: readonly TypeVariableEntity[], methods: readonly TypeMethodEntity[], operators: readonly OperatorEntity[], constructors: readonly ConstructorEntity[], destructors: readonly DestructorEntity[], indexers: readonly SourceIndexerEntity[], dereferenceOperators: readonly DereferenceOperatorEntity[]);
 }
 export {};

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

@@ -17,12 +17,13 @@ export declare class Resolver {
     private resolveBaseConstructorOrMethodAccess;
     private resolveBaseConstructorAccess;
     private resolveBaseMethodAccess;
+    private resolveBaseOperatorAccess;
     private resolveBaseObjectAccess;
     private invalidContextMeaning;
     private getBaseOrAliasedType;
-    private findContainingConstructorOrTypeMethod;
+    private getContainingTypeMemberDeclaration;
 }
-export type Meaning = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | Meaning_overriddenMethodAccess | Meaning_unresolved;
+export type Meaning = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | Meaning_overriddenMethodAccess | Meaning_overriddenOperatorAccess | Meaning_unresolved;
 declare class Meaning_baseObjectAccess {
     readonly type: types.Type;
     readonly kind = "base-object-access";
@@ -55,6 +56,11 @@ declare class Meaning_overriddenMethodAccess {
     readonly kind = "overridden-method-access";
     constructor(method: types.Method);
 }
+declare class Meaning_overriddenOperatorAccess {
+    readonly operator: types.Operator;
+    readonly kind = "overridden-operator-access";
+    constructor(operator: types.Operator);
+}
 declare class Meaning_unresolved {
     readonly diagnostic: Diagnostic;
     readonly kind = "unresolved";

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

@@ -14,12 +14,17 @@ export declare class Resolver {
     private resolveConstructorCallExpressionMeaning;
     private getNodeForDiagnostics;
 }
-export type Meaning = Meaning_methodCall | Meaning_objectMethodCall | Meaning_constructorCall | Meaning_unresolved;
+export type Meaning = Meaning_methodCall | Meaning_operatorCall | Meaning_objectMethodCall | Meaning_constructorCall | Meaning_unresolved;
 declare class Meaning_methodCall {
     readonly method: WithLocalization<AccessedMethod>;
     readonly kind = "method-call";
     constructor(method: WithLocalization<AccessedMethod>);
 }
+declare class Meaning_operatorCall {
+    readonly operator: WithLocalization<types.Operator>;
+    readonly kind = "operator-call";
+    constructor(operator: WithLocalization<types.Operator>);
+}
 declare class Meaning_objectMethodCall {
     readonly type: types.MethodType;
     readonly kind = "object-method-call";

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

@@ -28,6 +28,7 @@ export declare class DiagnosticCollector {
     private checkPackageVariableGetterDeclaration;
     private checkPackageVariableSetterDeclaration;
     private checkTypeMethodDeclaration;
+    private checkOperatorDeclaration;
     private checkTypeVariableGetterDeclaration;
     private checkTypeVariableSetterDeclaration;
     private checkTypeIndexedGetterDeclaration;

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

@@ -1,15 +1,17 @@
 import { LocalizedSubprogramSignature, LocalizedTypeHeader, TypeEntityWithHeaderLocalization } from '../analysis/AnalyzedTranslationPackage.js';
 import { Analyzer } from '../analysis/index.js';
 import { Localization } from '../analysis/Localization.js';
-import { ConstructorEntity, DestructorEntity, IndexerEntity, MethodEntity, MethodTypeEntity } from '../entities/index.js';
+import { ConstructorEntity, DestructorEntity, IndexerEntity, MethodEntity, MethodTypeEntity, OperatorEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
 export declare class EntityLocalizationHelper {
     static getLocalizedMethodSignature(method: MethodEntity, localization: Localization): LocalizedSubprogramSignature;
+    static getLocalizedOperatorSignature(operator: OperatorEntity, localization: Localization): LocalizedSubprogramSignature;
     static getLocalizedMethodTypeSignature(methodType: MethodTypeEntity, localization: Localization): LocalizedSubprogramSignature;
     static getLocalizedConstructorSignature(constructor: ConstructorEntity, localization: Localization): LocalizedSubprogramSignature;
     static getLocalizedDestructorSignature(destructor: DestructorEntity, localization: Localization): LocalizedSubprogramSignature;
     static getLocalizedIndexerSignature(indexer: IndexerEntity, localization: Localization): LocalizedSubprogramSignature;
     static getLocalizedTypeHeader(type: TypeEntityWithHeaderLocalization, localization: Localization): LocalizedTypeHeader;
     static getLocalizedSignatureTypeOfMethod(analyzer: Analyzer, method: MethodEntity, signatureType: types.MethodType, localization: Localization): types.MethodType;
+    static getLocalizedSignatureTypeOfOperator(analyzer: Analyzer, operator: OperatorEntity, signatureType: types.MethodType, localization: Localization): types.MethodType;
     static localizeMethodType(analyzer: Analyzer, type: types.MethodType, localizedSignature: LocalizedSubprogramSignature): types.MethodType;
 }

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

@@ -1,10 +1,10 @@
 import { Name } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity, VariableEntity, VariantEntity } from '../entities/index.js';
-import { IdentifierExpression } from '../tree/index.js';
+import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { AccessedMethod } from './AccessedMethod.js';
-import { FoundNamedDeclaration } from './FoundDeclaration.js';
+import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import * as scope from './Scope.js';
 import * as variableAccess from './VariableAccess.js';
@@ -15,8 +15,9 @@ export declare class Resolver {
     private readonly _node;
     private readonly _targetTypeHint;
     private get semanticContext();
-    constructor(analyzer: Analyzer, node: IdentifierExpression, targetTypeHint: TargetTypeHint | undefined);
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, targetTypeHint: TargetTypeHint | undefined);
     resolve(): ResolutionResult;
+    private resolveOperatorAccessMeaning;
     private resolveMethodOverload;
     private createAccessedMethod;
     private convertSyntacticAccessKind;
@@ -26,7 +27,7 @@ export declare class ResolutionResult {
     readonly diagnostic?: Diagnostic | undefined;
     constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
 }
-export type Meaning = Meaning_variantAccess | Meaning_variableAccess | Meaning_methodAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+export type Meaning = Meaning_variantAccess | Meaning_variableAccess | Meaning_methodAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_variantAccess {
     readonly variant: FoundNamedDeclaration<VariantEntity>;
     readonly kind = "variant-access";
@@ -45,6 +46,13 @@ declare class Meaning_methodAccess {
     get singleSuitableMethod(): FoundNamedDeclaration<AccessedMethod> | undefined;
     constructor(candidates: readonly FoundNamedDeclaration<AccessedMethod>[], suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[]);
 }
+declare class Meaning_operatorAccess {
+    readonly candidates: readonly FoundAnonymousDeclaration<types.Operator>[];
+    readonly suitableOperators: readonly FoundAnonymousDeclaration<types.Operator>[];
+    readonly kind = "operator-access";
+    get singleSuitableOperator(): FoundAnonymousDeclaration<types.Operator> | undefined;
+    constructor(candidates: readonly FoundAnonymousDeclaration<types.Operator>[], suitableOperators: readonly FoundAnonymousDeclaration<types.Operator>[]);
+}
 declare class Meaning_packageAliasAccess {
     readonly packageAlias: PackageAliasEntity;
     readonly kind = "package-alias-access";

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

@@ -1,6 +1,7 @@
 import { Query, SearchName } from '../common/index.js';
-import { IEntityHidingMatcher, TypeEntity, TypeExtensionEntity } from '../entities/index.js';
-import { FoundNamedDeclaration } from './FoundDeclaration.js';
+import { IEntityHidingMatcher, OperatorKind, TypeEntity, TypeExtensionEntity } from '../entities/index.js';
+import * as types from '../types/index.js';
+import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { IScope, NamedDeclaration, TypeOrContainerWithTypes } from './Scope.js';
 export declare class Lookup {
     private readonly _scopeChain;
@@ -10,9 +11,12 @@ export declare class Lookup {
     getTypesOrContainersWithTypesByName(name: SearchName): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getNamedDeclarations(): FoundNamedDeclaration<NamedDeclaration>[];
     getNamedDeclarationsByName(name: SearchName): FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(): FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind): FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(type: TypeEntity): TypeExtensionEntity[];
     private checkTypeOrPackageDeclarationShadowing;
     private checkNamedDeclarationShadowing;
+    private checkOperatorShadowing;
 }
 export declare class ScopeChain {
     private readonly _entry;

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

@@ -17,11 +17,9 @@ import { Analyzer } from './index.js';
 export declare class PrefixUnaryOperatorResolver {
     private readonly _analyzer;
     private readonly _node;
-    private readonly _operandType;
-    private get operandType();
     private get operand();
     private get operatorNode();
     private get operatorKind();
     constructor(_analyzer: Analyzer, _node: PrefixUnaryExpression | NotExpression);
-    resolve(): WithDiagnostics<FoundAnonymousDeclaration<types.UnaryOperator>>;
+    resolve(): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
 }

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

@@ -1,9 +1,9 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { PackageTypeEntity, PackageVariableEntity, VariantEntity } from '../entities/index.js';
-import { PropertyAccessExpression } from '../tree/index.js';
+import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { AccessedMethod } from './AccessedMethod.js';
-import { FoundNamedDeclaration } from './FoundDeclaration.js';
+import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import * as variableAccess from './VariableAccess.js';
 import { Analyzer, TargetTypeHint } from './index.js';
@@ -13,9 +13,10 @@ export declare class Resolver {
     private readonly _node;
     private readonly _targetTypeHint;
     private get propertySearchName();
+    private get isOperatorName();
     private get semanticContext();
     private get receiver();
-    constructor(analyzer: Analyzer, node: PropertyAccessExpression, targetTypeHint: TargetTypeHint | undefined);
+    constructor(analyzer: Analyzer, node: tree.PropertyAccessExpression, targetTypeHint: TargetTypeHint | undefined);
     resolve(): ResolutionResult;
     private resolvePackageAliasMemberAccessMeaning;
     private resolvePackageMemberAccessMeaning;
@@ -24,6 +25,7 @@ export declare class Resolver {
     private resolveStaticMemberOrVariantAccessMeaning;
     private createAccessedMethodFromTypeMember;
     private resolveInstanceMemberAccessMeaning;
+    private resolveOperatorAccessMeaning;
     private resolveMethodOverload;
     private convertSyntacticAccessKind;
 }
@@ -32,7 +34,7 @@ export declare class ResolutionResult {
     readonly diagnostic?: Diagnostic | undefined;
     constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
 }
-export type Meaning = Meaning_packageVariableAccess | Meaning_packageMethodAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_variantAccess | Meaning_staticVariableAccess | Meaning_staticMethodAccess | Meaning_instanceVariableAccess | Meaning_instanceMethodAccess | Meaning_unresolved;
+export type Meaning = Meaning_packageVariableAccess | Meaning_packageMethodAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_variantAccess | Meaning_staticVariableAccess | Meaning_staticMethodAccess | Meaning_instanceVariableAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_unresolved;
 declare class Meaning_packageVariableAccess {
     readonly variable: FoundNamedDeclaration<PackageVariableEntity>;
     readonly access: variableAccess.VariableAccess;
@@ -92,6 +94,13 @@ declare class Meaning_instanceMethodAccess {
     get singleSuitableMethod(): FoundNamedDeclaration<AccessedMethod> | undefined;
     constructor(candidates: readonly FoundNamedDeclaration<AccessedMethod>[], suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[]);
 }
+declare class Meaning_operatorAccess {
+    readonly candidates: readonly FoundAnonymousDeclaration<types.Operator>[];
+    readonly suitableOperators: readonly FoundAnonymousDeclaration<types.Operator>[];
+    readonly kind = "operator-access";
+    get singleSuitableOperator(): FoundAnonymousDeclaration<types.Operator> | undefined;
+    constructor(candidates: readonly FoundAnonymousDeclaration<types.Operator>[], suitableOperators: readonly FoundAnonymousDeclaration<types.Operator>[]);
+}
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }

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

@@ -1,9 +1,9 @@
 import { Name, PackageLocale, SearchName } from '../common/index.js';
-import { AliasTypeEntity, EntityHidingLevel, IEntityHidingMatcher, MethodEntity, NamedTypeEntity, PackageAliasEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, TypeEntity, TypeExtensionEntity, TypeParameterEntity, VariableEntity, VariantEntity } from '../entities/index.js';
+import { AliasTypeEntity, EntityHidingLevel, IEntityHidingMatcher, MethodEntity, NamedTypeEntity, OperatorKind, PackageAliasEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, TypeEntity, TypeExtensionEntity, TypeParameterEntity, VariableEntity, VariantEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
-import { FoundNamedDeclaration } from './FoundDeclaration.js';
+import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Lookup } from './Lookup.js';
 import { TypeMemberLookup } from './TypeMemberLookup.js';
@@ -12,6 +12,8 @@ export interface IScope {
     getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
     getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(typeEntity: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
 }
 export type TypeOrContainerWithTypes = TypeOrContainerWithTypes_type | TypeOrContainerWithTypes_packageAlias | TypeOrContainerWithTypes_packageNameSegment;
@@ -233,6 +235,8 @@ export declare class SourceFileScope implements IScope {
     getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
     getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(_hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(_kind: OperatorKind, _hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     private convertPackageMembersTypeDeclaration;
     private convertPackageMemberToNamedDeclaration;
@@ -256,6 +260,8 @@ export declare class GenericScope implements IScope {
     getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
     getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(_hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(_kind: OperatorKind, _hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(typeEntity: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     private checkHiding;
 }
@@ -273,6 +279,8 @@ export declare class ParameterDeclarationsScope implements IScope {
     getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
     getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(_hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(_kind: OperatorKind, _hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(typeEntity: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     private checkHiding;
 }
@@ -284,6 +292,8 @@ export declare class StructuredTypeBodyScope implements IScope {
     getTypesOrContainersWithTypesByName(_name: SearchName, _hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
     getNamedDeclarationsByName(name: SearchName, hidingMatcher: IEntityHidingMatcher | undefined): FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(_typeEntity: TypeEntity, _hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     private convertNamedMember;
 }
@@ -301,9 +311,13 @@ export declare class TypeExtensionBodyScope implements IScope {
     getTypesOrContainersWithTypesByName(_name: SearchName, _hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getNamedDeclarations(hidingMatcher: IEntityHidingMatcher | undefined): FoundNamedDeclaration<NamedDeclaration>[];
     getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(_typeEntity: TypeEntity, _hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
-    private convertTypeExtensionMember;
+    private convertNamedTypeExtensionMember;
+    private convertTypeExtensionOperator;
     private convertExtendedTypeMember;
+    private checkOperatorShadowing;
     private checkNamedDeclarationShadowing;
 }
 export {};