@artel/artc 0.6.25259 → 0.6.25260

package/build/types/analysis/semantic-context/SemanticContextBase.d.ts

@@ -10,10 +10,11 @@ import { FunctionDeclaration, GetterDeclaration, RegularOrBlockFunctionLiteral,
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
 export declare abstract class SemanticContextBase {
-    protected static readonly _emptyTypesOrContainersWithTypes: readonly TypeOrContainerWithTypes[];
-    protected static readonly _emptyNamedDeclarations: readonly NamedDeclaration[];
-    protected static readonly _emptyOperators: readonly types.Operator[];
-    protected static readonly _emptyTypeExtensions: readonly TypeExtensionEntity[];
+    protected static readonly emptyTypesOrContainersWithTypes: readonly TypeOrContainerWithTypes[];
+    protected static readonly emptyNamedDeclarations: readonly NamedDeclaration[];
+    protected static readonly emptyOperators: readonly types.Operator[];
+    protected static readonly emptyTypeExtensions: readonly TypeExtensionEntity[];
+    private hidingMatcher;
     abstract readonly outer: SemanticContext | undefined;
     protected abstract readonly asContext: SemanticContext;
     abstract getContainingSubprogram(): SubprogramInfo | undefined;
@@ -42,8 +43,8 @@ export type SubprogramInfo = SubprogramInfo.Function | SubprogramInfo.Operator |
 export declare namespace SubprogramInfo {
     export class Function implements ISubprogramInfo {
         readonly kind = "function";
-        private readonly _analyzer;
-        private readonly _node;
+        private readonly analyzer;
+        private readonly node;
         constructor(analyzer: Analyzer, node: FunctionDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
@@ -53,8 +54,8 @@ export declare namespace SubprogramInfo {
     }
     export class Operator implements ISubprogramInfo {
         readonly kind = "operator";
-        private readonly _analyzer;
-        private readonly _node;
+        private readonly analyzer;
+        private readonly node;
         constructor(analyzer: Analyzer, node: tree.OperatorDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
@@ -63,8 +64,8 @@ export declare namespace SubprogramInfo {
     }
     export class Constructor implements ISubprogramInfo {
         readonly kind = "constructor";
-        private readonly _analyzer;
-        private readonly _node;
+        private readonly analyzer;
+        private readonly node;
         constructor(analyzer: Analyzer, node: tree.ConstructorDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
@@ -74,8 +75,8 @@ export declare namespace SubprogramInfo {
     }
     export class Destructor implements ISubprogramInfo {
         readonly kind = "destructor";
-        private readonly _analyzer;
-        private readonly _node;
+        private readonly analyzer;
+        private readonly node;
         constructor(analyzer: Analyzer, node: tree.DestructorDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
@@ -84,8 +85,8 @@ export declare namespace SubprogramInfo {
     }
     export class Getter implements ISubprogramInfo {
         readonly kind = "getter";
-        private readonly _analyzer;
-        private readonly _node;
+        private readonly analyzer;
+        private readonly node;
         constructor(analyzer: Analyzer, node: GetterDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
@@ -94,8 +95,8 @@ export declare namespace SubprogramInfo {
     }
     export class Setter implements ISubprogramInfo {
         readonly kind = "setter";
-        private readonly _analyzer;
-        private readonly _node;
+        private readonly analyzer;
+        private readonly node;
         constructor(analyzer: Analyzer, node: SetterDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
@@ -104,8 +105,8 @@ export declare namespace SubprogramInfo {
     }
     export class PackageConstructor implements ISubprogramInfo {
         readonly kind = "package-constructor";
-        private readonly _analyzer;
-        private readonly _node;
+        private readonly analyzer;
+        private readonly node;
         constructor(analyzer: Analyzer, node: tree.PackageConstructorDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
@@ -115,8 +116,8 @@ export declare namespace SubprogramInfo {
     }
     export class PackageEntryPoint implements ISubprogramInfo {
         readonly kind = "package-entry-point";
-        private readonly _analyzer;
-        private readonly _node;
+        private readonly analyzer;
+        private readonly node;
         constructor(analyzer: Analyzer, node: tree.PackageEntryPointDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
@@ -126,8 +127,8 @@ export declare namespace SubprogramInfo {
     }
     export class FunctionLiteral implements ISubprogramInfo {
         readonly kind = "function-literal";
-        private readonly _analyzer;
-        private readonly _node;
+        private readonly analyzer;
+        private readonly node;
         constructor(analyzer: Analyzer, node: RegularOrBlockFunctionLiteral);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;

package/build/types/analysis/semantic-context/SemanticContextBasedEntityHidingMatcher.d.ts

@@ -4,10 +4,10 @@ import { TypeEntity } from '../../entities/TypeEntity.js';
 import { SourceFile } from '../../project/SourceFile.js';
 import { SemanticContext } from './SemanticContext.js';
 export declare class SemanticContextBasedEntityHidingMatcher extends BaseEntityHidingMatcher {
-    private readonly _semanticContext;
-    private readonly _sourceFile;
-    private readonly _typeEntity;
-    private readonly _package;
+    private readonly semanticContext;
+    private readonly typeEntity_;
+    private sourceFile_;
+    private package_;
     protected get sourceFile(): SourceFile;
     protected get package(): PackageEntity;
     protected get typeEntity(): TypeEntity | undefined;

package/build/types/analysis/semantic-context/SemanticContextBuilder.d.ts

@@ -4,31 +4,31 @@ import { FunctionDeclaration, IndexedElementAccessorDeclaration, PackageTypeDecl
 import { BlockSemanticContext, CatchClauseSemanticContext, ConstructorSemanticContext, DestructorSemanticContext, ForStatementSemanticContext, FunctionBlockSemanticContext, FunctionLiteralSemanticContext, FunctionSemanticContext, IndexedElementAccessorSemanticContext, OperatorSemanticContext, OutermostSemanticContextOfSubprogram, OutermostSemanticContextOfType, PackageConstructorSemanticContext, PackageEntryPointSemanticContext, ParametersOfFunctionTypeSemanticContext, SemanticContext, SemanticContextContainingTypeMember, SourceFileSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterSemanticContext, SubprogramTypeParameterSemanticContext, TypeBodySemanticContext, TypeDeclarationCreatingSemanticContext, TypeDeclarationWithMembersBody, TypeExtensionBodySemanticContext, TypeParametersOfTypeSemanticContext, VariableAccessorDeclaration, VariableAccessorSemanticContext } from '../semantic-context/index.js';
 import { TranslationTextTemplateSemanticContext } from './TranslationTextTemplateSemanticContext.js';
 export declare class SemanticContextBuilder {
-    private readonly _analyzer;
-    private readonly _sourceFileContexts;
-    private readonly _indexedElementAccessorContexts;
-    private readonly _operatorContexts;
-    private readonly _fieldWithInitializerContexts;
-    private readonly _forStatementContexts;
-    private readonly _catchClauseSemanticContexts;
-    private readonly _destructorContexts;
-    private readonly _constructorContexts;
-    private readonly _functionLiteralContexts;
-    private readonly _packageEntryPointContexts;
-    private readonly _packageConstructorContexts;
-    private readonly _variableAccessorContexts;
-    private readonly _typeDeclarationTypeParameterContexts;
-    private readonly _typeDeclarationBodyContexts;
-    private readonly _parametersOfFunctionTypeContext;
-    private readonly _statementBlockContexts;
-    private readonly _functionBlockContexts;
-    private readonly _specialLocalDeclarationContexts;
-    private readonly _subprogramTypeParameterContexts;
-    private readonly _subprogramParameterContexts;
-    private readonly _outermostContextsOfFunctionDeclaration;
-    private readonly _outermostContextsOfTypeDeclaration;
-    private readonly _typeExtensionDeclarationBodyContexts;
-    private readonly _translationTextTemplateContexts;
+    private readonly analyzer;
+    private readonly sourceFileContexts;
+    private readonly indexedElementAccessorContexts;
+    private readonly operatorContexts;
+    private readonly fieldWithInitializerContexts;
+    private readonly forStatementContexts;
+    private readonly catchClauseSemanticContexts;
+    private readonly destructorContexts;
+    private readonly constructorContexts;
+    private readonly functionLiteralContexts;
+    private readonly packageEntryPointContexts;
+    private readonly packageConstructorContexts;
+    private readonly variableAccessorContexts;
+    private readonly typeDeclarationTypeParameterContexts;
+    private readonly typeDeclarationBodyContexts;
+    private readonly parametersOfFunctionTypeContext;
+    private readonly statementBlockContexts;
+    private readonly functionBlockContexts;
+    private readonly specialLocalDeclarationContexts;
+    private readonly subprogramTypeParameterContexts;
+    private readonly subprogramParameterContexts;
+    private readonly outermostContextsOfFunctionDeclaration;
+    private readonly outermostContextsOfTypeDeclaration;
+    private readonly typeExtensionDeclarationBodyContexts;
+    private readonly translationTextTemplateContexts;
     constructor(analyzer: Analyzer);
     /**
      * Возвращает контекст, содержащий узел. Если в качестве узла передан исходный файл,

package/build/types/analysis/semantic-context/SemanticContextValidatingNameConflicts.d.ts

@@ -1,7 +1,7 @@
 import { Name } from '../../common/index.js';
 import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
 import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
-import { LocalVariableEntity, NestedFunctionEntity, ParameterVariableEntity, TextTemplateParameterVariableEntity, TypeParameterEntity } from '../../entities/index.js';
+import { LocalVariableEntity, NestedFunctionEntity, ParameterEntity, TextTemplateParameterEntity, TypeParameterEntity } from '../../entities/index.js';
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
@@ -13,13 +13,13 @@ export interface NameConflictsValidator {
 export declare abstract class SemanticContextValidatingNameConflictsBase extends SemanticContextWithParent implements NameConflictsValidator {
     abstract readonly outer: SemanticContext;
     abstract readonly node: tree.Node;
-    protected readonly _analyzer: Analyzer;
-    private readonly _memberEntities;
-    private _memberEntitiesByNameKey;
-    private readonly _namedDeclarations;
-    private readonly _typesOrContainerWithTypes;
-    private readonly _namedDeclarationsByName;
-    private readonly _typesOrContainerWithTypesByName;
+    protected readonly analyzer: Analyzer;
+    private readonly memberEntities_;
+    private memberEntitiesByNameKey;
+    private readonly namedDeclarations_;
+    private readonly typesOrContainerWithTypes_;
+    private readonly namedDeclarationsByName_;
+    private readonly typesOrContainerWithTypesByName_;
     private get memberEntities();
     private get namedDeclarations();
     private get typesOrContainerWithTypes();
@@ -38,5 +38,5 @@ export declare abstract class SemanticContextValidatingNameConflictsBase extends
     private createNamedDeclarations;
     private createTypesOrContainerWithTypes;
 }
-export type MemberOfSemanticContextValidatingNameConflicts = LocalVariableEntity | ParameterVariableEntity | TextTemplateParameterVariableEntity | NestedFunctionEntity | TypeParameterEntity;
+export type MemberOfSemanticContextValidatingNameConflicts = LocalVariableEntity | ParameterEntity | TextTemplateParameterEntity | NestedFunctionEntity | TypeParameterEntity;
 export type MemberOfSemanticContextValidatingNameConflictsForTypeLookup = TypeParameterEntity;

package/build/types/analysis/semantic-context/SourceFileSemanticContext.d.ts

@@ -12,14 +12,14 @@ export declare class SourceFileSemanticContext extends SemanticContextBase {
     readonly kind = "source-file";
     readonly outer: SemanticContext | undefined;
     protected asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _sourceFile;
-    private readonly _sourceFileMembers;
-    private readonly _containingPackageMemberLookup;
-    private readonly _importedPackageMemberLookups;
-    private readonly _packageNameSegments;
-    private readonly _packageNameSegmentsByKey;
-    private readonly _diagnosticArgumentFactory;
+    private readonly analyzer;
+    private readonly sourceFile;
+    private readonly sourceFileMembers;
+    private readonly containingPackageMemberLookup;
+    private readonly importedPackageMemberLookups;
+    private readonly packageNameSegments;
+    private readonly packageNameSegmentsByKey_;
+    private readonly diagnosticArgumentFactory;
     private get packageNameSegmentsByKey();
     constructor(analyzer: Analyzer, node: tree.SourceFile);
     getContainingSubprogram(): SubprogramInfo | undefined;

package/build/types/analysis/semantic-context/SubprogramSemanticContext.d.ts

@@ -27,9 +27,9 @@ export declare abstract class OutermostSemanticContextOfSubprogram extends Seman
 export declare class FunctionSemanticContext extends OutermostSemanticContextOfSubprogram {
     readonly outer: SemanticContext;
     protected readonly asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _subprogramInfo;
+    private readonly analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
     constructor(analyzer: Analyzer, node: FunctionDeclaration, outer: SemanticContext);
     getContainingSubprogram(): SubprogramInfo;
     isStatic(): boolean;
@@ -37,27 +37,27 @@ export declare class FunctionSemanticContext extends OutermostSemanticContextOfS
 export declare class PackageConstructorSemanticContext extends OutermostSemanticContextOfSubprogram {
     readonly outer: SourceFileSemanticContext;
     protected readonly asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _subprogramInfo;
+    private readonly analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
     constructor(analyzer: Analyzer, node: tree.PackageConstructorDeclaration, outer: SourceFileSemanticContext);
     getContainingSubprogram(): SubprogramInfo;
 }
 export declare class PackageEntryPointSemanticContext extends OutermostSemanticContextOfSubprogram {
     readonly outer: SourceFileSemanticContext;
     protected readonly asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _subprogramInfo;
+    private readonly analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
     constructor(analyzer: Analyzer, node: tree.PackageEntryPointDeclaration, outer: SourceFileSemanticContext);
     getContainingSubprogram(): SubprogramInfo;
 }
 export declare class OperatorSemanticContext extends OutermostSemanticContextOfSubprogram {
     readonly outer: SemanticContextContainingTypeMember;
     protected readonly asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _subprogramInfo;
+    private readonly analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
     constructor(analyzer: Analyzer, node: tree.OperatorDeclaration, outer: SemanticContextContainingTypeMember);
     getContainingSubprogram(): SubprogramInfo;
     isStatic(): boolean;
@@ -65,18 +65,18 @@ export declare class OperatorSemanticContext extends OutermostSemanticContextOfS
 export declare class ConstructorSemanticContext extends OutermostSemanticContextOfSubprogram {
     readonly outer: SemanticContextContainingTypeMember;
     protected readonly asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _subprogramInfo;
+    private readonly analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
     constructor(analyzer: Analyzer, node: tree.ConstructorDeclaration, outer: SemanticContextContainingTypeMember);
     getContainingSubprogram(): SubprogramInfo;
 }
 export declare class DestructorSemanticContext extends OutermostSemanticContextOfSubprogram {
     readonly outer: SemanticContextContainingTypeMember;
     protected readonly asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _subprogramInfo;
+    private readonly analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
     constructor(analyzer: Analyzer, node: tree.DestructorDeclaration, outer: SemanticContextContainingTypeMember);
     getContainingSubprogram(): SubprogramInfo;
 }
@@ -85,9 +85,9 @@ export type VariableAccessorDeclaration = PackageVariableAccessorDeclaration | F
 export declare class VariableAccessorSemanticContext extends OutermostSemanticContextOfSubprogram {
     readonly outer: AccessorSemanticContextParent;
     protected readonly asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _subprogramInfo;
+    private readonly analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
     constructor(analyzer: Analyzer, node: VariableAccessorDeclaration, outer: AccessorSemanticContextParent);
     getContainingSubprogram(): SubprogramInfo;
     isStatic(): boolean;
@@ -95,9 +95,9 @@ export declare class VariableAccessorSemanticContext extends OutermostSemanticCo
 export declare class IndexedElementAccessorSemanticContext extends OutermostSemanticContextOfSubprogram {
     readonly outer: AccessorSemanticContextParent;
     protected readonly asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _subprogramInfo;
+    private readonly analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
     constructor(analyzer: Analyzer, node: IndexedElementAccessorDeclaration, outer: AccessorSemanticContextParent);
     getContainingSubprogram(): SubprogramInfo;
     isStatic(): boolean;
@@ -105,9 +105,9 @@ export declare class IndexedElementAccessorSemanticContext extends OutermostSema
 export declare class FunctionLiteralSemanticContext extends OutermostSemanticContextOfSubprogram {
     readonly outer: SemanticContext;
     protected readonly asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _subprogramInfo;
+    private readonly analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
     constructor(analyzer: Analyzer, node: RegularOrBlockFunctionLiteral, outer: SemanticContext);
     getContainingSubprogram(): SubprogramInfo;
 }

package/build/types/analysis/semantic-context/TypeSemanticContext.d.ts

@@ -22,8 +22,8 @@ export declare class OutermostSemanticContextOfType extends SemanticContextWithP
     readonly kind = "outermost-of-type";
     readonly outer: SemanticContext;
     protected readonly asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _node;
+    private readonly analyzer;
+    private readonly node;
     constructor(analyzer: Analyzer, node: TypeDeclarationCreatingSemanticContext, outer: SemanticContext);
     getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
     getContainingSubprogram(): SubprogramInfo | undefined;
@@ -40,7 +40,7 @@ export declare class TypeParametersOfTypeSemanticContext extends SemanticContext
     readonly outer: OutermostSemanticContextOfType;
     readonly node: TypeDeclarationWithTypeParameters;
     protected readonly asContext: SemanticContext;
-    private readonly _typeParameterClause;
+    private readonly typeParameterClause;
     constructor(analyzer: Analyzer, node: TypeDeclarationWithTypeParameters, typeParameterClause: tree.TypeParameterClause, outer: OutermostSemanticContextOfType);
     protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
     protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
@@ -62,9 +62,9 @@ export declare class TypeBodySemanticContext extends TypeOrExtensionBodySemantic
     readonly kind = "type-body";
     readonly outer: TypeBodySemanticContextParent;
     protected readonly asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _memberLookup;
+    private readonly analyzer;
+    private readonly node;
+    private readonly memberLookup_;
     protected get memberLookup(): TypeMemberLookup;
     constructor(analyzer: Analyzer, node: TypeDeclarationWithMembersBody, outer: TypeBodySemanticContextParent);
     private getTypeEntity;
@@ -73,9 +73,9 @@ export declare class TypeExtensionBodySemanticContext extends TypeOrExtensionBod
     readonly kind = "type-extension-body";
     readonly outer: SourceFileSemanticContext;
     protected readonly asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _memberLookup;
+    private readonly analyzer;
+    private readonly node;
+    private readonly memberLookup_;
     protected get memberLookup(): TypeMemberLookup;
     constructor(analyzer: Analyzer, node: tree.TypeExtensionDeclaration, outer: SourceFileSemanticContext);
     getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;

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

@@ -1,7 +1,7 @@
 export * from '../analysis/AccessedFunction.js';
 export * from '../analysis/AnalyzedTranslationPackage.js';
 export * from '../analysis/Analyzer.js';
-export { MatchResult, MatchResultValueParameter } from '../analysis/ArgumentToParameterMatchResult.js';
+export { MatchResult, MatchResultParameter } from '../analysis/ArgumentToParameterMatchResult.js';
 export type { Meaning as AutotypeCallExpressionMeaning } from '../analysis/AutotypeCallExpressionMeaning.js';
 export type { Meaning as BaseExpressionMeaning } from '../analysis/BaseExpressionMeaning.js';
 export type { Meaning as CallExpressionMeaning } from '../analysis/CallExpressionMeaning.js';
@@ -11,7 +11,6 @@ export * from '../analysis/FindModifier.js';
 export type { Meaning as IdentifierExpressionMeaning, ResolutionResult as IdentifierExpressionResolutionResult } from '../analysis/IdentifierExpressionMeaning.js';
 export * from '../analysis/ImportedPackageNameTree.js';
 export type { Meaning as IndexedAccessExpressionMeaning } from '../analysis/IndexedAccessExpressionMeaning.js';
-export * from '../analysis/Localization.js';
 export type { Meaning as MemberAccessExpressionMeaning, ResolutionResult as MemberAccessExpressionResolutionResult } from '../analysis/MemberAccessExpressionMeaning.js';
 export * from '../analysis/NodeTypeUtils.js';
 export type { Meaning as ObjectExpressionMeaning } from '../analysis/ObjectExpressionMeaning.js';
@@ -22,6 +21,7 @@ export * from '../analysis/SourcePackageDependencyGraph.js';
 export * from '../analysis/SubstitutedFunction.js';
 export type { Meaning as TagMeaning } from '../analysis/TagMeaning.js';
 export * from '../analysis/Tags.js';
+export * from '../analysis/Translation.js';
 export * from '../analysis/TypeMemberLookup.js';
 export * from '../analysis/Utils.js';
 export * from '../analysis/Visitor.js';

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

@@ -1,7 +1,7 @@
 export declare class Cached<T> {
-    private _hasValue;
-    private _value?;
-    private _isEvaluating;
+    private hasValue_;
+    private value?;
+    private isEvaluating;
     get hasValue(): boolean;
     insert(value: T): void;
     getOrInsertWith(fn: () => T): T;

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

@@ -6,8 +6,8 @@ export declare class CancelledError extends Error {
     constructor(message?: string);
 }
 export declare class GenericCancellationToken implements CancellationToken {
-    private readonly _isCancellationRequested;
+    private readonly isCancellationRequested_;
     get isCancellationRequested(): boolean;
-    constructor(_isCancellationRequested: () => boolean);
+    constructor(isCancellationRequested_: () => boolean);
     throwIfCancellationRequested(): void;
 }

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

@@ -1,6 +1,6 @@
 export declare class Delayed<T> {
-    private _hasValue;
-    private _value?;
+    private hasValue_;
+    private value_?;
     get hasValue(): boolean;
     get value(): T;
     set value(value: T);

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

@@ -2,9 +2,9 @@ export interface Displayable {
     getDisplayText(): string;
 }
 export declare class DisplayableArray implements Displayable {
-    private readonly _array;
-    private readonly _separator;
-    constructor(_array: readonly DisplayableOrPrimitive[], _separator: string);
+    private readonly array;
+    private readonly separator;
+    constructor(array: readonly DisplayableOrPrimitive[], separator: string);
     getDisplayText(): string;
 }
 export type DisplayableOrPrimitive = Displayable | string | number | boolean;

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

@@ -9,6 +9,7 @@ export declare const enum HelperPhraseKind {
     Variable = 6,
     Overloads = 7,
     EnumeratorMethodName = 8,
-    InvokeMethodName = 9
+    InvokeMethodName = 9,
+    EmptyUnionType = 10
 }
 export declare function getHelperPhrase(kind: HelperPhraseKind, locale: PackageLocale): string;

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

@@ -1,4 +1,4 @@
 export declare class Interner<TKey, TValue> {
-    private readonly _values;
+    private readonly values;
     intern(key: TKey, value: TValue): TValue;
 }

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

@@ -1,7 +1,7 @@
 export declare class Lazy<T> {
-    private _factory;
-    private _isEvaluating;
-    private _value?;
+    private factory;
+    private isEvaluating;
+    private value_?;
     constructor(factory: () => T);
     static immediate<T>(value: T): Lazy<T>;
     get value(): T;

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

@@ -1,6 +1,6 @@
 export declare class Option<T> {
-    private readonly _isSome;
-    private readonly _value?;
+    private readonly isSome_;
+    private readonly value?;
     private constructor();
     static some<T>(value: T): Option<T>;
     static none<T>(): Option<T>;

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

@@ -1,7 +1,7 @@
 export declare class PerformanceMeasurement {
     static isEnabled: boolean;
-    private static readonly _durations;
-    private static readonly _measureInfoStack;
+    private static readonly durations;
+    private static readonly measureInfoStack;
     static markStart(label: string | number): void;
     static markEnd(): void;
     static getDurationMs(label: string | number): number;

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

@@ -4,6 +4,20 @@ export declare abstract class Query<T> implements Iterable<T> {
     static fromNullable<T>(source: Iterable<T> | undefined): Query<T>;
     static empty<T>(): Query<T>;
     static ofSuccessors<T>(first: T, next: (t: T) => T | undefined): Query<T>;
+    static map<T, K>(source: Iterable<T>, fn: (t: T, i: number) => K): Query<K>;
+    static toMap<T, K, V>(source: Iterable<T>, keySelector: (t: T) => K, valueSelector: (t: T) => V): Map<K, V>;
+    static toMap<T>(source: Iterable<T>): T extends readonly [infer K, infer V] ? Map<K, V> : never;
+    static filter<T, K extends T>(source: Iterable<T>, fn: (t: T) => t is K): Query<K>;
+    static filter<T>(source: Iterable<T>, fn: (t: T) => boolean): Query<T>;
+    static mapAndFilter<T, K>(source: Iterable<T>, fn: (t: T) => K | undefined): Query<K>;
+    static zip<T, TRight, TResult>(source: Iterable<T>, other: Iterable<TRight>, fn: (left: T, right: TRight) => TResult): Query<TResult>;
+    static zipLongest<T, TRight, TResult>(source: Iterable<T>, other: Iterable<TRight>, fn: (left: T | undefined, right: TRight | undefined) => TResult): Query<TResult>;
+    static all<T>(source: Iterable<T>, fn: (t: T) => boolean): boolean;
+    static any<T>(source: Iterable<T>, fn: (t: T) => boolean): boolean;
+    static groupByToMap<T, K>(source: Iterable<T>, keySelector: (t: T) => K): Map<K, T[]>;
+    static groupByToMap<T, K, V>(source: Iterable<T>, keySelector: (t: T) => K, mapFn: (t: T) => V): Map<K, V[]>;
+    static maxByValue<T>(source: Iterable<T>, valueSelector: (t: T) => number): T | undefined;
+    static minByValue<T>(source: Iterable<T>, valueSelector: (t: T) => number): T | undefined;
     abstract [Symbol.iterator](): Iterator<T, void, undefined>;
     map<K>(fn: (t: T, i: number) => K): Query<K>;
     forEach(fn: (t: T) => void): void;
@@ -28,6 +42,7 @@ export declare abstract class Query<T> implements Iterable<T> {
     all(fn: (t: T) => boolean): boolean;
     any(fn: (t: T) => boolean): boolean;
     skipWhile(fn: (t: T) => boolean): Query<T>;
+    skip(count: number): Query<T>;
     takeWhile(fn: (t: T) => boolean): Query<T>;
     scan<TState, K>(initial: TState, fn: (state: TState, t: T) => K | undefined): Query<K>;
     reduce<K>(initial: K, fn: (state: K, t: T) => K): K;

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

@@ -1,11 +1,11 @@
 import { CancellationToken } from './index.js';
 export declare class ThrottledCancellationToken {
-    private readonly _token;
-    private readonly _throttleTimeMs;
-    private readonly _checkThrottleTimeEveryN;
-    private _checkNumber;
-    private _lastTimeMs;
-    constructor(_token: CancellationToken, _throttleTimeMs: number, _checkThrottleTimeEveryN: number);
+    private readonly token;
+    private readonly throttleTimeMs;
+    private readonly checkThrottleTimeEveryN;
+    private checkNumber;
+    private lastTimeMs;
+    constructor(token: CancellationToken, throttleTimeMs: number, checkThrottleTimeEveryN: number);
     isThrottleTimeOver(): boolean;
     throwIfCancellationRequestedAndReset(): void;
     throwIfCancellationRequestedAndResetAsync(): Promise<void>;

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

@@ -3,17 +3,14 @@ import { TypeWithMembersDeclaration } from '../analysis/NodeTypeUtils.js';
 import { PackageEntity, TypeEntity } from '../entities/index.js';
 import { SourceFile, SourcePackage } from '../project/index.js';
 import * as tree from '../tree/index.js';
-import { PackageLocale } from './PackageLocale.js';
 export declare class TreeQuery {
-    static getSourceFileNode(node: tree.Node): tree.SourceFile;
     static getSourceFile(node: tree.Node, analyzer: Analyzer): SourceFile;
     static getSourcePackage(node: tree.Node, analyzer: Analyzer): SourcePackage;
     static getPackageEntity(node: tree.Node, analyzer: Analyzer): PackageEntity;
-    static getLocale(node: tree.Node, analyzer: Analyzer): PackageLocale;
 }
 export declare class TypeMemberQuery {
-    static getContainingDeclaration(node: tree.TypeMemberDeclaration): TypeWithMemberOrTypeExtensionDeclaration;
+    static getContainingDeclaration(node: tree.TypeMemberDeclaration): TypeWithMembersOrTypeExtensionDeclaration;
     static getOutermostMemberBlock(node: tree.TypeMemberDeclaration): tree.TypeMemberDeclarationBlock;
     static getContextualTypeEntity(node: tree.TypeMemberDeclaration, analyzer: Analyzer): TypeEntity | undefined;
 }
-export type TypeWithMemberOrTypeExtensionDeclaration = TypeWithMembersDeclaration | tree.TypeExtensionDeclaration;
+export type TypeWithMembersOrTypeExtensionDeclaration = TypeWithMembersDeclaration | tree.TypeExtensionDeclaration;