@artel/artc 0.6.25258 → 0.6.25260

package/build/types/services/LanguageServer.d.ts

@@ -5,35 +5,35 @@ import { TypeScriptLibrariesProvider } from '../ts-interop/TsLibrariesProvider.j
 import { WorkspaceFileSystem } from './workspace/index.js';
 export declare class LanguageServer {
     static readonly DefaultCancellationTokenThrottleTime = 50;
-    private readonly _connection;
-    private readonly _config;
-    private readonly _disposables;
-    private _clientCapabilities;
-    private _workspace;
-    private _isInitialized;
-    private _enableRequestCancellation;
-    private _sendRefreshDiagnosticsRequestDebounced;
-    private _workspaceDiagnosticsPartialResultToken;
-    private _fileSystemUpdateNotificationsPublisher;
-    private _manuallyUpdatedFileSystemTreeProvider;
-    private readonly _sourceFileItemsService;
-    private readonly _workspaceItemsService;
-    private _definitionService;
-    private _sourceGenerationService;
-    private readonly _referencesService;
-    private readonly _documentHighlightService;
-    private readonly _renameService;
-    private readonly _hoverService;
-    private readonly _evaluatableExpressionService;
-    private readonly _completionService;
-    private readonly _semanticTokensService;
-    private readonly _semanticTokenTypeIndexBySemanticTokenKind;
-    private readonly _protocolSemanticTokenModifierFlagByIndex;
-    private readonly _signatureHelpService;
-    private readonly _fileSystemTreeDisplayService;
-    private readonly _selectionRangeService;
-    private readonly _addPropertyAssignmentService;
-    private readonly _codeActionsService;
+    private readonly connection;
+    private readonly config;
+    private readonly disposables;
+    private clientCapabilities;
+    private workspace;
+    private isInitialized;
+    private enableRequestCancellation;
+    private sendRefreshDiagnosticsRequestDebounced;
+    private workspaceDiagnosticsPartialResultToken;
+    private fileSystemUpdateNotificationsPublisher;
+    private manuallyUpdatedFileSystemTreeProvider;
+    private readonly sourceFileItemsService;
+    private readonly workspaceItemsService;
+    private definitionService;
+    private sourceGenerationService;
+    private readonly referencesService;
+    private readonly documentHighlightService;
+    private readonly renameService;
+    private readonly hoverService;
+    private readonly evaluatableExpressionService;
+    private readonly completionService;
+    private readonly semanticTokensService;
+    private readonly semanticTokenTypeIndexBySemanticTokenKind;
+    private readonly protocolSemanticTokenModifierFlagByIndex;
+    private readonly signatureHelpService;
+    private readonly fileSystemTreeDisplayService;
+    private readonly selectionRangeService;
+    private readonly assignFieldService;
+    private readonly codeActionsService;
     constructor(config: LanguageServerConfig);
     start(): void;
     dispose(): void;
@@ -60,7 +60,7 @@ export declare class LanguageServer {
     private convertSourceFileItemKind;
     private convertDiagnostic;
     private onExecuteCommand;
-    private onAddPropertyAssignment;
+    private onAssignField;
     private convertSourceFileEdit;
     private convertSourceFileEditsToWorkspaceEdit;
     private onGetNodeRange;
@@ -127,8 +127,8 @@ export interface ArtelServerInitializationOptions {
     standardPackagesUri?: ls.URI;
 }
 export declare class ClientCancellationToken implements CancellationToken {
-    private readonly _token;
+    private readonly token;
     get isCancellationRequested(): boolean;
-    constructor(_token: ls.CancellationToken);
+    constructor(token: ls.CancellationToken);
     throwIfCancellationRequested(): void;
 }

package/build/types/services/NodeSemanticInfo.d.ts

@@ -1,9 +1,9 @@
 import { AccessedFunction } from '../analysis/AccessedFunction.js';
-import { MatchResultValueParameter } from '../analysis/ArgumentToParameterMatchResult.js';
+import { MatchResultParameter } from '../analysis/ArgumentToParameterMatchResult.js';
 import { PackageNameTreeNode } from '../analysis/ImportedPackageNameTree.js';
 import { Analyzer } from '../analysis/index.js';
-import { Translation } from '../analysis/Localization.js';
 import { IndexedElementAccessorDeclaration } from '../analysis/NodeTypeUtils.js';
+import { Translation } from '../analysis/Translation.js';
 import { AccessKind, ReadonlyNonEmptyArray } from '../common/index.js';
 import { AliasTypeEntity, Entity, FunctionEntity, FunctionTypeEntity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity, VariantTypeEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
@@ -56,7 +56,7 @@ export declare class ReferenceNodeSemanticInfo {
     get firstBetterTargetWithFallback(): ReferenceTarget;
     constructor(targets: ReadonlyNonEmptyArray<ReferenceTarget>, isAmbiguous: boolean, betterTargets?: ReadonlyNonEmptyArray<ReferenceTarget> | undefined);
 }
-export type ReferenceTarget = EntityReferenceTarget | FieldReferenceTarget | TypeValueParameterReferenceTarget | ConstructorReferenceTarget | OperatorReferenceTarget | DereferenceOperatorReferenceTarget | AccessedFunctionReferenceTarget | IndexerReferenceTarget | MatchResultValueParameterReferenceTarget | PackageReferenceTarget | PackageNameTreeNodeReferenceTarget | TypeContextReferenceTarget;
+export type ReferenceTarget = EntityReferenceTarget | FieldReferenceTarget | TypeParameterReferenceTarget | ConstructorReferenceTarget | OperatorReferenceTarget | DereferenceOperatorReferenceTarget | AccessedFunctionReferenceTarget | IndexerReferenceTarget | MatchResultParameterReferenceTarget | PackageReferenceTarget | PackageNameTreeNodeReferenceTarget | TypeContextReferenceTarget;
 export declare class EntityReferenceTarget {
     readonly entity: Entity;
     readonly accessKind: AccessKind;
@@ -71,11 +71,11 @@ export declare class FieldReferenceTarget {
     readonly kind = "field";
     constructor(field: types.Field, accessKind: AccessKind, narrowedType: types.Type | undefined);
 }
-export declare class TypeValueParameterReferenceTarget {
-    readonly parameter: types.ValueParameter;
+export declare class TypeParameterReferenceTarget {
+    readonly parameter: types.Parameter;
     readonly accessKind: AccessKind;
     readonly kind = "type-value-parameter";
-    constructor(parameter: types.ValueParameter, accessKind: AccessKind);
+    constructor(parameter: types.Parameter, accessKind: AccessKind);
 }
 export declare class ConstructorReferenceTarget {
     readonly constructor_: types.Constructor;
@@ -98,11 +98,11 @@ export declare class OperatorReferenceTarget {
     readonly kind = "operator";
     constructor(operator: types.Operator);
 }
-export declare class MatchResultValueParameterReferenceTarget {
-    readonly parameter: MatchResultValueParameter;
+export declare class MatchResultParameterReferenceTarget {
+    readonly parameter: MatchResultParameter;
     readonly accessKind: AccessKind;
     readonly kind = "match-result-value-parameter";
-    constructor(parameter: MatchResultValueParameter, accessKind: AccessKind);
+    constructor(parameter: MatchResultParameter, accessKind: AccessKind);
 }
 export declare class PackageReferenceTarget {
     readonly package_: PackageEntity;

package/build/types/services/ProjectItemsService.d.ts

@@ -1,6 +1,6 @@
 import { Compilation } from '../project/index.js';
 import { Item } from './SourceFileItemsService.js';
 export declare class WorkspaceItemsService {
-    private readonly _sourceFileItemsService;
+    private readonly sourceFileItemsService;
     getItems(compilations: readonly Compilation[]): Item[];
 }

package/build/types/services/RenameService.d.ts

@@ -2,7 +2,7 @@ import { Analyzer } from '../analysis/index.js';
 import { CancellationToken, Range } from '../common/index.js';
 import { SourceFile } from '../project/index.js';
 export declare class RenameService {
-    private readonly _referencesService;
+    private readonly referencesService;
     prepareRename(analyzer: Analyzer, sourceFile: SourceFile, offset: number): Range | undefined;
     rename(analyzer: Analyzer, sourceFile: SourceFile, offset: number, newText: string, cancellationToken: CancellationToken | undefined): Promise<Rename[]>;
     private canRename;

package/build/types/services/SemanticTokensService.d.ts

@@ -15,7 +15,7 @@ export declare class SemanticToken {
     constructor(range: Range, kind: SemanticTokenKind, modifiers: SemanticTokenModifiers);
 }
 export declare class SemanticTokenModifiers {
-    private _flags;
+    private flags_;
     get flags(): number;
     makeConst(): this;
     makeDeclaration(): this;

package/build/types/services/SourceFileItemsService.d.ts

@@ -1,7 +1,7 @@
 import { Range } from '../common/index.js';
 import { SourceFile } from '../project/index.js';
 export declare class SourceFileItemsService {
-    private _sourceFile;
+    private sourceFile;
     getItems(sourceFile: SourceFile): Item[];
     private get locale();
     private get dialect();

package/build/types/services/TranslationService.d.ts

@@ -3,7 +3,7 @@ import { Analyzer } from '../analysis/index.js';
 import { Range } from '../common/index.js';
 import { SourceFile } from '../project/index.js';
 export declare class TranslationService {
-    private readonly _translationCache;
+    private readonly translationCache;
     constructor();
     translateSourceFile(analyzer: Analyzer, sourceFile: SourceFile, localeText: string): Translation;
     clearTranslationCache(): void;

package/build/types/services/signature-help/{ValueParametersSignatureHelpProvider.d.ts → ParametersSignatureHelpProvider.d.ts}

@@ -1,15 +1,15 @@
 import { Analyzer } from '../../analysis/index.js';
 import { SourceFile } from '../../project/index.js';
 import { SignatureHelp } from './SignatureHelpService.js';
-export declare class ValueParametersSignatureHelpProvider {
-    private readonly _signatureContext;
-    private readonly _analyzer;
-    private readonly _sourceFile;
-    private readonly _offset;
+export declare class ParametersSignatureHelpProvider {
+    private readonly signatureContext_;
+    private readonly analyzer;
+    private readonly sourceFile;
+    private readonly offset;
     private get signatureContext();
     constructor(analyzer: Analyzer, sourceFile: SourceFile, offset: number);
     provideSignatureHelp(): SignatureHelp | undefined;
-    private getNodeWithValueArgumentsInfoAtOffset;
+    private getNodeWithArgumentsInfoAtOffset;
     private getArgumentIndexInList;
     private getSignatureDisplayParts;
 }

package/build/types/services/signature-help/{SignatureWithValueParameters.d.ts → SignatureWithParameters.d.ts}

@@ -1,18 +1,18 @@
 import { AccessedFunction } from '../../analysis/AccessedFunction.js';
 import { Analyzer } from '../../analysis/index.js';
 import { Name } from '../../common/index.js';
-import { ParameterVariableEntity } from '../../entities/index.js';
+import { ParameterEntity } from '../../entities/index.js';
 import * as tree from '../../tree/index.js';
 import * as types from '../../types/index.js';
-export declare class ValueArgumentFactory {
-    static createValueArgumentsOfCallExpression(node: tree.CallExpression): ValueArgument[];
-    static createValueArgumentsOfAutotypeCallExpression(node: tree.AutotypeCallExpression): ValueArgument[];
-    static createValueArgumentsOfIndexedAccessExpression(node: tree.IndexedAccessExpression): ValueArgument[];
-    static createValueArgumentsOfTag(node: tree.Tag): ValueArgument[];
-    private static createValueArgumentsFromList;
+export declare class ArgumentFactory {
+    static createArgumentsOfCallExpression(node: tree.CallExpression): Argument[];
+    static createArgumentsOfAutotypeCallExpression(node: tree.AutotypeCallExpression): Argument[];
+    static createArgumentsOfIndexedAccessExpression(node: tree.IndexedAccessExpression): Argument[];
+    static createArgumentsOfTag(node: tree.Tag): Argument[];
+    private static createArgumentsFromList;
 }
 export declare class SignatureForNode {
-    static getSignaturesForNode(analyzer: Analyzer, node: NodeWithValueArguments): SignaturesWithSingleSuitable | undefined;
+    static getSignaturesForNode(analyzer: Analyzer, node: NodeWithArguments): SignaturesWithSingleSuitable | undefined;
     static getSignaturesForCallExpression(analyzer: Analyzer, node: tree.CallExpression): SignaturesWithSingleSuitable | undefined;
     static getSignaturesForAutotypeCallExpression(analyzer: Analyzer, node: tree.AutotypeCallExpression): SignaturesWithSingleSuitable | undefined;
     static getSignaturesForIndexedAccessExpression(analyzer: Analyzer, node: tree.IndexedAccessExpression): SignaturesWithSingleSuitable | undefined;
@@ -20,21 +20,21 @@ export declare class SignatureForNode {
     private static getSignaturesOfConstructors;
 }
 export declare class SimplifiedArgumentToParameterMatcher {
-    static match(analyzer: Analyzer, arguments_: readonly ValueArgument[], signature: Signature): SimplifiedArgumentToParameterMatchResult;
+    static match(analyzer: Analyzer, arguments_: readonly Argument[], signature: Signature): SimplifiedArgumentToParameterMatchResult;
 }
 export declare class SimplifiedArgumentToParameterMatchResult {
-    readonly arguments: readonly ValueArgument[];
-    readonly parameterByArgumentIndex: ReadonlyArray<ValueParameter | undefined>;
-    private readonly _parameterByArgument;
-    get parameterByArgument(): ReadonlyMap<ValueArgument, ValueParameter>;
-    constructor(arguments_: readonly ValueArgument[], parameterByArgumentIndex: ReadonlyArray<ValueParameter | undefined>);
+    readonly arguments: readonly Argument[];
+    readonly parameterByArgumentIndex: ReadonlyArray<Parameter | undefined>;
+    private readonly parameterByArgument_;
+    get parameterByArgument(): ReadonlyMap<Argument, Parameter>;
+    constructor(arguments_: readonly Argument[], parameterByArgumentIndex: ReadonlyArray<Parameter | undefined>);
 }
 export declare class SimplifiedOverloadResolver {
-    static isSuitableSignature(analyzer: Analyzer, matchedSignature: MatchedSignature, valueArguments: readonly ValueArgument[]): boolean;
-    static getMostSuitableSignatureIndex(analyzer: Analyzer, matchedSignatures: readonly MatchedSignature[], valueArguments: readonly ValueArgument[]): number;
+    static isSuitableSignature(analyzer: Analyzer, matchedSignature: MatchedSignature, args: readonly Argument[]): boolean;
+    static getMostSuitableSignatureIndex(analyzer: Analyzer, matchedSignatures: readonly MatchedSignature[], args: readonly Argument[]): number;
 }
-export type NodeWithValueArguments = tree.CallExpression | tree.AutotypeCallExpression | tree.IndexedAccessExpression | tree.Tag;
-export declare class ValueArgument {
+export type NodeWithArguments = tree.CallExpression | tree.AutotypeCallExpression | tree.IndexedAccessExpression | tree.Tag;
+export declare class Argument {
     readonly name: string | undefined;
     readonly expression: tree.Expression | undefined;
     constructor(name: string | undefined, expression: tree.Expression | undefined);
@@ -53,50 +53,50 @@ export type Signature = AccessedFunctionSignature | OperatorSignature | Function
 export declare class AccessedFunctionSignature implements ISignature {
     readonly kind = "accessed-function";
     readonly func: AccessedFunction;
-    private readonly _valueParameters;
+    private readonly parameters;
     constructor(func: AccessedFunction);
-    getValueParameters(): readonly ValueParameter[];
+    getParameters(): readonly Parameter[];
 }
 export declare class OperatorSignature implements ISignature {
     readonly kind = "operator";
     readonly operator: types.Operator;
-    private readonly _valueParameters;
+    private readonly parameters;
     constructor(operator: types.Operator);
-    getValueParameters(): readonly ValueParameter[];
+    getParameters(): readonly Parameter[];
 }
 export declare class FunctionTypeSignature implements ISignature {
     readonly kind = "function-type";
     readonly functionType: types.FunctionType;
-    private readonly _valueParameters;
+    private readonly parameters;
     constructor(functionType: types.FunctionType);
-    getValueParameters(): readonly ValueParameter[];
+    getParameters(): readonly Parameter[];
 }
 export declare class ConstructorSignature implements ISignature {
     readonly kind = "constructor";
     readonly constructor_: types.Constructor;
-    private readonly _valueParameters;
+    private readonly parameters;
     constructor(constructor_: types.Constructor);
-    getValueParameters(): readonly ValueParameter[];
+    getParameters(): readonly Parameter[];
 }
 export declare class IndexerSignature implements ISignature {
     readonly kind = "indexer";
     readonly indexer: types.Indexer;
-    private readonly _valueParameters;
+    private readonly parameters;
     constructor(indexer: types.Indexer);
-    getValueParameters(): readonly ValueParameter[];
+    getParameters(): readonly Parameter[];
 }
 interface ISignature {
-    getValueParameters(): readonly ValueParameter[];
+    getParameters(): readonly Parameter[];
 }
-export type ValueParameter = UniversalValueParameter;
-export declare class UniversalValueParameter implements IValueParameter {
+export type Parameter = UniversalParameter;
+export declare class UniversalParameter implements IParameter {
     readonly type: types.Type;
-    readonly entity: ParameterVariableEntity;
-    constructor(type: types.Type, entity: ParameterVariableEntity);
+    readonly entity: ParameterEntity;
+    constructor(type: types.Type, entity: ParameterEntity);
     getName(): Name;
     getType(): types.Type;
 }
-interface IValueParameter {
+interface IParameter {
     getName(): Name;
     getType(): types.Type;
 }

package/build/types/services/signature-help/TypeParameterSignatureHelpProvider.d.ts

@@ -2,10 +2,10 @@ import { Analyzer } from '../../analysis/index.js';
 import { SourceFile } from '../../project/index.js';
 import { SignatureHelp } from './SignatureHelpService.js';
 export declare class TypeParameterSignatureHelpProvider {
-    private readonly _signatureContext;
-    private readonly _analyzer;
-    private readonly _sourceFile;
-    private readonly _offset;
+    private readonly signatureContext_;
+    private readonly analyzer;
+    private readonly sourceFile;
+    private readonly offset;
     private get signatureContext();
     constructor(analyzer: Analyzer, sourceFile: SourceFile, offset: number);
     provideSignatureHelp(): SignatureHelp | undefined;

package/build/types/services/source-generation/EntityToSyntax.d.ts

@@ -2,8 +2,8 @@ import { Analyzer } from '../../analysis/Analyzer.js';
 import { PackageEntity } from '../../entities/PackageEntity.js';
 import * as tree from '../../tree/index.js';
 export declare class EntityToSyntax {
-    private readonly _analyzer;
-    private readonly _entity;
+    private readonly analyzer;
+    private readonly entity;
     constructor(analyzer: Analyzer, entity: PackageEntity);
     convert(): tree.SourceFile;
     private convertPackage;
@@ -28,8 +28,8 @@ export declare class EntityToSyntax {
     private createFunctionTypeDeclarationBody;
     private convertTypeParameters;
     private convertTypeParameter;
-    private convertValueParameters;
-    private convertValueParameter;
+    private convertParameters;
+    private convertParameter;
     private createHidingModifier;
     private convertTags;
     private getEntityName;

package/build/types/services/source-generation/SourceGenerationService.d.ts

@@ -7,12 +7,12 @@ import { TypeScriptLibrariesProvider } from '../../ts-interop/TsLibrariesProvide
 import { SourceLocation } from '../Types.js';
 import { CompilationController, ReadonlyClientTrackedSourceFiles } from '../workspace/index.js';
 export declare class SourceGenerationService extends ObservableObject {
-    private readonly _trackedSourceFiles;
-    private readonly _tsLibrariesProvider;
-    private readonly _standardPackageContentsProviders;
-    private readonly _generatedPackageStates;
+    private readonly trackedSourceFiles;
+    private readonly tsLibrariesProvider;
+    private readonly standardPackageContentsProviders;
+    private readonly generatedPackageStates;
     get compilationControllers(): readonly CompilationController[];
-    constructor(_trackedSourceFiles: ReadonlyClientTrackedSourceFiles, _tsLibrariesProvider: TypeScriptLibrariesProvider, _standardPackageContentsProviders: (cancellationToken: CancellationToken | undefined) => Promise<readonly PackageContent[] | undefined>);
+    constructor(trackedSourceFiles: ReadonlyClientTrackedSourceFiles, tsLibrariesProvider: TypeScriptLibrariesProvider, standardPackageContentsProviders: (cancellationToken: CancellationToken | undefined) => Promise<readonly PackageContent[] | undefined>);
     getDefinitionInGeneratedCode(analyzer: Analyzer, entity: Entity, cancellationToken: CancellationToken | undefined): Promise<SourceLocation[] | undefined>;
     entityDefinitionRequiresSourceGeneration(entity: Entity): boolean;
     protected onOpenedSourceFilesChanged(): void;

package/build/types/services/workspace/CompilationController.d.ts

@@ -9,24 +9,24 @@ import { ReadonlyClientTrackedSourceFiles } from './ClientTrackedSourceFiles.js'
 export declare class CompilationController extends ObservableObject {
     readonly mainCompilationReloadIndicator: Indicator;
     readonly configurationControllersUpdateIndictor: Indicator;
-    private readonly _mainAnalyzerChangedIndicator;
-    private readonly _fileSystemTree;
+    private readonly mainAnalyzerChangedIndicator;
+    private readonly fileSystemTree;
     readonly config: CompilationControllerConfig;
     isConfigurationsProcessingEnabled: boolean;
     isDiagnosticsCollectionInBackgroundEnabled: boolean;
-    private readonly _rootDirectory;
-    private _configurationControllerByPackageUri;
-    private _mainCompilationState?;
-    private _previousCompilationLoadResult;
-    private _sourceFilesForWhichDiagnosticsWereReported;
-    private readonly _checkedConfigurationVersionByPackageUri;
-    private _packageConfigurationsVersion;
-    private _packageConfigurationsVersionDuringCompilationLoad;
-    private _tsInteropInputs;
-    private _tsInteropInputsKey;
-    private _tsProgramLoaderInputs;
-    private _state;
-    private _configurationsOfPackagesOutsideProject;
+    private readonly rootDirectory;
+    private configurationControllerByPackageUri_;
+    private mainCompilationState_?;
+    private previousCompilationLoadResult;
+    private sourceFilesForWhichDiagnosticsWereReported;
+    private readonly checkedConfigurationVersionByPackageUri;
+    private packageConfigurationsVersion;
+    private packageConfigurationsVersionDuringCompilationLoad;
+    private tsInteropInputs;
+    private tsInteropInputsKey;
+    private tsProgramLoaderInputs;
+    private state_;
+    private configurationsOfPackagesOutsideProject_;
     get uri(): Uri;
     get mainCompilationState(): ReadonlyCompilationState | undefined;
     get configurationControllerByPackageUri(): ReadonlyMap<string, ConfigurationController>;
@@ -88,7 +88,7 @@ export declare class ChangedPackageConfiguration {
 export declare class ReadonlyCompilationState {
     readonly analyzer: Analyzer;
     readonly version: number;
-    private _diagnosticsCollectionSummaryByUri;
+    private diagnosticsCollectionSummaryByUri;
     constructor(analyzer: Analyzer, version: number);
     collectSourceFileDiagnosticsWithHighPriority(sourceFile: SourceFile, cancellationToken: CancellationToken | undefined): Promise<readonly Diagnostic[]>;
     collectSourceFileDiagnosticsWithLowPriority(sourceFile: SourceFile, cancellationToken: CancellationToken | undefined): Promise<readonly Diagnostic[]>;
@@ -104,11 +104,11 @@ declare class ConfigurationController extends ObservableObject {
     readonly packageUri: Uri;
     readonly processingIndicator: Indicator;
     readonly rootDirectory: fsTree.Directory;
-    private readonly _mainCompilationController;
-    private _jsonConfigurationFile;
-    private _convertedJsonConfigurationFileVersion;
-    private _convertedConfiguration;
-    private _convertedConfigurationVersion;
+    private readonly mainCompilationController;
+    private jsonConfigurationFile;
+    private convertedJsonConfigurationFileVersion;
+    private convertedConfiguration_;
+    private convertedConfigurationVersion_;
     get convertedConfiguration(): ConvertedConfiguration | undefined;
     get convertedConfigurationVersion(): number;
     get hasConvertedConfiguration(): boolean;
@@ -118,7 +118,7 @@ declare class ConfigurationController extends ObservableObject {
     protected processConfiguration(): Promise<void>;
 }
 export declare class TsInteropInputsCache {
-    private readonly _inputsByKey;
+    private readonly inputsByKey;
     getTsInteropInputs(tsProgramLoaderInputs: TsProgramLoaderInputs, librariesProvider: TypeScriptLibrariesProvider): {
         inputs: TsInteropInputs;
         key: string;

package/build/types/services/workspace/FileSystemTreeProviderBasedOnWatchedFileSystem.d.ts

@@ -7,22 +7,22 @@ import type { WorkspaceFileSystem } from './WorkspaceFileSystem.js';
 export declare class FileSystemTreeProviderBasedOnWatchedFileSystem extends ObservableObject implements FileSystemTreeProvider {
     readonly fileSystemTree: fsTree.FileSystemTree;
     readonly loadedWorkspaceFolderByUri: ObservableMap<string, fsTree.Directory>;
-    private readonly _fileSystem;
-    private readonly _notificationsPublisher;
-    private readonly _listener;
-    private _workspaceFolderUris;
-    private _trackedSourceFiles;
-    private _isInitialized;
-    private _lastCheckedWorkspaceFolderUris;
+    private readonly fileSystem;
+    private readonly notificationsPublisher;
+    private readonly listener;
+    private workspaceFolderUris;
+    private trackedSourceFiles;
+    private isInitialized;
+    private lastCheckedWorkspaceFolderUris;
     /**
      * Очередь используется для обработки запросов, изменяющих дерево файловой системы.
      * Очередь позволяет избежать конкурентного редактирования, а также сохранить порядок обработки.
      */
-    private readonly _taskQueue;
-    private readonly _namesOfDirectoriesToIgnore;
-    private readonly _additionalUrisOfDirectoriesToLoad;
-    private readonly _lastCheckedTrackedSourceFileInfoVersionByUri;
-    private readonly _loadedDirectoryUris;
+    private readonly taskQueue;
+    private readonly namesOfDirectoriesToIgnore;
+    private readonly additionalUrisOfDirectoriesToLoad;
+    private readonly lastCheckedTrackedSourceFileInfoVersionByUri;
+    private readonly loadedDirectoryUris;
     constructor(fileSystem: WorkspaceFileSystem, notificationsPublisher: FileSystemUpdateNotificationsPublisher, namesOfDirectoriesToIgnore?: string[], additionalUrisOfDirectoriesToLoad?: readonly Uri[]);
     initialize(workspaceFolderUris: ObservableArray<Uri>, trackedSourceFiles: ReadonlyClientTrackedSourceFiles): void;
     waitLoaded(cancellationToken: CancellationToken | undefined): Promise<void>;
@@ -51,7 +51,7 @@ export interface FileSystemUpdateNotificationsPublisher {
     removeListener(listener: FileSystemUpdateNotificationsListener): void;
 }
 export declare class SimpleFileSystemUpdateNotificationsPublisher implements FileSystemUpdateNotificationsPublisher {
-    private readonly _listeners;
+    private readonly listeners;
     publish(notifications: readonly FileSystemUpdateNotification[]): void;
     addListener(listener: FileSystemUpdateNotificationsListener): void;
     removeListener(listener: FileSystemUpdateNotificationsListener): void;

package/build/types/services/workspace/ManuallyUpdatedFileSystemTreeProvider.d.ts

@@ -7,10 +7,10 @@ import { FileSystemTreeProvider } from './WorkspaceFiles.js';
 export declare class ManuallyUpdatedFileSystemTreeProvider extends ObservableObject implements FileSystemTreeProvider {
     readonly fileSystemTree: fsTree.FileSystemTree;
     readonly loadedWorkspaceFolderByUri: ObservableMap<string, fsTree.Directory>;
-    private _workspaceFolderUris;
-    private _trackedSourceFiles;
-    private readonly _lastCheckedTrackedSourceFileInfoByUri;
-    private readonly _manuallyCreatedSourceFileTextByUri;
+    private workspaceFolderUris;
+    private trackedSourceFiles;
+    private readonly lastCheckedTrackedSourceFileInfoByUri;
+    private readonly manuallyCreatedSourceFileTextByUri;
     initialize(workspaceFolderUris: ObservableArray<Uri>, trackedSourceFiles: ReadonlyClientTrackedSourceFiles): void;
     waitLoaded(_cancellationToken: CancellationToken | undefined): Promise<void>;
     dispose(): void;

package/build/types/services/workspace/Workspace.d.ts

@@ -10,13 +10,13 @@ import { CompilationController, DiagnosticsCollectedInBackgroundHandler, RawPack
 import { FileSystemTreeProvider } from './WorkspaceFiles.js';
 export declare class Workspace extends ObservableObject {
     isReadyToAcceptWorkspaceDiagnostics: boolean;
-    private readonly _config;
-    private readonly _compilationControllers;
-    private readonly _controllersWithOpenedFiles;
-    private _atLeastOneFileOfCompilationHasBeenOpened;
-    private readonly _files;
-    private _standardPackageContents;
-    private readonly _tsInteropInputsCache;
+    private readonly config;
+    private readonly compilationControllers_;
+    private readonly controllersWithOpenedFiles;
+    private atLeastOneFileOfCompilationHasBeenOpened;
+    private readonly files;
+    private readonly standardPackageContents;
+    private readonly tsInteropInputsCache;
     get compilationControllers(): readonly CompilationController[];
     get trackedSourceFiles(): ReadonlyClientTrackedSourceFiles;
     get loadedWorkspaceFolderByUri(): ObservableMap<string, fsTree.Directory>;

package/build/types/services/workspace/WorkspaceFiles.d.ts

@@ -6,7 +6,7 @@ export declare class WorkspaceFiles extends ObservableObject {
     readonly trackedSourceFiles: ClientTrackedSourceFiles;
     readonly workspaceFolderUris: ObservableArray<Uri>;
     readonly workspaceFolderWithArtelProjectByUri: ObservableMap<string, fsTree.Directory>;
-    private readonly _fileSystemTreeProvider;
+    private readonly fileSystemTreeProvider;
     get fileSystemTree(): fsTree.ReadonlyFileSystemTree;
     get isMissingConfigurationDirectoryAllowed(): boolean;
     get loadedWorkspaceFolderByUri(): ObservableMap<string, fsTree.Directory>;

package/build/types/tree/BaseNode.d.ts

@@ -1,15 +1,19 @@
-import { Range } from '../common/index.js';
-import { Node } from './Nodes.js';
+import { PackageDialect, PackageLocale, Range } from '../common/index.js';
+import { Node, SourceFile } from './Nodes.js';
 import { Token } from './Token.js';
 export declare abstract class BaseNode {
     protected static readonly emptyChildren_: [];
     abstract readonly children: readonly (Node | undefined)[];
     protected parent_: BaseNode | undefined;
+    protected sourceFile_: SourceFile | undefined;
     protected rangeWithTrivia_: Range | undefined;
     protected rangeWithoutTrivia_: Range | undefined;
     protected abstract thisAsNode: Node;
-    constructor(rangeWithTrivia?: Range);
+    constructor(rangeWithTrivia: Range | undefined);
     get parent(): Node | undefined;
+    get sourceFile(): SourceFile;
+    get locale(): PackageLocale;
+    get dialect(): PackageDialect;
     get rangeWithTrivia(): Range;
     get rangeWithoutTrivia(): Range;
     get debuggerDisplay(): string;
@@ -21,8 +25,13 @@ export declare abstract class BaseNode {
      * Информация для оценки размера дерева при отладке.
      */
     get tokenCount(): number;
+    /**
+     * Позволяет получить путь к синтаксическому узлу при отладке.
+     */
+    get nodePath(): string;
     findLeftmostToken(): Token | undefined;
     findRightmostToken(): Token | undefined;
+    protected setSourceFileForChildren(): void;
     protected setParentForChildren(): void;
     protected getLengthWithTrivia(): number;
     protected getStartWithTrivia(): number;