@artel/artc 0.6.25191

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

@@ -0,0 +1,27 @@
+import { PackageLocale, Query, SearchName } from '../common/index.js';
+import { BinaryOperatorKind, IEntityHidingMatcher, TypeEntity, UnaryOperatorKind } from '../entities/index.js';
+import * as types from '../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
+import { LocalizationContext } from './LocalizationContext.js';
+import { Lookup } from './Lookup.js';
+export declare class TypeMemberLookup {
+    private readonly _analyzer;
+    private readonly _type;
+    private readonly _localizationContext;
+    private readonly _searchLocale;
+    /**
+     * Язык, на котором будет осуществляться поиск членов типа.
+     */
+    get searchLocale(): PackageLocale;
+    constructor(_analyzer: Analyzer, _type: types.Type, _localizationContext: LocalizationContext | undefined);
+    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
+    getNamedMembers(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundNamedDeclaration<types.NamedTypeMember>>;
+    getNamedMembersByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundNamedDeclaration<types.NamedTypeMember>>;
+    getConstructors(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundAnonymousDeclaration<types.Constructor>>;
+    getIndexers(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundAnonymousDeclaration<types.Indexer>>;
+    getDereferenceOperators(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundAnonymousDeclaration<types.DereferenceOperator>>;
+    getBinaryOperators(kind: BinaryOperatorKind, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundAnonymousDeclaration<types.BinaryOperator>>;
+    getUnaryOperators(kind: UnaryOperatorKind, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundAnonymousDeclaration<types.UnaryOperator>>;
+    private getLocaleOfTypeEntity;
+}

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

@@ -0,0 +1,7 @@
+export declare class Resolver<TCandidate extends ICandidate> {
+    resolveByArgumentCount(candidates: Iterable<TCandidate>, argumentCount: number): Iterable<TCandidate>;
+}
+export interface ICandidate {
+    getParameterCount(): number;
+    getRequiredParameterCount(): number;
+}

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

@@ -0,0 +1,37 @@
+import { WithDiagnostics } from '../common/index.js';
+import { BinaryOperatorKind } from '../entities/index.js';
+import { Expression, Node } from '../tree/index.js';
+import * as types from '../types/index.js';
+import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
+import { Analyzer } from './index.js';
+/**
+ * Определяет подходящую двухместную операцию, определённую пользователем (+, *, == и др.).
+ *
+ * Алгоритм:
+ *
+ * 1. Определить тип левого выражение (targetType = undefined).
+ * 2. Найти в типе операторы необходимого вида.
+ * 3. Если операторы найдены:
+ *    1. Если найден один оператор - проверить, совместимы ли типы выражений с типами операндов.
+ *    2. Если найдено несколько операторов - решить перегрузку, представив двоичное выражение как операцию с
+ *       двумя параметрами.
+ *    3. Если остался один подходящий оператор - алгоритм завершается. Если подошло несколько операторов -
+ *       ошибка неоднозначного доступа. Если не подошёл ни один - алгоритм продолжается.
+ * 4. Определить тип правого выражения (targetType = undefined) и найти операторы в нём. Если операторы найдены -
+ *    выполнить пункт 3.
+ * 5. Если ни один оператор не подошёл - алгоритм завершается с соответствующим сообщением об ошибке.
+ */
+export declare class UserDefinableBinaryOperatorResolver {
+    private readonly _analyzer;
+    private readonly _left;
+    private readonly _right;
+    private readonly _operatorKind;
+    private readonly _operatorNodeForDiagnostic;
+    private readonly _leftType;
+    private readonly _rightType;
+    private get leftType();
+    private get rightType();
+    constructor(_analyzer: Analyzer, _left: Expression, _right: Expression, _operatorKind: BinaryOperatorKind, _operatorNodeForDiagnostic: Node);
+    resolve(): WithDiagnostics<FoundAnonymousDeclaration<types.BinaryOperator>>;
+    private chooseSuitableOperators;
+}

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

@@ -0,0 +1,17 @@
+import { Entity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
+import * as tree from '../tree/index.js';
+import * as types from '../types/index.js';
+import { Tag } from './Tags.js';
+type StringToken = tree.Token<tree.TokenKind.TextLiteral> | tree.Token<tree.TokenKind.TextTemplateHead> | tree.Token<tree.TokenKind.TextTemplatePart> | tree.Token<tree.TokenKind.TextTemplateTail>;
+export declare function getUnescapedTextFromStringToken(token: StringToken): string;
+export declare function unwrapParenthesizedExpressions(expression: tree.Expression): tree.Expression;
+export declare function getParentSkippingParenthesizedExpressions(expression: tree.Expression): tree.ExpressionParent;
+export declare function unaliasType(type: types.Type): types.Type;
+export declare function unaliasType(type: types.Type | undefined): types.Type | undefined;
+export declare function getPackageContainingEntity(entity: Entity): PackageEntity;
+export declare function findTag(tagTypeEntity: StructuredTypeEntity, tags: readonly Tag[]): Tag | undefined;
+export declare function getRequiredTypeParameterCount(typeParameters: readonly TypeParameterEntity[]): number;
+export declare function flattenPackageMemberDeclarationList(list: tree.PackageMemberDeclarationList): Iterable<Exclude<tree.PackageMemberDeclaration, tree.PackageMemberGroupDeclaration>>;
+export declare function flattenTypeMemberDeclarationList(list: tree.TypeMemberDeclarationList): Iterable<Exclude<tree.TypeMemberDeclaration, tree.TypeMemberGroupDeclaration>>;
+export declare function isComputedVariableEntity(entity: VariableEntity): boolean;
+export {};

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

@@ -0,0 +1,10 @@
+import { AccessKind } from '../common/index.js';
+import { GetterEntity, SetterEntity, VariableEntity } from '../entities/index.js';
+export type VariableAccess = {
+    kind: AccessKind.Get;
+    accessorEntity: GetterEntity | undefined;
+} | {
+    kind: AccessKind.Set;
+    accessorEntity: SetterEntity | undefined;
+};
+export declare function create(entity: VariableEntity, accessKind: AccessKind): VariableAccess;

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

@@ -0,0 +1,20 @@
+import { PackageLocale, Query, SearchName } from '../common/index.js';
+import { VariantEntity } from '../entities/VariantEntity.js';
+import { VariantTypeEntity } from '../entities/VariantTypeEntity.js';
+import { FoundNamedDeclaration } from './FoundDeclaration.js';
+import { LocalizationContext } from './LocalizationContext.js';
+export declare class VariantLookup {
+    private readonly _variantTypeEntity;
+    private readonly _localizationContext;
+    private readonly _searchLocale;
+    private _translatedVariants;
+    /**
+     * Язык, на котором будет осуществляться поиск вариантов.
+     */
+    get searchLocale(): PackageLocale;
+    private get translatedVariants();
+    constructor(_variantTypeEntity: VariantTypeEntity, _localizationContext: LocalizationContext | undefined);
+    get(): Query<FoundNamedDeclaration<VariantEntity>>;
+    getByName(name: SearchName): Query<FoundNamedDeclaration<VariantEntity>>;
+    private getLocaleOfTypeEntity;
+}

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

@@ -0,0 +1,7 @@
+import { Node, SourceFile } from '../tree/index.js';
+type ChildNodeVisitor = (syntaxNode: VisitedChildNode) => void;
+export type VisitedNode = Node;
+export type VisitedChildNode = Exclude<Node, SourceFile>;
+export declare function visitChildren(node: VisitedNode, visitChildCb: ChildNodeVisitor): void;
+export declare function visitChildrenRecursively(node: VisitedNode, visitChildCb: ChildNodeVisitor): void;
+export {};

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

@@ -0,0 +1,34 @@
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { AliasTypeEntity, StructuredTypeEntity, VariantTypeEntity } from '../entities/index.js';
+export declare class WellKnownDeclarationsLoadError extends Error {
+    readonly diagnostic: Diagnostic;
+    constructor(diagnostic: Diagnostic);
+}
+export declare class WellKnownDeclarations {
+    refObject: StructuredTypeEntity;
+    plainObject: StructuredTypeEntity;
+    number: StructuredTypeEntity;
+    integer: StructuredTypeEntity;
+    text: StructuredTypeEntity;
+    textTemplate: StructuredTypeEntity;
+    char: StructuredTypeEntity;
+    yesNo: VariantTypeEntity;
+    none: StructuredTypeEntity;
+    enumerable: StructuredTypeEntity;
+    enumerator: StructuredTypeEntity;
+    array: StructuredTypeEntity;
+    readonlyArray: StructuredTypeEntity;
+    map: StructuredTypeEntity;
+    readonlyMap: StructuredTypeEntity;
+    set: StructuredTypeEntity;
+    readonlySet: StructuredTypeEntity;
+    measure: StructuredTypeEntity;
+    reference: StructuredTypeEntity;
+    task: StructuredTypeEntity;
+    error: StructuredTypeEntity;
+    method: StructuredTypeEntity;
+    parameterArray: AliasTypeEntity;
+    defaultImport: StructuredTypeEntity;
+    realName: StructuredTypeEntity;
+    typeVariableProxy: StructuredTypeEntity;
+}

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

@@ -0,0 +1,8 @@
+export * from './CallArgumentsToParametersMatcher.js';
+export * from './Analyzer.js';
+export * from './FindModifier.js';
+export * from './OverloadResolver.js';
+export * from './DiagnosticCollector.js';
+export * from './TargetTypeHint.js';
+export * from './Visitor.js';
+export * from './WellKnownDeclarations.js';

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

@@ -0,0 +1,59 @@
+export * from '../analysis/AccessedMethod.js';
+export * from '../analysis/AnalyzedTranslationPackage.js';
+export * from '../analysis/Analyzer.js';
+export type { Meaning as AutotypeCallExpressionMeaning } from '../analysis/AutotypeCallExpressionMeaning.js';
+export type { Meaning as BaseExpressionMeaning } from '../analysis/BaseExpressionMeaning.js';
+export { MatchResult, MatchResultValueParameter } from '../analysis/CallArgumentToParameterMatchResult.js';
+export type { Meaning as CallExpressionMeaning } from '../analysis/CallExpressionMeaning.js';
+export type { Meaning as DereferenceExpressionMeaning } from '../analysis/DereferenceExpressionMeaning.js';
+export * from '../analysis/DiagnosticCollector.js';
+export * from '../analysis/EntityLocalizationHelper.js';
+export * from '../analysis/FindModifier.js';
+export * from '../analysis/FoundDeclaration.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 * as indexerAccess from '../analysis/IndexerAccess.js';
+export * from '../analysis/Localization.js';
+export * from '../analysis/LocalizationContext.js';
+export * from '../analysis/Lookup.js';
+export * from '../analysis/NodeTypeUtils.js';
+export type { Meaning as ObjectExpressionMeaning } from '../analysis/ObjectExpressionMeaning.js';
+export * from '../analysis/PackageMemberLookup.js';
+export type { Meaning as PropertyAccessExpressionMeaning, ResolutionResult as PropertyAccessExpressionResolutionResult } from '../analysis/PropertyAccessExpressionMeaning.js';
+export type { IScope, NamedDeclaration, TypeDeclaration, TypeOrContainerWithTypes } from '../analysis/Scope.js';
+export * from '../analysis/SemanticContext.js';
+export * from '../analysis/SourceFileMembers.js';
+export * from '../analysis/SourcePackageDependencyGraph.js';
+export * from '../analysis/SubstitutedMethod.js';
+export type { Meaning as TagMeaning } from '../analysis/TagMeaning.js';
+export * from '../analysis/Tags.js';
+export * from '../analysis/TargetTypeHint.js';
+export * from '../analysis/TypeMemberLookup.js';
+export * from '../analysis/Utils.js';
+export * as variableAccess from '../analysis/VariableAccess.js';
+export * from '../analysis/VariantLookup.js';
+export * from '../analysis/Visitor.js';
+export * from '../analysis/WellKnownDeclarations.js';
+export * from '../common/index.js';
+export * from '../diagnostic/Diagnostic.js';
+export * from '../diagnostic/DiagnosticCode.js';
+export * from '../diagnostic/DiagnosticData.js';
+export * from '../emitter/Emitter.js';
+export * from '../entities/index.js';
+export * from '../executor/Compiler.js';
+export * from '../generated/BuiltInSystemPackages.js';
+export * from '../parser/CharacterCodes.js';
+export * from '../parser/KeywordDictionary.js';
+export * from '../parser/ParseNumber.js';
+export * from '../parser/Parser.js';
+export * from '../parser/ReservedIdentifierDictionary.js';
+export * from '../parser/Scanner.js';
+export { TokenKind as ScannerTokenKind } from '../parser/TokenKind.js';
+export * from '../parser/UnescapeText.js';
+export * from '../project/index.js';
+export * as green from '../tree/green/index.js';
+export * as tree from '../tree/index.js';
+export * from '../ts-interop/TsLibrariesProvider.js';
+export * from '../ts-interop/Utils.js';
+export * as type from '../types/index.js';

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

@@ -0,0 +1,5 @@
+export * from '../executor/CommandLineCompiler.js';
+export * from '../executor/FileSystemUri.js';
+export * from '../executor/NodeCompiler.js';
+export * from '../executor/PhysicalFileSystem.js';
+export * from '../executor/PhysicalTypeScriptLibrariesProvider.js';

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

@@ -0,0 +1,3 @@
+export * from '../services/CustomCommand.js';
+export * from '../services/LanguageServer.js';
+export * from '../services/workspace/WorkspaceFileSystem.js';

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

@@ -0,0 +1,4 @@
+export declare const enum AccessKind {
+    Get = 0,
+    Set = 1
+}

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

@@ -0,0 +1,2 @@
+import { Uri } from './Uri.js';
+export declare function isSourceOrConfigurationFileName(nameOrUri: string | Uri): boolean;

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

@@ -0,0 +1,6 @@
+export declare class Cached<T> {
+    private _hasValue;
+    private _value?;
+    getOrInsertWith(fn: () => T): T;
+    clear(): void;
+}

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

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

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

@@ -0,0 +1,19 @@
+import { PackageDialect } from './PackageDialect.js';
+import { PackageLocale } from './PackageLocale.js';
+export declare const ArtelVersion: string;
+export declare const ArtelSourceFileExtensions: string[];
+export declare const ArtelSourceFileExtensionSet: Set<string>;
+export declare const ArtelSourceAndConfigurationFileExtensionSet: Set<string>;
+export declare const ConfigurationDirectoryNamesByLocale: Map<PackageLocale, string[]>;
+export declare const ConfigurationDirectoryNameSet: Set<string>;
+export declare const LocaleByConfigurationDirectoryName: Map<string, PackageLocale>;
+export declare const JsonConfigurationFileNamesByLocale: Map<PackageLocale, string[]>;
+export declare const JsonConfigurationFileNameSet: Set<string>;
+export declare const LocaleByJsonConfigurationFileName: Map<string, PackageLocale>;
+export declare const BuiltInSystemPackagesScheme = "artel-builtin";
+export declare const GeneratedSourceFileScheme = "artel-gen";
+export declare const DefaultTsLibDeclarationsFileName = "lib.es2023.d.ts";
+export declare const DefaultLocale = PackageLocale.Ru;
+export declare const DefaultDialect = PackageDialect.Mixed;
+export declare const DefaultNamesOfDirectoriesToIgnore: string[];
+export declare const NodeModulesDirectoryName = "node_modules";

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

@@ -0,0 +1,10 @@
+export declare class Debug {
+    static assertNotNull<T>(value: T | null | undefined, message?: string): asserts value is T;
+    static assert(value: boolean, message?: string): asserts value;
+    static unreachable(message?: string): never;
+    static notImplemented(): never;
+    static never(value: never): never;
+    static typeIsAssignableTo<Target, _Source extends Target>(): void;
+    static cast<T>(_value: unknown): asserts _value is T;
+    static internalError(message?: string): never;
+}

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

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

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

@@ -0,0 +1,3 @@
+export declare class ErrorHandlingStrategy {
+    static throwErrors: boolean;
+}

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

@@ -0,0 +1,5 @@
+/**
+ * @example
+ * "Сообщение: {0} Экранирование: \{0}", ["Привет!"] -> "Сообщение: Привет! Экранирование: {0}"
+ */
+export declare function formatString(text: string, ...formatArguments: readonly string[]): string;

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

@@ -0,0 +1,11 @@
+import { PackageLocale } from './PackageLocale.js';
+export declare const enum HelperPhraseKind {
+    Unresolved = 0,
+    Invalid = 1,
+    TypeParameter = 2,
+    Package = 3,
+    PackageAlias = 4,
+    Variable = 5,
+    Overloads = 6
+}
+export declare function getHelperPhrase(kind: HelperPhraseKind, locale: PackageLocale): string;

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

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

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

@@ -0,0 +1 @@
+export declare function configureL10n(locale?: string): void;

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

@@ -0,0 +1,9 @@
+export declare class Lazy<T> {
+    private _factory;
+    private _isEvaluating;
+    private _value?;
+    constructor(factory: () => T);
+    static immediate<T>(value: T): Lazy<T>;
+    get value(): T;
+    getCachedValue(): T | undefined;
+}

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

@@ -0,0 +1,10 @@
+import { ReservedIdentifierKind } from '../parser/ReservedIdentifierDictionary.js';
+import * as tree from '../tree/index.js';
+import { HelperPhraseKind } from './HelperPhrases.js';
+import { PackageDialect, PackageLocale } from './index.js';
+export declare class LocalizationHelper {
+    static localizeKeyword(kind: tree.KeywordKind, locale: PackageLocale, dialect: PackageDialect): readonly string[];
+    static localizeKeywordAndTakeFirst(kind: tree.KeywordKind, locale: PackageLocale, dialect: PackageDialect): string;
+    static localizeReservedIdentifier(kind: ReservedIdentifierKind, locale: PackageLocale): string;
+    static localizeHelperPhrase(kind: HelperPhraseKind, locale: PackageLocale): string;
+}

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

@@ -0,0 +1,10 @@
+import { EmitterError } from '../emitter/error-boundary.js';
+import { Node } from '../tree/index.js';
+export declare class Logger {
+    static info(message: string): void;
+    static error(message: string): void;
+    static error(error: Error | unknown): void;
+    static errorAtNode(message: string, node: Node): void;
+    static errorWithStackTrace(message: string): void;
+    static emitterError(error: EmitterError): void;
+}

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

@@ -0,0 +1,83 @@
+export declare const enum NameFlags {
+    /**
+     * Обычное имя, например: имя, имя-первое, имяПервое, имя-1, имя_первое.
+     */
+    None = 0,
+    /**
+     * Имя на языке оригинала, начинается со знака тильды, например: ~имя, ~'имя с пробелами'
+     */
+    OriginalName = 2,
+    /**
+     * Имя в одиночных кавычках, например: 'имя', 'имя с пробелами', '+'.
+     */
+    QuotedName = 4,
+    /**
+     * Имя не может быть отображено без кавычек, например: 'имя с пробелами', '+'.
+     */
+    RequiresQuotes = 8,
+    /**
+     * Имя с обратным апострофом для превращения служебного слова в обычное имя, например: тип\`, объект\`.
+     */
+    EscapedKeyword = 16,
+    /**
+     * Имя с обратным апострофом для избежания конфликта между параметром метода и свойством объекта,
+     * например: имя\`, 'имя с пробелами'\`.
+     */
+    ConflictResolvingParameterName = 32,
+    /**
+     * Имя с двойным обратным апострофом для избежания конфликта между вычисляемым свойством и скрытой
+     * хранимой переменной объекта, например: длина\`\`, 'имя с пробелами'\`\`.
+     */
+    BackingVariableName = 64,
+    /**
+     * Имя операции, написанное как знак или служебное слово в одиночных кавычках, например: '+', 'как'.
+     */
+    OperatorSignOrName = 128
+}
+export declare class Name {
+    /**
+     * Исходное имя без символов '~' в начале, символов '\`' в конце и без одиночных кавычек.
+     */
+    readonly originalWithoutQuotes: string;
+    /**
+     * Флаги, указывающие на наличии у имени символов '~', '\`', одиночных кавычек и их смысл.
+     */
+    readonly flags: NameFlags;
+    /**
+     * Предпочтительное для использования исходное имя. Эквивалентно при сравнении по ключу исходному имени
+     * (`original`). Может отличаться от исходного в случае, если получено путём эквивалентного преобразования
+     * из исходного, например, из формата camelCase в формат kebab-case при загрузке объявлений из d.ts-файла.
+     */
+    readonly preferredOriginal: string;
+    /**
+     * Ключ, используемый для сравнения имён на эквивалентность без учёта флагов, а также для генерации кода.
+     * Получается из исходного имени путём:
+     * 1. удаления символов '~' из начала, символов '`' из конца имени и удаления одиночных кавычек из остатка;
+     * 2. удаления символов '-' и замены первых следующих за ними букв на заглавные.
+     */
+    readonly keyWithoutBackQuotes: string;
+    /**
+     * Исходное имя, при необходимости взятое в одиночные кавычки и содержащее обратные кавычки согласно флагам.
+     * Не содержит символ '~'.
+     */
+    get original(): string;
+    /**
+     * Ключ, используемый для сравнения имён на эквивалентность с учётом флагов. Получается из
+     * `keyWithoutBackQuotes` путём добавления символов '`' `meaningfulBackQuoteCount` число раз.
+     */
+    get key(): string;
+    /**
+     * Количество значащих символов '`', соответствующих флагам.
+     */
+    get meaningfulBackQuoteCount(): number;
+    /**
+     * @param original Имя в том виде, в котором оно записано в исходном коде.
+     * @param flags Дополнительные флаги имени. `NameFlags.None` по умолчанию.
+     * @param preferredOriginal Имя, предпочтительное для использования. Принимается `original` по умолчанию.
+     */
+    constructor(original: string, flags?: NameFlags, preferredOriginal?: string);
+    considerEqual(other: Name, considerBackQuotes?: boolean): boolean;
+    toString(): string;
+    private static parse;
+    private static toOriginal;
+}

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

@@ -0,0 +1,12 @@
+export declare function kebabCaseToCamelCase(s: string): string;
+/**
+ * Преобразует имя в формат kebab-case таким образом, чтобы при сравнении полученного имени
+ * с исходным метод `Name.universallyEquals` вернул `true`.
+ *
+ * @example
+ * myIdentifier -> my-identifier
+ * MyIdentifier -> My-identifier
+ * MY_NAME -> MY_NAME
+ * decodeURIComponent -> decode-URI-component
+ */
+export declare function convertNameToKebabCasePreservingUniversalEquality(name: string): string;

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

@@ -0,0 +1,8 @@
+export type NonEmptyArray<T> = [T, ...T[]];
+export type ReadonlyNonEmptyArray<T> = readonly [T, ...T[]];
+export declare function createNonEmptyArray<T>(array: T[]): NonEmptyArray<T>;
+export declare function createNonEmptyArray<T>(array: readonly T[]): ReadonlyNonEmptyArray<T>;
+export declare function createNonEmptyArray<T>(array: T[] | undefined): NonEmptyArray<T> | undefined;
+export declare function createNonEmptyArray<T>(array: readonly T[] | undefined): ReadonlyNonEmptyArray<T> | undefined;
+export declare function isNonEmptyArray<T>(array: T[] | undefined): array is NonEmptyArray<T>;
+export declare function isNonEmptyArray<T>(array: readonly T[] | undefined): array is ReadonlyNonEmptyArray<T>;

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

@@ -0,0 +1,28 @@
+export declare class Option<T> {
+    private readonly _isSome;
+    private readonly _value?;
+    private constructor();
+    static some<T>(value: T): Option<T>;
+    static none<T>(): Option<T>;
+    static fromNullable<T>(value: T | undefined): Option<T>;
+    toNullable(): T | undefined;
+    isSome(): boolean;
+    isSomeAnd(fn: (arg: T) => boolean): boolean;
+    isNone(): boolean;
+    unwrap(): T;
+    unwrapOr<K>(defaultValue: K): T | K;
+    unwrapOrWith(f: () => T): T;
+    map<K>(fn: (arg: T) => K): Option<K>;
+    mapOr<K>(fn: (arg: T) => K, defaultValue: K): K;
+    flatten(): FlatOption<T>;
+    flatMap<K>(fn: (arg: T) => K): FlatOption<K>;
+    expect(message: string): T;
+    filterMap<K>(fn: (arg: T) => Option<K>): Option<K>;
+    zip<K>(other: Option<K>): Option<[T, K]>;
+    filter(f: (arg: T) => boolean): Option<T>;
+    or(other: Option<T>): Option<T>;
+    orWith(f: () => Option<T>): Option<T>;
+    and(other: Option<T>): Option<T>;
+}
+type FlatOption<T> = T extends Option<unknown> ? T : Option<T>;
+export {};

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

@@ -0,0 +1,5 @@
+export declare enum PackageDialect {
+    Mixed = 0,
+    Usual = 1,
+    Special = 2
+}

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

@@ -0,0 +1,15 @@
+export declare enum PackageLocale {
+    En = 0,
+    Ru = 1
+}
+export declare const locales: readonly [{
+    readonly locale: PackageLocale.En;
+    readonly code: "en";
+    readonly names: ["english", "английский"];
+}, {
+    readonly locale: PackageLocale.Ru;
+    readonly code: "ru";
+    readonly names: ["руc", "русский", "rus", "russian"];
+}];
+export declare function localeToString(locale: PackageLocale): string;
+export declare function tryParseLocale(locale: string): PackageLocale | undefined;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+/**
+ * Возвращает расширение, включая точку.
+ * @example
+ * 'Файл.арт' -> '.арт'
+ * 'Файл.тест.арт' -> '.арт'
+ * '.артель' -> ''
+ */
+export declare function getFileExtension(nameOrPath: string): string;

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

@@ -0,0 +1,20 @@
+export declare class PerformanceMeasurement {
+    static isEnabled: boolean;
+    private static readonly _durations;
+    private static readonly _measureInfoStack;
+    static markStart(label: string | number): void;
+    static markEnd(): void;
+    static getDurationMs(label: string | number): number;
+    static reset(): void;
+    private static nowMs;
+}
+export declare const enum PerformanceMeasurementStage {
+    Parsing = 0,
+    Analyzing = 1,
+    Emitting = 2,
+    IO = 3
+}
+export declare const performanceMeasurementStages: readonly [PerformanceMeasurementStage.Parsing, PerformanceMeasurementStage.Analyzing, PerformanceMeasurementStage.Emitting, PerformanceMeasurementStage.IO];
+export declare const performanceMeasurementStageNames: {
+    [S in PerformanceMeasurementStage]: string;
+};

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

@@ -0,0 +1,39 @@
+export declare abstract class Query<T> implements Iterable<T> {
+    static from<T>(source: Iterable<T>): Query<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>;
+    abstract [Symbol.iterator](): Iterator<T, void, undefined>;
+    map<K>(fn: (t: T) => K): Query<K>;
+    forEach(fn: (t: T) => void): void;
+    exhaust(): void;
+    last(): T | undefined;
+    first(): T | undefined;
+    first<K extends T>(fn: (t: T) => t is K): K | undefined;
+    first(fn: (t: T) => boolean): T | undefined;
+    toMap<K, V>(keySelector: (t: T) => K, valueSelector: (t: T) => V): Map<K, V>;
+    flatMap<K>(fn: (t: T) => Iterable<K>): Query<K>;
+    toArray(): T[];
+    count(): number;
+    chain(other: Iterable<T>): Query<T>;
+    filter<K extends T>(fn: (t: T) => t is K): Query<K>;
+    filter(fn: (t: T) => boolean): Query<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>;
+    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>;
+    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;
+    join(separator: string): string;
+    groupBy<K>(keySelector: (t: T) => K): Query<[K, T[]]>;
+    groupByToMap<K>(keySelector: (t: T) => K): Map<K, T[]>;
+    groupByToMap<K, V>(keySelector: (t: T) => K, mapFn: (t: T) => V): Map<K, V[]>;
+    unique(keySelector?: (t: T) => any): Query<T>;
+    uniqueToSet(): Set<T>;
+    maxByValue(valueSelector: (t: T) => number): T | undefined;
+}