@artel/artc 0.6.25207 → 0.6.25209

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

@@ -14,7 +14,7 @@ export declare abstract class Query<T> implements Iterable<T> {
     toMap<K, V>(keySelector: (t: T) => K, valueSelector: (t: T) => V): Map<K, V>;
     flatMap<K>(fn: (t: T) => Iterable<K>): Query<K>;
     toArray(): T[];
-    count(): number;
+    count(fn?: (t: T) => boolean): number;
     chain(other: Iterable<T>): Query<T>;
     filter<K extends T>(fn: (t: T) => t is K): Query<K>;
     filter(fn: (t: T) => boolean): Query<T>;
@@ -34,6 +34,11 @@ 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;
+    minByValue(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 {};

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

@@ -1,344 +1,49 @@
-import { SourcePackageDependencyGraph } from '../analysis/SourcePackageDependencyGraph.js';
-import * as tags from '../analysis/Tags.js';
-import { Analyzer } from '../analysis/index.js';
-import { CancellationToken, PackageLocale, Uri } from '../common/index.js';
-import { OriginalPackageMembers } from '../entities/PackageMembers.js';
-import { AliasTypeEntity, ConstructorEntity, DereferenceOperatorEntity, Entity, EntityKind, IndexerEntity, InterfacePackageEntityInfo, MethodEntity, MethodTypeEntity, PackageAliasEntity, PackageEntity, PackageEntityDefinition, PackageMemberEntity, PackageVariableEntity, StructuredTypeEntity, TypeEntity, TypeEntityWithMembers, TypeMethodEntity, TypeParameterEntity, TypeVariableEntity, VariableEntity, VariantEntity, VariantTypeEntity } from '../entities/index.js';
-import { JavaScriptImplementationConfig, PackageName, PlatformKind, ProgramPackage, SourceFile as ProjectSourceFile } from '../project/index.js';
-import * as types from '../types/index.js';
-import { EmitterPackage } from './EmitterPackage.js';
-import { EntityNameProvider, RegisteredEntityNames } from './EntityNameProviders.js';
-import * as ir from './ir/index.js';
-import { AssignmentExpression, AssignmentOperator, BaseConstructorCallExpression, BinaryExpressionOperator, BlockStatement, CallArguments, Expression, MethodAccessExpression, OrderedCallArguments, OwnConstructorCallExpression, SourceFile, TypeMethodAccessExpression, TypeVariableAccessExpression, UnorderedCallArguments, VariableAccessExpression } from './ir/index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
+import { Type, TypeOrExtensionEntity } from './Entities.js';
+import { EntityMap } from './EntityMap.js';
+import { Expression } from './ir/index.js';
 export declare class EmitterContext {
     readonly analyzer: Analyzer;
-    readonly targetPlatform: PlatformKind;
-    readonly extensionLikeMembers: ExtensionLikeMembers;
-    readonly type: Type;
-    readonly utils: Utils;
-    readonly membersForCopyOnWrite: MembersForCopyOnWriteContext;
-    readonly realName: RealName;
-    readonly linker: ExternalDeclarationLinker;
-    readonly helperMethods: HelperMethods;
-    readonly jsStandardTypes: JsStandardTypes;
-    readonly generatedName: GeneratedName;
-    private readonly _declarationsUsageCountResults;
-    private readonly _emitterPackages;
-    private readonly _packageMethodByPackageVariableGetter;
-    private readonly _packageMethodByPackageVariableSetter;
-    private readonly _typeMethodByIndexedGetter;
-    private readonly _typeMethodByIndexedSetter;
-    private readonly _typeDereferencedVariableVariableByDereferenceOperator;
-    private readonly _overloadedConstructorGroupByType;
-    private readonly _typeMethodNamesByType;
-    private readonly _typeMethodByPlainObjectConstructor;
-    private readonly _plainObjectDefaultEmptyConstructorByPlainObject;
-    private readonly _proxyTypeVariables;
-    private readonly _lazySystemForJavaScriptPackage;
-    private readonly _lazySystemInteroperabilityPackage;
-    private readonly _esPackage;
-    private readonly _packageByPackageMember;
-    private readonly _registeredEntityNamesForCompilation;
-    private _packageGraph;
-    private readonly _isConstantPlainObjectResults;
-    get systemPackage(): PackageEntity;
-    get systemJavaScriptPackage(): PackageEntity;
-    get systemInteroperabilityPackage(): PackageEntity;
-    get platformJavaScriptPackage(): PackageEntity;
-    get standardTypes(): types.StandardTypes;
-    get packageByPackageMember(): ReadonlyMap<Entity, EmitterPackage>;
-    get registeredEntityNamesForCompilation(): RegisteredEntityNames;
-    get packageGraph(): SourcePackageDependencyGraph;
-    private constructor();
-    static create(analyzer: Analyzer, cancellationToken: CancellationToken | undefined, targetPlatform?: PlatformKind): Promise<EmitterContext>;
-    buildIR(sourceFile: ProjectSourceFile): ir.SourceFile;
-    enumerateEmittingPackages(): Iterable<EmitterPackage>;
-    enumerateEmittingSourcePackages(): Iterable<ProgramPackage>;
-    /**
-     * Главным считается файл главного пакета, в котором находится блок "создание" или блок "выполнить".
-     */
-    getMainFileUri(): Uri | undefined;
-    getTypeIndexedElementGetter(indexer: IndexerEntity): TypeMethodEntity;
-    getTypeIndexedElementSetter(indexer: IndexerEntity): TypeMethodEntity;
-    getTypeDereferencedVariableVariable(operator: DereferenceOperatorEntity): TypeVariableEntity;
-    getPackageMethodForPackageVariableGetter(variable: PackageVariableEntity): MethodEntity;
-    getPackageMethodForPackageVariableSetter(variable: PackageVariableEntity): MethodEntity;
-    getOverloadedConstructorGroupForType(entity: TypeEntityWithMembers): OverloadedConstructorGroup;
-    getTypeMethodNames(entity: TypeEntityWithMembers): UniqueEntityNames;
-    getTypeMethodForPlainObjectConstructor(entity: ConstructorEntity, containingType: TypeEntityWithMembers): TypeMethodEntity;
-    getPlainObjectDefaultEmptyConstructor(entity: StructuredTypeEntity): ConstructorEntity;
-    createUniqueNamesForReferencedPackageMemberEntities(ownNames: UniqueEntityNames, referencedEntities: ReferencedPackageMemberEntities): UniqueEntityNames;
-    createImportDirectivesForPackage(referencedEntities: ReferencedPackageMemberEntities, referencedEntityNames: UniqueEntityNames, mode: ImportDirectivesCreationMode, fileLocale: PackageLocale): readonly ir.Statement[];
-    /**
-     * Проверяет, является ли простой объект константным. Если объект является таковым, для него не нужно выполнять
-     * copy-on-write.
-     *
-     * @returns Возвращает `true`, если
-     * 1. Все поля объекта - конст.
-     * 2. Типы всех полей либо не являются простыми объектами, либо являются константными простыми объектами.
-     */
-    isConstantPlainObject(entity: StructuredTypeEntity, entitiesBeingChecked?: Set<StructuredTypeEntity>): boolean;
-    ifProxiedTypeVariableThenProxyTag(entity: TypeVariableEntity): tags.Tag | undefined;
-    getProxyTypeVariable(proxiedVariable: TypeVariableEntity): TypeVariableEntity;
-    private tryGetEmitterPackage;
-    private createPackageByPackageMember;
-    private createRegisteredEntityNamesForCompilation;
+    readonly entityMap: EntityMap;
+    readonly type: TypeUtils;
+    readonly standardTypes: StandardTypes;
+    constructor(analyzer: Analyzer, entityMap: EntityMap);
+    createIdentitySubstitutedType(entity: TypeOrExtensionEntity): Type;
+    unaliasTypeEntity(typeEntity: TypeOrExtensionEntity): Type;
 }
-export type ImportDirectivesCreationMode = ImportDirectivesCreationMode.OnlyJsLibrariesDependencies | ImportDirectivesCreationMode.AllDependencies;
-export declare namespace ImportDirectivesCreationMode {
-    class OnlyJsLibrariesDependencies {
-        readonly kind = "only-js-libraries-dependencies";
-    }
-    class AllDependencies {
-        readonly package_: EmitterPackage;
-        readonly getArtelPackageImportPath: (p: EmitterPackage) => string;
-        readonly kind = "all-dependencies";
-        constructor(package_: EmitterPackage, getArtelPackageImportPath: (p: EmitterPackage) => string);
-    }
-}
-declare class Utils {
-    private readonly _ectx;
-    private _id;
-    constructor(_ectx: EmitterContext);
-    getOrderedCallArguments(callArguments: CallArguments): OrderedCallArguments;
-    orderCallArgumentsAccordingToParameters(callArguments: UnorderedCallArguments): OrderedCallArguments;
-    findOwnConstructorCall(body: BlockStatement): OwnConstructorCall | undefined;
-    findBaseConstructorCall(body: BlockStatement): BaseConstructorCall | undefined;
-    createUniqueLocalVariableEntity(locale: PackageLocale, type: types.Type): VariableEntity;
-    getBinaryExpressionOperatorFromAssignmentOperator(operator: AssignmentOperator): BinaryExpressionOperator;
-    generateId(): number;
-    createIdentitySubstitutedStructuredType(entity: StructuredTypeEntity): types.StructuredType;
-    createIdentitySubstitutedVariantType(entity: VariantTypeEntity): types.VariantType;
-    createInitializedTemporaryVariable(locale: PackageLocale, initializer: Expression, tempVariables?: VariableEntity[]): [VariableEntity, AssignmentExpression, VariableAccessExpression];
-    lowerOwnTypeVariableAccessExpression(expression: VariableAccessExpression): TypeVariableAccessExpression;
-    lowerOwnTypeMethodAccessExpression(expression: MethodAccessExpression): TypeMethodAccessExpression;
-    getPackageStructuredTypeRequired(originalName: string, packageEntity: PackageEntity): StructuredTypeEntity;
-    getPackageMethodRequired(originalName: string, packageEntity: PackageEntity): MethodEntity;
-    getTypeMethodRequired(originalName: string, type: TypeEntityWithMembers): TypeMethodEntity;
-    getTypeVariableRequired(originalName: string, type: TypeEntityWithMembers): TypeVariableEntity;
-    getTypeConstructorRequired(type: TypeEntityWithMembers): ConstructorEntity;
-    private createReceiverForOwnMemberAccess;
-}
-declare class Type {
-    private readonly _ectx;
-    private get standardTypes();
-    constructor(_ectx: EmitterContext);
-    ofExpression(expression: Expression): types.Type;
-}
-declare class GeneratedName {
-    ofMainFunction(locale: PackageLocale): string;
-    ofPackageConstructor(locale: PackageLocale, id: number): string;
-    ofPackageRunFunction(locale: PackageLocale, id: number): string;
-    ofPlainObjectConstructor(locale: PackageLocale, id: number): string;
-    ofExtensionConstructor(locale: PackageLocale): string;
-    ofExtensionMethodTargetParameter(locale: PackageLocale): string;
-    ofGlobalVariableGetter(locale: PackageLocale, originalName: string): string;
-    ofGlobalVariableSetter(locale: PackageLocale, originalName: string): string;
-    ofTypeVariableGetter(locale: PackageLocale, originalName: string): string;
-    ofTypeVariableSetter(locale: PackageLocale, originalName: string): string;
-    ofTypeIndexedElementGetter(locale: PackageLocale): string;
-    ofTypeIndexedElementSetter(locale: PackageLocale): string;
-    ofTypeDereferencedVariable(locale: PackageLocale): string;
-    ofTypeBackingVariable(locale: PackageLocale, originalName: string): string;
-    ofTempVariable(locale: PackageLocale, id: number): string;
-    ofDefaultImport(locale: PackageLocale, id: number): string;
-    ofNamespaceImport(locale: PackageLocale, id: number): string;
-    ofRefCountVariable(locale: PackageLocale): string;
-    ofAddReferenceMethod(locale: PackageLocale): string;
-    ofRemoveReferenceMethod(locale: PackageLocale): string;
-    ofShallowCopyMethod(locale: PackageLocale): string;
-    ofMergedConstructorIdParameter(locale: PackageLocale): string;
-    ofMergedConstructorParameter(locale: PackageLocale, id: number): string;
-    ofAnonymousType(locale: PackageLocale): string;
-    ofPlainObjectMethodNewThisVariable(locale: PackageLocale): string;
-    ofPlainObjectMethodResultNewThisProperty(locale: PackageLocale): string;
-    ofPlainObjectMethodResultResultProperty(locale: PackageLocale): string;
-    ofProxyVariable(locale: PackageLocale, originalName: string): string;
-}
-type OwnConstructorCall = {
-    expression: OwnConstructorCallExpression;
-    statementIndex: number;
-};
-type BaseConstructorCall = {
-    expression: BaseConstructorCallExpression;
-    statementIndex: number;
-};
-declare class ExtensionLikeMembers {
-    private readonly _ectx;
-    private readonly _methodSubstitutions;
-    private readonly _getterSubstitutions;
-    private readonly _setterSubstitutions;
-    private readonly _constructorSubstitutions;
-    constructor(_ectx: EmitterContext);
-    isExtensionLikeMethod(entity: TypeMethodEntity): ExtensionLikeMethodInfo | undefined;
-    isExtensionLikeConstructor(entity: ConstructorEntity): ExtensionLikeConstructorInfo | undefined;
-    isExtensionLikeVariable(entity: TypeVariableEntity): ExtensionLikeVariableInfo | undefined;
-    getMethodSubstitution(method: ExtensionLikeMethodInfo): TypeMethodEntity;
-    getConstructorSubstitution(constructor: ExtensionLikeConstructorInfo): TypeMethodEntity;
-    getVariableGetterSubstitution(variable: ExtensionLikeVariableInfo): TypeMethodEntity;
-    getVariableSetterSubstitution(variable: ExtensionLikeVariableInfo): TypeMethodEntity;
-    private ifContainerOfExtensionLikeMemberThenTargetType;
-    private createTargetParameter;
-}
-export declare class ExtensionLikeMethodInfo {
-    readonly entity: TypeMethodEntity;
-    readonly targetType: types.Type;
-    constructor(entity: TypeMethodEntity, targetType: types.Type);
-}
-export declare class ExtensionLikeConstructorInfo {
-    readonly entity: ConstructorEntity;
-    readonly targetType: types.Type;
-    constructor(entity: ConstructorEntity, targetType: types.Type);
-}
-export declare class ExtensionLikeVariableInfo {
-    readonly entity: TypeVariableEntity;
-    readonly targetType: types.Type;
-    constructor(entity: TypeVariableEntity, targetType: types.Type);
-}
-export declare class MembersForCopyOnWriteContext {
-    private readonly _ectx;
-    private readonly _membersForCopyOnWrite;
-    constructor(_ectx: EmitterContext);
-    ofType(entity: StructuredTypeEntity): MembersForCopyOnWrite;
-    private createReferenceCountField;
-    private createAddReferenceMethod;
-    private createRemoveReferenceMethod;
-    private createShallowCopyMethod;
-    private createIdentitySubstitutedType;
-}
-export declare class MembersForCopyOnWrite {
-    readonly referenceCountField: TypeVariableEntity;
-    readonly incrementReferenceCountMethod: TypeMethodEntity;
-    readonly decrementReferenceCountMethod: TypeMethodEntity;
-    readonly shallowCopyMethod: TypeMethodEntity;
-    constructor(referenceCountField: TypeVariableEntity, incrementReferenceCountMethod: TypeMethodEntity, decrementReferenceCountMethod: TypeMethodEntity, shallowCopyMethod: TypeMethodEntity);
-}
-export declare class OverloadedConstructorGroup {
-    private readonly _ectx;
-    readonly constructors: readonly ConstructorEntity[];
-    private readonly _containingType;
-    readonly mergedConstructor: ConstructorEntity;
-    constructor(_ectx: EmitterContext, constructors: readonly ConstructorEntity[], _containingType: TypeEntityWithMembers);
-    getOverloadId(constructor: ConstructorEntity): number;
-    private createMergedConstructor;
-}
-export declare class UniqueEntityNames {
-    private readonly _nameByEntity;
-    private readonly _uniqueNames;
-    get nameByEntity(): ReadonlyMap<Entity, string>;
-    constructor(uniqueNameByEntity?: ReadonlyMap<Entity, string>);
-    getName(entity: Entity): string;
-    registerEntity(entity: Entity, suggestedName: string): string;
-    registerEntity(entity: Entity, nameProvider: EntityNameProvider): string;
-    registerUniqueName(entity: Entity, uniqueName: string): void;
-    private generateUniqueName;
-}
-export declare class RealName {
-    private readonly _ectx;
-    static readonly RealNameArgumentName: string;
-    constructor(_ectx: EmitterContext);
-    ofEntity(entity: Entity): string | undefined;
-    private ofTypeMethod;
-    private ofTypeVariable;
-    ofMethod(entity: MethodEntity): string | undefined;
-    private getRealName;
-    private getLinkedTypeMethodOrPreserve;
-    private getLinkedTypeVariableOrPreserve;
-}
-export type NamedEntity = VariableEntity | VariantEntity | VariantTypeEntity | MethodEntity | TypeParameterEntity | MethodTypeEntity | StructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;
-declare class ExternalDeclarationLinker {
+declare class TypeUtils {
     private readonly _ectx;
-    private readonly _targetPlatform;
-    constructor(_ectx: EmitterContext, _targetPlatform: PlatformKind);
-    link(sourceFile: SourceFile): void;
-    getLinkedVariable(variable: VariableEntity): VariableEntity | undefined;
-    getLinkedTypeVariable(variable: TypeVariableEntity): TypeVariableEntity | undefined;
-    getLinkedMethod(method: MethodEntity): MethodEntity | undefined;
-    getLinkedTypeMethod(method: TypeMethodEntity): TypeMethodEntity | undefined;
-    getLinkedIndexer(indexer: IndexerEntity): IndexerEntity | undefined;
-    getLinkedConstructor(constructor: ConstructorEntity): ConstructorEntity | undefined;
-    getLinkedTypeEntity(entity: TypeEntity): TypeEntity | undefined;
-    getLinkedType(type: types.Type): types.Type | undefined;
-    private linkVariableAccessExpression;
-    private linkInstanceVariableAccessExpression;
-    private linkMethodAccessExpression;
-    private linkInstanceMethodAccessExpression;
-    private linkAsExpression;
-    private linkIsExpression;
-    private linkIndexedAccessExpression;
-    private linkConstructorCallExpression;
-    private linkBaseConstructorCallExpression;
-    private linkTypeAccessExpression;
-    private linkPackageTypeDeclarationBaseType;
-    private entityShouldBeLinked;
-    private aspectEntityShouldBeLinked;
-    private typeShouldBeLinked;
-}
-declare class HelperMethods {
-    private readonly _ectx;
-    private readonly _integerDivisionMethod;
-    private readonly _numberIsIntegerMethod;
-    private readonly _throwErrorMethod;
     constructor(_ectx: EmitterContext);
-    createIntegerDivisionMethodCall(dividend: Expression, divisor: Expression): Expression;
-    createNumberIsIntegerMethodCall(integer: Expression): Expression;
-    createThrowErrorMethodCall(argument?: Expression): Expression;
-    private createHelperMethodCall;
-    private findHelperMethodLazy;
-}
-declare class JsStandardTypes {
-    private readonly _ectx;
-    private readonly _numberType;
-    private readonly _integerType;
-    private readonly _textType;
-    private readonly _charType;
-    private readonly _yesNoType;
-    private readonly _noneType;
-    private readonly _methodType;
-    private readonly _referenceType;
-    private readonly _jsObject;
-    get number(): types.Type;
-    get integer(): types.Type;
-    get text(): types.Type;
-    get char(): types.Type;
-    get yesNo(): types.Type;
-    get none(): types.Type;
-    get method(): types.Type;
-    get reference(): types.Type;
-    get jsObject(): types.StructuredType;
-    constructor(ectx: EmitterContext);
-    private findStandardType;
-    private findJsType;
-}
-export declare class ReferencedPackageMemberEntities {
-    private readonly _packageByPackageMember;
-    private readonly _entitiesFromArtel;
-    private readonly _entitiesFromJs;
-    get entitiesFromArtel(): ReadonlyMap<EmitterPackage, ReadonlySet<Entity>>;
-    get entitiesFromJs(): ReadonlyMap<JavaScriptImplementationConfig, ReadonlySet<PackageMemberEntity>>;
-    constructor(_analyzer: Analyzer, node: ir.SourceFile, packageByPackageMember: ReadonlyMap<Entity, EmitterPackage>);
-    private addPackageMember;
-    private addEntityFromArtel;
-    private addEntityFromJs;
-}
-export declare class ReferencedEntityFromJs {
-    readonly value: NamedEntity;
-    readonly isDefaultImport: boolean;
-    constructor(value: NamedEntity, isDefaultImport: boolean);
-}
-export declare class EntitiesImportedFromJs {
-    readonly libraryName: string;
-    readonly values: Map<Entity, ReferencedEntityFromJs>;
-    constructor(libraryName: string, values: Map<Entity, ReferencedEntityFromJs>);
-}
-export declare class DummyPackageEntity implements PackageEntity {
-    readonly kind = EntityKind.Package;
-    getName(): PackageName;
-    getLocale(): PackageLocale;
-    getMembers(): OriginalPackageMembers;
-    isInterface(): InterfacePackageEntityInfo | undefined;
-    getImplementedInterfacePackage(): PackageEntity | undefined;
-    getSupportedPlatforms(): readonly PlatformKind[];
-    getDefinition(): PackageEntityDefinition;
+    ofExpression(expression: Expression): Type;
+    private getTypeOfComputedAccess;
+}
+declare class StandardTypes {
+    private readonly _analyzer;
+    private readonly _entityMap;
+    private _none;
+    private _yesNo;
+    private _refObject;
+    private _plainObject;
+    private _number;
+    private _integer;
+    private _text;
+    private _char;
+    private _array;
+    private _method;
+    private _textTemplate;
+    private _reference;
+    get none(): Type;
+    get yesNo(): Type;
+    get refObject(): Type;
+    get plainObject(): Type;
+    get number(): Type;
+    get integer(): Type;
+    get text(): Type;
+    get char(): Type;
+    get array(): Type;
+    get method(): Type;
+    get textTemplate(): Type;
+    get reference(): Type;
+    constructor(_analyzer: Analyzer, _entityMap: EntityMap);
 }
 export {};