@artel/artc 0.6.25207 → 0.6.25209

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

@@ -1,8 +1,8 @@
 import { PackageLocale } from '../common/index.js';
 export declare const enum EmitterGeneratedDeclarationKind {
     MainFunction = 0,
-    PackageConstructorPrefix = 1,
-    PackageRunFunctionPrefix = 2,
+    PackageConstructor = 1,
+    PackageRunFunction = 2,
     PlainObjectConstructorPrefix = 3,
     ExtensionConstructor = 4,
     ExtensionMethodTargetParameter = 5,
@@ -13,24 +13,62 @@ export declare const enum EmitterGeneratedDeclarationKind {
     TypeIndexedElementGetter = 10,
     TypeIndexedElementSetter = 11,
     TypeDereferencedVariable = 12,
-    TypeBackingVariablePrefix = 13,
-    TempVariablePrefix = 14,
-    DefaultImportPrefix = 15,
-    NamespaceImportPrefix = 16,
-    RefCountVariable = 17,
-    AddReferenceMethod = 18,
-    RemoveReferenceMethod = 19,
-    ShallowCopyMethod = 20,
-    MergedConstructorIdParameter = 21,
-    MergedConstructorParameterPrefix = 22,
-    AnonymousType = 23,
-    PlainObjectMethodNewThisVariable = 24,
-    PlainObjectMethodResultNewThisProperty = 25,
-    PlainObjectMethodResultResultProperty = 26,
-    ProxyVariable = 27
+    TypeDereferencedVariableGetter = 13,
+    TypeDereferencedVariableSetter = 14,
+    TypeBackingVariablePrefix = 15,
+    TempVariablePrefix = 16,
+    DefaultImportPrefix = 17,
+    NamespaceImportPrefix = 18,
+    RefCountVariable = 19,
+    AddReferenceMethod = 20,
+    RemoveReferenceMethod = 21,
+    ShallowCopyMethod = 22,
+    MergedConstructorIdParameter = 23,
+    MergedConstructorParameterPrefix = 24,
+    AnonymousType = 25,
+    PlainObjectMethodNewThisVariable = 26,
+    PlainObjectMethodResultNewThisProperty = 27,
+    PlainObjectMethodResultResultProperty = 28,
+    ProxyVariable = 29,
+    TypeConstructor = 30,
+    TypeExtensionPrefix = 31
 }
 export declare const emitterGeneratedDeclarationNamesByLocale: {
     [T in PackageLocale]: {
         [T in EmitterGeneratedDeclarationKind]: string;
     };
 };
+export declare class EmitPhaseName {
+    static ofMainFunction(locale: PackageLocale): string;
+    static ofPackageConstructor(locale: PackageLocale): string;
+    static ofPackageRunFunction(locale: PackageLocale): string;
+    static ofPlainObjectConstructor(locale: PackageLocale, id: number): string;
+    static ofExtensionConstructor(locale: PackageLocale): string;
+    static ofExtensionMethodTargetParameter(locale: PackageLocale): string;
+    static ofGlobalVariableGetter(locale: PackageLocale, originalName: string): string;
+    static ofGlobalVariableSetter(locale: PackageLocale, originalName: string): string;
+    static ofTypeVariableGetter(locale: PackageLocale, originalName: string): string;
+    static ofTypeVariableSetter(locale: PackageLocale, originalName: string): string;
+    static ofTypeIndexedElementGetter(locale: PackageLocale): string;
+    static ofTypeIndexedElementSetter(locale: PackageLocale): string;
+    static ofTypeDereferencedVariable(locale: PackageLocale): string;
+    static ofTypeDereferencedVariableGetter(locale: PackageLocale): string;
+    static ofTypeDereferencedVariableSetter(locale: PackageLocale): string;
+    static ofTypeBackingVariable(locale: PackageLocale, originalName: string): string;
+    static ofTempVariable(locale: PackageLocale, id: number): string;
+    static ofDefaultImport(locale: PackageLocale, id: number): string;
+    static ofNamespaceImport(locale: PackageLocale, id: number): string;
+    static ofRefCountVariable(locale: PackageLocale): string;
+    static ofAddReferenceMethod(locale: PackageLocale): string;
+    static ofRemoveReferenceMethod(locale: PackageLocale): string;
+    static ofShallowCopyMethod(locale: PackageLocale): string;
+    static ofMergedConstructorIdParameter(locale: PackageLocale): string;
+    static ofMergedConstructorParameter(locale: PackageLocale, id: number): string;
+    static ofAnonymousType(locale: PackageLocale): string;
+    static ofPlainObjectMethodNewThisVariable(locale: PackageLocale): string;
+    static ofPlainObjectMethodResultNewThisProperty(locale: PackageLocale): string;
+    static ofPlainObjectMethodResultResultProperty(locale: PackageLocale): string;
+    static ofProxyVariable(locale: PackageLocale, originalName: string): string;
+    static ofTypeConstructor(locale: PackageLocale): string;
+    static ofTypeExtension(locale: PackageLocale, extendedTypeName: string): string;
+}

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

@@ -0,0 +1,144 @@
+import { PackageLocale } from '../common/index.js';
+import { JavaScriptImplementationConfig } from '../project/SourcePackage.js';
+export interface MethodEntity {
+    readonly kind: 'method';
+    methodEntityKind: MethodEntityKind;
+    name: string;
+    parameters: readonly VariableEntity[];
+    returnType: Type;
+    isTypeMember: TypeMemberEntityInfo | undefined;
+    isPackageMember: boolean;
+    containingPackage: PackageEntity;
+    details: MethodEntityDetails;
+}
+export declare enum MethodEntityKind {
+    RegularMethod = 0,
+    GetterOrSetter = 1,
+    Constructor = 2,
+    Destructor = 3,
+    Operator = 4
+}
+export declare class MethodEntityDetails {
+    isAsync: boolean;
+    isPackageConstructor: boolean;
+    isPackageEntryPoint: boolean;
+    overriddenMember: MethodEntity | undefined;
+    ifRedefinableAliasTypeMethodThenRealMethod: MethodEntity | undefined;
+    isEnumeratorMethod: boolean;
+    isDefaultExport: boolean;
+    isFormerInstanceAliasTypeOrExtensionMember: boolean;
+}
+export interface VariableEntity {
+    readonly kind: 'variable';
+    name: string;
+    type: Type;
+    isTypeMember: TypeMemberEntityInfo | undefined;
+    isPackageMember: boolean;
+    containingPackage: PackageEntity;
+    getter: MethodEntity | undefined;
+    setter: MethodEntity | undefined;
+    details: VariableEntityDetails;
+}
+export declare class VariableEntityDetails {
+    isVariadicParameter: boolean;
+    overriddenMember: VariableEntity | undefined;
+    isProxiedTypeVariable: ProxiedTypeVariableInfo | undefined;
+    isDefaultExport: boolean;
+}
+export interface ProxiedTypeVariableInfo {
+    readonly tagType: TypeOrExtensionEntity;
+    readonly constructor: MethodEntity;
+}
+export type TypeMemberEntity = MethodEntity | VariableEntity;
+export interface TypeOrExtensionEntity {
+    readonly kind: 'type-or-extension';
+    name: string;
+    baseType: TypeOrExtensionEntity | undefined;
+    typeOrExtensionKind: TypeOrExtensionEntityKind;
+    members: readonly TypeMemberEntity[];
+    containingPackage: PackageEntity;
+    details: TypeOrExtensionEntityDetails;
+}
+export declare class TypeOrExtensionEntityDetails {
+    structuredTypeKind: StructuredTypeKind;
+    aliasedType: Type | undefined;
+    isDefaultExport: boolean;
+}
+export declare enum TypeOrExtensionEntityKind {
+    StructuredType = 0,
+    AliasType = 1,
+    VariantType = 2,
+    MethodType = 3,
+    ParameterType = 4,
+    TypeExtension = 5
+}
+export declare enum StructuredTypeKind {
+    RefObject = 0,
+    PlainObject = 1,
+    Aspect = 2
+}
+export type PackageMemberEntity = MethodEntity | VariableEntity | TypeOrExtensionEntity;
+export interface PackageEntity {
+    readonly kind: 'package';
+    name: string;
+    locale: PackageLocale;
+    members: readonly PackageMemberEntity[];
+    details: PackageEntityDetails;
+}
+export declare class PackageEntityDetails {
+    isJavaScriptPackage: JavaScriptImplementationConfig | undefined;
+    isSource: boolean;
+    isPackageWithMainMethod: boolean;
+}
+export interface TypeMemberEntityInfo {
+    containingType: TypeOrExtensionEntity;
+    isStatic: boolean;
+}
+export type Type = SimpleType | UnionType;
+export declare class SimpleType {
+    readonly entity: TypeOrExtensionEntity;
+    readonly typeArguments: readonly Type[];
+    readonly kind = "simple";
+    constructor(entity: TypeOrExtensionEntity, typeArguments: readonly Type[]);
+}
+export declare class UnionType {
+    readonly types: readonly Type[];
+    readonly kind = "union";
+    constructor(types: readonly Type[]);
+}
+export type Entity = VariableEntity | MethodEntity | TypeOrExtensionEntity | PackageEntity;
+export type NamedEntity = VariableEntity | MethodEntity | TypeOrExtensionEntity;
+export declare function isComputedVariableEntity(entity: VariableEntity): boolean;
+export declare class IntrinsicVariableEntity implements VariableEntity {
+    name: string;
+    type: Type;
+    containingPackage: PackageEntity;
+    readonly kind = "variable";
+    isVariadicParameter: boolean;
+    isTypeMember: TypeMemberEntityInfo | undefined;
+    isPackageMember: boolean;
+    getter: MethodEntity | undefined;
+    setter: MethodEntity | undefined;
+    details: VariableEntityDetails;
+    constructor(name: string, type: Type, containingPackage: PackageEntity);
+}
+export declare class IntrinsicMethodEntity implements MethodEntity {
+    methodEntityKind: MethodEntityKind;
+    name: string;
+    parameters: readonly VariableEntity[];
+    returnType: Type;
+    containingPackage: PackageEntity;
+    readonly kind = "method";
+    isTypeMember: TypeMemberEntityInfo | undefined;
+    isPackageMember: boolean;
+    details: MethodEntityDetails;
+    constructor(methodEntityKind: MethodEntityKind, name: string, parameters: readonly VariableEntity[], returnType: Type, containingPackage: PackageEntity);
+}
+export declare class IntrinsicPackageEntity implements PackageEntity {
+    name: string;
+    locale: PackageLocale;
+    readonly kind = "package";
+    members: readonly PackageMemberEntity[];
+    details: PackageEntityDetails;
+    constructor(name: string, locale: PackageLocale);
+}

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

@@ -0,0 +1,45 @@
+import { Analyzer } from '../analysis/Analyzer.js';
+import * as analyzerEntities from '../entities/index.js';
+import { PlatformKind } from '../project/SourcePackage.js';
+import * as analyzerTypes from '../types/index.js';
+import * as emitterEntities from './Entities.js';
+/**
+ * Отображает неизменяемые сущности этапа анализа на изменяемые сущности этапа генерации кода, а также
+ * - заменяет сущности из интерфейсных пакетов на сущности из реализационных пакетов для заданной целевой платформы,
+ * - заменяет имя сущности на НастоящееИмя, если указан соответствующий тег.
+ */
+export declare class EntityMap {
+    private readonly _analyzer;
+    private readonly _targetPlatform;
+    private readonly _variables;
+    private readonly _methods;
+    private readonly _typeOrExtensions;
+    private readonly _packages;
+    private readonly _linkedPackages;
+    private readonly _enumeratorMethod;
+    private get enumeratorMethod();
+    constructor(analyzer: Analyzer, targetPlatform: PlatformKind);
+    getVariableEntity(entity: analyzerEntities.VariableEntity): emitterEntities.VariableEntity;
+    getVariantEntity(entity: analyzerEntities.VariantEntity): emitterEntities.VariableEntity;
+    getMethodEntity(entity: analyzerEntities.MethodEntity): emitterEntities.MethodEntity;
+    getConstructorEntity(entity: analyzerEntities.ConstructorEntity): emitterEntities.MethodEntity;
+    getDestructorEntity(entity: analyzerEntities.DestructorEntity): emitterEntities.MethodEntity;
+    getGetterEntity(entity: analyzerEntities.GetterEntity): emitterEntities.MethodEntity;
+    getSetterEntity(entity: analyzerEntities.SetterEntity): emitterEntities.MethodEntity;
+    getUnaryOperatorEntity(entity: analyzerEntities.UnaryOperatorEntity): emitterEntities.MethodEntity;
+    getBinaryOperatorEntity(entity: analyzerEntities.BinaryOperatorEntity): emitterEntities.MethodEntity;
+    getStructuredTypeEntity(entity: analyzerEntities.StructuredTypeEntity): emitterEntities.TypeOrExtensionEntity;
+    getVariantTypeEntity(entity: analyzerEntities.VariantTypeEntity): emitterEntities.TypeOrExtensionEntity;
+    getTypeParameterEntity(entity: analyzerEntities.TypeParameterEntity): emitterEntities.TypeOrExtensionEntity;
+    getMethodTypeEntity(entity: analyzerEntities.MethodTypeEntity): emitterEntities.TypeOrExtensionEntity;
+    getAliasTypeEntity(entity: analyzerEntities.AliasTypeEntity): emitterEntities.TypeOrExtensionEntity;
+    getTypeExtensionEntity(entity: analyzerEntities.TypeExtensionEntity): emitterEntities.TypeOrExtensionEntity;
+    getTypeOrExtensionEntity(entity: analyzerEntities.TypeEntity | analyzerEntities.TypeExtensionEntity): emitterEntities.TypeOrExtensionEntity;
+    getPackageEntity(entity: analyzerEntities.PackageEntity): emitterEntities.PackageEntity;
+    getType(type: analyzerTypes.Type): emitterEntities.Type;
+    private getPackageEntityInternal;
+    private createTypeMembers;
+    private getContainingPackageAndAccumulateIfMember;
+    private getNameText;
+    private isDefaultExport;
+}

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

@@ -1,4 +1,4 @@
-import { VariableEntity } from '../entities/index.js';
+import { VariableEntity } from './Entities.js';
 import { TransformationContinuationAction } from './TransformationContinuationAction.js';
 import { Expression } from './ir/index.js';
 export declare enum Kind {

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

@@ -1,72 +1,8 @@
-import { PackageLocale } from '../common/index.js';
+import { EmitterPackage } from './Emitter.js';
 import { EmitterContext } from './EmitterContext.js';
-import { RegisteredEntityNames } from './EntityNameProviders.js';
-import { PackageMethodDeclaration, SourceFile } from './ir/index.js';
 export declare class GeneralLowering {
     private readonly _ectx;
-    static readonly toStringArtelMethodName = "\u0432-\u0442\u0435\u043A\u0441\u0442";
-    private readonly _ctx;
-    private readonly _referenceExpressionLowering;
-    private readonly _extensionLikeMembersLowering;
-    private readonly _copyOnWriteLowering;
-    private readonly _modifyingMethodLowering;
-    private readonly _methodObjectLowering;
-    private readonly _textTemplateLowering;
-    private readonly _isExpressionLowering;
-    private readonly _enumerableLowering;
-    private readonly _overloadedConstructorsLowering;
-    private readonly _indexerSetAccessLowering;
-    private readonly _variableProxyLowering;
-    private readonly _packageEntryPointMethods;
-    private readonly _packageConstructorMethods;
-    private readonly _registeredEntityNames;
-    private readonly _lazyInlineJsMethod;
-    private get inlineJsMethod();
-    constructor(_ectx: EmitterContext, locale: PackageLocale);
-    lower(sourceFile: SourceFile): GeneralLoweringResult;
-    private excludeRedefinableMethodsFromAliasType;
-    private substituteBaseAliasType;
-    private lowerImplicitVariantAccessExpression;
-    private lowerImplicitConversionExpression;
-    private addRedefinableMethodsToPrototype;
-    private lowerMethodTypeInvokeMethodCall;
-    private lowerParamObjectMemberAccessExpression;
-    private removeObjectFromBaseTypes;
-    private removeUnnecessaryBaseConstructorCalls;
-    private registerUniqueRuntimeNamesForPackageMemberDeclarations;
-    private lowerAssignmentWithIntegerDivision;
-    private lowerBinaryExpressionWithIntegerDivision;
-    private moveInstanceFieldInitializationsToConstructor;
-    private extractStaticFieldInitializations;
-    private orderPackageMemberDeclarations;
-    private lowerInlineJsMethodCall;
-    private lowerBaseConstructorCall;
-    private lowerBlockStatementWithClauses;
-    private lowerRunStatementWithClauses;
-    private lowerNumericVariantVariants;
-    private lowerForStatementWithIndexVariable;
-    private lowerIndexerGetAccessExpression;
-    private lowerIndexerSetAccess;
-    private lowerJsIndexerGetAccessExpression;
-    private lowerJsIndexerSetAccess;
-    private lowerPackageVariableSetAccessExpression;
-    private lowerPackageVariableGetAccessExpression;
-    private lowerStructuredTypeIndexerDeclaration;
-    private lowerPackageEntryPointDeclaration;
-    private lowerPackageConstructorDeclaration;
-    private lowerComputedPackageVariableDeclaration;
-    private lowerPackageVariableGetterDeclaration;
-    private lowerPackageVariableSetterDeclaration;
-    private lowerSubprogramBody;
-    private lowerComputedTypeVariableDeclaration;
-    private registerRuntimeNamesForTypeMethods;
-    private registerRuntimeNamesForNestedMethodsOfBlockStatement;
-    private lowerTypeDereferenceOperatorDeclaration;
-}
-export declare class GeneralLoweringResult {
-    readonly sourceFile: SourceFile;
-    readonly registeredEntityNames: RegisteredEntityNames;
-    readonly packageEntryPointMethods: readonly PackageMethodDeclaration[];
-    readonly packageConstructorMethods: readonly PackageMethodDeclaration[];
-    constructor(sourceFile: SourceFile, registeredEntityNames: RegisteredEntityNames, packageEntryPointMethods: readonly PackageMethodDeclaration[], packageConstructorMethods: readonly PackageMethodDeclaration[]);
+    private readonly _packages;
+    constructor(ectx: EmitterContext, packages: readonly EmitterPackage[]);
+    lower(): void;
 }

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

@@ -1,5 +1,4 @@
 export * as blockStatementTransformationResult from './BlockStatementTransformationResult.js';
-export * from './EmitterPackage.js';
 export * as expressionTransformationResult from './ExpressionTransformationResult.js';
 export * from './IrBuilder.js';
 export * as packageMemberDeclarationTransformationResult from './PackageMemberDeclarationTransformationResult.js';

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

@@ -1,21 +1,25 @@
-import { Analyzer } from '../analysis/index.js';
 import { DeclarationsUsageCountResult } from '../analysis/DeclarationsUsageCounter.js';
+import { Analyzer } from '../analysis/index.js';
 import { SourceFile } from '../project/index.js';
+import { EntityMap } from './EntityMap.js';
 import * as ir from './ir/index.js';
 export declare class IrBuilder {
     private readonly _analyzer;
     private readonly _sourceFile;
-    private readonly _config;
+    private readonly _declarationsUsageCountResult;
+    private readonly _declarationsOfPackageSourceFilesUsageCountResults;
+    private readonly _entityMap;
     private readonly _typesCreatedFromAnonymousTypes;
+    private readonly _textTemplateToTextMethod;
     private _id;
     private _currentLoopLabel;
-    constructor(analyzer: Analyzer, sourceFile: SourceFile, config: IrBuilderConfig);
-    buildIR(): ir.SourceFile;
-    private buildSourceFile;
+    private get textTemplateToTextMethod();
+    constructor(params: IrBuilderParams);
+    build(): ir.PackageMemberDeclaration[];
     private buildPackageMemberDeclarationList;
     private buildPackageConstructorDeclaration;
+    private buildBodyOfSubprogramWithResult;
     private buildStatementBlock;
-    private buildRunStatementClause;
     private buildStatement;
     private buildAssignmentStatement;
     private buildContinueLoopStatement;
@@ -25,7 +29,8 @@ export declare class IrBuilder {
     private buildPackageStructuredTypeDeclaration;
     private buildPackageAliasTypeDeclaration;
     private buildPackageVariableDeclaration;
-    private buildComputedPackageVariable;
+    private buildPackageVariableGetterDeclaration;
+    private buildPackageVariableSetterDeclaration;
     private buildBackingPackageVariable;
     private buildPackageVariantTypeDeclaration;
     private buildVariantDeclaration;
@@ -34,11 +39,14 @@ export declare class IrBuilder {
     private buildTypeConstructorDeclaration;
     private createDefaultStructuredTypeConstructor;
     private buildTypeDestructorDeclaration;
-    private buildTypeIndexerDeclaration;
-    private buildTypeDereferenceOperatorDeclaration;
+    private buildTypeIndexedGetterDeclaration;
+    private buildTypeIndexedSetterDeclaration;
+    private buildTypeDereferencedVariableGetterDeclaration;
+    private buildTypeDereferencedVariableSetterDeclaration;
     private buildTypeMethodDeclaration;
     private buildTypeVariableDeclaration;
-    private buildComputedTypeVariable;
+    private buildTypeVariableGetterDeclaration;
+    private buildTypeVariableSetterDeclaration;
     private buildBackingTypeVariable;
     private buildDisposeStatement;
     private buildRunStatement;
@@ -51,16 +59,15 @@ export declare class IrBuilder {
     private buildNestedMethodDeclarationStatement;
     private buildParameterList;
     private buildLocalVariableDeclarationStatement;
-    private buildUnobservableStatement;
     private buildLoopStatement;
     private buildReturnStatement;
     private buildSwitchStatement;
     private isDefaultSwitchStatementCaseClause;
-    private buildTransactionalStatement;
     private buildWhileStatement;
     private buildYieldStatement;
     private buildExpression;
-    private getImplicitConversionKind;
+    private applyImplicitConversionIfRequired;
+    private convertTextTemplateToText;
     private expressionCanBeImplicitlyConverted;
     private buildArrayLiteral;
     private buildAssertionExpression;
@@ -72,12 +79,13 @@ export declare class IrBuilder {
     private buildAutotypeCallExpression;
     private buildIndexedAccessExpression;
     private buildIsExpression;
-    private buildUnobservableExpression;
     private buildNotExpression;
     private buildMethodLiteral;
     private buildParenthesizedExpression;
     private buildPrefixUnaryExpression;
     private buildPropertyAccessExpression;
+    private convertIndexedAccess;
+    private convertDereferencedVariableAccess;
     private buildReferenceExpression;
     private buildWhenTernaryExpression;
     private buildTextTemplateLiteral;
@@ -85,11 +93,11 @@ export declare class IrBuilder {
     private buildKeywordExpression;
     private buildObjectExpression;
     private buildBaseExpression;
-    private buildTransactionalExpression;
     private buildDereferenceExpression;
     private buildGenericSpecializationExpression;
     private buildDefaultMatchExpression;
     private buildIdentifierExpression;
+    private createExplicitReceiver;
     private getEntityFromType;
     private buildCallArgumentList;
     private buildAndSaveTypeIfIsAnonymousTypeSpecifier;
@@ -98,11 +106,13 @@ export declare class IrBuilder {
     private buildAnonymousVariantTypeDeclaration;
     private getUnderlyingTypeKind;
     private expressionIsCallee;
-    private preserveVariableOrUndefinedIfUnused;
     private generateLoopLabel;
     private getSourceLocation;
 }
-export interface IrBuilderConfig {
+export interface IrBuilderParams {
+    analyzer: Analyzer;
+    sourceFile: SourceFile;
     declarationsUsageCountResult: DeclarationsUsageCountResult;
     declarationsOfPackageSourceFilesUsageCountResults: readonly DeclarationsUsageCountResult[];
+    entityMap: EntityMap;
 }

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

@@ -1,16 +1,16 @@
 import * as js from '@babel/types';
 import { DebugStack } from './DebugStack.js';
-import { EntityNameProvider } from './EntityNameProviders.js';
+import { Entity } from './Entities.js';
 import * as ir from './ir/index.js';
-export interface IrToJsConfig {
+export interface IrToJsOptions {
     /**
      * static:  import { MyType } from 'my-lib'
      *
      * dynamic: const { MyType } = await import('my-lib')
      */
-    readonly importMode: ImportEmitMode;
-    readonly runtimeEntityNames: EntityNameProvider;
-    readonly attachSourceLocation?: boolean;
+    importMode?: ImportEmitMode;
+    entityNameOverrides?: ReadonlyMap<Entity, string>;
+    attachSourceLocation?: boolean;
 }
 export type ImportEmitMode = ImportEmitMode.Static | ImportEmitMode.Dynamic;
 export declare namespace ImportEmitMode {
@@ -24,12 +24,14 @@ export declare namespace ImportEmitMode {
     }
 }
 export declare class IrToJs {
-    private readonly _config;
     static readonly customImportFunctionName = "_artelImport";
     protected readonly _debugStack: DebugStack;
-    constructor(_config: IrToJsConfig);
-    convert(sourceFile: ir.SourceFile): js.File;
-    private convertSourceFile;
+    private _importMode;
+    private _entityNameOverrides;
+    private _attachSourceLocation;
+    constructor(options?: IrToJsOptions);
+    convert(pkg: ir.Package): js.File;
+    private convertPackage;
     private convertPackageMemberDeclaration;
     private convertEsModuleImportDirectiveStatement;
     private convertCjsModuleImportDirectiveStatement;
@@ -42,7 +44,6 @@ export declare class IrToJs {
     private convertPackageMethodDeclaration;
     private convertValueParameters;
     private convertPackageTypeDeclaration;
-    private convertPropertyDeclaration;
     private convertPackageVariableDeclaration;
     private convertPackageVariantTypeDeclaration;
     private convertNumericVariants;
@@ -54,6 +55,7 @@ export declare class IrToJs {
     private convertCallExpression;
     private convertCharLiteral;
     private convertNoneLiteral;
+    private convertIndexedAccessExpression;
     private convertHelperMethodCallExpression;
     private convertNotExpression;
     private convertIntegerLiteral;
@@ -76,13 +78,14 @@ export declare class IrToJs {
     private convertVariableAccessExpression;
     private convertMethodAccessExpression;
     private convertVariantAccessExpression;
-    private convertInstanceVariableAccessExpression;
+    private convertTypeVariableAccessExpression;
     private convertTypeMethodAccessExpression;
     private convertConstructorCallExpression;
     private convertCallArguments;
     private convertInlineJsExpression;
     private convertAssignmentExpression;
     private convertCommaExpression;
+    private convertBaseConstructorCallExpression;
     private convertJsIndexedAccessExpression;
     private convertJsObjectLiteral;
     private convertJsPropertyAccessExpression;
@@ -108,6 +111,9 @@ export declare class IrToJs {
     private convertTypeConstructorDeclaration;
     private convertTypeMethodDeclaration;
     private convertTypeVariableDeclaration;
+    private convertTypeVariableGetterDeclaration;
+    private convertTypeVariableSetterDeclaration;
     private addNodeLocation;
+    private getEntityName;
     private convertArrayWithErrorBoundary;
 }

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

@@ -1,9 +1,9 @@
-import { VariableEntity } from '../entities/index.js';
+import { VariableEntity } from './Entities.js';
 import { Statement } from './ir/index.js';
 export declare const enum Kind {
     Preserve = 0,
     Replace = 1,
-    ReplaceAndAddLocalVariables = 2
+    Remove = 2
 }
 export type Type = {
     kind: Kind.Preserve;
@@ -11,6 +11,9 @@ export type Type = {
     kind: Kind.Replace;
     statement: Statement;
     hoistedLocalVariables?: readonly VariableEntity[];
+} | {
+    kind: Kind.Remove;
 };
 export declare function preserve(): Type;
 export declare function replace(statement: Statement, hoistedLocalVariables?: readonly VariableEntity[]): Type;
+export declare function remove(): Type;