@artel/artc 0.6.26018 → 0.6.26019

package/build/types/entities/translated/TranslatedVariantTypeEntity.d.ts

@@ -1,34 +1,21 @@
-import { AnalyzedTranslationPackage } from '../../analysis/AnalyzedTranslationPackage.js';
-import { Tag } from '../../analysis/Tag.js';
-import { Translation } from '../../analysis/Translation.js';
 import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
-import * as tree from '../../tree/index.js';
 import * as types from '../../types/Type.js';
 import { BaseObjectType } from '../BaseObjectType.js';
-import { EntityHidingLevel } from '../EntityHiding.js';
-import { EntityNaming } from '../EntityNaming.js';
-import { EntityKind } from '../index.js';
-import { PackageEntity } from '../interfaces/PackageEntity.js';
-import { TypeParameterEntity } from '../interfaces/TypeParameterEntity.js';
-import type { PackageVariantTypeEntity } from '../interfaces/VariantTypeEntity.js';
-import { VariantTypeEntityDefinition } from '../interfaces/VariantTypeEntity.js';
-import { SubstitutionApplicationMode } from '../SubstitutionApplicationMode.js';
-import { TypeEntityKind } from '../TypeEntity.js';
-import { TypeEntityMembers } from '../TypeEntityMembers.js';
-export declare class TranslatedPackageVariantTypeEntity implements PackageVariantTypeEntity {
+import { EntityHidingLevel, EntityKind, EntityNaming, PackageEntity, PackageVariantTypeEntity, SubstitutionApplicationMode, Tag, Translation, TypeEntityKind, TypeEntityMembers, TypeParameterEntity, VariantTypeEntityDefinition } from '../index.js';
+export declare abstract class TranslatedPackageVariantTypeEntity implements PackageVariantTypeEntity {
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Variant;
     readonly subkind = "package";
-    private readonly originalEntity;
-    private readonly translation;
-    private readonly name;
-    private readonly translationPackage;
-    private readonly node;
-    private readonly typeParameters;
+    protected readonly originalEntity: PackageVariantTypeEntity;
+    protected readonly translation: Translation;
+    protected readonly name: Name;
+    private readonly containingPackage;
     private readonly underlyingType;
-    private readonly members;
     private readonly baseObjectType;
-    constructor(originalEntity: PackageVariantTypeEntity, translation: Translation, name: Name, translationPackage: AnalyzedTranslationPackage, node: tree.TypeTranslationDeclaration | undefined);
+    private get localizationContext();
+    constructor(originalEntity: PackageVariantTypeEntity, translation: Translation, name: Name);
+    abstract getTypeParameters(): readonly TypeParameterEntity[];
+    abstract getMembers(): TypeEntityMembers;
     getName(): Name;
     getContainingPackage(): PackageEntity;
     getTranslation(): Translation | undefined;
@@ -36,9 +23,7 @@ export declare class TranslatedPackageVariantTypeEntity implements PackageVarian
     getDialect(): PackageDialect;
     getOriginalEntity(): PackageVariantTypeEntity;
     getNaming(): EntityNaming;
-    getTypeParameters(): readonly TypeParameterEntity[];
     getUnderlyingType(): types.Type;
-    getMembers(): TypeEntityMembers;
     getDefinition(): VariantTypeEntityDefinition;
     getArity(): number;
     isHidden(): EntityHidingLevel | undefined;

package/build/types/entities/translated/source/a/SourceTranslatedAliasTypeEntity.d.ts

@@ -0,0 +1,14 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { Name } from '../../../../common/index.js';
+import * as tree from '../../../../tree/a/index.js';
+import { AliasTypeEntity, Translation, TypeEntityMembers, TypeParameterEntity } from '../../../index.js';
+import { TranslatedAliasTypeEntity } from '../../index.js';
+export declare class SourceTranslatedAliasTypeEntity extends TranslatedAliasTypeEntity {
+    private readonly translationPackage;
+    private readonly node;
+    private readonly typeParameters;
+    private readonly members;
+    constructor(originalEntity: AliasTypeEntity, translation: Translation, name: Name, translationPackage: ResolvedTranslationPackage, node: tree.TypeTranslationDeclaration | tree.FunctionTypeTranslationDeclaration | undefined);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+}

package/build/types/entities/translated/source/a/SourceTranslatedConstructorEntity.d.ts

@@ -0,0 +1,12 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { Analyzer } from '../../../../analysis/Analyzer.js';
+import * as tree from '../../../../tree/a/index.js';
+import { ConstructorEntity, ParameterEntity, Translation, TypeWithMembersOrExtensionEntity } from '../../../index.js';
+import { TranslatedConstructorEntity } from '../../TranslatedConstructorEntity.js';
+export declare class SourceTranslatedConstructorEntity extends TranslatedConstructorEntity {
+    private readonly translationPackage;
+    private readonly node;
+    private readonly parameters;
+    constructor(analyzer: Analyzer, originalEntity: ConstructorEntity, translation: Translation, translationPackage: ResolvedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity, node: tree.ConstructorTranslation | undefined);
+    getParameters(): readonly ParameterEntity[];
+}

package/build/types/entities/translated/source/a/SourceTranslatedDestructorEntity.d.ts

@@ -0,0 +1,9 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { DestructorEntity, ParameterEntity, Translation, TypeWithMembersOrExtensionEntity } from '../../../index.js';
+import { TranslatedDestructorEntity } from '../../TranslatedDestructorEntity.js';
+export declare class SourceTranslatedDestructorEntity extends TranslatedDestructorEntity {
+    private readonly translationPackage;
+    private readonly parameters;
+    constructor(originalEntity: DestructorEntity, translation: Translation, translationPackage: ResolvedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
+    getParameters(): readonly ParameterEntity[];
+}

package/build/types/entities/translated/source/a/SourceTranslatedFunctionEntity.d.ts

@@ -0,0 +1,24 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { Analyzer } from '../../../../analysis/Analyzer.js';
+import { Name } from '../../../../common/index.js';
+import * as tree from '../../../../tree/a/index.js';
+import { MethodEntity, PackageFunctionEntity, ParameterEntity, Translation, TypeParameterEntity, TypeWithMembersOrExtensionEntity } from '../../../index.js';
+import { TranslatedMethodEntity, TranslatedPackageFunctionEntity } from '../../index.js';
+export declare class SourceTranslatedPackageFunctionEntity extends TranslatedPackageFunctionEntity {
+    private readonly translationPackage;
+    private readonly node;
+    private readonly typeParameters;
+    private readonly parameters;
+    constructor(originalEntity: PackageFunctionEntity, translation: Translation, name: Name, translationPackage: ResolvedTranslationPackage, node: tree.PackageFunctionTranslationDeclaration | undefined);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly ParameterEntity[];
+}
+export declare class SourceTranslatedMethodEntity extends TranslatedMethodEntity {
+    private readonly node;
+    private readonly translationPackage;
+    private readonly typeParameters;
+    private readonly parameters;
+    constructor(analyzer: Analyzer, originalEntity: MethodEntity, translation: Translation, name: Name, translationPackage: ResolvedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity, node: tree.MethodTranslation | undefined);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly ParameterEntity[];
+}

package/build/types/entities/translated/source/a/SourceTranslatedFunctionTypeEntity.d.ts

@@ -0,0 +1,13 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import * as tree from '../../../../tree/a/index.js';
+import { AnonymousFunctionTypeEntity, ParameterEntity, Translation, TypeEntityMembers } from '../../../index.js';
+import { TranslatedAnonymousFunctionTypeEntity } from '../../TranslatedFunctionTypeEntity.js';
+export declare class SourceTranslatedAnonymousFunctionTypeEntity extends TranslatedAnonymousFunctionTypeEntity {
+    private readonly translationPackage;
+    private readonly node;
+    private readonly parameters;
+    private readonly members;
+    constructor(originalEntity: AnonymousFunctionTypeEntity, translation: Translation, translationPackage: ResolvedTranslationPackage, node: tree.FunctionTypeTranslationDeclaration | undefined);
+    getParameters(): readonly ParameterEntity[];
+    getMembers(): TypeEntityMembers;
+}

package/build/types/entities/translated/source/a/SourceTranslatedIndexerEntity.d.ts

@@ -0,0 +1,11 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import * as tree from '../../../../tree/a/index.js';
+import { IndexerEntity, ParameterEntity, Translation, TypeWithMembersOrExtensionEntity } from '../../../index.js';
+import { TranslatedIndexerEntity } from '../../TranslatedIndexerEntity.js';
+export declare class SourceTranslatedIndexerEntity extends TranslatedIndexerEntity {
+    readonly translationPackage: ResolvedTranslationPackage;
+    private readonly node;
+    private readonly parameters;
+    constructor(originalEntity: IndexerEntity, translation: Translation, translationPackage: ResolvedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity, node: tree.IndexerTranslation | undefined);
+    getParameters(): readonly ParameterEntity[];
+}

package/build/types/entities/translated/source/a/SourceTranslatedPackageEntity.d.ts

@@ -0,0 +1,19 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { PackageName } from '../../../../project/SourcePackage.js';
+import { NameTranslationPackageEntity, PackageEntityMembers, ProgramPackageEntity, TextTranslationPackageEntity, Translation } from '../../../index.js';
+import { TranslatedNameTranslationPackageEntity, TranslatedProgramPackageEntity, TranslatedTextTranslationPackageEntity } from '../../index.js';
+export declare class SourceTranslatedProgramPackageEntity extends TranslatedProgramPackageEntity {
+    private readonly translationPackage;
+    constructor(originalEntity: ProgramPackageEntity, translation: Translation, name: PackageName, translationPackage: ResolvedTranslationPackage);
+    getMembers(): PackageEntityMembers;
+}
+export declare class SourceTranslatedNameTranslationPackageEntity extends TranslatedNameTranslationPackageEntity {
+    private readonly translationPackage;
+    constructor(originalEntity: NameTranslationPackageEntity, translation: Translation, name: PackageName, translationPackage: ResolvedTranslationPackage);
+    getMembers(): PackageEntityMembers;
+}
+export declare class SourceTranslatedTextTranslationPackageEntity extends TranslatedTextTranslationPackageEntity {
+    private readonly translationPackage;
+    constructor(originalEntity: TextTranslationPackageEntity, translation: Translation, name: PackageName, translationPackage: ResolvedTranslationPackage);
+    getMembers(): PackageEntityMembers;
+}

package/build/types/entities/translated/source/a/SourceTranslatedPackageStructuredTypeEntity.d.ts

@@ -0,0 +1,20 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { Name } from '../../../../common/index.js';
+import * as tree from '../../../../tree/a/index.js';
+import { AnonymousStructuredTypeEntity, PackageStructuredTypeEntity, Translation, TypeEntityMembers, TypeParameterEntity } from '../../../index.js';
+import { TranslatedAnonymousStructuredTypeEntity, TranslatedPackageStructuredTypeEntity } from '../../TranslatedStructuredTypeEntity.js';
+export declare class SourceTranslatedPackageStructuredTypeEntity extends TranslatedPackageStructuredTypeEntity {
+    private readonly translationPackage;
+    private readonly node;
+    private readonly typeParameters;
+    private readonly members;
+    constructor(originalEntity: PackageStructuredTypeEntity, translation: Translation, name: Name, translationPackage: ResolvedTranslationPackage, node: tree.TypeTranslationDeclaration | undefined);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+}
+export declare class SourceTranslatedAnonymousStructuredTypeEntity extends TranslatedAnonymousStructuredTypeEntity {
+    private readonly translationPackage;
+    private readonly members;
+    constructor(originalEntity: AnonymousStructuredTypeEntity, translation: Translation, translationPackage: ResolvedTranslationPackage);
+    getMembers(): TypeEntityMembers;
+}

package/build/types/entities/translated/source/a/SourceTranslatedPackageVariantTypeEntity.d.ts

@@ -0,0 +1,14 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { Name } from '../../../../common/index.js';
+import * as tree from '../../../../tree/a/index.js';
+import { PackageVariantTypeEntity, Translation, TypeEntityMembers, TypeParameterEntity } from '../../../index.js';
+import { TranslatedPackageVariantTypeEntity } from '../../TranslatedVariantTypeEntity.js';
+export declare class SourceTranslatedPackageVariantTypeEntity extends TranslatedPackageVariantTypeEntity {
+    private readonly translationPackage;
+    private readonly node;
+    private readonly typeParameters;
+    private readonly members;
+    constructor(originalEntity: PackageVariantTypeEntity, translation: Translation, name: Name, translationPackage: ResolvedTranslationPackage, node: tree.TypeTranslationDeclaration | undefined);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+}

package/build/types/entities/translated/source/a/SourceTranslatedReducedTypeEntity.d.ts

@@ -0,0 +1,14 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { Name } from '../../../../common/index.js';
+import * as tree from '../../../../tree/a/index.js';
+import { ReducedTypeEntity, Translation, TypeEntityMembers, TypeParameterEntity } from '../../../index.js';
+import { TranslatedReducedTypeEntity } from '../../TranslatedReducedTypeEntity.js';
+export declare class SourceTranslatedReducedTypeEntity extends TranslatedReducedTypeEntity {
+    private readonly translationPackage;
+    private readonly node;
+    private readonly typeParameters;
+    private readonly members;
+    constructor(originalEntity: ReducedTypeEntity, translation: Translation, name: Name, translationPackage: ResolvedTranslationPackage, node: tree.TypeTranslationDeclaration | undefined);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+}

package/build/types/entities/translated/source/a/SourceTranslatedTypeExtensionEntity.d.ts

@@ -0,0 +1,9 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { Translation, TypeEntityMembers, TypeExtensionEntity } from '../../../index.js';
+import { TranslatedTypeExtensionEntity } from '../../index.js';
+export declare class SourceTranslatedTypeExtensionEntity extends TranslatedTypeExtensionEntity {
+    private readonly translationPackage;
+    private readonly members;
+    constructor(originalEntity: TypeExtensionEntity, translation: Translation, translationPackage: ResolvedTranslationPackage);
+    getMembers(): TypeEntityMembers;
+}

package/build/types/entities/translated/source/a/index.d.ts

@@ -0,0 +1,11 @@
+export * from './SourceTranslatedAliasTypeEntity.js';
+export * from './SourceTranslatedConstructorEntity.js';
+export * from './SourceTranslatedDestructorEntity.js';
+export * from './SourceTranslatedFunctionEntity.js';
+export * from './SourceTranslatedFunctionTypeEntity.js';
+export * from './SourceTranslatedIndexerEntity.js';
+export * from './SourceTranslatedPackageEntity.js';
+export * from './SourceTranslatedPackageStructuredTypeEntity.js';
+export * from './SourceTranslatedPackageVariantTypeEntity.js';
+export * from './SourceTranslatedReducedTypeEntity.js';
+export * from './SourceTranslatedTypeExtensionEntity.js';

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

@@ -1,4 +1,4 @@
-import { Analyzer } from '../analysis/index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
 import { TaskController, Uri } from '../common/index.js';
 import { Diagnostic, DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { EmitOptions } from '../emitter/index.js';

package/build/types/parser/{ConvertTokenKind.d.ts → a/ConvertTokenKind.d.ts}

@@ -1,3 +1,3 @@
-import { TokenKind as TreeTokenKind } from '../tree/index.js';
+import { TokenKind as TreeTokenKind } from '../../tree/a/index.js';
 import { TokenKind as ScannerTokenKind } from './TokenKind.js';
 export declare function scannerTokenKindToTreeTokenKind(kind: ScannerTokenKind): TreeTokenKind;

package/build/types/parser/{KeywordDictionary.d.ts → a/KeywordDictionary.d.ts}

@@ -1,6 +1,7 @@
-import { PackageDialect, PackageLocale } from '../common/index.js';
-import { KeywordFlags } from '../tree/KeywordFlags.js';
-import { KeywordKind } from '../tree/KeywordKind.js';
+import { PackageDialect } from '../../common/PackageDialect.js';
+import { PackageLocale } from '../../common/PackageLocale.js';
+import { KeywordFlags } from '../../tree/a/KeywordFlags.js';
+import { KeywordKind } from '../../tree/a/KeywordKind.js';
 export type KeywordDictionary = Map<string, Array<KeywordPart>>;
 export type KeywordKindDictionary = Map<KeywordKind, Array<Keyword>>;
 export declare enum KeywordPartKind {

package/build/types/parser/{Parser.d.ts → a/Parser.d.ts}

@@ -1,5 +1,5 @@
-import { PackageDialect, PackageLocale } from '../common/index.js';
-import * as tree from '../tree/index.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
+import * as tree from '../../tree/a/index.js';
 export declare class Parser {
     private readonly parser;
     constructor(text: string, locale?: PackageLocale, dialect?: PackageDialect);

package/build/types/parser/a/TokenKind.d.ts

@@ -0,0 +1,80 @@
+export declare enum TokenKind {
+    Unknown = 0,
+    EndOfFile = 1,
+    Whitespace = 2,
+    NewLine = 3,
+    SingleLineComment = 4,
+    MultiLineComment = 5,
+    IntegerLiteral = 6,
+    RealLiteral = 7,
+    MeasureLiteral = 8,
+    CharLiteral = 9,
+    TextLiteral = 10,
+    TextTemplateHead = 11,
+    TextTemplatePart = 12,
+    TextTemplateTail = 13,
+    LocalizableTextLiteral = 14,
+    LocalizableTextTemplateHead = 15,
+    LocalizableTextTemplateTail = 16,
+    Identifier = 17,
+    QuotedIdentifier = 18,
+    Ampersand = 19,
+    AmpersandAmpersand = 20,
+    AmpersandEquals = 21,
+    Asterisk = 22,
+    AsteriskAsterisk = 23,
+    AsteriskEquals = 24,
+    BackQuote = 25,
+    Bar = 26,
+    BarBar = 27,
+    BarEquals = 28,
+    BarBarEquals = 29,
+    BarLeftAngle = 30,
+    BarLeftAngleEquals = 31,
+    BarRightAngle = 32,
+    BarRightAngleEquals = 33,
+    BarRightAngleRightAngle = 34,
+    BarRightAngleRightAngleEquals = 35,
+    Caret = 36,
+    RightBrace = 37,
+    RightParenthesis = 38,
+    RightSquareBracket = 39,
+    Colon = 40,
+    Comma = 41,
+    CommercialAt = 42,
+    Dot = 43,
+    DoublePeriod = 44,
+    Ellipsis = 45,
+    EqualsEquals = 46,
+    Exclamation = 47,
+    ExclamationEquals = 48,
+    RightAngle = 49,
+    RightAngleEquals = 50,
+    HashSign = 51,
+    LeftAngle = 52,
+    LeftAngleEquals = 53,
+    LeftAngleMinus = 54,
+    Minus = 55,
+    MinusMinus = 56,
+    MinusEquals = 57,
+    MinusRightAngle = 58,
+    LeftBrace = 59,
+    LeftParenthesis = 60,
+    LeftSquareBracket = 61,
+    Plus = 62,
+    PlusPlus = 63,
+    PlusEquals = 64,
+    Question = 65,
+    QuestionQuestion = 66,
+    Semicolon = 67,
+    Slash = 68,
+    SlashEquals = 69,
+    Tilde = 70,
+    TildeTilde = 71,
+    Underscore = 72,
+    Equals = 73,
+    Percent = 74,
+    PercentEquals = 75,
+    PercentPercent = 76,
+    BackSlash = 77
+}

package/build/types/parser/{TriviaInterner.d.ts → a/TriviaInterner.d.ts}

@@ -1,4 +1,4 @@
-import { Trivia } from '../tree/index.js';
+import { Trivia } from '../../tree/a/index.js';
 export declare class TriviaInterner {
     private readonly triviaCache;
     private readonly triviaArrayCache;

package/build/types/project/SourceFile.d.ts

@@ -1,23 +1,47 @@
 import { PackageDialect, PackageLocale, Uri } from '../common/index.js';
+import * as treeA from '../tree/a/index.js';
 import * as tree from '../tree/index.js';
-import { SourcePackage } from './SourcePackage.js';
+import * as treeM from '../tree/m/index.js';
+import { SourcePackage, SourcePackageA, SourcePackageM } from './SourcePackage.js';
 import { TextFile } from './TextFile.js';
-export declare class SourceFile extends TextFile {
+export declare abstract class BaseSourceFile extends TextFile {
     readonly name: string;
     private package_;
-    private readonly node;
     get package(): SourcePackage;
     get locale(): PackageLocale;
-    get dialect(): PackageDialect;
-    private constructor();
-    static create(text: string, uri: Uri, version: number): SourceFile;
+    protected constructor(text: string, uri: Uri, version: number);
+    abstract getSyntaxNode(): tree.SourceFile;
+    abstract parse(): tree.SourceFile;
+    abstract getSyntaxNodeIfParsed(): tree.SourceFile | undefined;
     /**
      * Данный метод должен вызываться только пакетом этого исходного файла.
      */
     setPackage(package_: SourcePackage): void;
-    createCopy(): SourceFile;
     getSourceText(): string;
-    getSyntaxNode(): tree.SourceFile;
-    parse(): tree.SourceFile;
-    getSyntaxNodeIfParsed(): tree.SourceFile | undefined;
+}
+export declare class SourceFileA extends BaseSourceFile {
+    readonly dialect = PackageDialect.ArtelA;
+    private readonly node;
+    get package(): SourcePackageA;
+    protected constructor(text: string, uri: Uri, version: number, node: treeA.SourceFile | undefined);
+    getSyntaxNode(): treeA.SourceFile;
+    parse(): treeA.SourceFile;
+    getSyntaxNodeIfParsed(): treeA.SourceFile | undefined;
+    static create(text: string, uri: Uri, version: number): SourceFileA;
+    createCopy(): SourceFileA;
+}
+export declare class SourceFileM extends BaseSourceFile {
+    readonly dialect = PackageDialect.ArtelM;
+    private readonly node;
+    get package(): SourcePackageM;
+    protected constructor(text: string, uri: Uri, version: number, node: treeM.SourceFile | undefined);
+    getSyntaxNode(): treeM.SourceFile;
+    parse(): treeM.SourceFile;
+    getSyntaxNodeIfParsed(): treeM.SourceFile | undefined;
+    static create(text: string, uri: Uri, version: number): SourceFileM;
+    createCopy(): SourceFileM;
+}
+export type SourceFile = SourceFileA | SourceFileM;
+export declare namespace SourceFile {
+    function create(text: string, uri: Uri, version: number, dialect: PackageDialect): SourceFile;
 }

package/build/types/project/SourcePackage.d.ts

@@ -1,49 +1,95 @@
 import { Name, PackageDialect, PackageLocale, ReadonlyNonEmptyArray, Uri } from '../common/index.js';
 import { Compilation } from './Compilation.js';
-import { SourceFile } from './SourceFile.js';
+import { SourceFile, SourceFileA, SourceFileM } from './SourceFile.js';
 export type SourcePackage = ProgramPackage | TranslationPackage | TextTranslationPackage;
+export type SourcePackageA = ProgramPackageA | TranslationPackageA | TextTranslationPackageA;
+export type SourcePackageM = ProgramPackageM | TranslationPackageM | TextTranslationPackageM;
 export type ProgramOrTextTranslationPackage = ProgramPackage | TextTranslationPackage;
-declare abstract class SourcePackageBase {
+export type ProgramOrTextTranslationPackageA = ProgramOrTextTranslationPackage & SourcePackageA;
+export type ProgramOrTextTranslationPackageM = ProgramOrTextTranslationPackage & SourcePackageM;
+declare abstract class BaseSourcePackage {
     readonly uri: Uri;
     readonly name: PackageName;
-    readonly sourceFiles: readonly SourceFile[];
     private compilation_;
+    abstract readonly sourceFiles: SourceFiles;
     get compilation(): Compilation;
-    protected abstract get asPackage(): SourcePackage;
-    abstract get locale(): PackageLocale;
-    abstract get dialect(): PackageDialect;
-    constructor(uri: Uri, name: PackageName, sourceFiles: readonly SourceFile[]);
+    protected abstract readonly asPackage: SourcePackage;
+    abstract readonly locale: PackageLocale;
+    abstract readonly dialect: PackageDialect;
+    constructor(uri: Uri, name: PackageName);
     /**
      * Данный метод должен вызываться только из конструктора компиляции (Compilation).
      */
     setCompilation(compilation: Compilation): void;
 }
-export declare class ProgramPackage extends SourcePackageBase {
+export declare abstract class BaseProgramPackage extends BaseSourcePackage {
     readonly kind = "program";
     readonly configuration: ProgramPackageConfiguration;
-    protected get asPackage(): SourcePackage;
     get locale(): PackageLocale;
-    get dialect(): PackageDialect;
-    constructor(uri: Uri, configuration: ProgramPackageConfiguration, sourceFiles: readonly SourceFile[]);
+    constructor(uri: Uri, configuration: ProgramPackageConfiguration);
+}
+export declare class ProgramPackageA extends BaseProgramPackage {
+    readonly dialect = PackageDialect.ArtelA;
+    readonly sourceFiles: SourceFilesA;
+    protected get asPackage(): SourcePackage;
+    constructor(uri: Uri, configuration: ProgramPackageConfiguration, sourceFiles: SourceFilesA);
+}
+export declare class ProgramPackageM extends BaseProgramPackage {
+    readonly dialect = PackageDialect.ArtelM;
+    readonly sourceFiles: SourceFilesM;
+    protected get asPackage(): SourcePackage;
+    constructor(uri: Uri, configuration: ProgramPackageConfiguration, sourceFiles: SourceFilesM);
 }
-export declare class TranslationPackage extends SourcePackageBase {
+export type ProgramPackage = ProgramPackageA | ProgramPackageM;
+export declare namespace ProgramPackage {
+    function create(uri: Uri, configuration: ProgramPackageConfiguration, sourceFiles: readonly SourceFile[]): ProgramPackage;
+}
+export declare abstract class BaseTranslationPackage extends BaseSourcePackage {
     readonly kind = "translation";
     readonly configuration: TranslationPackageConfiguration;
-    protected get asPackage(): SourcePackage;
     get locale(): PackageLocale;
-    get dialect(): PackageDialect;
-    constructor(uri: Uri, configuration: TranslationPackageConfiguration, sourceFiles: SourceFile[]);
+    constructor(uri: Uri, configuration: TranslationPackageConfiguration);
+}
+export declare class TranslationPackageA extends BaseTranslationPackage {
+    readonly dialect = PackageDialect.ArtelA;
+    readonly sourceFiles: SourceFilesA;
+    protected get asPackage(): SourcePackage;
+    constructor(uri: Uri, configuration: TranslationPackageConfiguration, sourceFiles: SourceFilesA);
 }
-export declare class TextTranslationPackage extends SourcePackageBase {
+export declare class TranslationPackageM extends BaseTranslationPackage {
+    readonly dialect = PackageDialect.ArtelM;
+    readonly sourceFiles: SourceFilesM;
+    protected get asPackage(): SourcePackage;
+    constructor(uri: Uri, configuration: TranslationPackageConfiguration, sourceFiles: SourceFilesM);
+}
+export type TranslationPackage = TranslationPackageA | TranslationPackageM;
+export declare namespace TranslationPackage {
+    function create(uri: Uri, configuration: TranslationPackageConfiguration, sourceFiles: readonly SourceFile[]): TranslationPackage;
+}
+export declare abstract class BaseTextTranslationPackage extends BaseSourcePackage {
     readonly kind = "text-translation";
     readonly configuration: TextTranslationPackageConfiguration;
-    protected get asPackage(): SourcePackage;
     get locale(): PackageLocale;
-    get dialect(): PackageDialect;
     get translationLocale(): string;
     get targetPackageName(): PackageName;
     get isPrimary(): boolean;
-    constructor(uri: Uri, configuration: TextTranslationPackageConfiguration, sourceFiles: SourceFile[]);
+    constructor(uri: Uri, configuration: TextTranslationPackageConfiguration);
+}
+export declare class TextTranslationPackageA extends BaseTextTranslationPackage {
+    readonly dialect = PackageDialect.ArtelA;
+    readonly sourceFiles: SourceFilesA;
+    protected get asPackage(): SourcePackage;
+    constructor(uri: Uri, configuration: TextTranslationPackageConfiguration, sourceFiles: SourceFilesA);
+}
+export declare class TextTranslationPackageM extends BaseTextTranslationPackage {
+    readonly dialect = PackageDialect.ArtelM;
+    readonly sourceFiles: SourceFilesM;
+    protected get asPackage(): SourcePackage;
+    constructor(uri: Uri, configuration: TextTranslationPackageConfiguration, sourceFiles: SourceFilesM);
+}
+export type TextTranslationPackage = TextTranslationPackageA | TextTranslationPackageM;
+export declare namespace TextTranslationPackage {
+    function create(uri: Uri, configuration: TextTranslationPackageConfiguration, sourceFiles: readonly SourceFile[]): TextTranslationPackage;
 }
 export type PackageConfiguration = ProgramPackageConfiguration | TranslationPackageConfiguration | TextTranslationPackageConfiguration;
 export declare class TranslationPackageConfiguration {
@@ -93,6 +139,9 @@ export declare class PackageName {
     considerEqual(name: PackageName): boolean;
     toString(original?: boolean): string;
 }
+export type SourceFilesA = readonly SourceFileA[];
+export type SourceFilesM = readonly SourceFileM[];
+export type SourceFiles = SourceFilesA | SourceFilesM;
 export type RequiredPackageConfig = RequiredPackageConfig.Npm | RequiredPackageConfig.NuGet;
 export declare namespace RequiredPackageConfig {
     class Npm {

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

@@ -18,22 +18,22 @@ export declare class LanguageServer {
     private manuallyUpdatedFileSystemTreeProvider;
     private readonly sourceFileItemsService;
     private readonly workspaceItemsService;
-    private definitionService;
+    private definitionServiceA;
     private sourceGenerationService;
     private readonly referencesService;
     private readonly documentHighlightService;
-    private readonly renameService;
-    private readonly hoverService;
-    private readonly evaluatableExpressionService;
-    private readonly completionService;
-    private readonly semanticTokensService;
+    private readonly renameServiceA;
+    private readonly hoverServiceA;
+    private readonly evaluatableExpressionServiceA;
+    private readonly completionServiceA;
+    private readonly semanticTokensServiceA;
     private readonly semanticTokenTypeIndexBySemanticTokenKind;
     private readonly protocolSemanticTokenModifierFlagByIndex;
-    private readonly signatureHelpService;
+    private readonly signatureHelpServiceA;
     private readonly fileSystemTreeDisplayService;
-    private readonly selectionRangeService;
-    private readonly scriptEditingService;
-    private readonly codeActionsService;
+    private readonly selectionRangeServiceA;
+    private readonly scriptEditingServiceA;
+    private readonly codeActionsServiceA;
     constructor(config: LanguageServerConfig);
     start(): void;
     dispose(): void;

package/build/types/services/a/CodeActionsService.d.ts

@@ -0,0 +1,10 @@
+import { Analyzer } from '../../analysis/a/Analyzer.js';
+import { DiagnosticCode } from '../../diagnostic/DiagnosticCode.js';
+import { SourceFileA } from '../../project/SourceFile.js';
+import { CodeAction } from '../common/code-action/Types.js';
+import { SourceFileEdit } from '../common/Types.js';
+export declare class CodeActionsServiceA {
+    private readonly translationsGeneratorService;
+    getCodeActions(analyzer: Analyzer, sourceFile: SourceFileA, offset: number, diagnosticCodes: readonly DiagnosticCode[] | undefined): CodeAction[] | undefined;
+    resolveEdits(analyzer: Analyzer, sourceFile: SourceFileA, offset: number, name: string, data: any): SourceFileEdit[] | undefined;
+}