@artel/artc 0.6.25258 → 0.6.25260

package/build/types/entities/translated/TranslatedPackageEntity.d.ts

@@ -1,4 +1,5 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
+import { Tag } from '../../analysis/Tags.js';
+import { Translation } from '../../analysis/Translation.js';
 import { PackageDialect } from '../../common/PackageDialect.js';
 import { PackageLocale } from '../../common/PackageLocale.js';
 import { PackageName, PlatformKind } from '../../project/SourcePackage.js';
@@ -9,11 +10,11 @@ import { InterfacePackageEntityInfo, PackageEntityDefinition } from '../PackageE
 import { PackageEntityMembers } from '../PackageMembers.js';
 export declare class TranslatedPackageEntity implements PackageEntity {
     readonly kind = EntityKind.Package;
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _name;
-    private readonly _localizationContext;
-    private readonly _members;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly name;
+    private readonly localizationContext;
+    private readonly members;
     constructor(originalEntity: PackageEntity, translation: Translation, name: PackageName, localizationContext: EntityLocalizationContext);
     getName(): PackageName;
     getLocale(): PackageLocale;
@@ -23,6 +24,8 @@ export declare class TranslatedPackageEntity implements PackageEntity {
     getImplementedInterfacePackage(): PackageEntity | undefined;
     getSupportedPlatforms(): readonly PlatformKind[];
     getDefinition(): PackageEntityDefinition;
-    getLocalization(): Localization;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
     getOriginalEntity(): PackageEntity;
+    getTags(): readonly Tag[];
 }

package/build/types/entities/translated/TranslatedSetterEntity.d.ts

@@ -1,22 +1,26 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
+import { Translation } from '../../analysis/Translation.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
 import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
-import { EntityKind } from '../index.js';
+import { EntityKind, PackageEntity } from '../index.js';
 import type { SetterEntity } from '../SetterEntity.js';
 import { EntityOwningSetter, SetterEntityDefinition } from '../SetterEntity.js';
 export declare class TranslatedSetterEntity implements SetterEntity {
     readonly kind = EntityKind.Setter;
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _localizationContext;
-    private readonly _owningEntity;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly localizationContext;
+    private readonly owningEntity;
     constructor(originalEntity: SetterEntity, translation: Translation, localizationContext: EntityLocalizationContext);
     getDefinition(): SetterEntityDefinition;
     isModifyingOwningPlainObject(): boolean;
     getOwningEntity(): EntityOwningSetter;
+    getContainingPackage(): PackageEntity;
     isHidden(): EntityHidingLevel | undefined;
     getTags(): readonly Tag[];
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): SetterEntity;
 }

package/build/types/entities/translated/TranslatedStructuredTypeEntity.d.ts

@@ -1,14 +1,16 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
-import { Name } from '../../common/index.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
 import * as types from '../../types/index.js';
+import { BaseAspectTypes } from '../BaseAspectTypes.js';
+import { BaseObjectType } from '../BaseObjectType.js';
 import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
 import { EntityNaming } from '../EntityNaming.js';
 import { EntityContext, EntityKind } from '../index.js';
 import { PackageEntity } from '../PackageEntity.js';
-import type { AnonymousStructuredTypeEntity, PackageStructuredTypeEntity } from '../StructuredTypeEntity.js';
-import { BaseAspectTypes, BaseObjectType, CycleFreeBaseAspectTypesResolutionResult, CycleFreeBaseObjectTypeResolutionResult, StructuredTypeEntityDefinition } from '../StructuredTypeEntity.js';
+import type { AnonymousStructuredTypeEntity, PackageStructuredTypeEntity, StructuredTypeKind } from '../StructuredTypeEntity.js';
+import { CycleFreeBaseAspectTypesResolutionResult, CycleFreeBaseObjectTypeResolutionResult, StructuredTypeEntityDefinition } from '../StructuredTypeEntity.js';
 import { SubstitutionApplicationMode } from '../SubstitutionApplicationMode.js';
 import { TypeEntityKind } from '../TypeEntity.js';
 import { TypeEntityMembers } from '../TypeEntityMembers.js';
@@ -17,20 +19,22 @@ export declare class TranslatedPackageStructuredTypeEntity implements PackageStr
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Structured;
     readonly subkind = "package";
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _name;
-    private readonly _localizationContext;
-    private readonly _containingPackage;
-    private readonly _typeParameters;
-    private readonly _members;
-    private readonly _baseObjectType;
-    private readonly _baseAspectTypes;
-    private readonly _context;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly name;
+    private readonly localizationContext;
+    private readonly containingPackage;
+    private readonly typeParameters;
+    private readonly members;
+    private readonly baseObjectType;
+    private readonly baseAspectTypes;
+    private readonly context;
     constructor(originalEntity: PackageStructuredTypeEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
     getName(): Name;
     getContainingPackage(): PackageEntity;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): PackageStructuredTypeEntity;
     getNaming(): EntityNaming;
     getTypeParameters(): readonly TypeParameterEntity[];
@@ -38,9 +42,7 @@ export declare class TranslatedPackageStructuredTypeEntity implements PackageStr
     getDefinition(): StructuredTypeEntityDefinition;
     markedBasic(): boolean;
     isAbstract(): boolean;
-    isAspect(): boolean;
-    isRefObject(): boolean;
-    isPlainObject(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
     getArity(): number;
     getBaseObjectType(): BaseObjectType;
     getBaseAspectTypes(): BaseAspectTypes;
@@ -53,18 +55,20 @@ export declare class TranslatedAnonymousStructuredTypeEntity implements Anonymou
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Structured;
     readonly subkind = "anonymous";
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _localizationContext;
-    private readonly _containingPackage;
-    private readonly _typeParameters;
-    private readonly _members;
-    private readonly _baseObjectType;
-    private readonly _baseAspectTypes;
-    private readonly _context;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly localizationContext;
+    private readonly containingPackage;
+    private readonly typeParameters;
+    private readonly members;
+    private readonly baseObjectType;
+    private readonly baseAspectTypes;
+    private readonly context;
     constructor(originalEntity: AnonymousStructuredTypeEntity, translation: Translation, localizationContext: EntityLocalizationContext);
     getContainingPackage(): PackageEntity;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): AnonymousStructuredTypeEntity;
     getNaming(): EntityNaming;
     getTypeParameters(): readonly TypeParameterEntity[];
@@ -72,9 +76,7 @@ export declare class TranslatedAnonymousStructuredTypeEntity implements Anonymou
     getDefinition(): StructuredTypeEntityDefinition;
     markedBasic(): boolean;
     isAbstract(): boolean;
-    isAspect(): boolean;
-    isRefObject(): boolean;
-    isPlainObject(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
     getArity(): number;
     getBaseObjectType(): BaseObjectType;
     getBaseAspectTypes(): BaseAspectTypes;
@@ -84,10 +86,10 @@ export declare class TranslatedAnonymousStructuredTypeEntity implements Anonymou
     getContext(): EntityContext;
 }
 export declare class LocalizedBaseObjectType extends BaseObjectType {
-    private readonly _original;
-    private readonly _localizationContext;
-    private readonly _declared;
-    private readonly _cycleFree;
+    private readonly original;
+    private readonly localizationContext;
+    private readonly declared_;
+    private readonly cycleFree_;
     get declared(): types.Type | undefined;
     get cycleFree(): types.Type | undefined;
     get causesCycle(): boolean;
@@ -95,10 +97,10 @@ export declare class LocalizedBaseObjectType extends BaseObjectType {
     resolveBaseObjectType(circularityTrackingStack: boolean[]): CycleFreeBaseObjectTypeResolutionResult;
 }
 export declare class LocalizedBaseAspectTypes extends BaseAspectTypes {
-    private readonly _original;
-    private readonly _localizationContext;
-    private readonly _declared;
-    private readonly _cycleFree;
+    private readonly original;
+    private readonly localizationContext;
+    private readonly declared_;
+    private readonly cycleFree_;
     get declared(): readonly types.Type[];
     get cycleFree(): readonly types.Type[];
     get causesCycle(): boolean;

package/build/types/entities/translated/TranslatedTypeExtensionEntity.d.ts

@@ -1,5 +1,6 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
+import { Translation } from '../../analysis/Translation.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
 import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
 import { EntityContext, EntityKind, NamedTypeEntity } from '../index.js';
@@ -8,13 +9,13 @@ import { TypeEntityMembers } from '../TypeEntityMembers.js';
 import type { TypeExtensionEntity, TypeExtensionEntityDefinition } from '../TypeExtensionEntity.js';
 export declare class TranslatedTypeExtensionEntity implements TypeExtensionEntity {
     readonly kind = EntityKind.TypeExtension;
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _localizationContext;
-    private readonly _containingPackage;
-    private readonly _members;
-    private readonly _extendedTypeEntity;
-    private readonly _context;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly localizationContext;
+    private readonly containingPackage;
+    private readonly members;
+    private readonly extendedTypeEntity;
+    private readonly context;
     constructor(originalEntity: TypeExtensionEntity, translation: Translation, localizationContext: EntityLocalizationContext);
     getMembers(): TypeEntityMembers;
     getContainingPackage(): PackageEntity;
@@ -23,6 +24,8 @@ export declare class TranslatedTypeExtensionEntity implements TypeExtensionEntit
     isHidden(): EntityHidingLevel | undefined;
     getTags(): readonly Tag[];
     getContext(): EntityContext;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): TypeExtensionEntity;
 }

package/build/types/entities/translated/TranslatedTypeParameterEntity.d.ts

@@ -1,24 +1,24 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
-import { Name } from '../../common/index.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
 import * as types from '../../types/index.js';
 import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
-import { EntityContext, EntityKind } from '../index.js';
+import { EntityContext, EntityKind, PackageEntity } from '../index.js';
 import { TypeEntityKind } from '../TypeEntity.js';
 import type { TypeParameterEntity } from '../TypeParameterEntity.js';
 import { CycleFreeConstraintResolutionResult, EntityContainingTypeParameter, TypeParameterConstraint, TypeParameterEntityDefinition } from '../TypeParameterEntity.js';
 export declare class TranslatedTypeParameterEntity implements TypeParameterEntity {
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Parameter;
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _name;
-    private readonly _localizationContext;
-    private readonly _defaultType;
-    private readonly _constraint;
-    private readonly _context;
-    private readonly _containingEntity;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly name;
+    private readonly localizationContext;
+    private readonly defaultType;
+    private readonly constraint;
+    private readonly context;
+    private readonly containingEntity;
     constructor(originalEntity: TypeParameterEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
     getName(): Name;
     getConstraint(): TypeParameterConstraint;
@@ -27,17 +27,20 @@ export declare class TranslatedTypeParameterEntity implements TypeParameterEntit
     getArity(): number;
     getTypeParameters(): readonly TypeParameterEntity[];
     getContainingEntity(): EntityContainingTypeParameter;
+    getContainingPackage(): PackageEntity;
     isHidden(): EntityHidingLevel | undefined;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): TypeParameterEntity;
     getContext(): EntityContext;
     getTags(): readonly Tag[];
 }
 export declare class LocalizedTypeParameterConstraint extends TypeParameterConstraint {
-    private readonly _original;
-    private readonly _localizationContext;
-    private readonly _declared;
-    private readonly _cycleFree;
+    private readonly original;
+    private readonly localizationContext;
+    private readonly declared_;
+    private readonly cycleFree_;
     get declared(): types.Type | undefined;
     get cycleFree(): types.Type | undefined;
     get causesCycle(): boolean;

package/build/types/entities/translated/TranslatedVariableEntity.d.ts

@@ -1,29 +1,31 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
-import { Name } from '../../common/index.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
 import * as types from '../../types/index.js';
 import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
 import { GetterEntity } from '../GetterEntity.js';
-import { EntityKind, TypeMemberEntityContainer } from '../index.js';
+import { EntityKind, TypeWithMembersOrExtensionEntity } from '../index.js';
 import { PackageEntity } from '../PackageEntity.js';
 import { SetterEntity } from '../SetterEntity.js';
-import type { FieldEntity, PackageVariableEntity, ParameterVariableEntity } from '../VariableEntity.js';
-import { ParameterVariableEntityContainer, SpecialVariableEntityInfo, VariableEntityDefinition } from '../VariableEntity.js';
+import type { FieldEntity, PackageVariableEntity, ParameterEntity } from '../VariableEntity.js';
+import { EntityContainingParameter, SpecialVariableEntityInfo, VariableEntityDefinition } from '../VariableEntity.js';
 export declare class TranslatedPackageVariableEntity implements PackageVariableEntity {
     readonly kind = EntityKind.Variable;
     readonly subkind = "package";
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _name;
-    private readonly _localizationContext;
-    private readonly _containingPackage;
-    private readonly _type;
-    private readonly _getter;
-    private readonly _setter;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly name;
+    private readonly localizationContext;
+    private readonly containingPackage;
+    private readonly type;
+    private readonly getter;
+    private readonly setter;
     constructor(originalEntity: PackageVariableEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
     getContainingPackage(): PackageEntity;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): PackageVariableEntity;
     getName(): Name;
     getType(): types.Type;
@@ -39,18 +41,21 @@ export declare class TranslatedPackageVariableEntity implements PackageVariableE
 export declare class TranslatedFieldEntity implements FieldEntity {
     readonly kind = EntityKind.Variable;
     readonly subkind = "field";
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _name;
-    private readonly _localizationContext;
-    private readonly _container;
-    private readonly _type;
-    private readonly _getter;
-    private readonly _setter;
-    private readonly _overriddenMembers;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly name;
+    private readonly localizationContext;
+    private readonly containingEntity;
+    private readonly type;
+    private readonly getter;
+    private readonly setter;
+    private readonly overriddenMembers;
     constructor(originalEntity: FieldEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
-    getContainer(): TypeMemberEntityContainer;
-    getLocalization(): Localization;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): FieldEntity;
     getName(): Name;
     getType(): types.Type;
@@ -69,21 +74,24 @@ export declare class TranslatedFieldEntity implements FieldEntity {
     getTags(): readonly Tag[];
     ensureAllDiagnosticsReported?(): void;
 }
-export declare class TranslatedParameterVariableEntity implements ParameterVariableEntity {
+export declare class TranslatedParameterEntity implements ParameterEntity {
     readonly kind = EntityKind.Variable;
     readonly subkind = "parameter";
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _name;
-    private readonly _localizationContext;
-    private readonly _container;
-    private readonly _type;
-    constructor(originalEntity: ParameterVariableEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
-    getContainer(): ParameterVariableEntityContainer;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly name;
+    private readonly localizationContext;
+    private readonly containingEntity;
+    private readonly type;
+    constructor(originalEntity: ParameterEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
+    getContainingEntity(): EntityContainingParameter;
+    getContainingPackage(): PackageEntity;
     isOptional(): boolean;
     isVariadic(): boolean;
-    getLocalization(): Localization;
-    getOriginalEntity(): ParameterVariableEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): ParameterEntity;
     getName(): Name;
     getType(): types.Type;
     getDefinition(): VariableEntityDefinition;

package/build/types/entities/translated/TranslatedVariantTypeEntity.d.ts

@@ -1,13 +1,13 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
-import { Name } from '../../common/index.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
 import * as types from '../../types/Type.js';
+import { BaseObjectType } from '../BaseObjectType.js';
 import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
 import { EntityNaming } from '../EntityNaming.js';
 import { EntityContext, EntityKind } from '../index.js';
 import { PackageEntity } from '../PackageEntity.js';
-import { BaseObjectType } from '../StructuredTypeEntity.js';
 import { SubstitutionApplicationMode } from '../SubstitutionApplicationMode.js';
 import { TypeEntityKind } from '../TypeEntity.js';
 import { TypeEntityMembers } from '../TypeEntityMembers.js';
@@ -18,20 +18,22 @@ export declare class TranslatedPackageVariantTypeEntity implements PackageVarian
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Variant;
     readonly subkind = "package";
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _name;
-    private readonly _localizationContext;
-    private readonly _containingPackage;
-    private readonly _typeParameters;
-    private readonly _underlyingType;
-    private readonly _members;
-    private readonly _baseObjectType;
-    private readonly _context;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly name;
+    private readonly localizationContext;
+    private readonly containingPackage;
+    private readonly typeParameters;
+    private readonly underlyingType;
+    private readonly members;
+    private readonly baseObjectType;
+    private readonly context;
     constructor(originalEntity: PackageVariantTypeEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
     getName(): Name;
     getContainingPackage(): PackageEntity;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): PackageVariantTypeEntity;
     getNaming(): EntityNaming;
     getTypeParameters(): readonly TypeParameterEntity[];
@@ -49,18 +51,20 @@ export declare class TranslatedAnonymousVariantTypeEntity implements AnonymousVa
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Variant;
     readonly subkind = "anonymous";
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _localizationContext;
-    private readonly _containingPackage;
-    private readonly _typeParameters;
-    private readonly _underlyingType;
-    private readonly _members;
-    private readonly _baseObjectType;
-    private readonly _context;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly localizationContext;
+    private readonly containingPackage;
+    private readonly typeParameters;
+    private readonly underlyingType;
+    private readonly members;
+    private readonly baseObjectType;
+    private readonly context;
     constructor(originalEntity: AnonymousVariantTypeEntity, translation: Translation, localizationContext: EntityLocalizationContext);
     getContainingPackage(): PackageEntity;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): AnonymousVariantTypeEntity;
     getNaming(): EntityNaming;
     getTypeParameters(): readonly TypeParameterEntity[];

package/build/types/executor/NodeCompiler.d.ts

@@ -6,7 +6,7 @@ import { Compilation } from '../project/index.js';
 import { TypeScriptLibrariesProvider } from '../ts-interop/TsLibrariesProvider.js';
 export type LaunchPath = string;
 export declare class NodeCompiler {
-    private static _fileSystem;
+    private static fileSystem_;
     private static get fileSystem();
     static findStandardTypeScriptLibrary(nodeModulesSearchPaths: readonly string[], defaultTsLibraryPath?: string): Promise<Uri | undefined>;
     static createTypeScriptLibrariesProvider(nodeModulesSearchPaths: readonly string[], defaultTsLibraryPath: string | undefined, diagnostics: DiagnosticAcceptor | undefined): Promise<TypeScriptLibrariesProvider | undefined>;
@@ -34,12 +34,12 @@ export interface NodeCompilerTask {
 }
 export declare class PrintingDiagnosticAcceptor implements DiagnosticAcceptor {
     private readonly noWarnings;
-    private readonly _formatter;
+    private readonly formatter;
     constructor(noWarnings: boolean, basePath?: string);
     addDiagnostic(diagnostic: Diagnostic): void;
 }
 export declare class NodeDiagnosticFormatter {
-    private readonly _formatDiagnosticOptions;
+    private readonly formatDiagnosticOptions;
     constructor(basePath?: string);
     format(diagnostic: Diagnostic): string;
 }

package/build/types/executor/PhysicalTypeScriptLibrariesProvider.d.ts

@@ -1,8 +1,8 @@
 import { Uri } from '../common/Uri.js';
 import { TypeScriptLibrariesProvider } from '../ts-interop/TsLibrariesProvider.js';
 export declare class PhysicalTypeScriptLibrariesProvider implements TypeScriptLibrariesProvider {
-    private readonly _standardLibraryUri;
-    private readonly _isCaseSensitive;
+    private readonly standardLibraryUri;
+    private readonly isCaseSensitive_;
     constructor(standardLibraryUri: Uri);
     getStandardLibraryUri(): Uri;
     readFileSync(uri: Uri): string | undefined;

package/build/types/parser/Parser.d.ts

@@ -1,7 +1,7 @@
 import { PackageDialect, PackageLocale } from '../common/index.js';
 import * as tree from '../tree/index.js';
 export declare class Parser {
-    private readonly parser_;
+    private readonly parser;
     constructor(text: string, locale?: PackageLocale, dialect?: PackageDialect);
     parse(): tree.SourceFile;
 }

package/build/types/parser/TriviaInterner.d.ts

@@ -1,8 +1,8 @@
 import { Trivia } from '../tree/index.js';
 export declare class TriviaInterner {
-    private readonly triviaCache_;
-    private readonly triviaArrayCache_;
-    private readonly emptyTriviaArray_;
+    private readonly triviaCache;
+    private readonly triviaArrayCache;
+    private readonly emptyTriviaArray;
     internTrivia(trivia: Trivia): Trivia;
     internTriviaArray(trivia: readonly Trivia[] | undefined): readonly Trivia[];
 }

package/build/types/project/Compilation.d.ts

@@ -8,9 +8,9 @@ export declare class Compilation {
     readonly userPackages: readonly SourcePackage[];
     readonly libraryPackages: readonly SourcePackage[];
     readonly allPackages: readonly SourcePackage[];
-    private _parsedSourceFiles;
-    private readonly _packageByUri;
-    private readonly _sourceFileByUri;
+    private parsedSourceFiles;
+    private readonly packageByUri;
+    private readonly sourceFileByUri;
     constructor(uri: Uri, mainPackage: ProgramPackage | undefined, userPackages: readonly SourcePackage[], libraryPackages: readonly SourcePackage[]);
     getSourceFileByUri(uri: Uri): SourceFile | undefined;
     getSourceFileByNode(node: tree.SourceFile): SourceFile;

package/build/types/project/CompilationLoader.d.ts

@@ -7,11 +7,11 @@ import * as packageContent from './PackageContent.js';
 import { PackageName, ProgramPackageConfiguration } from './SourcePackage.js';
 export declare class CompilationLoader {
     static readonly artelSystemPackageName: PackageName;
-    private readonly _source;
-    private readonly _config;
-    private readonly _diagnostics;
-    private readonly _cancellationToken;
-    private _configurationsByPackageOrGroupUri;
+    private readonly source;
+    private readonly config;
+    private readonly diagnostics;
+    private readonly cancellationToken;
+    private configurationsByPackageOrGroupUri;
     private constructor();
     static loadUsingSourcesProvider(uri: Uri, sourcesProvider: SourcesProvider, options?: CompilationLoaderOptions, diagnostics?: DiagnosticAcceptor, workspaceUri?: Uri, namesOfDirectoriesToIgnore?: readonly string[], cancellationToken?: CancellationToken): Promise<{
         loadResult: CompilationLoadResult;

package/build/types/project/FileSystemTree.d.ts

@@ -1,12 +1,12 @@
 import { ObservableObject } from 'reactronic';
 import { Uri } from '../common/index.js';
 export declare class FileSystemTree extends ObservableObject implements ReadonlyFileSystemTree {
-    private readonly _handleInconsistentRequestsWithoutErrors;
-    private readonly _deleteEmptyDirectories;
-    private readonly _rootsByScheme;
-    private _version;
-    private _createdDirectoriesVersion;
-    private _deletedDirectoriesVersion;
+    private readonly handleInconsistentRequestsWithoutErrors;
+    private readonly deleteEmptyDirectories;
+    private readonly rootsByScheme;
+    private version_;
+    private createdDirectoriesVersion_;
+    private deletedDirectoriesVersion_;
     get version(): number;
     get createdDirectoriesVersion(): number;
     get deletedDirectoriesVersion(): number;

package/build/types/project/SourceFile.d.ts

@@ -4,8 +4,8 @@ import { SourcePackage } from './SourcePackage.js';
 import { TextFile } from './TextFile.js';
 export declare class SourceFile extends TextFile {
     readonly name: string;
-    private _package;
-    private readonly _node;
+    private package_;
+    private readonly node;
     get package(): SourcePackage;
     private constructor();
     static create(text: string, uri: Uri, version: number): SourceFile;

package/build/types/project/SourcePackage.d.ts

@@ -6,7 +6,7 @@ declare abstract class SourcePackageBase {
     readonly uri: Uri;
     readonly name: PackageName;
     readonly sourceFiles: readonly SourceFile[];
-    private _compilation;
+    private compilation_;
     get compilation(): Compilation;
     protected abstract get asPackage(): SourcePackage;
     abstract get locale(): PackageLocale;