@artel/artc 0.6.25244 → 0.6.25245

package/build/{chunk-V7EU2U6Y.js → chunk-TVZEHLXD.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-C7RKXERX.js";
+} from "./chunk-FVBS6MPY.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-BAAUJYMH.js";
+} from "./chunk-T7WG4Z7I.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";

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

@@ -1,18 +1,19 @@
 import { Name, PackageLocale } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { EntityLocalizationContext } from '../entities/EntityLocalizationContext.js';
 import { PackageEntity } from '../entities/PackageEntity.js';
-import { NamedTypeMemberEntity } from '../entities/TypeEntityMembers.js';
-import { PackageVariableEntity, ParameterVariableEntity, FieldEntity } from '../entities/VariableEntity.js';
-import { AliasTypeEntity, ConstructorEntity, DestructorEntity, IndexerEntity, FunctionEntity, FunctionTypeEntity, NamedPackageMemberEntity, OperatorEntity, PackageFunctionEntity, PackageFunctionTypeEntity, PackageTypeEntity, StructuredTypeEntity, MethodEntity, TypeParameterEntity, VariantTypeEntity } from '../entities/index.js';
+import { FieldEntity, PackageVariableEntity, ParameterVariableEntity } from '../entities/VariableEntity.js';
+import { AliasTypeEntity, ConstructorEntity, DestructorEntity, FunctionEntity, FunctionTypeEntity, IndexerEntity, MethodEntity, NamedEntity, NamedPackageMemberEntity, NamedTypeMemberEntity, OperatorEntity, PackageFunctionEntity, PackageFunctionTypeEntity, PackageTypeEntity, StructuredTypeEntity, 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';
-import { LocalizedName } from './Localization.js';
-import { NamedEntity } from './LocalizationContext.js';
+import { Translation } from './Localization.js';
 export declare class AnalyzedTranslationPackage {
     private readonly _analyzer;
     private readonly _package;
-    private readonly _translatedPackage;
+    private readonly _targetTarget;
+    readonly entityLocalizationContext: EntityLocalizationContext;
+    private readonly _localizedPackageByOriginalReferencedPackage;
     private readonly _members;
     private readonly _translatedTypeEntityMembers;
     private readonly _functionSignatureTranslations;
@@ -21,11 +22,13 @@ export declare class AnalyzedTranslationPackage {
     private readonly _constructorSignatureTranslations;
     private readonly _indexerSignatureTranslations;
     private readonly _translatedTypeHeaders;
-    constructor(_analyzer: Analyzer, _package: TranslationPackage, _translatedPackage: PackageEntity);
-    getTranslatedPackage(): PackageEntity;
+    constructor(_analyzer: Analyzer, _package: TranslationPackage, _targetTarget: PackageEntity);
+    getTargetPackage(): PackageEntity;
+    getPackageInTranslatedLanguage(): PackageEntity;
     getDefinition(): TranslationPackage;
     getTranslatedName(): PackageName;
     getTranslationLocale(): PackageLocale;
+    getLocalizedPackageByOriginalReferencedPackage(): ReadonlyMap<PackageEntity, PackageEntity>;
     getMembers(): TranslatedPackageMembers;
     getTypeEntityMembers(typeEntity: PackageTypeEntity): TranslatedTypeEntityMembers | undefined;
     getPackageVariableTranslationTarget(node: tree.PackageVariableTranslation): GetSingleTranslationTargetResult<PackageVariableEntity>;
@@ -39,16 +42,17 @@ export declare class AnalyzedTranslationPackage {
     getMethodTranslationTargets(node: tree.MethodTranslation): GetMultipleTranslationTargetsResult<MethodEntity>;
     getConstructorTranslationTargets(node: tree.ConstructorTranslation): GetMultipleTranslationTargetsResult<ConstructorEntity>;
     getIndexerTranslationTargets(node: tree.IndexerTranslation): GetMultipleTranslationTargetsResult<IndexerEntity>;
-    getFunctionSignature(entity: FunctionEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getOperatorSignature(entity: OperatorEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getPackageFunctionSignature(entity: PackageFunctionEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getMethodSignature(entity: MethodEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getFunctionTypeSignature(entity: FunctionTypeEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getConstructorSignature(entity: ConstructorEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getDestructorSignature(entity: DestructorEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getIndexerSignature(entity: IndexerEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getTypeHeader(entity: TypeEntityWithHeaderLocalization): LocalizedTypeHeader.Translated | undefined;
-    getEntityName(entity: NamedEntity): Name | undefined;
+    getFunctionSignature(entity: FunctionEntity): TranslatedSubprogramSignature | undefined;
+    getOperatorSignature(entity: OperatorEntity): TranslatedSubprogramSignature | undefined;
+    getPackageFunctionSignature(entity: PackageFunctionEntity): TranslatedSubprogramSignature | undefined;
+    getMethodSignature(entity: MethodEntity): TranslatedSubprogramSignature | undefined;
+    getFunctionTypeSignature(entity: FunctionTypeEntity): TranslatedSubprogramSignature | undefined;
+    getConstructorSignature(entity: ConstructorEntity): TranslatedSubprogramSignature | undefined;
+    getDestructorSignature(entity: DestructorEntity): TranslatedSubprogramSignature | undefined;
+    getIndexerSignature(entity: IndexerEntity): TranslatedSubprogramSignature | undefined;
+    getTypeHeader(entity: TypeEntityWithHeaderLocalization): TranslatedTypeHeader | undefined;
+    getEntityName(entity: NamedEntity): TranslatedName | undefined;
+    private createLocalizedPackageByOriginalReferencedPackage;
     private createPackageMembers;
     private createTypeEntityMembers;
     private createTranslatedSubprogramSignatureFromPackageFunctionTranslation;
@@ -64,94 +68,54 @@ export declare class AnalyzedTranslationPackage {
 }
 export declare class TranslatedPackageMembers {
     private readonly _namedMembers;
-    private readonly _membersByNameKey;
     private readonly _nameByEntity;
-    private get membersByNameKey();
     private get nameByEntity();
     constructor(_namedMembers: readonly TranslatedNamedPackageMember[]);
     getNamedMembers(): readonly TranslatedNamedPackageMember[];
-    getNamedMembersByName(name: Name): readonly TranslatedNamedPackageMember[];
-    getMemberName(entity: NamedPackageMemberEntity): Name | undefined;
+    getMemberName(entity: NamedPackageMemberEntity): TranslatedName | undefined;
 }
 export declare class TranslatedNamedPackageMember {
     readonly value: NamedPackageMemberEntity;
-    readonly name: LocalizedName.Translated;
-    constructor(value: NamedPackageMemberEntity, name: LocalizedName.Translated);
+    readonly name: TranslatedName;
+    constructor(value: NamedPackageMemberEntity, name: TranslatedName);
 }
 export declare class TranslatedTypeEntityMembers {
     private readonly _namedMembers;
     readonly translationPackage: AnalyzedTranslationPackage;
-    private readonly _membersByNameKey;
     private readonly _nameByEntity;
-    private get membersByNameKey();
     private get nameByEntity();
     constructor(_namedMembers: readonly TranslatedNamedTypeEntityMember[], translationPackage: AnalyzedTranslationPackage);
     getNamedMembers(): readonly TranslatedNamedTypeEntityMember[];
-    getNamedMembersByName(name: Name): readonly TranslatedNamedTypeEntityMember[];
-    getMemberName(entity: NamedTypeMemberEntity): Name | undefined;
+    getMemberName(entity: NamedTypeMemberEntity): TranslatedName | undefined;
 }
 export declare class TranslatedNamedTypeEntityMember {
     readonly value: NamedTypeMemberEntity;
-    readonly name: LocalizedName.Translated;
-    constructor(value: NamedTypeMemberEntity, name: LocalizedName.Translated);
+    readonly name: TranslatedName;
+    constructor(value: NamedTypeMemberEntity, name: TranslatedName);
 }
-export type LocalizedSubprogramSignature = LocalizedSubprogramSignature.Original | LocalizedSubprogramSignature.Translated;
-export declare namespace LocalizedSubprogramSignature {
-    export class Original implements ILocalizedSubprogramSignature {
-        readonly typeParameters: readonly Name[];
-        readonly valueParameters: readonly Name[];
-        readonly locale: PackageLocale;
-        readonly kind = "original";
-        constructor(typeParameters: readonly Name[], valueParameters: readonly Name[], locale: PackageLocale);
-        getTypeParameterNames(): readonly LocalizedName[];
-        getValueParameterNames(): readonly LocalizedName[];
-    }
-    export class Translated implements ILocalizedSubprogramSignature {
-        readonly typeParameters: readonly TranslatedTypeParameter[];
-        readonly valueParameters: readonly TranslatedValueParameter[];
-        readonly kind = "translated";
-        constructor(typeParameters: readonly TranslatedTypeParameter[], valueParameters: readonly TranslatedValueParameter[]);
-        getTypeParameterNames(): readonly LocalizedName[];
-        getValueParameterNames(): readonly LocalizedName[];
-        getTypeParameterName(entity: TypeParameterEntity): Name | undefined;
-        getValueParameterName(entity: ParameterVariableEntity): Name | undefined;
-    }
-    interface ILocalizedSubprogramSignature {
-        getTypeParameterNames(): readonly LocalizedName[];
-        getValueParameterNames(): readonly LocalizedName[];
-    }
-    export {};
+export declare class TranslatedSubprogramSignature {
+    readonly translation: Translation;
+    readonly typeParameters: readonly TranslatedTypeParameter[];
+    readonly valueParameters: readonly TranslatedValueParameter[];
+    constructor(translation: Translation, typeParameters: readonly TranslatedTypeParameter[], valueParameters: readonly TranslatedValueParameter[]);
+    getTypeParameterName(entity: TypeParameterEntity): TranslatedName | undefined;
+    getValueParameterName(entity: ParameterVariableEntity): TranslatedName | undefined;
 }
 export declare class TranslatedTypeParameter {
     readonly value: TypeParameterEntity;
-    readonly name: LocalizedName.Translated;
-    constructor(value: TypeParameterEntity, name: LocalizedName.Translated);
+    readonly name: TranslatedName;
+    constructor(value: TypeParameterEntity, name: TranslatedName);
 }
 export declare class TranslatedValueParameter {
     readonly value: ParameterVariableEntity;
-    readonly name: LocalizedName.Translated;
-    constructor(value: ParameterVariableEntity, name: LocalizedName.Translated);
+    readonly name: TranslatedName;
+    constructor(value: ParameterVariableEntity, name: TranslatedName);
 }
-export type LocalizedTypeHeader = LocalizedTypeHeader.Original | LocalizedTypeHeader.Translated;
-export declare namespace LocalizedTypeHeader {
-    export class Original implements ILocalizedTypeHeader {
-        readonly typeParameters: readonly Name[];
-        readonly locale: PackageLocale;
-        readonly kind = "original";
-        constructor(typeParameters: readonly Name[], locale: PackageLocale);
-        getTypeParameterNames(): readonly LocalizedName[];
-    }
-    export class Translated implements ILocalizedTypeHeader {
-        readonly typeParameters: readonly TranslatedTypeParameter[];
-        readonly kind = "translated";
-        constructor(typeParameters: readonly TranslatedTypeParameter[]);
-        getTypeParameterNames(): readonly LocalizedName[];
-        getTypeParameterName(entity: TypeParameterEntity): Name | undefined;
-    }
-    interface ILocalizedTypeHeader {
-        getTypeParameterNames(): readonly LocalizedName[];
-    }
-    export {};
+export declare class TranslatedTypeHeader {
+    readonly translation: Translation;
+    readonly typeParameters: readonly TranslatedTypeParameter[];
+    constructor(translation: Translation, typeParameters: readonly TranslatedTypeParameter[]);
+    getTypeParameterName(entity: TypeParameterEntity): TranslatedName | undefined;
 }
 export type TypeEntityWithHeaderLocalization = StructuredTypeEntity | VariantTypeEntity | AliasTypeEntity;
 export declare class GetSingleTranslationTargetResult<T> {
@@ -174,3 +138,8 @@ export declare class GetMultipleTranslationTargetsResult<T> {
     static invalid<T>(diagnostics: readonly Diagnostic[]): GetMultipleTranslationTargetsResult<T>;
     static invalid<T>(diagnostics: readonly Diagnostic[], targets: readonly T[], isAmbiguous: boolean): GetMultipleTranslationTargetsResult<T>;
 }
+export declare class TranslatedName {
+    readonly value: Name;
+    readonly translation: Translation;
+    constructor(value: Name, translation: Translation);
+}

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

@@ -1,11 +1,10 @@
 import ts from 'typescript';
-import { CancellationToken, Lazy, Name, PackageLocale, Range, SearchName, WithDiagnostics } from '../common/index.js';
+import { CancellationToken, Lazy, Name, PackageLocale, Range, WithDiagnostics } from '../common/index.js';
 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 { OriginalPackageMembers } from '../entities/PackageMembers.js';
-import { NamedTypeMemberEntity } from '../entities/TypeEntityMembers.js';
+import { PackageEntityMembers } from '../entities/PackageMembers.js';
 import * as e from '../entities/index.js';
 import { ReservedIdentifierKind } from '../parser/ReservedIdentifierDictionary.js';
 import * as project from '../project/index.js';
@@ -23,13 +22,10 @@ import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import * as constructorOverloadResolver from './ConstructorOverloadResolver.js';
 import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
 import * as dereferenceExpressionMeaning from './DereferenceExpressionMeaning.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 import * as functionOverloadResolver from './FunctionOverloadResolver.js';
 import * as identifierExpressionResolution from './IdentifierExpressionMeaning.js';
 import { ImportedPackageNameTree, PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import * as indexedAccessExpressionMeaning from './IndexedAccessExpressionMeaning.js';
-import { WithLocalization } from './Localization.js';
-import { LocalizationContext } from './LocalizationContext.js';
 import * as memberAccessExpressionResolution from './MemberAccessExpressionMeaning.js';
 import { ModifierFlags } from './ModifierFlags.js';
 import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver.js';
@@ -52,8 +48,16 @@ export declare class Analyzer {
      * Пакет с именем 'Артель', содержащий стандартные типы.
      */
     readonly systemPackage: e.PackageEntity;
-    readonly wellKnownDeclarations: WellKnownDeclarations;
-    readonly standardTypes: types.StandardTypes;
+    /**
+     * Стандартные объявления на языке оригинала. Для получения стандартных объявлений на желаемом языке используйте
+     * {@link getLocalizedWellKnownDeclarations}.
+     */
+    readonly originalWellKnownDeclarations: WellKnownDeclarations;
+    /**
+     * Стандартные типы на языке оригинала. Для получения стандартных типов на желаемом языке используйте
+     * {@link getLocalizedStandardTypes}.
+     */
+    readonly originalStandardTypes: types.StandardTypes;
     readonly typeFactory: TypeFactory;
     readonly type: Type;
     readonly returnType: ReturnType;
@@ -101,6 +105,10 @@ export declare class Analyzer {
     private readonly _sourcePackageMemberConflictsDiagnostics;
     private readonly _notExplicitlyImplementedAbstractTypeMembers;
     private readonly _typeMemberImplementationCheckResults;
+    private _originalPackageEntitiesByNameKey;
+    private _packageEntitiesByNameKey;
+    private readonly _localizedWellKnownDeclarations;
+    private readonly _localizedStandardTypes;
     get tsInterop(): TsInteropContext;
     constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
     getProjectSourceFile(node: tree.SourceFile): project.SourceFile;
@@ -172,11 +180,9 @@ export declare class Analyzer {
     checkIdentifierNameIsReserved(name: string, locale: PackageLocale): ReservedIdentifierKind | undefined;
     getReservedIdentifierName(reservedIdentifierKind: ReservedIdentifierKind, locale: PackageLocale): string;
     createNameFromIdentifier(node: tree.Identifier): Name;
-    createSearchNameFromIdentifier(identifier: tree.Identifier): SearchName;
-    createLocalizationContext(sourceFile: project.SourceFile): LocalizationContext;
     getImplicitBaseTypeForStructuredType(entity: e.StructuredTypeEntity): types.StructuredType | undefined;
-    getImplicitBaseTypeForVariantType(): types.StructuredType;
-    getImplicitBaseTypeForFunctionType(): types.StructuredType;
+    getImplicitBaseTypeForVariantType(locale: PackageLocale): types.StructuredType;
+    getImplicitBaseTypeForFunctionType(locale: PackageLocale): types.StructuredType;
     resolveNamedTypeSpecifier(node: tree.NamedTypeSpecifier): NamedTypeSpecifierResolutionResult;
     checkExpressionDenotesType(expression: tree.Expression): {
         type: types.Type | undefined;
@@ -192,13 +198,16 @@ export declare class Analyzer {
     checkFunctionBlockWithYieldStatement(node: tree.FunctionBlock): boolean;
     enumerateAspects(type: types.Type): Iterable<types.StructuredType>;
     checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: e.StructuredTypeEntity): boolean;
-    resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
-    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
-    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
+    resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): WithDiagnostics<types.Operator>;
+    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): WithDiagnostics<types.Operator>;
+    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): WithDiagnostics<types.Operator>;
     classifyBinaryExpressionOperator(operator: tree.BinaryExpressionOperator): BinaryExpressionOperatorClassificationResult;
     getBinaryOperatorKindIfCompoundAssignmentOperator(operator: tree.AssignmentStatementOperator): BinaryOperatorKind | undefined;
+    getOriginalPackageEntities(): readonly e.PackageEntity[];
     getPackageEntities(): readonly e.PackageEntity[];
-    getPackageEntity(name: PackageName): e.PackageEntity | undefined;
+    getOriginalPackageEntityByName(name: PackageName): e.PackageEntity | undefined;
+    getPackageEntityByName(name: PackageName): e.PackageEntity | undefined;
+    getAnalyzedTranslationPackages(): readonly AnalyzedTranslationPackage[];
     createFunctionTypeInvokeMethod(entity: e.FunctionTypeEntity): e.MethodEntity;
     /**
      * Преобразует тип таким образом, чтобы он не мог содержать значение `пусто`.
@@ -222,13 +231,16 @@ export declare class Analyzer {
     canTypeParameterBeNone(type: types.ParameterType): boolean;
     /**
      * Делает тип `Пусто` совместимым с данным типом.
+     *
+     * @param locale Язык для типа Пусто.
+     *
      * @example
      * - Число         -> Число | Пусто
      * - Число | Пусто -> Число | Пусто
      * - Т: Объект?    -> (Т: Объект?) | Пусто (см. метод isNoneAssignableToType)
      * - Т: Объект     -> (Т: Объект) | Пусто
      */
-    includeNoneToType(type: types.Type): types.Type;
+    includeNoneToType(type: types.Type, locale: PackageLocale): types.Type;
     /**
      * Отвечает на вопрос "Совместим ли тип `Пусто` с данным типом?" (Можно ли присвоить `пусто` в переменную с данным типом?).
      * @example Для следующих типов метод вернёт:
@@ -239,16 +251,17 @@ export declare class Analyzer {
     isNoneAssignableToType(type: types.Type): boolean;
     excludeTypeFromUnion(initialType: types.Type, excludedType: types.Type): types.Type;
     isValueParameterVariadic(entity: e.VariableEntity): boolean;
-    getDefaultTypeParameterConstraint(): types.Type;
+    getDefaultTypeParameterConstraint(locale: PackageLocale): types.Type;
     getOriginalSignatureTypeOfFunctionEntity(entity: e.FunctionEntity): types.FunctionType;
     getFunctionBlockLiteralValueParameters(node: tree.FunctionBlockLiteral): readonly e.ParameterVariableEntity[];
     getExtendedType(node: tree.TypeExtensionDeclaration): WithDiagnostics<e.NamedTypeEntity>;
     getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
-    getAnalyzedTranslationPackageForPackage(entity: e.PackageEntity, locale: PackageLocale): AnalyzedTranslationPackage | undefined;
+    findAnalyzedTranslationPackageForLocale(entity: e.PackageEntity, locale: PackageLocale): AnalyzedTranslationPackage | undefined;
+    getLocalizedPackageWithLocale(originalPackageEntity: e.PackageEntity, locale: PackageLocale): e.PackageEntity | undefined;
     enumerateAnalyzedTranslationPackages(): Iterable<AnalyzedTranslationPackage>;
     getLinkedMultiPlatformPackagesByPlatform(entity: e.PackageEntity): ReadonlyMap<PlatformKind, LinkedMultiPlatformPackage> | undefined;
     getLinkedMultiPlatformPackage(entity: e.PackageEntity, platform: PlatformKind): LinkedMultiPlatformPackage | undefined;
-    createPackageMembers(pkg: SourcePackage): OriginalPackageMembers;
+    createPackageMembers(pkg: SourcePackage): PackageEntityMembers;
     instantiateType(entity: e.TypeEntity, typeArguments?: readonly types.Type[]): types.Type;
     instantiateType(entity: e.TypeEntity, substitutions?: types.Substitutions): types.Type;
     instantiateTypeByIdentitySubstitution(entity: e.TypeEntity): types.Type;
@@ -262,7 +275,7 @@ export declare class Analyzer {
     createTypeMemberHiding(node: tree.TypeMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
     getDeclarationsUsageCount(sourceFile: tree.SourceFile, cancellationToken: CancellationToken | undefined): Promise<DeclarationsUsageCountResult>;
     createBackingPackageVariables(declaredMembers: readonly (e.NamedPackageMemberEntity | e.PackageAliasEntity)[], pkg: e.PackageEntity): e.PackageVariableEntity[];
-    createBackingFields(declaredMembers: readonly NamedTypeMemberEntity[], type: e.TypeEntity): e.FieldEntity[];
+    createBackingFields(declaredMembers: readonly e.NamedTypeMemberEntity[], type: e.TypeEntity): e.FieldEntity[];
     createNodeDiagnostic(code: DiagnosticCode, node: tree.Node, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
     createSourceFileRangeDiagnostic(code: DiagnosticCode, range: Range, nodeOrSourceFile: tree.Node | project.SourceFile, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
     createDiagnostic(code: DiagnosticCode, location: DiagnosticLocation | undefined, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
@@ -273,14 +286,14 @@ export declare class Analyzer {
         basicMethodOfOriginalType: e.MethodEntity;
     } | undefined;
     getControlFlowGraph(sourceFile: project.SourceFile): controlFlow.GraphBuildResult;
-    createAmbiguousEntityAccessDiagnostic(entities: readonly WithLocalization<e.Entity>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
-    createAmbiguousEntityAccessLazyDiagnostic(entities: readonly WithLocalization<e.Entity>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
-    createAmbiguousFunctionAccessDiagnostic(functions: readonly WithLocalization<AccessedFunction>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
-    createAmbiguousFunctionAccessLazyDiagnostic(functions: readonly WithLocalization<AccessedFunction>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
-    createAmbiguousTypeMemberAccessDiagnostic(members: readonly WithLocalization<types.TypeMember>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
-    createAmbiguousTypeMemberAccessLazyDiagnostic(members: readonly WithLocalization<types.TypeMember>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
-    createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly WithLocalization<semanticContext.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
-    createAmbiguousNamedScopeDeclarationAccessLazyDiagnostic(declarations: readonly WithLocalization<semanticContext.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
+    createAmbiguousEntityAccessDiagnostic(entities: readonly e.Entity[], node: tree.Node): Diagnostic;
+    createAmbiguousEntityAccessLazyDiagnostic(entities: readonly e.Entity[], node: tree.Node): Lazy<Diagnostic>;
+    createAmbiguousFunctionAccessDiagnostic(functions: readonly AccessedFunction[], node: tree.Node): Diagnostic;
+    createAmbiguousFunctionAccessLazyDiagnostic(functions: readonly AccessedFunction[], node: tree.Node): Lazy<Diagnostic>;
+    createAmbiguousTypeMemberAccessDiagnostic(members: readonly types.TypeMember[], node: tree.Node): Diagnostic;
+    createAmbiguousTypeMemberAccessLazyDiagnostic(members: readonly types.TypeMember[], node: tree.Node): Lazy<Diagnostic>;
+    createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly semanticContext.NamedDeclaration[], node: tree.Node): Diagnostic;
+    createAmbiguousNamedScopeDeclarationAccessLazyDiagnostic(declarations: readonly semanticContext.NamedDeclaration[], node: tree.Node): Lazy<Diagnostic>;
     addDiagnosticComputedLazily(diagnostic: Diagnostic): void;
     getAcceptorForDiagnosticsComputedLazily(): DiagnosticAcceptor;
     getSourceFileDiagnosticsComputedLazily(sourceFile: project.SourceFile): readonly Diagnostic[];
@@ -290,6 +303,9 @@ export declare class Analyzer {
     getTypeMemberImplementationCheckResult(typeEntity: e.TypeEntityWithMembers): TypeMemberImplementationCheckResult;
     createEntityContextForTypeDeclaration(node: TypeDeclaration): e.EntityContext;
     isFunctionBlockWithImplicitlyReturnedExpression(node: tree.FunctionBlock): boolean;
+    getLocalizedWellKnownDeclarations(locale: PackageLocale): WellKnownDeclarations;
+    getLocalizedStandardTypes(locale: PackageLocale): types.StandardTypes;
+    determineUnderlyingTypeOfSourceVariantType(memberList: tree.TypeMemberDeclarationList): types.Type;
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -324,8 +340,8 @@ declare class Type {
     constructor(_analyzer: Analyzer);
     ofExpression(node: tree.Expression, targetTypeHint?: TargetTypeHint): types.Type;
     ofTypeSpecifier(node: tree.TypeSpecifier): types.Type;
-    ofAccessedFunction(accessedFunction: WithLocalization<AccessedFunction>): types.Type;
-    ofAccessedOperator(operator: WithLocalization<types.Operator>): types.Type;
+    ofAccessedFunction(accessedFunction: AccessedFunction): types.Type;
+    ofAccessedOperator(operator: types.Operator): types.Type;
     ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral, targetTypeHint?: TargetTypeHint): types.FunctionType;
     ofFunctionLiteral(node: tree.FunctionLiteral, targetTypeHint?: TargetTypeHint): types.FunctionType;
     private ofArrayLiteral;
@@ -646,16 +662,15 @@ declare class PackageImports {
     private readonly _importedPackageNameTrees;
     constructor(_analyzer: Analyzer);
     analyzeExplicitPackageImports(sourceFile: project.SourceFile): AnalyzedPackageImports;
-    getPackagesAvailableForImport(pkg: project.SourcePackage): readonly AvailablePackage[];
+    getPackagesAvailableForImport(pkg: project.SourcePackage): readonly e.PackageEntity[];
     getUniqueImportedPackages(sourceFile: project.SourceFile): readonly PackageImportInfo[];
     getImportedPackageNameTree(node: tree.SourceFile): ImportedPackageNameTree;
     private getAutomaticallyImportedPackages;
 }
 export declare class AnalyzedPackageImport {
     readonly entity: e.PackageEntity | undefined;
-    readonly translationPackage: AnalyzedTranslationPackage | undefined;
     readonly isAliasedImport: e.PackageAliasEntity | undefined;
-    constructor(entity: e.PackageEntity | undefined, translationPackage: AnalyzedTranslationPackage | undefined, isAliasedImport: e.PackageAliasEntity | undefined);
+    constructor(entity: e.PackageEntity | undefined, isAliasedImport: e.PackageAliasEntity | undefined);
 }
 export declare class AnalyzedPackageImports {
     readonly packageImportInfos: Map<tree.PackageImport, AnalyzedPackageImport>;
@@ -664,9 +679,8 @@ export declare class AnalyzedPackageImports {
 }
 export declare class PackageImportInfo {
     readonly entity: e.PackageEntity;
-    readonly translationPackage: AnalyzedTranslationPackage | undefined;
     readonly isAliasedImport: e.PackageAliasEntity | undefined;
-    constructor(entity: e.PackageEntity, translationPackage: AnalyzedTranslationPackage | undefined, isAliasedImport: e.PackageAliasEntity | undefined);
+    constructor(entity: e.PackageEntity, isAliasedImport: e.PackageAliasEntity | undefined);
 }
 declare class TypeUtils {
     private readonly _analyzer;
@@ -732,44 +746,16 @@ declare class ConflictsCheck {
 export type EntityWithoutTypeParametersInSignature = e.ConstructorEntity | e.DestructorEntity | e.OperatorEntity | e.IndexerEntity;
 export type TypeMemberWithoutTypeParametersInSignature = types.Constructor | types.Destructor | types.Operator | types.Indexer;
 export declare class ExpressionDenotesFunctionCheckResult {
-    readonly candidates: readonly WithLocalization<AccessedFunction>[];
-    readonly suitableFunctions: readonly WithLocalization<AccessedFunction>[];
-    get singleSuitableFunction(): WithLocalization<AccessedFunction> | undefined;
-    constructor(candidates: readonly WithLocalization<AccessedFunction>[], suitableFunctions: readonly WithLocalization<AccessedFunction>[]);
+    readonly candidates: readonly AccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
+    get singleSuitableFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
 }
 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>[]);
-}
-type AvailablePackage = AvailablePackage.Original | AvailablePackage.Translated;
-declare namespace AvailablePackage {
-    export class Original implements IAvailablePackage {
-        readonly value: e.PackageEntity;
-        readonly kind = "original";
-        constructor(value: e.PackageEntity);
-        getImportName(): PackageName;
-        getLocale(): PackageLocale;
-        getEntity(): e.PackageEntity;
-        getTranslationPackage(): AnalyzedTranslationPackage | undefined;
-    }
-    export class Translated implements IAvailablePackage {
-        readonly value: AnalyzedTranslationPackage;
-        readonly kind = "translated";
-        constructor(value: AnalyzedTranslationPackage);
-        getImportName(): PackageName;
-        getLocale(): PackageLocale;
-        getEntity(): e.PackageEntity;
-        getTranslationPackage(): AnalyzedTranslationPackage | undefined;
-    }
-    interface IAvailablePackage {
-        getImportName(): PackageName;
-        getLocale(): PackageLocale;
-        getEntity(): e.PackageEntity;
-        getTranslationPackage(): AnalyzedTranslationPackage | undefined;
-    }
-    export {};
+    readonly candidates: readonly types.Operator[];
+    readonly suitableOperators: readonly types.Operator[];
+    get singleSuitableOperator(): types.Operator | undefined;
+    constructor(candidates: readonly types.Operator[], suitableOperators: readonly types.Operator[]);
 }
 export declare class DeclaredTypeMemberEntities {
     readonly variables: readonly e.FieldEntity[];
@@ -779,7 +765,7 @@ export declare class DeclaredTypeMemberEntities {
     readonly destructors: readonly e.DestructorEntity[];
     readonly indexers: readonly e.SourceIndexerEntity[];
     readonly dereferenceOperators: readonly e.DereferenceOperatorEntity[];
-    get namedMembers(): NamedTypeMemberEntity[];
+    get namedMembers(): e.NamedTypeMemberEntity[];
     constructor(variables: readonly e.FieldEntity[], methods: readonly e.MethodEntity[], operators: readonly e.OperatorEntity[], constructors: readonly e.ConstructorEntity[], destructors: readonly e.DestructorEntity[], indexers: readonly e.SourceIndexerEntity[], dereferenceOperators: readonly e.DereferenceOperatorEntity[]);
 }
 export {};

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

@@ -1,29 +1,27 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { ParameterVariableEntity } from '../entities/index.js';
-import { Argument, AutotypeCallExpression, CallExpression, IndexedAccessExpression, Tag } from '../tree/index.js';
+import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
-import { LocalizedName } from './Localization.js';
 import { Analyzer } from './index.js';
 export declare class ArgumentToParameterMatchResult {
     private readonly _analyzer;
     private readonly _matchResults;
     constructor(_analyzer: Analyzer);
-    ofCallExpression(node: CallExpression): MatchResult | undefined;
-    ofAutotypeCallExpression(node: AutotypeCallExpression): MatchResult | undefined;
-    ofTag(node: Tag): MatchResult | undefined;
-    ofIndexedAccessExpression(node: IndexedAccessExpression): MatchResult | undefined;
+    ofCallExpression(node: tree.CallExpression): MatchResult | undefined;
+    ofAutotypeCallExpression(node: tree.AutotypeCallExpression): MatchResult | undefined;
+    ofTag(node: tree.Tag): MatchResult | undefined;
+    ofIndexedAccessExpression(node: tree.IndexedAccessExpression): MatchResult | undefined;
     private convertMatchResult;
     private convertParameter;
 }
 export declare class MatchResult {
-    readonly parameterByArgument: ReadonlyMap<Argument, MatchResultValueParameter>;
+    readonly parameterByArgument: ReadonlyMap<tree.Argument, MatchResultValueParameter>;
     readonly unmatchedParameters: readonly MatchResultValueParameter[];
     readonly diagnostics: readonly Diagnostic[];
-    constructor(parameterByArgument: ReadonlyMap<Argument, MatchResultValueParameter>, unmatchedParameters: readonly MatchResultValueParameter[], diagnostics: readonly Diagnostic[]);
+    constructor(parameterByArgument: ReadonlyMap<tree.Argument, MatchResultValueParameter>, unmatchedParameters: readonly MatchResultValueParameter[], diagnostics: readonly Diagnostic[]);
 }
 export declare class MatchResultValueParameter {
     readonly entity: ParameterVariableEntity;
     readonly type: types.Type;
-    readonly name: LocalizedName;
-    constructor(entity: ParameterVariableEntity, type: types.Type, name: LocalizedName);
+    constructor(entity: ParameterVariableEntity, type: types.Type);
 }

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

@@ -1,7 +1,6 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { AutotypeCallExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 import { Analyzer, TargetTypeHint } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
@@ -20,8 +19,8 @@ declare class Meaning_constructorCall {
      * с ним совместим.
      */
     readonly type: types.Type;
-    readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
-    readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly candidates: readonly types.Constructor[];
+    readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "constructor-call";
     constructor(
     /**
@@ -31,7 +30,7 @@ declare class Meaning_constructorCall {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
 }
 declare class Meaning_unresolved {
     readonly diagnostics: readonly Diagnostic[];

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

@@ -2,7 +2,6 @@ import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 /**
  * "основа" не является самостоятельным выражением и может использоваться только в следующих конструкциях:
  * 1. `основа()` - в конструкторе для вызова базового конструктора или в методе для вызова базового метода.
@@ -41,8 +40,8 @@ declare class Meaning_baseConstructorAccess {
      * с ним совместим.
      */
     readonly type: types.Type;
-    readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
-    readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly candidates: readonly types.Constructor[];
+    readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "base-constructor-access";
     constructor(
     /**
@@ -52,7 +51,7 @@ declare class Meaning_baseConstructorAccess {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
 }
 declare class Meaning_overriddenMethodAccess {
     readonly method: types.Method;

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

@@ -3,26 +3,26 @@ import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { IEntityHidingMatcher, TypeEntityWithMembers } from '../entities/index.js';
 import { Node } from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
-import { LocalizationContext } from './LocalizationContext.js';
 export declare class BaseMemberConflictsValidator {
     private readonly _analyzer;
     private readonly _typeEntity;
     private readonly _hidingMatcher;
-    private readonly _localizationContext;
     private readonly _dialect;
     private readonly _diagnostics;
     private readonly _nodeForDiagnostic;
     private _displayService;
     private get displayService();
-    constructor(_analyzer: Analyzer, _typeEntity: TypeEntityWithMembers, _hidingMatcher: IEntityHidingMatcher, _localizationContext: LocalizationContext, _dialect: PackageDialect | undefined, _diagnostics: DiagnosticAcceptor, _nodeForDiagnostic: Node);
+    constructor(_analyzer: Analyzer, _typeEntity: TypeEntityWithMembers, _hidingMatcher: IEntityHidingMatcher, _dialect: PackageDialect | undefined, _diagnostics: DiagnosticAcceptor, _nodeForDiagnostic: Node);
     validate(): void;
     private getAllNotShadowedNotOverriddenMembers;
-    private validateMemberConflictsMutatingMap;
-    private validateNamedMemberConflictsUsingOriginalNames;
+    private validateMemberConflicts;
     private doTypeMembersConflict;
+    private doNamedTypeMemberConflictInOriginalLanguage;
+    private doNamedTypeMembersConflict;
     private reportMembersConflictDiagnostic;
     private reportMembersOriginalNameConflictConflictDiagnostic;
     private addOverriddenMembersRecursively;
     private typeMemberMatchesHiding;
-    private getOriginalNameOfLeastOverriddenMember;
+    private getOriginalTypeMemberNameConsideringOverriddenMembers;
+    private getLeastOverriddenNamedMember;
 }