@artel/artc 0.6.25259 → 0.6.25261

package/build/{chunk-VQI5PLBW.js → chunk-7OS2G5WZ.js}

@@ -10,7 +10,7 @@ import {
   WellKnownDeclarationsLoadError,
   __async,
   createTsInteropInputsForCompilation
-} from "./chunk-HE4MTX63.js";
+} from "./chunk-66RH6JKB.js";
 
 // source/executor/Compiler.ts
 var Compiler = class {

package/build/{chunk-GVYF4DV5.js → chunk-UWQKBRAT.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-VQI5PLBW.js";
+} from "./chunk-7OS2G5WZ.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-HE4MTX63.js";
+} from "./chunk-66RH6JKB.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";
@@ -120,11 +120,11 @@ import { lstatSync, readFileSync } from "fs";
 import { platform as platform2 } from "os";
 var PhysicalTypeScriptLibrariesProvider = class {
   constructor(standardLibraryUri) {
-    this._isCaseSensitive = new Cached();
-    this._standardLibraryUri = standardLibraryUri;
+    this.isCaseSensitive_ = new Cached();
+    this.standardLibraryUri = standardLibraryUri;
   }
   getStandardLibraryUri() {
-    return this._standardLibraryUri;
+    return this.standardLibraryUri;
   }
   readFileSync(uri) {
     const path = FileSystemUri.toPath(uri);
@@ -156,7 +156,7 @@ var PhysicalTypeScriptLibrariesProvider = class {
     return result;
   }
   isCaseSensitive() {
-    return this._isCaseSensitive.getOrInsertWith(() => {
+    return this.isCaseSensitive_.getOrInsertWith(() => {
       const platformName = platform2();
       if (platformName === "win32") {
         return false;
@@ -189,7 +189,7 @@ var DiagnosticFormatter = class {
 // source/executor/NodeCompiler.ts
 var NodeCompiler = class {
   static get fileSystem() {
-    return this._fileSystem ??= new PhysicalFileSystem();
+    return this.fileSystem_ ??= new PhysicalFileSystem();
   }
   static findStandardTypeScriptLibrary(nodeModulesSearchPaths, defaultTsLibraryPath) {
     return __async(this, null, function* () {
@@ -319,11 +319,11 @@ var NodeCompiler = class {
 var PrintingDiagnosticAcceptor = class {
   constructor(noWarnings, basePath) {
     this.noWarnings = noWarnings;
-    this._formatter = new NodeDiagnosticFormatter(basePath);
+    this.formatter = new NodeDiagnosticFormatter(basePath);
   }
   addDiagnostic(diagnostic) {
     if (diagnostic.data.kind === 0 /* Error */ || diagnostic.data.kind === 1 /* Warning */ && !this.noWarnings) {
-      const diagnosticText = this._formatter.format(diagnostic);
+      const diagnosticText = this.formatter.format(diagnostic);
       console.log(diagnosticText);
     }
   }
@@ -331,7 +331,7 @@ var PrintingDiagnosticAcceptor = class {
 var NodeDiagnosticFormatter = class {
   constructor(basePath) {
     basePath ??= process2.cwd();
-    this._formatDiagnosticOptions = {
+    this.formatDiagnosticOptions = {
       convertUri(uri) {
         if (uri.scheme === "file") {
           const path = FileSystemUri.toPath(uri);
@@ -344,7 +344,7 @@ var NodeDiagnosticFormatter = class {
     };
   }
   format(diagnostic) {
-    return DiagnosticFormatter.format(diagnostic, this._formatDiagnosticOptions);
+    return DiagnosticFormatter.format(diagnostic, this.formatDiagnosticOptions);
   }
 };
 

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

@@ -1,5 +1,5 @@
 import { Name } from '../common/index.js';
-import { FunctionEntity, MethodEntity, PackageOrNestedFunctionEntity, ParameterVariableEntity, TypeParameterEntity } from '../entities/index.js';
+import { FunctionEntity, MethodEntity, PackageOrNestedFunctionEntity, ParameterEntity, TypeParameterEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import { SubstitutedFunction } from './SubstitutedFunction.js';
@@ -8,12 +8,12 @@ export type NotSubstitutedAccessedFunction = AccessedFunction_entity | AccessedF
 export declare class AccessedFunction_entity implements IAccessedFunction {
     readonly value: PackageOrNestedFunctionEntity;
     readonly kind = "entity";
-    private readonly _valueParameters;
-    private readonly _signatureType;
+    private readonly parameters;
+    private readonly signatureType;
     get debuggerDisplay(): string;
     constructor(value: PackageOrNestedFunctionEntity);
     getTypeParameters(): readonly TypeParameterEntity[];
-    getValueParameters(): readonly AccessedFunctionValueParameter[];
+    getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
     getEntity(): PackageOrNestedFunctionEntity;
     getName(): Name;
@@ -24,11 +24,11 @@ export declare class AccessedFunction_entity implements IAccessedFunction {
 export declare class AccessedFunction_typeMember implements IAccessedFunction {
     readonly value: types.Method;
     readonly kind = "type-member";
-    private readonly _valueParameters;
+    private readonly parameters;
     get debuggerDisplay(): string;
     constructor(value: types.Method);
     getTypeParameters(): readonly TypeParameterEntity[];
-    getValueParameters(): readonly AccessedFunctionValueParameter[];
+    getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
     getEntity(): MethodEntity;
     getName(): Name;
@@ -42,21 +42,21 @@ export declare class AccessedFunction_substitutedFunction implements IAccessedFu
     get debuggerDisplay(): string;
     constructor(value: SubstitutedFunction);
     getTypeParameters(): readonly TypeParameterEntity[];
-    getValueParameters(): readonly AccessedFunctionValueParameter[];
+    getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
     getEntity(): FunctionEntity;
     getName(): Name;
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     getOuterSubstitutions(): types.Substitutions | undefined;
 }
-export declare class AccessedFunctionValueParameter {
-    readonly entity: ParameterVariableEntity;
+export declare class AccessedFunctionParameter {
+    readonly entity: ParameterEntity;
     readonly type: types.Type;
-    constructor(entity: ParameterVariableEntity, type: types.Type);
+    constructor(entity: ParameterEntity, type: types.Type);
 }
 interface IAccessedFunction {
     getTypeParameters(): readonly TypeParameterEntity[];
-    getValueParameters(): readonly AccessedFunctionValueParameter[];
+    getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
     getEntity(): FunctionEntity;
     getName(): Name;

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

@@ -2,28 +2,28 @@ import { Name, PackageLocale } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { EntityLocalizationContext } from '../entities/EntityLocalizationContext.js';
 import { PackageEntity } from '../entities/PackageEntity.js';
-import { FieldEntity, PackageVariableEntity, ParameterVariableEntity } from '../entities/VariableEntity.js';
+import { FieldEntity, PackageVariableEntity, ParameterEntity } from '../entities/VariableEntity.js';
 import { AliasTypeEntity, ConstructorEntity, DestructorEntity, FunctionEntity, FunctionTypeEntity, IndexerEntity, MethodEntity, NamedEntity, NamedPackageMemberEntity, NamedTypeMemberEntity, OperatorEntity, PackageFunctionEntity, PackageFunctionTypeEntity, PackageTypeEntity, StructuredTypeEntity, TypeParameterEntity, VariantTypeEntity } from '../entities/index.js';
 import { PackageName, TranslationPackage } from '../project/index.js';
 import * as tree from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
-import { Translation } from './Localization.js';
+import { Translation } from './Translation.js';
 export declare class AnalyzedTranslationPackage {
-    private readonly _analyzer;
-    private readonly _package;
-    private readonly _targetTarget;
+    private readonly analyzer;
+    private readonly package_;
+    private readonly targetPackage;
     readonly entityLocalizationContext: EntityLocalizationContext;
-    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;
-    constructor(_analyzer: Analyzer, _package: TranslationPackage, _targetTarget: PackageEntity);
+    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;
+    constructor(analyzer: Analyzer, package_: TranslationPackage, targetPackage: PackageEntity);
     getTargetPackage(): PackageEntity;
     getPackageInTranslatedLanguage(): PackageEntity;
     getDefinition(): TranslationPackage;
@@ -67,10 +67,10 @@ export declare class AnalyzedTranslationPackage {
     private getTypeEntityTranslationNode;
 }
 export declare class TranslatedPackageMembers {
-    private readonly _namedMembers;
-    private readonly _nameByEntity;
+    private readonly namedMembers;
+    private readonly nameByEntity_;
     private get nameByEntity();
-    constructor(_namedMembers: readonly TranslatedNamedPackageMember[]);
+    constructor(namedMembers: readonly TranslatedNamedPackageMember[]);
     getNamedMembers(): readonly TranslatedNamedPackageMember[];
     getMemberName(entity: NamedPackageMemberEntity): TranslatedName | undefined;
 }
@@ -80,11 +80,11 @@ export declare class TranslatedNamedPackageMember {
     constructor(value: NamedPackageMemberEntity, name: TranslatedName);
 }
 export declare class TranslatedTypeEntityMembers {
-    private readonly _namedMembers;
+    private readonly namedMembers;
     readonly translationPackage: AnalyzedTranslationPackage;
-    private readonly _nameByEntity;
+    private readonly nameByEntity_;
     private get nameByEntity();
-    constructor(_namedMembers: readonly TranslatedNamedTypeEntityMember[], translationPackage: AnalyzedTranslationPackage);
+    constructor(namedMembers: readonly TranslatedNamedTypeEntityMember[], translationPackage: AnalyzedTranslationPackage);
     getNamedMembers(): readonly TranslatedNamedTypeEntityMember[];
     getMemberName(entity: NamedTypeMemberEntity): TranslatedName | undefined;
 }
@@ -96,20 +96,20 @@ export declare class TranslatedNamedTypeEntityMember {
 export declare class TranslatedSubprogramSignature {
     readonly translation: Translation;
     readonly typeParameters: readonly TranslatedTypeParameter[];
-    readonly valueParameters: readonly TranslatedValueParameter[];
-    constructor(translation: Translation, typeParameters: readonly TranslatedTypeParameter[], valueParameters: readonly TranslatedValueParameter[]);
+    readonly parameters: readonly TranslatedParameter[];
+    constructor(translation: Translation, typeParameters: readonly TranslatedTypeParameter[], parameters: readonly TranslatedParameter[]);
     getTypeParameterName(entity: TypeParameterEntity): TranslatedName | undefined;
-    getValueParameterName(entity: ParameterVariableEntity): 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 TranslatedValueParameter {
-    readonly value: ParameterVariableEntity;
+export declare class TranslatedParameter {
+    readonly value: ParameterEntity;
     readonly name: TranslatedName;
-    constructor(value: ParameterVariableEntity, name: TranslatedName);
+    constructor(value: ParameterEntity, name: TranslatedName);
 }
 export declare class TranslatedTypeHeader {
     readonly translation: Translation;