@artel/artc 0.6.25207 → 0.6.25209

package/build/{chunk-OORYH37I.js → chunk-GKEW2LBL.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-FYWHIGGV.js";
+} from "./chunk-4EDLYSNW.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-F6DF37J3.js";
+} from "./chunk-5SWGY25I.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";
@@ -224,18 +224,20 @@ var NodeCompiler = class {
       return new PhysicalTypeScriptLibrariesProvider(standardLibraryUri);
     });
   }
-  static loadCompilation(projectPath, tsLibrariesProvider, diagnostics, workspacePath, standardPackagesPath, cancellationToken) {
+  static loadCompilation(projectPath, tsLibrariesProvider, diagnostics, options, cancellationToken) {
     return __async(this, null, function* () {
       const projectUri = FileSystemUri.pathToUri(projectPath);
-      const workspaceUri = workspacePath !== void 0 ? FileSystemUri.pathToUri(workspacePath) : void 0;
-      const standardPackagesUri = standardPackagesPath !== void 0 ? FileSystemUri.pathToUri(standardPackagesPath) : void 0;
+      const loadCompilationOptions = {
+        workspaceUri: options?.workspacePath !== void 0 ? FileSystemUri.pathToUri(options.workspacePath) : void 0,
+        builtInsStandardPackagesUri: options?.builtInsStandardPackagesPath !== void 0 ? FileSystemUri.pathToUri(options.builtInsStandardPackagesPath) : void 0,
+        userStandardPackagesUri: options?.userStandardPackagesPath !== void 0 ? FileSystemUri.pathToUri(options.userStandardPackagesPath) : void 0
+      };
       return yield Compiler.loadCompilation(
         projectUri,
         this.fileSystem,
         tsLibrariesProvider,
         diagnostics,
-        workspaceUri,
-        standardPackagesUri,
+        loadCompilationOptions,
         cancellationToken
       );
     });
@@ -282,8 +284,7 @@ var NodeCompiler = class {
         task.projectPath,
         typeScriptLibrariesProvider,
         task.diagnostics,
-        task.workspacePath,
-        task.standardPackagesPath,
+        task.loadCompilationOptions,
         task.cancellationToken
       );
       if (compilation === void 0) {
@@ -386,16 +387,18 @@ var CommandLineCompiler = class {
             fileURLToPath(new URL("..", import.meta.url))
           ],
           projectPath: parsedArguments.projectPath,
+          loadCompilationOptions: {
+            workspacePath: parsedArguments.workspacePath,
+            userStandardPackagesPath: parsedArguments.standardPackagesPath,
+            builtInsStandardPackagesPath: parsedArguments.builtInStandardPackagesPath
+          },
           outputPath: parsedArguments.outputPath,
-          workspacePath: parsedArguments.workspacePath,
-          standardPackagesPath: parsedArguments.standardPackagesPath,
           diagnostics,
           defaultTsLibraryPath: parsedArguments.defaultTsLibraryPath,
           emitOptions: {
             sourceMap: {
               mode: "linked" /* Linked */,
-              includeSourcesContent: true,
-              justApplicationCode: false
+              includeSourcesContent: false
             }
           }
         };
@@ -465,7 +468,8 @@ var ArgumentsParser = class {
       measurePerformance: false,
       defaultTsLibraryPath: void 0,
       workspacePath: void 0,
-      standardPackagesPath: void 0
+      standardPackagesPath: void 0,
+      builtInStandardPackagesPath: void 0
     };
     const index = this.parseMainCommand(0, args, result);
     this.parseNamedArguments(index, args, result);
@@ -563,6 +567,15 @@ var ArgumentsParser = class {
           }
           break;
         }
+        case "--built-in-standard-packages":
+        case "--\u0432\u0441\u0442\u0440\u043E\u0435\u043D\u043D\u044B\u0435-\u0441\u0442\u0430\u043D\u0434\u0430\u0440\u0442\u043D\u044B\u0435-\u043F\u0430\u043A\u0435\u0442\u044B": {
+          const path = this.tryParseStringArgument(index + 1, args);
+          if (path !== void 0) {
+            result.builtInStandardPackagesPath = resolve(cwd, path);
+            index++;
+          }
+          break;
+        }
         case "--\u0431\u0435\u0437-\u043F\u0440\u0435\u0434\u0443\u043F\u0440\u0435\u0436\u0434\u0435\u043D\u0438\u0439":
         case "--no-warnings": {
           result.noWarnings = true;

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

@@ -35,7 +35,10 @@ export declare class AnalyzedTranslationPackage {
     getPackageMethodTranslationTargets(node: tree.PackageMethodTranslation): GetMultipleTranslationTargetsResult<PackageMethodEntity>;
     getMethodTypeTranslationTarget(node: tree.MethodTypeTranslation): GetSingleTranslationTargetResult<PackageMethodTypeEntity>;
     getTypeTranslationTarget(node: tree.TypeTranslation): GetSingleTranslationTargetResult<PackageTypeEntity>;
-    getTypeVariableOrVariantTranslationTarget(node: tree.TypeVariableOrVariantTranslation): GetSingleTranslationTargetResult<TypeVariableEntity | VariantEntity>;
+    /**
+     * В случае, когда имя переменной экземпляра совпадает с именем статической переменной, перевод будет иметь две цели.
+     */
+    getTypeVariableOrVariantTranslationTargets(node: tree.TypeVariableOrVariantTranslation): GetMultipleTranslationTargetsResult<TypeVariableEntity | VariantEntity>;
     getTypeMethodTranslationTargets(node: tree.TypeMethodTranslation): GetMultipleTranslationTargetsResult<TypeMethodEntity>;
     getConstructorTranslationTargets(node: tree.ConstructorTranslation): GetMultipleTranslationTargetsResult<ConstructorEntity>;
     getIndexerTranslationTargets(node: tree.IndexerTranslation): GetMultipleTranslationTargetsResult<IndexerEntity>;
@@ -53,18 +56,19 @@ export declare class AnalyzedTranslationPackage {
     private createVariants;
     private createTranslatedSubprogramSignatureFromPackageMethodTranslation;
     private createTranslatedSubprogramSignatureFromTypeMethodTranslation;
-    private createTranslatedSubprogramSignatureFromMethodTypeAlias;
-    private createTranslatedSubprogramSignatureFromConstructorAlias;
-    private createTranslatedSubprogramSignatureFromIndexerAlias;
+    private createTranslatedSubprogramSignatureFromMethodTypeTranslation;
+    private createTranslatedSubprogramSignatureFromConstructorTranslation;
+    private createTranslatedSubprogramSignatureFromIndexerTranslation;
+    private createTranslatedSubprogramSignatureForDefaultConstructor;
     private createTranslatedTypeSignature;
     private enumerateTranslationsDeclarations;
     private findTypeTranslation;
 }
 export declare class TranslatedPackageMembers {
     private readonly _namedMembers;
-    private readonly _membersByUniversalName;
+    private readonly _membersByNameKey;
     private readonly _nameByEntity;
-    private get membersByUniversalName();
+    private get membersByNameKey();
     private get nameByEntity();
     constructor(_namedMembers: readonly TranslatedNamedPackageMember[]);
     getNamedMembers(): readonly TranslatedNamedPackageMember[];
@@ -79,9 +83,9 @@ export declare class TranslatedNamedPackageMember {
 export declare class TranslatedTypeEntityMembers {
     private readonly _namedMembers;
     readonly translationPackage: AnalyzedTranslationPackage;
-    private readonly _membersByUniversalName;
+    private readonly _membersByNameKey;
     private readonly _nameByEntity;
-    private get membersByUniversalName();
+    private get membersByNameKey();
     private get nameByEntity();
     constructor(_namedMembers: readonly TranslatedNamedTypeEntityMember[], translationPackage: AnalyzedTranslationPackage);
     getNamedMembers(): readonly TranslatedNamedTypeEntityMember[];
@@ -96,9 +100,9 @@ export declare class TranslatedNamedTypeEntityMember {
 export declare class TranslatedVariants {
     private readonly _variants;
     readonly translationPackage: AnalyzedTranslationPackage;
-    private readonly _variantsByUniversalName;
+    private readonly _variantsByNameKey;
     private readonly _nameByEntity;
-    private get variantsByUniversalName();
+    private get variantsByNameKey();
     private get nameByEntity();
     constructor(_variants: readonly TranslatedVariant[], translationPackage: AnalyzedTranslationPackage);
     get(): readonly TranslatedVariant[];

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

@@ -1,9 +1,10 @@
 import ts from 'typescript';
-import { AccessKind, CancellationToken, Name, PackageLocale, Range, SearchName, WithDiagnostics } from '../common/index.js';
+import { CancellationToken, Name, PackageLocale, Range, SearchName, 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 * 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 { ReservedIdentifierKind } from '../parser/ReservedIdentifierDictionary.js';
@@ -42,7 +43,6 @@ import * as tags from './Tags.js';
 import { TargetTypeHint } from './TargetTypeHint.js';
 import * as typeOverloadResolver from './TypeOverloadResolver.js';
 import { WellKnownDeclarations } from './index.js';
-import { NamedTypeMemberEntity } from '../entities/TypeEntityMembers.js';
 export declare class Analyzer {
     static readonly enumeratorMethodName = "\u043F\u0435\u0440\u0435\u0431\u043E\u0440";
     static readonly methodTypeInvokeMethodName = "\u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u044C";
@@ -110,7 +110,7 @@ export declare class Analyzer {
     } | undefined;
     isTypeAssignableTo(source: types.Type, target: types.Type): boolean;
     checkStatementBlockInvokesAsyncMethods(node: tree.StatementBlock): boolean;
-    getExpressionAccessKind(node: tree.Expression): AccessKind;
+    getSyntacticAccessKind(node: tree.Expression): SyntacticAccessKind;
     getTypeMemberEntityContainer(node: tree.TypeMemberDeclaration): TypeMemberEntityContainer;
     getTargetTypeOfExpression(node: tree.Expression, hint?: TargetTypeHint): types.Type | undefined;
     getUnambiguousTargetMethodType(targetType: types.Type | undefined): types.MethodType | undefined;
@@ -249,6 +249,12 @@ export type BinaryExpressionOperatorClassificationResult = {
 } | {
     kind: 'question-question';
 };
+export declare const enum SyntacticAccessKind {
+    Get = 0,
+    Set = 1,
+    GetSet = 2,
+    ReferencedValue = 3
+}
 declare class Type {
     private readonly _analyzer;
     private readonly _unionTypeSpecifierTypes;
@@ -387,11 +393,11 @@ declare class ResultLocalVariableEntity {
     private readonly _analyzer;
     private readonly _entities;
     constructor(_analyzer: Analyzer);
-    ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): LocalVariableEntity | undefined;
-    ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): LocalVariableEntity | undefined;
-    ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): LocalVariableEntity | undefined;
-    ofMethodLiteral(node: tree.MethodLiteral): LocalVariableEntity | undefined;
-    ofMethodBlockLiteral(node: tree.MethodBlockLiteral): LocalVariableEntity | undefined;
+    ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): LocalVariableEntity;
+    ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): LocalVariableEntity;
+    ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): LocalVariableEntity;
+    ofMethodLiteral(node: tree.MethodLiteral): LocalVariableEntity;
+    ofMethodBlockLiteral(node: tree.MethodBlockLiteral): LocalVariableEntity;
     ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): LocalVariableEntity;
     ofTypeVariableGetterDeclaration(node: tree.TypeVariableGetterDeclaration): LocalVariableEntity;
     ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration): LocalVariableEntity;
@@ -497,7 +503,6 @@ declare class DefaultConstructors {
     private readonly _defaultConstructorEntities;
     constructor(_analyzer: Analyzer);
     ofStructuredType(type: StructuredTypeDeclaration): readonly ConstructorEntity[];
-    createAliasTypeDefaultConstructors(aliasTypeEntity: AliasTypeEntity, hasDeclaredConstructors: boolean): readonly ConstructorEntity[];
     private createDefaultConstructors;
     private getPublicInstanceStoredVariables;
 }
@@ -525,6 +530,7 @@ declare class Tags {
 declare class LinkedEntity {
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
+    entityCanBeLinked(entity: entities.Entity): boolean;
     ofType(entity: TypeEntity, platform: PlatformKind): TypeEntity | undefined;
     ofTypeWithMembers(entity: entities.TypeEntityWithMembers, platform: PlatformKind): entities.TypeEntityWithMembers | undefined;
     ofParameterType(entity: TypeParameterEntity, platform: PlatformKind): TypeParameterEntity | undefined;
@@ -535,6 +541,11 @@ declare class LinkedEntity {
     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;
 }
 export declare class LinkedMultiPlatformPackage {
     readonly analyzer: Analyzer;
@@ -565,13 +576,18 @@ export declare class LinkedTypeWithMembers {
     readonly targetType: entities.TypeEntityWithMembers;
     readonly linkedPackage: LinkedMultiPlatformPackage;
     private readonly _memberLookup;
+    private readonly _variantLookup;
     private get memberLookup();
+    private get variantLookup();
     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;
     getLinkedConstructor(entity: entities.ConstructorEntity): entities.ConstructorEntity | undefined;
-    getLinkedIndexerEntity(entity: entities.IndexerEntity): entities.IndexerEntity | undefined;
-    getLinkedDereferenceOperatorEntity(entity: entities.DereferenceOperatorEntity): entities.DereferenceOperatorEntity | 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 {
     private _analyzer;

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

@@ -12,10 +12,26 @@ export declare class Resolver {
 }
 export type Meaning = Meaning_constructorCall | Meaning_unresolved;
 declare class Meaning_constructorCall {
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    readonly type: types.Type;
     readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly kind = "constructor-call";
-    constructor(candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    constructor(
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
 }
 declare class Meaning_unresolved {
     readonly diagnostics: readonly Diagnostic[];

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

@@ -29,10 +29,26 @@ declare class Meaning_baseObjectAccess {
     constructor(type: types.Type);
 }
 declare class Meaning_baseConstructorAccess {
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    readonly type: types.Type;
     readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly kind = "base-constructor-access";
-    constructor(candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    constructor(
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
 }
 declare class Meaning_overriddenMethodAccess {
     readonly method: types.Method;

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

@@ -26,10 +26,26 @@ declare class Meaning_objectMethodCall {
     constructor(type: types.MethodType);
 }
 declare class Meaning_constructorCall {
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    readonly type: types.Type;
     readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly kind = "constructor-call";
-    constructor(candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    constructor(
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
 }
 declare class Meaning_unresolved {
     readonly diagnostics: readonly Diagnostic[];

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

@@ -1,19 +1,24 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { DereferenceExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
+import * as dereferencedVariableAccess from './DereferencedVariableAccess.js';
 import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 import { Analyzer } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
     private readonly _node;
+    private readonly _semanticContext;
+    private get semanticContext();
     constructor(_analyzer: Analyzer, _node: DereferenceExpression);
     resolve(): Meaning;
+    private convertSyntacticAccessKind;
 }
 export type Meaning = Meaning_resolved | Meaning_unresolved;
 declare class Meaning_resolved {
     readonly operator: FoundAnonymousDeclaration<types.DereferenceOperator>;
+    readonly access: dereferencedVariableAccess.DereferencedVariableAccess;
     readonly kind = "resolved";
-    constructor(operator: FoundAnonymousDeclaration<types.DereferenceOperator>);
+    constructor(operator: FoundAnonymousDeclaration<types.DereferenceOperator>, access: dereferencedVariableAccess.DereferencedVariableAccess);
 }
 declare class Meaning_unresolved {
     readonly diagnostic: Diagnostic | undefined;

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

@@ -0,0 +1,14 @@
+import { AccessKind } from '../common/index.js';
+import { DereferenceOperatorEntity, GetterEntity, SetterEntity } from '../entities/index.js';
+export type DereferencedVariableAccess = {
+    kind: AccessKind.Get;
+    getAccessor: GetterEntity | undefined;
+} | {
+    kind: AccessKind.Set;
+    setAccessor: SetterEntity | undefined;
+} | {
+    kind: AccessKind.GetSet;
+    getAccessor: GetterEntity | undefined;
+    setAccessor: SetterEntity | undefined;
+};
+export declare function create(indexerEntity: DereferenceOperatorEntity, accessKind: AccessKind): DereferencedVariableAccess;

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

@@ -32,11 +32,14 @@ export declare class DiagnosticCollector {
     private checkTypeVariableSetterDeclaration;
     private checkTypeIndexedGetterDeclaration;
     private checkTypeIndexedSetterDeclaration;
+    private checkTypeDereferencedVariableGetterDeclaration;
+    private checkTypeDereferencedVariableSetterDeclaration;
     private checkNestedMethodDeclaration;
     private checkPossibleGeneratorMethodReturnType;
     private checkReturnStatement;
     private checkYieldStatement;
     private checkTypeMemberBodyPresence;
+    private tryGetTypeMemberDeclarationEntity;
     private isAspectTypeMemberDeclaration;
     private collectIdentifierExpressionDiagnostics;
     private collectPropertyAccessExpressionDiagnostics;

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

@@ -10,19 +10,16 @@ import * as scope from './Scope.js';
 import * as variableAccess from './VariableAccess.js';
 import { Analyzer, TargetTypeHint } from './index.js';
 export declare class Resolver {
-    private readonly _identifierValue;
-    private readonly _accessKind;
     private readonly _semanticContext;
     private readonly _analyzer;
     private readonly _node;
     private readonly _targetTypeHint;
-    constructor(analyzer: Analyzer, node: IdentifierExpression, targetTypeHint: TargetTypeHint | undefined);
-    private get identifierSearchName();
-    private get accessKind();
     private get semanticContext();
+    constructor(analyzer: Analyzer, node: IdentifierExpression, targetTypeHint: TargetTypeHint | undefined);
     resolve(): ResolutionResult;
     private resolveMethodOverload;
     private createAccessedMethod;
+    private convertSyntacticAccessKind;
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;

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

@@ -0,0 +1,14 @@
+import { AccessKind } from '../common/index.js';
+import { GetterEntity, IndexerEntity, SetterEntity } from '../entities/index.js';
+export type IndexedAccess = {
+    kind: AccessKind.Get;
+    getAccessor: GetterEntity | undefined;
+} | {
+    kind: AccessKind.Set;
+    setAccessor: SetterEntity | undefined;
+} | {
+    kind: AccessKind.GetSet;
+    getAccessor: GetterEntity | undefined;
+    setAccessor: SetterEntity | undefined;
+};
+export declare function create(indexerEntity: IndexerEntity, accessKind: AccessKind): IndexedAccess;

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

@@ -2,21 +2,24 @@ import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { IndexedAccessExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
-import * as indexerAccess from './IndexerAccess.js';
+import * as indexedAccess from './IndexedAccess.js';
 import { Analyzer } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
     private readonly _node;
+    private readonly _semanticContext;
+    private get semanticContext();
     constructor(_analyzer: Analyzer, _node: IndexedAccessExpression);
     resolve(): Meaning;
     private getArgumentsRangeWithBrackets;
+    private convertSyntacticAccessKind;
 }
 export type Meaning = Meaning_resolved | Meaning_unresolved;
 declare class Meaning_resolved {
     readonly indexer: FoundAnonymousDeclaration<types.Indexer>;
-    readonly access: indexerAccess.IndexerAccess;
+    readonly access: indexedAccess.IndexedAccess;
     readonly kind = "resolved";
-    constructor(indexer: FoundAnonymousDeclaration<types.Indexer>, access: indexerAccess.IndexerAccess);
+    constructor(indexer: FoundAnonymousDeclaration<types.Indexer>, access: indexedAccess.IndexedAccess);
 }
 declare class Meaning_unresolved {
     readonly diagnostic: Diagnostic | undefined;

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

@@ -20,10 +20,26 @@ export declare class Resolver {
 }
 export type Meaning = Meaning_ownConstructorAccess | Meaning_objectAccess | Meaning_unresolved;
 declare class Meaning_ownConstructorAccess {
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    readonly type: types.Type;
     readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly kind = "own-constructor-access";
-    constructor(candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    constructor(
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
 }
 declare class Meaning_objectAccess {
     readonly type: types.Type;
@@ -31,8 +47,8 @@ declare class Meaning_objectAccess {
     constructor(type: types.Type);
 }
 declare class Meaning_unresolved {
-    readonly diagnostic: Diagnostic;
+    readonly diagnostic: Diagnostic | undefined;
     readonly kind = "unresolved";
-    constructor(diagnostic: Diagnostic);
+    constructor(diagnostic: Diagnostic | undefined);
 }
 export {};

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

@@ -8,17 +8,14 @@ import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import * as variableAccess from './VariableAccess.js';
 import { Analyzer, TargetTypeHint } from './index.js';
 export declare class Resolver {
-    private readonly _propertySearchName;
-    private readonly _accessKind;
     private readonly _semanticContext;
     private readonly _analyzer;
     private readonly _node;
     private readonly _targetTypeHint;
-    constructor(analyzer: Analyzer, node: PropertyAccessExpression, targetTypeHint: TargetTypeHint | undefined);
     private get propertySearchName();
-    private get accessKind();
     private get semanticContext();
     private get receiver();
+    constructor(analyzer: Analyzer, node: PropertyAccessExpression, targetTypeHint: TargetTypeHint | undefined);
     resolve(): ResolutionResult;
     private resolvePackageAliasMemberAccessMeaning;
     private resolvePackageMemberAccessMeaning;
@@ -28,6 +25,7 @@ export declare class Resolver {
     private createAccessedMethodFromTypeMember;
     private resolveInstanceMemberAccessMeaning;
     private resolveMethodOverload;
+    private convertSyntacticAccessKind;
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;

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

@@ -1,5 +1,5 @@
 import { IEntityHidingMatcher } from '../entities/EntityHiding.js';
-import { ConstructorEntity, PackageEntity, TypeEntityWithMembers, TypeExtensionEntity } from '../entities/index.js';
+import { ConstructorEntity, PackageEntity, TypeEntity, TypeEntityWithMembers, TypeExtensionEntity } from '../entities/index.js';
 import { SourceFile } from '../project/SourceFile.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -107,18 +107,18 @@ export declare namespace TypeOrTypeExtension {
         readonly value: TypeEntityWithMembers;
         readonly kind = "type";
         constructor(value: TypeEntityWithMembers);
-        getTypeEntity(): TypeEntityWithMembers | undefined;
+        getContextualTypeEntity(): TypeEntity | undefined;
         getEntity(): TypeEntityWithMembers;
     }
     export class TypeExtension implements ITypeOrTypeExtension {
         readonly value: TypeExtensionEntity;
         readonly kind = "type-extension";
         constructor(value: TypeExtensionEntity);
-        getTypeEntity(): TypeEntityWithMembers | undefined;
+        getContextualTypeEntity(): TypeEntity | undefined;
         getEntity(): TypeExtensionEntity;
     }
     interface ITypeOrTypeExtension {
-        getTypeEntity(): TypeEntityWithMembers | undefined;
+        getContextualTypeEntity(): TypeEntity | undefined;
         getEntity(): TypeEntityWithMembers | TypeExtensionEntity;
     }
     export {};

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

@@ -2,9 +2,13 @@ import { AccessKind } from '../common/index.js';
 import { GetterEntity, SetterEntity, VariableEntity } from '../entities/index.js';
 export type VariableAccess = {
     kind: AccessKind.Get;
-    accessorEntity: GetterEntity | undefined;
+    getAccessor: GetterEntity | undefined;
 } | {
     kind: AccessKind.Set;
-    accessorEntity: SetterEntity | undefined;
+    setAccessor: SetterEntity | undefined;
+} | {
+    kind: AccessKind.GetSet;
+    getAccessor: GetterEntity | undefined;
+    setAccessor: SetterEntity | undefined;
 };
 export declare function create(entity: VariableEntity, accessKind: AccessKind): VariableAccess;

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

@@ -30,5 +30,6 @@ export declare class WellKnownDeclarations {
     parameterArray: AliasTypeEntity;
     defaultImport: StructuredTypeEntity;
     realName: StructuredTypeEntity;
+    builtIntoPlatform: StructuredTypeEntity;
     typeVariableProxy: StructuredTypeEntity;
 }

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

@@ -1,8 +1,10 @@
-export * from './CallArgumentsToParametersMatcher.js';
 export * from './Analyzer.js';
+export * from './CallArgumentsToParametersMatcher.js';
+export * from './DeclarationsUsageCounter.js';
+export * from './DiagnosticCollector.js';
 export * from './FindModifier.js';
 export * from './OverloadResolver.js';
-export * from './DiagnosticCollector.js';
+export * from './SourcePackageDependencyGraph.js';
 export * from './TargetTypeHint.js';
 export * from './Visitor.js';
 export * from './WellKnownDeclarations.js';