@artel/artc 0.6.25275 → 0.6.25277

package/build/{chunk-ORP2UF4D.js → chunk-QK3TWMY2.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-TYQHZ7HH.js";
+} from "./chunk-DKZTCPRN.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-DB2CJDOL.js";
+} from "./chunk-EVYL6VFM.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";

package/build/types/analysis/AnalyzedTextTranslationPackage.d.ts

@@ -8,7 +8,7 @@ export declare class AnalyzedTextTranslationPackage {
     private readonly targetPackage;
     private readonly entitiesByTextKey;
     constructor(analyzer: Analyzer, package_: TextTranslationPackage, targetPackage: PackageEntity);
-    isPrimaryTranslation(): boolean;
+    isPrimary(): boolean;
     getTargetPackage(): PackageEntity;
     getDefinition(): TextTranslationPackage;
     getTargetPackageName(): PackageName;

package/build/types/analysis/AnalyzedTranslationPackage.d.ts

@@ -1,143 +1,67 @@
-import { Name, PackageLocale } from '../common/index.js';
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { PackageLocale } from '../common/index.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { EntityLocalizationContext } from '../entities/EntityLocalizationContext.js';
-import { AliasTypeEntity, ConstructorEntity, DestructorEntity, FieldEntity, FunctionEntity, FunctionTypeEntity, IndexerEntity, MethodEntity, NamedEntity, NamedPackageMemberEntity, NamedTypeMemberEntity, OperatorEntity, PackageEntity, PackageFunctionEntity, PackageFunctionTypeEntity, PackageTypeEntity, PackageVariableEntity, ParameterEntity, StructuredTypeEntity, TypeParameterEntity, VariantTypeEntity } from '../entities/index.js';
-import { PackageName, TranslationPackage } from '../project/index.js';
+import { AnonymousTypeEntity, Entity, EntityContainingParameter, EntityContainingTypeParameter, PackageEntity, PackageEntityMembers, PackageMemberEntity, ParameterEntity, TypeEntityMembers, TypeMemberEntity, TypeParameterEntity, TypeWithMembersOrExtensionEntity } from '../entities/index.js';
+import { PackageName, SourceFile, TranslationPackage } from '../project/index.js';
 import * as tree from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
-import { Translation } from './Translation.js';
 export declare class AnalyzedTranslationPackage {
+    private static readonly maxDisplayedNotTranslatedEntitiesCount;
+    readonly localizationContext: EntityLocalizationContext;
+    readonly translatedTargetPackage: PackageEntity;
     private readonly analyzer;
     private readonly package_;
     private readonly targetPackage;
-    readonly entityLocalizationContext: EntityLocalizationContext;
+    private readonly diagnostics;
     private readonly localizedPackageByOriginalReferencedPackage;
-    private readonly members;
-    private readonly translatedTypeEntityMembers;
-    private readonly functionSignatureTranslations;
-    private readonly operatorSignatureTranslations;
-    private readonly functionTypeSignatureTranslations;
-    private readonly constructorSignatureTranslations;
-    private readonly indexerSignatureTranslations;
-    private readonly translatedTypeHeaders;
-    private readonly typeTranslationByEntity;
+    private readonly translatedEntityByOriginal;
+    private hasCreatedPackageMembers;
+    private readonly typesOrExtensionsWithCreatedMembers;
+    private readonly packageMemberTranslationTargetsByNode;
+    private readonly typeMemberTranslationTargetsByNode;
     constructor(analyzer: Analyzer, package_: TranslationPackage, targetPackage: PackageEntity);
     getTargetPackage(): PackageEntity;
-    getTranslatedTargetPackage(): PackageEntity;
     getDefinition(): TranslationPackage;
     getTranslatedName(): PackageName;
     getTranslationLocale(): PackageLocale;
     getLocalizedPackageByOriginalReferencedPackage(): ReadonlyMap<PackageEntity, PackageEntity>;
-    getMembers(): TranslatedPackageMembers;
-    getTypeEntityMembers(typeEntity: PackageTypeEntity): TranslatedTypeEntityMembers | undefined;
-    getPackageVariableTranslationTarget(node: tree.PackageVariableTranslationDeclaration): GetSingleTranslationTargetResult<PackageVariableEntity>;
-    getPackageFunctionTranslationTargets(node: tree.PackageFunctionTranslationDeclaration): GetMultipleTranslationTargetsResult<PackageFunctionEntity>;
-    getFunctionTypeTranslationTarget(node: tree.FunctionTypeTranslationDeclaration): GetSingleTranslationTargetResult<PackageFunctionTypeEntity>;
-    getTypeTranslationTarget(node: tree.TypeTranslationDeclaration): GetSingleTranslationTargetResult<PackageTypeEntity>;
-    /**
-     * В случае, когда имя переменной экземпляра совпадает с именем статической переменной, перевод будет иметь две цели.
-     */
-    getFieldOrVariantTranslationTargets(node: tree.FieldOrVariantTranslation): GetMultipleTranslationTargetsResult<FieldEntity>;
-    getMethodTranslationTargets(node: tree.MethodTranslation): GetMultipleTranslationTargetsResult<MethodEntity>;
-    getConstructorTranslationTargets(node: tree.ConstructorTranslation): GetMultipleTranslationTargetsResult<ConstructorEntity>;
-    getIndexerTranslationTargets(node: tree.IndexerTranslation): GetMultipleTranslationTargetsResult<IndexerEntity>;
-    getFunctionSignature(entity: FunctionEntity): TranslatedSubprogramSignature | undefined;
-    getOperatorSignature(entity: OperatorEntity): TranslatedSubprogramSignature | undefined;
-    getPackageFunctionSignature(entity: PackageFunctionEntity): TranslatedSubprogramSignature | undefined;
-    getMethodSignature(entity: MethodEntity): TranslatedSubprogramSignature | undefined;
-    getFunctionTypeSignature(entity: FunctionTypeEntity): TranslatedSubprogramSignature | undefined;
-    getConstructorSignature(entity: ConstructorEntity): TranslatedSubprogramSignature | undefined;
-    getDestructorSignature(entity: DestructorEntity): TranslatedSubprogramSignature | undefined;
-    getIndexerSignature(entity: IndexerEntity): TranslatedSubprogramSignature | undefined;
-    getTypeHeader(entity: TypeEntityWithHeaderLocalization): TranslatedTypeHeader | undefined;
-    getEntityName(entity: NamedEntity): TranslatedName | undefined;
+    accumulateDiagnosticsForSourceFile(sourceFile: SourceFile, diagnostics: DiagnosticAcceptor): void;
+    getPackageMemberTranslationTargets(node: tree.TranslationDeclaration): TranslationTargets<PackageMemberEntity> | undefined;
+    getTypeMemberTranslationTargets(node: tree.TypeMemberTranslation): TranslationTargets<TypeMemberEntity> | undefined;
+    getTranslatedPackageMember(entity: PackageMemberEntity): PackageMemberEntity;
+    getTranslatedTypeMember(entity: TypeMemberEntity): TypeMemberEntity;
+    getTranslatedAnonymousTypeEntity(entity: AnonymousTypeEntity): AnonymousTypeEntity;
+    createTranslatedPackageMembers(): PackageEntityMembers;
+    createTranslatedTypeOrExtensionMembers(translatedTypeEntity: TypeWithMembersOrExtensionEntity, typeTranslationDeclaration: tree.TypeTranslationDeclaration | undefined): TypeEntityMembers;
+    createTranslatedTypeParameters(original: readonly TypeParameterEntity[], node: tree.TranslationTypeParameterList | undefined, containingEntity: EntityContainingTypeParameter): readonly TypeParameterEntity[];
+    createTranslatedParameters(original: readonly ParameterEntity[], node: tree.TranslationParameterList | undefined, containingEntity: EntityContainingParameter): readonly ParameterEntity[];
+    static isPackageMemberEntityThatShouldBeTranslatedByUser(entity: PackageMemberEntity): boolean;
+    static isTypeMemberEntityThatShouldBeTranslatedByUser(entity: TypeMemberEntity): boolean;
+    private ensurePackageMembersHaveBeenCreated;
+    private ensureTypeMembersHaveBeenCreated;
+    private reportPackageMemberHasAlreadyBeenTranslatedDiagnostic;
+    private reportTypeMemberHasAlreadyBeenTranslatedDiagnostic;
+    private createTranslatedNamedPackageMemberEntityWithMissingTranslation;
+    private createTranslatedTypeMemberEntityWithMissingTranslation;
+    private getPackageVariableTranslationTargets;
+    private getPackageFunctionTranslationTargets;
+    private getFunctionTypeTranslationTargets;
+    private getTypeTranslationTargets;
+    private getFieldOrVariantTranslationTargets;
+    private getMethodTranslationTargets;
+    private tryGetOperatorTranslationTargets;
+    private getConstructorTranslationTargets;
+    private getIndexerTranslationTargets;
+    private checkTranslatedTypeParameterCount;
+    private checkTranslatedParameterCount;
+    private areTypeParameterEntitiesEqualToTranslationTypeParameters;
+    private areParameterEntitiesEqualToTranslationParameters;
+    private createNotTranslatedEntitiesDiagnostic;
     private createLocalizedPackageByOriginalReferencedPackage;
-    private createPackageMembers;
-    private createTypeEntityMembers;
-    private createTranslatedSubprogramSignatureFromPackageFunctionTranslation;
-    private createTranslatedSubprogramSignatureFromMethodTranslation;
-    private createTranslatedSubprogramSignatureFromFunctionTypeTranslation;
-    private createTranslatedSubprogramSignatureFromConstructorTranslation;
-    private createTranslatedSubprogramSignatureFromIndexerTranslation;
-    private createTranslatedSubprogramSignatureForDefaultConstructor;
-    private createTranslatedTypeSignature;
+    private createTranslatedDefaultConstructorEntity;
     private enumerateTranslationsDeclarations;
-    private getTypeEntityTranslationNode;
 }
-export declare class TranslatedPackageMembers {
-    private readonly namedMembers;
-    private readonly nameByEntity_;
-    private get nameByEntity();
-    constructor(namedMembers: readonly TranslatedNamedPackageMember[]);
-    getNamedMembers(): readonly TranslatedNamedPackageMember[];
-    getMemberName(entity: NamedPackageMemberEntity): TranslatedName | undefined;
-}
-export declare class TranslatedNamedPackageMember {
-    readonly value: NamedPackageMemberEntity;
-    readonly name: TranslatedName;
-    constructor(value: NamedPackageMemberEntity, name: TranslatedName);
-}
-export declare class TranslatedTypeEntityMembers {
-    private readonly namedMembers;
-    readonly translationPackage: AnalyzedTranslationPackage;
-    private readonly nameByEntity_;
-    private get nameByEntity();
-    constructor(namedMembers: readonly TranslatedNamedTypeEntityMember[], translationPackage: AnalyzedTranslationPackage);
-    getNamedMembers(): readonly TranslatedNamedTypeEntityMember[];
-    getMemberName(entity: NamedTypeMemberEntity): TranslatedName | undefined;
-}
-export declare class TranslatedNamedTypeEntityMember {
-    readonly value: NamedTypeMemberEntity;
-    readonly name: TranslatedName;
-    constructor(value: NamedTypeMemberEntity, name: TranslatedName);
-}
-export declare class TranslatedSubprogramSignature {
-    readonly translation: Translation;
-    readonly typeParameters: readonly TranslatedTypeParameter[];
-    readonly parameters: readonly TranslatedParameter[];
-    constructor(translation: Translation, typeParameters: readonly TranslatedTypeParameter[], parameters: readonly TranslatedParameter[]);
-    getTypeParameterName(entity: TypeParameterEntity): TranslatedName | undefined;
-    getParameterName(entity: ParameterEntity): TranslatedName | undefined;
-}
-export declare class TranslatedTypeParameter {
-    readonly value: TypeParameterEntity;
-    readonly name: TranslatedName;
-    constructor(value: TypeParameterEntity, name: TranslatedName);
-}
-export declare class TranslatedParameter {
-    readonly value: ParameterEntity;
-    readonly name: TranslatedName;
-    constructor(value: ParameterEntity, name: TranslatedName);
-}
-export declare class TranslatedTypeHeader {
-    readonly translation: Translation;
-    readonly typeParameters: readonly TranslatedTypeParameter[];
-    constructor(translation: Translation, typeParameters: readonly TranslatedTypeParameter[]);
-    getTypeParameterName(entity: TypeParameterEntity): TranslatedName | undefined;
-}
-export type TypeEntityWithHeaderLocalization = StructuredTypeEntity | VariantTypeEntity | AliasTypeEntity;
-export declare class GetSingleTranslationTargetResult<T> {
-    readonly target: T | undefined;
-    readonly diagnostics: readonly Diagnostic[];
-    readonly isValid: boolean;
-    get validTarget(): T | undefined;
-    constructor(target: T | undefined, diagnostics: readonly Diagnostic[], isValid: boolean);
-    static valid<T>(target: T): GetSingleTranslationTargetResult<T>;
-    static invalid<T>(diagnostics: readonly Diagnostic[]): GetSingleTranslationTargetResult<T>;
-}
-export declare class GetMultipleTranslationTargetsResult<T> {
-    readonly targets: readonly T[];
-    readonly diagnostics: readonly Diagnostic[];
-    readonly isAmbiguous: boolean;
-    readonly isValid: boolean;
-    get validUnambiguousTargets(): readonly T[];
-    constructor(targets: readonly T[], diagnostics: readonly Diagnostic[], isAmbiguous: boolean, isValid: boolean);
-    static valid<T>(targets: readonly T[]): GetMultipleTranslationTargetsResult<T>;
-    static invalid<T>(diagnostics: readonly Diagnostic[]): GetMultipleTranslationTargetsResult<T>;
-    static invalid<T>(diagnostics: readonly Diagnostic[], targets: readonly T[], isAmbiguous: boolean): GetMultipleTranslationTargetsResult<T>;
-}
-export declare class TranslatedName {
-    readonly value: Name;
-    readonly translation: Translation;
-    constructor(value: Name, translation: Translation);
+export interface TranslationTargets<T extends Entity = Entity> {
+    readonly values: readonly T[];
+    readonly areSuitable: boolean;
 }

package/build/types/analysis/Analyzer.d.ts

@@ -95,7 +95,10 @@ export declare class Analyzer {
     private readonly extendedTypes;
     private readonly analyzedTranslationPackages;
     private readonly analyzedTextTranslationPackages;
-    private textTranslationPackagesMap;
+    private textTranslationPackagesByTargetPackage;
+    private primaryTextTranslationPackageByTargetPackage;
+    private primaryTextTranslationEntityByLocalizableText;
+    private primaryTextTranslationEntityByLocalizableTextTemplate;
     private readonly linkedMultiPlatformPackagesByPlatform;
     private readonly isFunctionGeneratorCheckResults;
     private readonly namedDeclarationsUsageCountResults;
@@ -267,7 +270,11 @@ export declare class Analyzer {
     enumerateAnalyzedTextTranslationPackages(): Query<AnalyzedTextTranslationPackage>;
     getLinkedMultiPlatformPackagesByPlatform(entity: e.PackageEntity): ReadonlyMap<PlatformKind, LinkedMultiPlatformPackage> | undefined;
     getLinkedMultiPlatformPackage(entity: e.PackageEntity, platform: PlatformKind): LinkedMultiPlatformPackage | undefined;
-    getTextTranslationPackagesMap(): ReadonlyMap<e.PackageEntity, ReadonlyMap<string, AnalyzedTextTranslationPackage>>;
+    getTextTranslationPackagesMap(): ReadonlyMap<e.PackageEntity, AnalyzedTextTranslationPackage[]>;
+    getTextTranslationPackagesOfTargetPackage(targetPackage: e.PackageEntity): AnalyzedTextTranslationPackage[] | undefined;
+    getPrimaryTextTranslationPackageOfTargetPackage(targetPackage: e.PackageEntity): AnalyzedTextTranslationPackage | undefined;
+    getPrimaryTextTranslationEntityByLocalizableText(node: tree.LocalizableTextLiteral): e.TextTranslationEntity | undefined;
+    getPrimaryTextTranslationEntityByLocalizableTextTemplate(node: tree.LocalizableTextTemplateLiteral): e.TextTranslationEntity | undefined;
     instantiateType(entity: e.TypeEntity, typeArguments: readonly types.Type[] | undefined): types.Type;
     instantiateTypeWithSubstitutions(entity: e.TypeEntity, substitutions: types.Substitutions): types.Type;
     instantiateTypeByIdentitySubstitution(entity: e.TypeEntity): types.Type;

package/build/types/analysis/DiagnosticCollector.d.ts

@@ -9,7 +9,6 @@ export declare class DiagnosticCollector {
     private readonly diagnosticArgumentFactory;
     private readonly translationPackage_;
     private readonly textTranslationPackage_;
-    private readonly primaryTextTranslationPackage_;
     private readonly diagnostics;
     private readonly diagnosticAcceptor;
     private namedDeclarationsUsageMap;
@@ -17,7 +16,6 @@ export declare class DiagnosticCollector {
     private readonly standardTypes_;
     private get translationPackage();
     private get textTranslationPackage();
-    private get primaryTextTranslationPackage();
     private get isInterfacePackageFile();
     private get standardTypes();
     constructor(analyzer: Analyzer, sourceFile: project.SourceFile);
@@ -30,12 +28,6 @@ export declare class DiagnosticCollector {
     private checkDereferenceExpression;
     private checkIndexedAccessExpression;
     private checkCallExpression;
-    private addNotTranslatedPackageMembersDiagnostics;
-    private collectNotTranslatedPackageMembers;
-    private addNotTranslatedTypeMembersDiagnostics;
-    private collectNotTranslatedTypeMembers;
-    private isNotTranslatedEntity;
-    private createNotTranslatedEntitiesDiagnostic;
     private addNotTranslatedTextsDiagnostics;
     private collectNotTranslatedTexts;
     private createNotTranslatedTextsDiagnostic;

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

@@ -1,12 +1,13 @@
 import { Name } from '../../common/index.js';
 import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
-import { ConstructorEntity, OperatorKind, PackageEntity, TypeEntity, TypeEntityWithMembers, TypeExtensionEntity } from '../../entities/index.js';
+import { ConstructorEntity, OperatorKind, PackageEntity, TextTranslationEntity, TypeEntity, TypeEntityWithMembers, TypeExtensionEntity } from '../../entities/index.js';
 import { SourceFile } from '../../project/SourceFile.js';
 import * as tree from '../../tree/index.js';
 import * as types from '../../types/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { DiagnosticArgumentFactory } from '../DiagnosticArgumentFactory.js';
 import { FunctionDeclaration, GetterDeclaration, RegularOrBlockFunctionLiteral, SetterDeclaration, SubprogramDeclarationOrLiteral } from '../NodeTypeUtils.js';
+import { TextKey } from '../TextIdentity.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
 export declare abstract class SemanticContextBase {
@@ -36,6 +37,7 @@ export declare abstract class SemanticContextBase {
     getOperators(noInstanceMembers?: boolean): readonly types.Operator[];
     getOperatorsByKind(kind: OperatorKind, noInstanceMembers?: boolean): readonly types.Operator[];
     getTypeExtensionsByType(type: TypeEntity): readonly TypeExtensionEntity[];
+    getPrimaryTextTranslationEntityByTextKey(key: TextKey): TextTranslationEntity | undefined;
     private enumerateSemanticContexts;
     private getSourceFileContext;
 }

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

@@ -1,5 +1,4 @@
-import { BaseEntityHidingMatcher } from '../../entities/BaseEntityHidingMatcher.js';
-import { PackageEntity } from '../../entities/index.js';
+import { BaseEntityHidingMatcher, PackageEntity } from '../../entities/index.js';
 import { TypeEntity } from '../../entities/TypeEntity.js';
 import { SourceFile } from '../../project/SourceFile.js';
 import { SemanticContext } from './SemanticContext.js';

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

@@ -1,10 +1,11 @@
 import { Name } from '../../common/index.js';
 import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
-import { PackageEntity, TypeEntity, TypeExtensionEntity } from '../../entities/index.js';
+import { PackageEntity, TextTranslationEntity, TypeEntity, TypeExtensionEntity } from '../../entities/index.js';
 import { SourceFile } from '../../project/SourceFile.js';
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { DiagnosticArgumentFactory } from '../DiagnosticArgumentFactory.js';
+import { TextKey } from '../TextIdentity.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
 import { SemanticContextBase, SubprogramInfo, TryStatementContextKind, TypeOrTypeExtension } from './SemanticContextBase.js';
@@ -20,7 +21,9 @@ export declare class SourceFileSemanticContext extends SemanticContextBase {
     private readonly packageNameSegments;
     private readonly packageNameSegmentsByKey_;
     private readonly diagnosticArgumentFactory;
+    private readonly primaryTextTranslationPackage_;
     private get packageNameSegmentsByKey();
+    private get primaryTextTranslationPackage();
     constructor(analyzer: Analyzer, node: tree.SourceFile);
     getContainingSubprogram(): SubprogramInfo | undefined;
     getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
@@ -34,6 +37,7 @@ export declare class SourceFileSemanticContext extends SemanticContextBase {
     getOwnNamedDeclarations(_noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): NamedDeclaration[];
     getOwnNamedDeclarationsByName(name: Name, _noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
     getOwnTypeExtensionsByType(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
+    getPrimaryTextTranslationEntityByTextKey(key: TextKey): TextTranslationEntity | undefined;
     private convertPackageMemberToNamedDeclaration;
     private convertPackageAliasToTypeOrContainerWithTypes;
     private convertPackageMemberToTypeOrContainerWithTypes;

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

@@ -1,3 +1,4 @@
+import { Displayable } from './Displayable.js';
 export declare const enum NameFlags {
     /**
      * Обычное имя, например: имя, имя-первое, имяПервое, имя-1, имя_первое.
@@ -26,7 +27,7 @@ export declare const enum NameFlags {
      */
     PreferKebabCase = 32
 }
-export declare class Name {
+export declare class Name implements Displayable {
     /**
      * Исходное имя без одиночных кавычек и без символов '\`' в конце.
      */
@@ -65,6 +66,7 @@ export declare class Name {
     considerEqual(other: Name, considerBackQuotes?: boolean): boolean;
     toString(): string;
     getPreferredUnescapedOriginal(flags: NameFlags): string;
+    getDisplayText(): string;
     static parse(original: string, initialFlags?: NameFlags): Name;
     private static toUnescapedOriginal;
 }

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

@@ -15,6 +15,7 @@ export declare abstract class Query<T> implements Iterable<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 zipLeft<T, TRight, TResult>(source: Iterable<T>, other: Iterable<TRight> | undefined, fn: (left: T, 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[]>;
@@ -40,12 +41,14 @@ export declare abstract class Query<T> implements Iterable<T> {
     mapAndFilter<K>(fn: (t: T) => K | undefined): Query<K>;
     zip<TRight, TResult>(other: Iterable<TRight>, fn: (left: T, right: TRight) => TResult): Query<TResult>;
     zipLongest<TRight, TResult>(other: Iterable<TRight>, fn: (left: T | undefined, right: TRight | undefined) => TResult): Query<TResult>;
+    zipLeft<TRight, TResult>(other: Iterable<TRight> | undefined, fn: (left: T, right: TRight | undefined) => TResult): Query<TResult>;
     unzip(): T extends readonly [infer TLeft, infer TRight] ? [TLeft[], TRight[]] : never;
     toNullable(): ([T] extends [(infer K) | undefined] ? K[] : never) | undefined;
     all(fn: (t: T) => boolean): boolean;
     any(fn: (t: T) => boolean): boolean;
     skipWhile(fn: (t: T) => boolean): Query<T>;
     skip(count: number): Query<T>;
+    take(n: 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;