@artel/artc 0.6.25208 → 0.6.25209

package/build/{chunk-LZ4IJBSA.js → chunk-GKEW2LBL.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-FABHNF5H.js";
+} from "./chunk-4EDLYSNW.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-PNUVVKWZ.js";
+} from "./chunk-5SWGY25I.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";
@@ -224,18 +224,20 @@ var NodeCompiler = class {
       return new PhysicalTypeScriptLibrariesProvider(standardLibraryUri);
     });
   }
-  static loadCompilation(projectPath, tsLibrariesProvider, diagnostics, workspacePath, standardPackagesPath, cancellationToken) {
+  static loadCompilation(projectPath, tsLibrariesProvider, diagnostics, options, cancellationToken) {
     return __async(this, null, function* () {
       const projectUri = FileSystemUri.pathToUri(projectPath);
-      const workspaceUri = workspacePath !== void 0 ? FileSystemUri.pathToUri(workspacePath) : void 0;
-      const standardPackagesUri = standardPackagesPath !== void 0 ? FileSystemUri.pathToUri(standardPackagesPath) : void 0;
+      const loadCompilationOptions = {
+        workspaceUri: options?.workspacePath !== void 0 ? FileSystemUri.pathToUri(options.workspacePath) : void 0,
+        builtInsStandardPackagesUri: options?.builtInsStandardPackagesPath !== void 0 ? FileSystemUri.pathToUri(options.builtInsStandardPackagesPath) : void 0,
+        userStandardPackagesUri: options?.userStandardPackagesPath !== void 0 ? FileSystemUri.pathToUri(options.userStandardPackagesPath) : void 0
+      };
       return yield Compiler.loadCompilation(
         projectUri,
         this.fileSystem,
         tsLibrariesProvider,
         diagnostics,
-        workspaceUri,
-        standardPackagesUri,
+        loadCompilationOptions,
         cancellationToken
       );
     });
@@ -282,8 +284,7 @@ var NodeCompiler = class {
         task.projectPath,
         typeScriptLibrariesProvider,
         task.diagnostics,
-        task.workspacePath,
-        task.standardPackagesPath,
+        task.loadCompilationOptions,
         task.cancellationToken
       );
       if (compilation === void 0) {
@@ -386,9 +387,12 @@ var CommandLineCompiler = class {
             fileURLToPath(new URL("..", import.meta.url))
           ],
           projectPath: parsedArguments.projectPath,
+          loadCompilationOptions: {
+            workspacePath: parsedArguments.workspacePath,
+            userStandardPackagesPath: parsedArguments.standardPackagesPath,
+            builtInsStandardPackagesPath: parsedArguments.builtInStandardPackagesPath
+          },
           outputPath: parsedArguments.outputPath,
-          workspacePath: parsedArguments.workspacePath,
-          standardPackagesPath: parsedArguments.standardPackagesPath,
           diagnostics,
           defaultTsLibraryPath: parsedArguments.defaultTsLibraryPath,
           emitOptions: {
@@ -464,7 +468,8 @@ var ArgumentsParser = class {
       measurePerformance: false,
       defaultTsLibraryPath: void 0,
       workspacePath: void 0,
-      standardPackagesPath: void 0
+      standardPackagesPath: void 0,
+      builtInStandardPackagesPath: void 0
     };
     const index = this.parseMainCommand(0, args, result);
     this.parseNamedArguments(index, args, result);
@@ -562,6 +567,15 @@ var ArgumentsParser = class {
           }
           break;
         }
+        case "--built-in-standard-packages":
+        case "--\u0432\u0441\u0442\u0440\u043E\u0435\u043D\u043D\u044B\u0435-\u0441\u0442\u0430\u043D\u0434\u0430\u0440\u0442\u043D\u044B\u0435-\u043F\u0430\u043A\u0435\u0442\u044B": {
+          const path = this.tryParseStringArgument(index + 1, args);
+          if (path !== void 0) {
+            result.builtInStandardPackagesPath = resolve(cwd, path);
+            index++;
+          }
+          break;
+        }
         case "--\u0431\u0435\u0437-\u043F\u0440\u0435\u0434\u0443\u043F\u0440\u0435\u0436\u0434\u0435\u043D\u0438\u0439":
         case "--no-warnings": {
           result.noWarnings = true;

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

@@ -56,9 +56,10 @@ export declare class AnalyzedTranslationPackage {
     private createVariants;
     private createTranslatedSubprogramSignatureFromPackageMethodTranslation;
     private createTranslatedSubprogramSignatureFromTypeMethodTranslation;
-    private createTranslatedSubprogramSignatureFromMethodTypeAlias;
-    private createTranslatedSubprogramSignatureFromConstructorAlias;
-    private createTranslatedSubprogramSignatureFromIndexerAlias;
+    private createTranslatedSubprogramSignatureFromMethodTypeTranslation;
+    private createTranslatedSubprogramSignatureFromConstructorTranslation;
+    private createTranslatedSubprogramSignatureFromIndexerTranslation;
+    private createTranslatedSubprogramSignatureForDefaultConstructor;
     private createTranslatedTypeSignature;
     private enumerateTranslationsDeclarations;
     private findTypeTranslation;

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

@@ -503,7 +503,6 @@ declare class DefaultConstructors {
     private readonly _defaultConstructorEntities;
     constructor(_analyzer: Analyzer);
     ofStructuredType(type: StructuredTypeDeclaration): readonly ConstructorEntity[];
-    createAliasTypeDefaultConstructors(aliasTypeEntity: AliasTypeEntity, hasDeclaredConstructors: boolean): readonly ConstructorEntity[];
     private createDefaultConstructors;
     private getPublicInstanceStoredVariables;
 }

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

@@ -12,10 +12,26 @@ export declare class Resolver {
 }
 export type Meaning = Meaning_constructorCall | Meaning_unresolved;
 declare class Meaning_constructorCall {
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    readonly type: types.Type;
     readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly kind = "constructor-call";
-    constructor(candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    constructor(
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
 }
 declare class Meaning_unresolved {
     readonly diagnostics: readonly Diagnostic[];

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

@@ -29,10 +29,26 @@ declare class Meaning_baseObjectAccess {
     constructor(type: types.Type);
 }
 declare class Meaning_baseConstructorAccess {
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    readonly type: types.Type;
     readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly kind = "base-constructor-access";
-    constructor(candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    constructor(
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
 }
 declare class Meaning_overriddenMethodAccess {
     readonly method: types.Method;

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

@@ -26,10 +26,26 @@ declare class Meaning_objectMethodCall {
     constructor(type: types.MethodType);
 }
 declare class Meaning_constructorCall {
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    readonly type: types.Type;
     readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly kind = "constructor-call";
-    constructor(candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    constructor(
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
 }
 declare class Meaning_unresolved {
     readonly diagnostics: readonly Diagnostic[];

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

@@ -32,11 +32,14 @@ export declare class DiagnosticCollector {
     private checkTypeVariableSetterDeclaration;
     private checkTypeIndexedGetterDeclaration;
     private checkTypeIndexedSetterDeclaration;
+    private checkTypeDereferencedVariableGetterDeclaration;
+    private checkTypeDereferencedVariableSetterDeclaration;
     private checkNestedMethodDeclaration;
     private checkPossibleGeneratorMethodReturnType;
     private checkReturnStatement;
     private checkYieldStatement;
     private checkTypeMemberBodyPresence;
+    private tryGetTypeMemberDeclarationEntity;
     private isAspectTypeMemberDeclaration;
     private collectIdentifierExpressionDiagnostics;
     private collectPropertyAccessExpressionDiagnostics;

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

@@ -20,10 +20,26 @@ export declare class Resolver {
 }
 export type Meaning = Meaning_ownConstructorAccess | Meaning_objectAccess | Meaning_unresolved;
 declare class Meaning_ownConstructorAccess {
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    readonly type: types.Type;
     readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly kind = "own-constructor-access";
-    constructor(candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    constructor(
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
 }
 declare class Meaning_objectAccess {
     readonly type: types.Type;

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

@@ -30,5 +30,6 @@ export declare class WellKnownDeclarations {
     parameterArray: AliasTypeEntity;
     defaultImport: StructuredTypeEntity;
     realName: StructuredTypeEntity;
+    builtIntoPlatform: StructuredTypeEntity;
     typeVariableProxy: StructuredTypeEntity;
 }

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

@@ -14,7 +14,7 @@ export declare abstract class Query<T> implements Iterable<T> {
     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;
+    count(fn?: (t: T) => boolean): 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>;
@@ -37,6 +37,7 @@ export declare abstract class Query<T> implements Iterable<T> {
     uniqueWithComparator(comparator: (t1: T, t2: T) => boolean): Query<T>;
     uniqueToSet(): Set<T>;
     maxByValue(valueSelector: (t: T) => number): T | undefined;
+    minByValue(valueSelector: (t: T) => number): T | undefined;
     single(): T | undefined;
     single<K extends T>(fn: (t: T) => t is K): K | undefined;
     single(fn: (t: T) => boolean): T | undefined;

package/build/types/entities/BinaryOperatorEntity.d.ts

@@ -1,3 +1,4 @@
+import { Tag } from '../analysis/Tags.js';
 import * as types from '../types/index.js';
 import { DefinitionKind, EntityHidingLevel, EntityKind, TypeMemberEntityContainer } from './index.js';
 export interface BinaryOperatorEntity {
@@ -9,6 +10,7 @@ export interface BinaryOperatorEntity {
     getDefinition(): BinaryOperatorDefinition;
     getContainer(): TypeMemberEntityContainer;
     isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
 }
 export type BinaryOperatorDefinition = {
     kind: DefinitionKind.Intrinsic;
@@ -45,4 +47,5 @@ export declare class IntrinsicBinaryOperatorEntity implements BinaryOperatorEnti
     getDefinition(): BinaryOperatorDefinition;
     getContainer(): TypeMemberEntityContainer;
     isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
 }

package/build/types/entities/ConstructorEntity.d.ts

@@ -3,7 +3,7 @@ import { Tag } from '../analysis/Tags.js';
 import { Analyzer } from '../analysis/index.js';
 import { TypeConstructorDeclaration } from '../tree/index.js';
 import * as types from '../types/index.js';
-import type { AliasTypeEntity, TypeEntityWithMembers } from './index.js';
+import type { TypeEntityWithMembers } from './index.js';
 import { DefinitionKind, EntityHidingLevel, EntityKind, ParameterVariableEntity, TypeMemberEntityContainer, TypeVariableEntity } from './index.js';
 export interface ConstructorEntity {
     readonly kind: EntityKind.Constructor;
@@ -17,9 +17,20 @@ export interface ConstructorEntity {
 }
 export declare class DefaultConstructorEntityInfo {
     readonly baseConstructor: types.Constructor | undefined;
-    readonly orderedParametersForBaseConstructor: readonly ParameterVariableEntity[];
+    readonly orderedParametersForBaseConstructor: readonly DefaultConstructorParameterForBaseConstructorInfo[];
     readonly hasParametersForFieldInitialization: boolean;
-    constructor(baseConstructor: types.Constructor | undefined, orderedParametersForBaseConstructor: readonly ParameterVariableEntity[], hasParametersForFieldInitialization: boolean);
+    readonly parametersForOwnFieldsInitialization: readonly ConstructorParameterInitializingFieldInfo[] | undefined;
+    constructor(baseConstructor: types.Constructor | undefined, orderedParametersForBaseConstructor: readonly DefaultConstructorParameterForBaseConstructorInfo[], hasParametersForFieldInitialization: boolean, parametersForOwnFieldsInitialization: readonly ConstructorParameterInitializingFieldInfo[] | undefined);
+}
+export declare class DefaultConstructorParameterForBaseConstructorInfo {
+    readonly parameter: ParameterVariableEntity;
+    readonly baseConstructorParameter: ParameterVariableEntity;
+    constructor(parameter: ParameterVariableEntity, baseConstructorParameter: ParameterVariableEntity);
+}
+export declare class ConstructorParameterInitializingFieldInfo {
+    readonly parameter: ParameterVariableEntity;
+    readonly field: TypeVariableEntity;
+    constructor(parameter: ParameterVariableEntity, field: TypeVariableEntity);
 }
 export type ConstructorEntityDefinition = {
     kind: DefinitionKind.Source;
@@ -65,8 +76,7 @@ export declare class DefaultConstructorEntity implements ConstructorEntity {
     private readonly _variablesToInitialize;
     private readonly _baseConstructor;
     readonly kind = EntityKind.Constructor;
-    private readonly _valueParameters;
-    private readonly _orderedParametersForBaseConstructor;
+    private readonly _parametersInfo;
     constructor(_analyzer: Analyzer, _containingType: TypeEntityWithMembers, _variablesToInitialize: readonly VariableToInitialize[], _baseConstructor: FoundAnonymousDeclaration<types.Constructor> | undefined);
     getValueParameters(): readonly ParameterVariableEntity[];
     getDefinition(): ConstructorEntityDefinition;
@@ -75,25 +85,11 @@ export declare class DefaultConstructorEntity implements ConstructorEntity {
     isHidden(): EntityHidingLevel | undefined;
     isAbstract(): boolean;
     getTags(): readonly Tag[];
-    private getOrderedParametersForBaseConstructor;
+    private getParametersInfo;
+    private createOrderedParametersForBaseConstructor;
 }
 export declare class VariableToInitialize {
     readonly entity: TypeVariableEntity;
     readonly hasInitializer: boolean;
     constructor(entity: TypeVariableEntity, hasInitializer: boolean);
 }
-export declare class SynthesizedAliasTypeConstructor implements ConstructorEntity {
-    private readonly _analyzer;
-    private readonly _originalConstructor;
-    private readonly _aliasTypeEntity;
-    readonly kind = EntityKind.Constructor;
-    private readonly _valueParameters;
-    constructor(_analyzer: Analyzer, _originalConstructor: types.Constructor, _aliasTypeEntity: AliasTypeEntity);
-    getValueParameters(): readonly ParameterVariableEntity[];
-    getDefinition(): ConstructorEntityDefinition;
-    getContainer(): TypeMemberEntityContainer;
-    isDefault(): DefaultConstructorEntityInfo | undefined;
-    isHidden(): EntityHidingLevel | undefined;
-    isAbstract(): boolean;
-    getTags(): readonly Tag[];
-}

package/build/types/entities/UnaryOperatorEntity.d.ts

@@ -1,3 +1,4 @@
+import { Tag } from '../analysis/Tags.js';
 import * as types from '../types/index.js';
 import { DefinitionKind, EntityHidingLevel, EntityKind, TypeMemberEntityContainer } from './index.js';
 export interface UnaryOperatorEntity {
@@ -8,6 +9,7 @@ export interface UnaryOperatorEntity {
     getDefinition(): UnaryOperatorDefinition;
     getContainer(): TypeMemberEntityContainer;
     isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
 }
 export type UnaryOperatorDefinition = {
     kind: DefinitionKind.Intrinsic;
@@ -30,4 +32,5 @@ export declare class IntrinsicUnaryOperatorEntity implements UnaryOperatorEntity
     getDefinition(): UnaryOperatorDefinition;
     getContainer(): TypeMemberEntityContainer;
     isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
 }

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

@@ -78,7 +78,7 @@ export declare function isNamedTypeEntity(entity: TypeEntity): entity is NamedTy
 export type PackageMemberEntity = PackageVariableEntity | PackageMethodEntity | PackageTypeEntity | TypeExtensionEntity;
 export declare function isPackageMemberEntity(entity: Entity): entity is PackageMemberEntity;
 export type NamedPackageMemberEntity = PackageVariableEntity | PackageMethodEntity | PackageTypeEntity;
-export type EntityWithTags = AliasTypeEntity | ConstructorEntity | DestructorEntity | IndexerEntity | DereferenceOperatorEntity | MethodEntity | MethodTypeEntity | StructuredTypeEntity | VariableEntity | VariantEntity | VariantTypeEntity;
+export type EntityWithTags = AliasTypeEntity | ConstructorEntity | DestructorEntity | IndexerEntity | DereferenceOperatorEntity | MethodEntity | MethodTypeEntity | StructuredTypeEntity | VariableEntity | VariantEntity | VariantTypeEntity | GetterEntity | SetterEntity;
 export declare function isEntityWithTags(entity: Entity): entity is EntityWithTags;
 export type TypeMemberEntity = TypeVariableEntity | TypeMethodEntity | ConstructorEntity | DestructorEntity | IndexerEntity | DereferenceOperatorEntity | UnaryOperatorEntity | BinaryOperatorEntity;
 export declare function isTypeMemberEntity(entity: Entity): entity is TypeMemberEntity;

package/build/types/executor/Compiler.d.ts

@@ -7,9 +7,14 @@ import { SourcesProvider } from '../project/CompilationLoader.js';
 import { TypeScriptLibrariesProvider } from '../ts-interop/TsLibrariesProvider.js';
 export type LaunchUri = Uri;
 export declare class Compiler {
-    static loadCompilation(projectUri: Uri, sourcesProvider: SourcesProvider, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, workspaceUri?: Uri, standardPackagesUri?: Uri, cancellationToken?: CancellationToken): Promise<Compilation | undefined>;
+    static loadCompilation(projectUri: Uri, sourcesProvider: SourcesProvider, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, options?: LoadCompilationOptions, cancellationToken?: CancellationToken): Promise<Compilation | undefined>;
     static createAnalyzer(compilation: Compilation, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, _cancellationToken?: CancellationToken): Promise<Analyzer | undefined>;
     static analyze(analyzer: Analyzer, diagnostics: DiagnosticAcceptor | undefined, cancellationToken?: CancellationToken): Promise<boolean>;
     static emit(analyzer: Analyzer, outputUri: Uri, outputAcceptor: OutputAcceptor, _diagnostics: DiagnosticAcceptor | undefined, emitOptions?: EmitOptions, cancellationToken?: CancellationToken): Promise<LaunchUri | undefined>;
     static emitToString(analyzer: Analyzer, _diagnostics: DiagnosticAcceptor | undefined, emitOptions?: EmitOptions, cancellationToken?: CancellationToken): Promise<string>;
 }
+export interface LoadCompilationOptions {
+    workspaceUri?: Uri;
+    builtInsStandardPackagesUri?: Uri;
+    userStandardPackagesUri?: Uri;
+}

package/build/types/executor/NodeCompiler.d.ts

@@ -10,19 +10,23 @@ export declare class NodeCompiler {
     private static get fileSystem();
     static findStandardTypeScriptLibrary(nodeModulesSearchPaths: readonly string[], defaultTsLibraryPath?: string): Promise<Uri | undefined>;
     static createTypeScriptLibrariesProvider(nodeModulesSearchPaths: readonly string[], defaultTsLibraryPath: string | undefined, diagnostics: DiagnosticAcceptor | undefined): Promise<TypeScriptLibrariesProvider | undefined>;
-    static loadCompilation(projectPath: string, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, workspacePath?: string, standardPackagesPath?: string, cancellationToken?: CancellationToken): Promise<Compilation | undefined>;
+    static loadCompilation(projectPath: string, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, options?: NodeCompilerLoadCompilationOptions, cancellationToken?: CancellationToken): Promise<Compilation | undefined>;
     static createAnalyzer(compilation: Compilation, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, cancellationToken?: CancellationToken): Promise<Analyzer | undefined>;
     static analyze(analyzer: Analyzer, diagnostics: DiagnosticAcceptor | undefined, cancellationToken?: CancellationToken): Promise<boolean>;
     static emit(analyzer: Analyzer, outputPath: string, diagnostics: DiagnosticAcceptor | undefined, emitOptions?: EmitOptions, cancellationToken?: CancellationToken): Promise<LaunchPath | undefined>;
     static compile(task: NodeCompilerTask): Promise<LaunchPath | undefined>;
 }
+export interface NodeCompilerLoadCompilationOptions {
+    workspacePath?: string;
+    builtInsStandardPackagesPath?: string;
+    userStandardPackagesPath?: string;
+}
 export interface NodeCompilerTask {
     nodeModulesWithTypeScriptSearchPaths: readonly string[];
     projectPath: string;
     outputPath: string;
-    workspacePath?: string;
-    standardPackagesPath?: string;
     diagnostics: DiagnosticAcceptor | undefined;
+    loadCompilationOptions?: NodeCompilerLoadCompilationOptions;
     defaultTsLibraryPath?: string;
     emitOptions?: EmitOptions;
     cancellationToken?: CancellationToken;

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

@@ -1,5 +1,6 @@
 import * as ls from 'vscode-languageserver';
 import { CancellationToken, Uri } from '../common/index.js';
+import { PackageContent } from '../project/PackageContent.js';
 import { TypeScriptLibrariesProvider } from '../ts-interop/TsLibrariesProvider.js';
 import { WorkspaceFileSystem } from './workspace/index.js';
 export declare class LanguageServer {
@@ -102,6 +103,7 @@ export interface LanguageServerConfig {
     readonly connection: ls.Connection;
     readonly fileSystemSynchronizationMode: FileSystemSynchronizationMode;
     readonly tsLibrariesProvider: TypeScriptLibrariesProvider;
+    readonly additionalPackageContents?: PackageContent[];
 }
 export type FileSystemSynchronizationMode = FileSystemSynchronizationMode.ClientSideFSWatcher | FileSystemSynchronizationMode.ClientToServerRequests;
 export declare namespace FileSystemSynchronizationMode {

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

@@ -60,4 +60,5 @@ export interface WorkspaceConfig {
     readonly standardPackagesUri?: Uri;
     readonly showErrorMessage?: (message: string) => Promise<void>;
     readonly builtInStandardPackagesUri?: Uri;
+    readonly additionalPackageContents?: readonly PackageContent[];
 }

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@artel/artc",
-  "version": "0.6.25208",
+  "version": "0.6.25209",
   "description": "Артель Компилятор | Artel Compiler",
   "author": "Nezaboodka Team <contact@nezaboodka.com>",
-  "license": "Apache License 2.0",
+  "license": "LGPL-3.0-or-later",
   "type": "module",
   "files": [
     "build/**/*.*js",
@@ -67,6 +67,7 @@
     "copy-global-storage": "node ../vscode-extension/scripts/copy-global-storage.js projects/compiler/СистемныеПакеты",
     "install-global": "npm run prepare-for-publish && npm i -g .",
     "generate-tree": "npm run bundle:debug && node build/Cli.js build ../tree-generator/ ../tree-generator/build --workspace ../.. --standard-packages ../СтандартныеПакеты && node ../tree-generator/build/launch.mjs ../compiler/source/tree",
-    "generate-configuration-json-schemas": "node ./scripts/generateConfigurationJsonSchemas.mjs"
+    "generate-configuration-json-schemas": "node ./scripts/generateConfigurationJsonSchemas.mjs",
+    "create-minimal-required-standard-package-contents-json": "esbuild ./scripts/createMinimalStandardPackageContentsJson.ts --bundle --outfile=../../build/scripts/createMinimalStandardPackageContentsJson.mjs --format=esm --platform=node --packages=external --supported:async-await=false && node ../../build/scripts/createMinimalStandardPackageContentsJson.mjs"
   }
 }