@artel/artc 0.6.25191

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

@@ -0,0 +1,10 @@
+export declare class Range {
+    readonly start: number;
+    readonly end: number;
+    get length(): number;
+    get isEmpty(): boolean;
+    constructor(start: number, end: number);
+    includes(offset: number): boolean;
+    equals(other: Range): boolean;
+    static empty(start: number): Range;
+}

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

@@ -0,0 +1,13 @@
+export type Result<TOk, TError> = Result.Ok<TOk> | Result.Error<TError>;
+export declare namespace Result {
+    class Ok<T> {
+        readonly value: T;
+        readonly kind = "ok";
+        constructor(value: T);
+    }
+    class Error<T> {
+        readonly error: T;
+        readonly kind = "error";
+        constructor(error: T);
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Name } from './Name.js';
+export declare class SearchName {
+    readonly value: Name;
+    /**
+     * Это имя, допускающее объявления только на языке оригинала? (прим.: ~имя)
+     */
+    readonly isStrictlyOriginal: boolean;
+    constructor(value: Name, 
+    /**
+     * Это имя, допускающее объявления только на языке оригинала? (прим.: ~имя)
+     */
+    isStrictlyOriginal: boolean);
+}

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

@@ -0,0 +1,17 @@
+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);
+    isThrottleTimeOver(): boolean;
+    throwIfCancellationRequestedAndReset(): void;
+    throwIfCancellationRequestedAndResetAsync(): Promise<void>;
+    withOptions(options: ThrottledCancellationTokenOptions): ThrottledCancellationToken;
+}
+export interface ThrottledCancellationTokenOptions {
+    throttleTimeMs?: number;
+    checkThrottleTimeEveryN?: number;
+}

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

@@ -0,0 +1,53 @@
+import { Analyzer } from '../analysis/index.js';
+import { StructuredTypeDeclaration, VariantTypeDeclaration } from '../analysis/NodeTypeUtils.js';
+import { Entity, PackageEntity, TypeEntity, TypeEntityWithMembers } from '../entities/index.js';
+import { SourceFile } from '../project/index.js';
+import * as tree from '../tree/index.js';
+export declare abstract class TreeQuery {
+    protected abstract get node(): tree.Node;
+    static fromNode(node: tree.Node): NodeQuery;
+    static fromTypeMemberDeclaration(node: tree.TypeMemberDeclaration): TypeMemberDeclarationQuery;
+    sourceFile(): tree.SourceFile;
+    projectSourceFile(analyzer: Analyzer): SourceFile;
+    packageEntity(analyzer: Analyzer): PackageEntity;
+    containingEntity(analyzer: Analyzer): Entity;
+}
+declare class NodeQuery extends TreeQuery {
+    private readonly _node;
+    constructor(_node: tree.Node);
+    protected get node(): tree.Node;
+}
+declare class TypeMemberDeclarationQuery extends TreeQuery {
+    private readonly _node;
+    constructor(_node: tree.TypeMemberDeclaration);
+    protected get node(): tree.Node;
+    container(): TypeMemberDeclarationContainer;
+}
+export type TypeMemberDeclarationContainer = TypeMemberDeclarationContainer_type | TypeMemberDeclarationContainer_typeExtension;
+declare class TypeMemberDeclarationContainer_type implements ITypeMemberDeclarationContainer {
+    readonly declaration: StructuredTypeDeclaration | VariantTypeDeclaration | tree.PackageAliasTypeDeclaration;
+    readonly memberBlock: tree.TypeMemberDeclarationBlock;
+    readonly kind = "type";
+    constructor(declaration: StructuredTypeDeclaration | VariantTypeDeclaration | tree.PackageAliasTypeDeclaration, memberBlock: tree.TypeMemberDeclarationBlock);
+    getNode(): StructuredTypeDeclaration | VariantTypeDeclaration | tree.PackageAliasTypeDeclaration;
+    getMemberBlock(): tree.TypeMemberDeclarationBlock;
+    getTypeEntity(analyzer: Analyzer): TypeEntityWithMembers;
+    getContextualTypeEntity(analyzer: Analyzer): TypeEntity | undefined;
+}
+declare class TypeMemberDeclarationContainer_typeExtension implements ITypeMemberDeclarationContainer {
+    readonly declaration: tree.TypeExtensionDeclaration;
+    readonly memberBlock: tree.TypeMemberDeclarationBlock;
+    readonly kind = "type-extension";
+    constructor(declaration: tree.TypeExtensionDeclaration, memberBlock: tree.TypeMemberDeclarationBlock);
+    getNode(): tree.TypeExtensionDeclaration;
+    getMemberBlock(): tree.TypeMemberDeclarationBlock;
+    getTypeEntity(_analyzer: Analyzer): TypeEntityWithMembers | undefined;
+    getContextualTypeEntity(analyzer: Analyzer): TypeEntity | undefined;
+}
+interface ITypeMemberDeclarationContainer {
+    getNode(): StructuredTypeDeclaration | VariantTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeExtensionDeclaration;
+    getMemberBlock(): tree.TypeMemberDeclarationBlock;
+    getTypeEntity(analyzer: Analyzer): TypeEntityWithMembers | undefined;
+    getContextualTypeEntity(analyzer: Analyzer): TypeEntity | undefined;
+}
+export {};

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

@@ -0,0 +1,13 @@
+import * as tree from '../tree/index.js';
+import { CancellationToken } from './index.js';
+export declare function traverseTreeWithCancellationToken(root: tree.Node, cancellationToken: CancellationToken | undefined, throttleTimeMs: number, visitNodeCb: (node: tree.Node, controller: TraversalController) => void): Promise<void>;
+export declare function traverseTree(root: tree.Node, visitNodeCb: (node: tree.Node, controller: TraversalController) => void): void;
+export declare class TraversalController {
+    isTraverseStopped: boolean;
+    isChildrenTraverseStopped: boolean;
+    shouldYieldExecution: boolean;
+    stopTraverse(): void;
+    stopChildrenTraverse(): void;
+    yieldExecutionAfterCurrentNode(): void;
+    reset(): void;
+}

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

@@ -0,0 +1,28 @@
+export declare class Uri {
+    readonly scheme: string;
+    readonly segments: string[];
+    constructor(scheme: string, segments: string[]);
+    static empty(scheme: string): Uri;
+    static fromString(uri: string): Uri;
+    isEmpty(): boolean;
+    isJust(segment: string): boolean;
+    parentUri(): Uri | undefined;
+    get lastSegment(): string | undefined;
+    get segmentBeforeLast(): string | undefined;
+    append(segment: string): Uri;
+    append(segments: string[]): Uri;
+    replaceLastSegment(segment: string): Uri;
+    equals(uri: Uri): boolean;
+    checkIfRelativeTo(uri: Uri): UrisRelativityKind;
+    getSegmentsRelativeTo(uri: Uri): string[] | undefined;
+    /**
+     * Метод toString() предназначен для отображения Uri в текстовых сообщениях, а также для случаев, когда Uri
+     * используется в качестве ключа словаря.
+     */
+    toString(): string;
+}
+export declare const enum UrisRelativityKind {
+    Equal = 0,
+    Relative = 1,
+    NotRelativeOrEqual = 2
+}

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

@@ -0,0 +1,41 @@
+import { Uri } from './Uri.js';
+export declare class UriTree<T> {
+    private readonly _roots;
+    add(uri: Uri, data: T): void;
+    /**
+     * @returns элемент если он существовал, иначе `undefined`.
+     */
+    delete(uri: Uri): T | undefined;
+    getItem(uri: Uri): T | undefined;
+    enumerateRoots(): Iterable<{
+        uri: Uri;
+        value: T;
+    }>;
+    enumerateChildren(uri: Uri): Iterable<{
+        uri: Uri;
+        value: T;
+    }>;
+    traverse(uri: Uri, f: (node: Node<T>) => void): readonly string[];
+    forEachItem(f: (item: T) => void): void;
+    enumerateItems(rootUri?: Uri): Iterable<{
+        uri: Uri;
+        value: T;
+    }>;
+    private getNode;
+    private getOrCreateRootNode;
+    private getRootNode;
+}
+declare class Node<T> {
+    readonly uri: Uri;
+    private _data;
+    private readonly _children;
+    constructor(uri: Uri, _data: T | undefined);
+    get item(): T | undefined;
+    getChild(segment: string): Node<T> | undefined;
+    getOrAddChild(segment: string, factory: () => Node<T>): Node<T>;
+    addChild(segment: string, node: Node<T>): void;
+    deleteChild(segment: string): void;
+    setData(data: T): void;
+    getChildren(): Iterable<Node<T>>;
+}
+export {};

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

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

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

@@ -0,0 +1,19 @@
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+export type WithDiagnostics<T> = WithDiagnostics_ok<T> | WithDiagnostics_error<T>;
+export declare class WithDiagnostics_ok<T> implements IWithDiagnostics<T> {
+    readonly value: T;
+    readonly kind = "ok";
+    constructor(value: T);
+    toNullable(): T | undefined;
+}
+export declare class WithDiagnostics_error<T> implements IWithDiagnostics<T> {
+    readonly kind = "error";
+    readonly value: readonly Diagnostic[];
+    constructor(diagnostic: Diagnostic);
+    constructor(diagnostics: readonly Diagnostic[]);
+    toNullable(): T | undefined;
+}
+interface IWithDiagnostics<T> {
+    toNullable(): T | undefined;
+}
+export {};

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

@@ -0,0 +1 @@
+export declare function yieldExecution(timeMs?: number): Promise<void>;

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

@@ -0,0 +1,32 @@
+export * from './AccessKind.js';
+export * from './ArtelFileCheck.js';
+export * from './Cached.js';
+export * from './CancellationToken.js';
+export * from './Constants.js';
+export * from './Debug.js';
+export * from './Delayed.js';
+export * from './FormatString.js';
+export * from './Interner.js';
+export * from './Lazy.js';
+export * from './LocalizationHelper.js';
+export * from './Logger.js';
+export * from './Name.js';
+export * from './NameFormatConversion.js';
+export * from './NonEmptyArray.js';
+export * from './Option.js';
+export * from './PackageLocale.js';
+export * from './PackageDialect.js';
+export * from './Path.js';
+export * from './PerformanceMeasurement.js';
+export * from './Query.js';
+export * from './Range.js';
+export * from './Result.js';
+export * from './SearchName.js';
+export * from './ThrottledCancellationToken.js';
+export * from './TreeQuery.js';
+export * from './TreeTraversal.js';
+export * from './Uri.js';
+export * from './UriTree.js';
+export * from './UserLocale.js';
+export * from './WithDiagnostics.js';
+export * from './YieldExecution.js';

package/build/types/diagnostic/Diagnostic.d.ts

@@ -0,0 +1,21 @@
+import { Range } from '../common/index.js';
+import { TextFile } from '../project/TextFile.js';
+import { DiagnosticData } from './DiagnosticData.js';
+export declare class Diagnostic {
+    readonly data: DiagnosticData;
+    readonly location: DiagnosticLocation | undefined;
+    constructor(data: DiagnosticData, location: DiagnosticLocation | undefined);
+}
+export declare class DiagnosticLocation {
+    readonly range: Range;
+    readonly file: TextFile;
+    constructor(range: Range, file: TextFile);
+}
+export interface DiagnosticAcceptor {
+    addDiagnostic(diagnostic: Diagnostic): void;
+}
+export declare class AccumulatingDiagnosticAcceptor implements DiagnosticAcceptor {
+    readonly items: Diagnostic[];
+    constructor(items?: Diagnostic[]);
+    addDiagnostic(diagnostic: Diagnostic): void;
+}

package/build/types/diagnostic/DiagnosticCode.d.ts

@@ -0,0 +1,146 @@
+export declare enum DiagnosticCode {
+    IdentifierExpected = 0,
+    TypeNameExpected = 1,
+    PackageNameExpected = 2,
+    IdentifierWithoutPrimeSymbolExpected = 3,
+    TypeMemberDeclarationExpected = 4,
+    SourceFileMemberExpected = 5,
+    EnumerationVariableDeclarationExpected = 6,
+    StatementExpected = 7,
+    ExpressionExpected = 8,
+    BaseTypeNameExpected = 9,
+    VariantDeclarationExpected = 10,
+    TypeSpecifierExpected = 11,
+    TypeBodyExpected = 12,
+    MethodCallArgumentExpected = 13,
+    TagArgumentExpected = 14,
+    TypeParameterExpected = 15,
+    ParameterExpected = 16,
+    RunStatementClauseExpected = 17,
+    PackageImportExpected = 18,
+    UsingDirectiveOrSourceFileMemberExpected = 19,
+    WordFormExpected = 20,
+    TypeMemberTranslationExpected = 21,
+    TranslationExpected = 22,
+    Expected0But1Found = 23,
+    InvalidTextTemplateLiteral = 24,
+    RunKeywordOnCreateKeywordOrModifierListExpected = 25,
+    ModifierListExpected = 26,
+    HidingLevelExpected = 27,
+    PropertyOrElementAccessExpected = 28,
+    VariantNotFound = 29,
+    TypeCannotBeUsedAsValue = 30,
+    PackageMemberNotFound = 31,
+    CannotAccessMembersOfUnresolvedPackage = 32,
+    TypeMemberNotFound = 33,
+    CannotAccessMembersOnMethodType = 34,
+    CannotAccessStaticMembersOnTypeParameter = 35,
+    CannotAccessStaticMembersOnUnionType = 36,
+    CannotAccessMembersOnUnresolvedType = 37,
+    CannotAccessInstanceMembersOnVariantType = 38,
+    CannotAccessInstanceMembersOnTypeParameterWithoutConstraint = 39,
+    CannotAccessIndexerOnVariantType = 40,
+    CannotAccessIndexerOnMethodType = 41,
+    CannotAccessIndexerOnTypeParameter = 42,
+    CannotAccessIndexerOnUnresolvedType = 43,
+    IndexerOfTheSpecifiedTypeNotFound = 44,
+    DereferenceOperatorOfTheSpecifiedTypeNotFound = 45,
+    IndexedGetterNotFound = 46,
+    IndexedSetterNotFound = 47,
+    IndexerNotFound = 48,
+    CannotCreateInstanceOfAspect = 49,
+    CannotCreateInstanceOfVariantType = 50,
+    CannotCreateInstanceOfMethodType = 51,
+    CannotCreateInstanceOfTypeParameter = 52,
+    CannotCreateInstanceOfUnresolvedType = 53,
+    CannotCreateInstanceOfInvalidType = 54,
+    TypeConstructorNotFound = 55,
+    CannotInvokeExpression = 56,
+    NamedArgumentExpectedButPositionalArgumentFound = 57,
+    ParameterWithGivenNameNotFound = 58,
+    ArgumentForParameterAlreadyPassed = 59,
+    PackageAliasCannotBeUsedAsValue = 60,
+    PackageNameCannotBeUsedAsValue = 61,
+    UnknownVariable = 62,
+    UnknownType = 63,
+    TypeWithArity0NotFound = 64,
+    CannotAccessMembersOnInvalidType = 65,
+    CannotAccessIndexerOnInvalidType = 66,
+    VariableUsedBeforeBeingDeclared = 67,
+    Type0IsNotAssignableToType1 = 68,
+    VariableNotFound = 69,
+    MethodNotFound = 70,
+    PackageAliasNotFound = 71,
+    VariantAliasExpected = 72,
+    UnknownPackage = 73,
+    CannotAssignValueToExpression = 74,
+    NotEveryRequiredParameterIsProvidedWithCallArgument = 75,
+    ParameterForPositionalCallArgumentNotFound = 76,
+    AliasTypeAliasMustNotContainMemberAliases = 77,
+    InvalidTypeAliasMustNotContainMemberAliases = 78,
+    CannotUseSpecialNameForLocalDeclaration = 79,
+    SpecialNameIsNotAllowed = 80,
+    MultipleValuesFound = 81,
+    CannotDetermineTargetTypeToCallTheConstructor = 82,
+    AmbiguousAccess = 83,
+    PackageNameConflictsWithDeclarationName = 84,
+    CannotAccessVariableDueToItsAccessibilityLevel = 85,
+    CannotAccessMethodDueToItsAccessibilityLevel = 86,
+    CannotAccessTypeDueToItsAccessibilityLevel = 87,
+    CanNotAssignValueToContextVariable = 88,
+    ExpectedPackageNameOrAliasButFoundType = 89,
+    TypeExpected = 90,
+    TypeOrPackageNotFound = 91,
+    TypeIsNotATag = 92,
+    ExpressionOfType0CanNotBeUsedForEnumeration = 93,
+    Operator0IsNotDefinedForTypes1And2 = 94,
+    Operator0IsNotDefinedForType1 = 95,
+    VariantMustHaveAssociatedValue = 96,
+    AssociatedValueMustBeANumberOrTextLiteral = 97,
+    PackageMemberOrPackageNotFound = 98,
+    TranslationsCanOnlyBeDeclaredInTranslationPackage = 99,
+    UnknownTranslatedPackage0 = 100,
+    BaseCannotBeUsedInThisContext = 101,
+    OverriddenMethodNotFound = 102,
+    ObjectCannotBeUsedInThisContext = 103,
+    BaseCannotBeUsedAsAnExpressionInItself = 104,
+    InterfacePackageMustNotContainImplementation = 105,
+    InterfacePackageVariablesMustNotHaveInitializers = 106,
+    InterfacePackageVariablesMustNotHaveAccessors = 107,
+    InterfacePackageIndexersMustNotHaveAccessors = 108,
+    BodyIsMissing = 109,
+    AbstractTypeMembersMustNotHaveBody = 110,
+    AbstractIndexersMustNotHaveAccessors = 111,
+    AbstractVariablesMustNotHaveInitializers = 112,
+    AbstractVariablesMustNotHaveAccessors = 113,
+    AccessorsAreMissing = 114,
+    PackageIsAlreadyImportedInAnotherLanguage = 115,
+    OnlySubprogramsWithReturnTypeCanReturnValue = 116,
+    MethodsUsingYieldStatementCanNotReturnValue = 117,
+    YieldStatementCanNotBeUsedInAnonymousMethods = 118,
+    YieldStatementCanNotBeUsedHere = 119,
+    MethodsUsingYieldStatementMustHaveEnumerableAsReturnType = 120,
+    YieldStatementCanNotBeUsedInRunStatementThatHasOnErrorClause = 121,
+    YieldStatementCanNotBeUsedInFinallyClause = 122,
+    SubprogramMustReturnValue = 123,
+    ResultVariableCanNotBeUsedInMethodsUsingYieldStatement = 124,
+    TypeAliasReferencesItself = 125,
+    TypeParameterHasCircularConstraint = 126,
+    BaseTypeCausesInheritanceCycle = 127,
+    OnlyGenericTypesAndFunctionsCanBeSpecialized = 128,
+    Expected0TypeArguments = 129,
+    ExpectedFrom0To1TypeArguments = 130,
+    Type0IsNotAssignableToConstraint1 = 131,
+    VariableIsDeclaredButNotUsed = 132,
+    DefaultConstructorArgumentsMustBeNamed = 133,
+    IncorrectBodyOfRedefinableAliasTypeMethod = 134,
+    TheFollowingDeclarationsAreNotTranslated0 = 135,
+    TheFollowingDeclarationAreNotTranslated0And1More = 136,
+    CanNotFindTsLibDirectoryBaseSearchPaths0 = 137,
+    SourceFile0IsNotPartOfThePackageAndWontBeLoaded = 138,
+    MainPackageConfigurationIsMissingProjectWontBeLoaded = 139,
+    ProgramWithoutMainPackageCanNotBeCompiled = 140,
+    JsonConfigurationValidationError = 141,
+    StandardPackage0NotFound = 142,
+    Declaration0NotFoundInStandardPackage1 = 143
+}

package/build/types/diagnostic/DiagnosticData.d.ts

@@ -0,0 +1,20 @@
+import { DiagnosticCode } from './DiagnosticCode.js';
+export declare class DiagnosticData {
+    readonly code: DiagnosticCode;
+    readonly message: string;
+    readonly kind: DiagnosticKind;
+    readonly flags: DiagnosticFlags;
+    constructor(code: DiagnosticCode, message: string, kind: DiagnosticKind, flags: DiagnosticFlags);
+    static withCode(code: DiagnosticCode, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): DiagnosticData;
+}
+export declare const enum DiagnosticKind {
+    Error = 0,
+    Warning = 1,
+    Information = 2,
+    Hint = 3
+}
+export declare const enum DiagnosticFlags {
+    None = 0,
+    Unused = 1,
+    Deprecated = 2
+}

package/build/types/diagnostic/DiagnosticFormatter.d.ts

@@ -0,0 +1,8 @@
+import { Uri } from '../common/index.js';
+import { Diagnostic } from './Diagnostic.js';
+export declare class DiagnosticFormatter {
+    static format(diagnostic: Diagnostic, options?: FormatDiagnosticOptions): string;
+}
+export interface FormatDiagnosticOptions {
+    convertUri?(uri: Uri): string;
+}

package/build/types/diagnostic/RangeDiagnostic.d.ts

@@ -0,0 +1,19 @@
+import { Range } from '../common/index.js';
+import { TextFile } from '../project/TextFile.js';
+import { Diagnostic, DiagnosticAcceptor } from './Diagnostic.js';
+import { DiagnosticData } from './DiagnosticData.js';
+export declare class RangeDiagnostic {
+    readonly data: DiagnosticData;
+    readonly range: Range;
+    constructor(data: DiagnosticData, range: Range);
+}
+export interface RangeDiagnosticAcceptor {
+    addDiagnostic(diagnostic: RangeDiagnostic): void;
+}
+export declare class RangeDiagnosticConverter implements RangeDiagnosticAcceptor {
+    private readonly _file;
+    private readonly _diagnosticAcceptor;
+    constructor(_file: TextFile, _diagnosticAcceptor: DiagnosticAcceptor | undefined);
+    static convert(diagnostic: RangeDiagnostic, file: TextFile): Diagnostic;
+    addDiagnostic(diagnostic: RangeDiagnostic): void;
+}

package/build/types/emitter/BlockStatementTransformationResult.d.ts

@@ -0,0 +1,10 @@
+import { statementTransformationResult } from './Internal.js';
+import { BlockStatement } from './ir/index.js';
+export type Type = {
+    kind: statementTransformationResult.Kind.Preserve;
+} | {
+    kind: statementTransformationResult.Kind.Replace;
+    statement: BlockStatement;
+};
+export declare function preserve(): Type;
+export declare function replace(statement: BlockStatement): Type;

package/build/types/emitter/CustomModuleLoader.d.ts

@@ -0,0 +1 @@
+export declare const CustomModuleLoaderCode = "// https://github.com/nodejs/loaders-test/blob/ed9a48ee2823816916f429fbce9553f2e8d3dad4/commonjs-extension-resolution-loader/loader.js\n\nimport { builtinModules } from 'node:module.js';\nimport { dirname } from 'node:path.js';\nimport { cwd } from 'node:process.js';\nimport { fileURLToPath, pathToFileURL } from 'node:url.js';\nimport { promisify } from 'node:util.js';\n\nimport resolveCallback from 'resolve/async.js.js';\n\nconst resolveAsync = promisify(resolveCallback);\n\nconst baseURL = pathToFileURL(cwd() + '/').href;\n\n\nexport async function resolve(specifier, context, next) {\n  const { parentURL = baseURL } = context;\n\n  if (specifier.startsWith('node:') || builtinModules.includes(specifier)) {\n    return next(specifier, context);\n  }\n\n  // `resolveAsync` works with paths, not URLs\n  if (specifier.startsWith('file://')) {\n    specifier = fileURLToPath(specifier);\n  }\n  const parentPath = fileURLToPath(parentURL);\n\n  let url;\n  try {\n    const resolution = await resolveAsync(specifier, {\n      basedir: dirname(parentPath),\n      // For whatever reason, --experimental-specifier-resolution=node doesn't search for .mjs extensions\n      // but it does search for index.mjs files within directories\n      extensions: ['.js', '.mjs'],\n    });\n    url = pathToFileURL(resolution).href;\n  } catch (error) {\n    if (error.code === 'MODULE_NOT_FOUND') {\n      // Match Node's error code\n      error.code = 'ERR_MODULE_NOT_FOUND';\n    }\n    throw error;\n  }\n\n  return next(url, context);\n}\n";

package/build/types/emitter/DebugStack.d.ts

@@ -0,0 +1,10 @@
+import * as ir from './ir/index.js';
+export declare function debugStack(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare class DebugStack {
+    private readonly _stack;
+    constructor(_stack?: ir.Node[]);
+    push(node: ir.Node): void;
+    pop(): void;
+    toString(): string;
+    clone(): DebugStack;
+}

package/build/types/emitter/Emitter.d.ts

@@ -0,0 +1,61 @@
+import { GeneratorResult } from '@babel/generator';
+import { Analyzer } from '../analysis/index.js';
+import { CancellationToken, PackageLocale, Uri } from '../common/index.js';
+import { EmitterContext } from './EmitterContext.js';
+import { EntityNameProviderChain } from './EntityNameProviders.js';
+import * as ir from './ir/index.js';
+import { SourceLocation } from './ir/index.js';
+export declare class Emitter {
+    static LaunchFileName: string;
+    static IndexFileName: string;
+    protected readonly _ectx: EmitterContext;
+    protected readonly _options: EmitOptions | undefined;
+    protected constructor(ectx: EmitterContext, options: EmitOptions | undefined);
+    static emitToFileSystem(analyzer: Analyzer, outputUri: Uri, outputAcceptor: OutputAcceptor, options?: EmitOptions, cancellationToken?: CancellationToken): Promise<void>;
+    static emitToString(analyzer: Analyzer, options?: EmitOptions, cancellationToken?: CancellationToken): Promise<string>;
+    protected createMainMethod(packageConstructors: readonly ir.PackageMethodDeclaration[], packageEntryPoints: readonly ir.PackageMethodDeclaration[], locale: PackageLocale): ir.PackageMethodDeclaration;
+    protected createMainMethodCall(mainMethod: ir.PackageMethodDeclaration, location: SourceLocation | undefined): ir.Statement;
+    protected generateJsFile(sourceFile: ir.SourceFile, nameProvider: EntityNameProviderChain): GeneratorResult;
+}
+export interface OutputAcceptor {
+    clearDirectory(uri: Uri): Promise<void>;
+    writeFile(uri: Uri, content: string): Promise<void>;
+}
+export interface EmitOptions {
+    sourceMap?: SourceMapOptions;
+    importEmitKind?: ImportEmitKind;
+    /**
+     * Является ли функция `_artelImport` синхронной?
+     */
+    isCustomImportSynchronous?: boolean;
+}
+export interface SourceMapOptions {
+    mode?: SourceMapMode;
+    useAbsolutePaths?: boolean;
+    includeSourcesContent?: boolean;
+    justApplicationCode?: boolean;
+    mapMainMethodCallToProgramFirstLine?: boolean;
+}
+export declare enum SourceMapMode {
+    Linked = "linked",
+    External = "external",
+    Inline = "inline"
+}
+export declare enum ImportEmitKind {
+    /**
+     * @example import { MyType } from 'my-lib'
+     */
+    Static = 0,
+    /**
+     * @example const { MyType } = await import('my-lib')
+     */
+    Dynamic = 1,
+    /**
+     * @example const { MyType } = await _artelImport('my-lib')
+     */
+    Custom = 2,
+    /**
+     * @example const { MyType } = typeof _artelImport === 'function' ? await _artelImport('my-lib') : await import('my-lib')
+     */
+    CustomWithFallbackToDynamic = 3
+}