@artel/artc 0.6.25207 → 0.6.25208

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>;
@@ -62,9 +65,9 @@ export declare class AnalyzedTranslationPackage {
 }
 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 +82,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 +99,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;
@@ -525,6 +531,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 +542,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 +577,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/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/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

@@ -31,8 +31,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/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';

package/build/types/api/Api.d.ts

@@ -5,6 +5,7 @@ export type { Meaning as AutotypeCallExpressionMeaning } from '../analysis/Autot
 export type { Meaning as BaseExpressionMeaning } from '../analysis/BaseExpressionMeaning.js';
 export { MatchResult, MatchResultValueParameter } from '../analysis/CallArgumentToParameterMatchResult.js';
 export type { Meaning as CallExpressionMeaning } from '../analysis/CallExpressionMeaning.js';
+export * as dereferencedVariableAccess from '../analysis/DereferencedVariableAccess.js';
 export type { Meaning as DereferenceExpressionMeaning } from '../analysis/DereferenceExpressionMeaning.js';
 export * from '../analysis/DiagnosticCollector.js';
 export * from '../analysis/EntityLocalizationHelper.js';
@@ -12,8 +13,8 @@ export * from '../analysis/FindModifier.js';
 export * from '../analysis/FoundDeclaration.js';
 export type { Meaning as IdentifierExpressionMeaning, ResolutionResult as IdentifierExpressionResolutionResult } from '../analysis/IdentifierExpressionMeaning.js';
 export * from '../analysis/ImportedPackageNameTree.js';
+export * as indexedAccess from '../analysis/IndexedAccess.js';
 export type { Meaning as IndexedAccessExpressionMeaning } from '../analysis/IndexedAccessExpressionMeaning.js';
-export * as indexerAccess from '../analysis/IndexerAccess.js';
 export * from '../analysis/Localization.js';
 export * from '../analysis/LocalizationContext.js';
 export * from '../analysis/Lookup.js';
@@ -42,7 +43,6 @@ export * from '../diagnostic/DiagnosticData.js';
 export * from '../emitter/Emitter.js';
 export * from '../entities/index.js';
 export * from '../executor/Compiler.js';
-export * from '../generated/BuiltInSystemPackages.js';
 export * from '../parser/CharacterCodes.js';
 export * from '../parser/KeywordDictionary.js';
 export * from '../parser/ParseNumber.js';

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

@@ -1,4 +1,5 @@
 export declare const enum AccessKind {
     Get = 0,
-    Set = 1
+    Set = 1,
+    GetSet = 2
 }

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

@@ -10,7 +10,7 @@ export declare const LocaleByConfigurationDirectoryName: Map<string, PackageLoca
 export declare const JsonConfigurationFileNamesByLocale: Map<PackageLocale, string[]>;
 export declare const JsonConfigurationFileNameSet: Set<string>;
 export declare const LocaleByJsonConfigurationFileName: Map<string, PackageLocale>;
-export declare const BuiltInSystemPackagesScheme = "artel-builtin";
+export declare const InMemoryPackageScheme = "artel-in-memory";
 export declare const GeneratedSourceFileScheme = "artel-gen";
 export declare const DefaultTsLibDeclarationsFileName = "lib.es2023.d.ts";
 export declare const DefaultLocale = PackageLocale.Ru;

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

@@ -0,0 +1,6 @@
+export declare const validJavaScriptIdentifierStartRegExp: RegExp;
+export declare const invalidJavaScriptIdentifierCharsRegExp: RegExp;
+export declare const javaScriptIdentifierRegExp: RegExp;
+export declare function isJavaScriptIdentifier(text: string, allowReserved?: boolean): boolean;
+export declare function isReservedJavaScriptIdentifier(text: string): boolean;
+export declare const reservedJavaScriptIdentifiers: ReadonlySet<string>;

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

@@ -2,6 +2,7 @@ import { EmitterError } from '../emitter/error-boundary.js';
 import { Node } from '../tree/index.js';
 export declare class Logger {
     static info(message: string): void;
+    static warn(message: string): void;
     static error(message: string): void;
     static error(error: Error | unknown): void;
     static errorAtNode(message: string, node: Node): void;

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

@@ -15,35 +15,26 @@ export declare const enum NameFlags {
      * Имя не может быть отображено без кавычек, например: 'имя с пробелами', '+'.
      */
     RequiresQuotes = 8,
-    /**
-     * Имя с обратным апострофом для превращения служебного слова в обычное имя, например: тип\`, объект\`.
-     */
-    EscapedKeyword = 16,
     /**
      * Имя с обратным апострофом для избежания конфликта между параметром метода и свойством объекта,
      * например: имя\`, 'имя с пробелами'\`.
      */
-    ConflictResolvingParameterName = 32,
+    ConflictResolvingParameterName = 16,
     /**
      * Имя с двойным обратным апострофом для избежания конфликта между вычисляемым свойством и скрытой
      * хранимой переменной объекта, например: длина\`\`, 'имя с пробелами'\`\`.
      */
-    BackingVariableName = 64,
+    BackingVariableName = 32,
     /**
-     * Имя операции, написанное как знак или служебное слово в одиночных кавычках, например: '+', 'как'.
+     * Конвертировать имя в формат kebab case при формировании исходного имени.
      */
-    OperatorSignOrName = 128
+    PreferKebabCase = 64
 }
 export declare class Name {
     /**
      * Исходное имя без одиночных кавычек и без символов '\`' в конце. Не содержит символ '~'.
      */
-    readonly originalWithoutQuotes: string;
-    /**
-     * Исходное имя, при необходимости взятое в одиночные кавычки и содержащее обратные кавычки согласно флагам.
-     * Не содержит символ '~'.
-     */
-    readonly original: string;
+    readonly unescapedOriginalWithoutQuotes: string;
     /**
      * Флаги, указывающие на наличии у имени символов '~', '\`', одиночных кавычек и их смысл.
      */
@@ -65,14 +56,20 @@ export declare class Name {
      */
     get meaningfulBackQuoteCount(): number;
     /**
-     * @param original Имя в том виде, в котором оно записано в исходном коде.
-     * @param flags Дополнительные флаги имени. `NameFlags.None` по умолчанию.
-     * @param preferredOriginal Имя, предпочтительное для использования. Принимается `original` по умолчанию.
+     * Исходное имя, при необходимости взятое в одиночные кавычки и содержащее обратные кавычки согласно флагам.
+     * Не содержит символ '~'.
+     */
+    get unescapedOriginal(): string;
+    /**
+     * @param unescapedOriginalWithoutQuotes Исходное имя без апострофов, одиночных кавычек и экранирования.
+     * @param flags Флаги имени (`NameFlags`). `NameFlags.None` по умолчанию.
      */
-    constructor(original: string, flags?: NameFlags);
+    constructor(unescapedOriginalWithoutQuotes: string, flags?: NameFlags);
+    toConflictResolvingParameterName(): Name;
+    toBackingVariableName(): Name;
     considerEqual(other: Name, considerBackQuotes?: boolean): boolean;
     toString(): string;
-    getPreferredOriginal(flags: NameFlags): string;
-    private static parse;
-    private static toOriginal;
+    getPreferredUnescapedOriginal(flags: NameFlags): string;
+    static parse(original: string, initialFlags?: NameFlags): Name;
+    private static toUnescapedOriginal;
 }

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

@@ -34,6 +34,10 @@ export declare abstract class Query<T> implements Iterable<T> {
     groupByToMap<K>(keySelector: (t: T) => K): Map<K, T[]>;
     groupByToMap<K, V>(keySelector: (t: T) => K, mapFn: (t: T) => V): Map<K, V[]>;
     unique(keySelector?: (t: T) => any): Query<T>;
+    uniqueWithComparator(comparator: (t1: T, t2: T) => boolean): Query<T>;
     uniqueToSet(): Set<T>;
     maxByValue(valueSelector: (t: T) => number): T | undefined;
+    single(): T | undefined;
+    single<K extends T>(fn: (t: T) => t is K): K | undefined;
+    single(fn: (t: T) => boolean): T | undefined;
 }

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

@@ -41,13 +41,11 @@ declare class TypeMemberDeclarationContainer_typeExtension implements ITypeMembe
     constructor(declaration: tree.TypeExtensionDeclaration, memberBlock: tree.TypeMemberDeclarationBlock);
     getNode(): tree.TypeExtensionDeclaration;
     getMemberBlock(): tree.TypeMemberDeclarationBlock;
-    getTypeEntity(_analyzer: Analyzer): TypeEntityWithMembers | undefined;
     getContextualTypeEntity(analyzer: Analyzer): TypeEntity | undefined;
 }
 interface ITypeMemberDeclarationContainer {
     getNode(): StructuredTypeDeclaration | VariantTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeExtensionDeclaration;
     getMemberBlock(): tree.TypeMemberDeclarationBlock;
-    getTypeEntity(analyzer: Analyzer): TypeEntityWithMembers | undefined;
     getContextualTypeEntity(analyzer: Analyzer): TypeEntity | undefined;
 }
 export {};

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

@@ -7,6 +7,7 @@ export * from './Debug.js';
 export * from './Delayed.js';
 export * from './FormatString.js';
 export * from './Interner.js';
+export * from './JavaScriptIdentifier.js';
 export * from './Lazy.js';
 export * from './LocalizationHelper.js';
 export * from './Logger.js';
@@ -14,8 +15,8 @@ export * from './Name.js';
 export * from './NameFormatConversion.js';
 export * from './NonEmptyArray.js';
 export * from './Option.js';
-export * from './PackageLocale.js';
 export * from './PackageDialect.js';
+export * from './PackageLocale.js';
 export * from './Path.js';
 export * from './PerformanceMeasurement.js';
 export * from './Query.js';

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

@@ -1,21 +1,46 @@
-import { GeneratorResult } from '@babel/generator';
-import { Analyzer } from '../analysis/index.js';
-import { CancellationToken, PackageLocale, Uri } from '../common/index.js';
-import { EmitterContext } from './EmitterContext.js';
-import { EntityNameProviderChain } from './EntityNameProviders.js';
+import { Analyzer, SourcePackageDependencyGraph } from '../analysis/index.js';
+import { CancellationToken, Uri } from '../common/index.js';
+import { JavaScriptImplementationConfig, PlatformKind } from '../project/index.js';
+import { NamedEntity, PackageEntity, PackageMemberEntity } from './Entities.js';
 import * as ir from './ir/index.js';
-import { SourceLocation } from './ir/index.js';
 export declare class Emitter {
-    static LaunchFileName: string;
-    static IndexFileName: string;
-    protected readonly _ectx: EmitterContext;
-    protected readonly _options: EmitOptions | undefined;
-    protected constructor(ectx: EmitterContext, options: EmitOptions | undefined);
-    static emitToFileSystem(analyzer: Analyzer, outputUri: Uri, outputAcceptor: OutputAcceptor, options?: EmitOptions, cancellationToken?: CancellationToken): Promise<void>;
-    static emitToString(analyzer: Analyzer, options?: EmitOptions, cancellationToken?: CancellationToken): Promise<string>;
-    protected createMainMethod(packageConstructors: readonly ir.PackageMethodDeclaration[], packageEntryPoints: readonly ir.PackageMethodDeclaration[], locale: PackageLocale): ir.PackageMethodDeclaration;
-    protected createMainMethodCall(mainMethod: ir.PackageMethodDeclaration, location: SourceLocation | undefined): ir.Statement;
-    protected generateJsFile(sourceFile: ir.SourceFile, nameProvider: EntityNameProviderChain): GeneratorResult;
+    static readonly LaunchFileName = "launch.mjs";
+    static readonly IndexFileName = "index.mjs";
+    readonly targetPlatform = PlatformKind.JavaScript;
+    private readonly _analyzer;
+    private readonly _declarationsUsageCountResults;
+    private readonly _options;
+    private readonly _entityMap;
+    private readonly _ectx;
+    private _packageGraph;
+    get packageGraph(): SourcePackageDependencyGraph;
+    private constructor();
+    static create(analyzer: Analyzer, options?: EmitOptions, cancellationToken?: CancellationToken): Promise<Emitter>;
+    emitToFileSystem(outputUri: Uri, outputAcceptor: OutputAcceptor): Promise<void>;
+    emitToString(): string;
+    private createEmitterPackageFromSource;
+    private enumerateEmittingSourcePackages;
+    private createPackageWithMainMethod;
+    private createMainMethod;
+    private createMainMethodCall;
+    private createUniqueNamesForPackageMembers;
+    private setOutputUris;
+    private addImports;
+    private addExportModifierToAllPackageMemberDeclarations;
+    private renameDeclarationsAndAddImportsInToStringMode;
+    private generateCode;
+    private generateCodeAndSourceMaps;
+    private prepareSourceMap;
+}
+export declare class EmitterPackage {
+    ir: ir.Package;
+    entity: PackageEntity;
+    outputUri: Uri;
+    packageLevelNames: ReadonlySet<string>;
+    entityNameOverrides: ReadonlyMap<NamedEntity, string> | undefined;
+    private _referencedPackageMembers;
+    constructor(ir: ir.Package, entity: PackageEntity);
+    getReferencedPackageMembers(): ReferencedPackageMembers;
 }
 export interface OutputAcceptor {
     clearDirectory(uri: Uri): Promise<void>;
@@ -59,3 +84,12 @@ export declare enum ImportEmitKind {
      */
     CustomWithFallbackToDynamic = 3
 }
+declare class ReferencedPackageMembers {
+    readonly entitiesByPackage: ReadonlyMap<PackageEntity, ReadonlySet<PackageMemberEntity>>;
+    constructor(entitiesByPackage: ReadonlyMap<PackageEntity, ReadonlySet<PackageMemberEntity>>);
+    excludeMembersOfPackage(entity: PackageEntity): ReferencedPackageMembers;
+    getNamesOfGlobalJsDeclarations(): ReadonlySet<string>;
+    getEntitiesFromJs(): ReadonlyMap<JavaScriptImplementationConfig, ReadonlySet<PackageMemberEntity>>;
+    getEntitiesFromArtel(): ReadonlyMap<PackageEntity, ReadonlySet<PackageMemberEntity>>;
+}
+export {};