@artel/artc 0.6.25191

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

@@ -0,0 +1,39 @@
+import { Analyzer } from '../analysis/index.js';
+import { CancellationToken, Uri } from '../common/index.js';
+import { Diagnostic, DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
+import { EmitOptions } from '../emitter/index.js';
+import { Compilation } from '../project/index.js';
+import { TypeScriptLibrariesProvider } from '../ts-interop/TsLibrariesProvider.js';
+export type LaunchPath = string;
+export declare class NodeCompiler {
+    private static _fileSystem;
+    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 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 NodeCompilerTask {
+    nodeModulesWithTypeScriptSearchPaths: readonly string[];
+    projectPath: string;
+    outputPath: string;
+    workspacePath?: string;
+    standardPackagesPath?: string;
+    diagnostics: DiagnosticAcceptor | undefined;
+    defaultTsLibraryPath?: string;
+    emitOptions?: EmitOptions;
+    cancellationToken?: CancellationToken;
+}
+export declare class PrintingDiagnosticAcceptor implements DiagnosticAcceptor {
+    private readonly _formatter;
+    constructor(basePath?: string);
+    addDiagnostic(diagnostic: Diagnostic): void;
+}
+export declare class NodeDiagnosticFormatter {
+    private readonly _formatDiagnosticOptions;
+    constructor(basePath?: string);
+    format(diagnostic: Diagnostic): string;
+}

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

@@ -0,0 +1,12 @@
+import { Uri } from '../common/index.js';
+import { OutputAcceptor } from '../emitter/Emitter.js';
+import { DirectoryEntry, SourcesProvider } from '../project/index.js';
+import { WorkspaceFileSystem } from '../services/workspace/WorkspaceFileSystem.js';
+export declare class PhysicalFileSystem implements WorkspaceFileSystem, SourcesProvider, OutputAcceptor {
+    readDirectory(uri: Uri): Promise<readonly DirectoryEntry[]>;
+    readFile(uri: Uri): Promise<string | undefined>;
+    readEntry(uri: Uri): Promise<DirectoryEntry | undefined>;
+    clearDirectory(uri: Uri): Promise<void>;
+    writeFile(uri: Uri, content: string): Promise<void>;
+    private tryLstat;
+}

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

@@ -0,0 +1,12 @@
+import { Uri } from '../common/Uri.js';
+import { TypeScriptLibrariesProvider } from '../ts-interop/TsLibrariesProvider.js';
+export declare class PhysicalTypeScriptLibrariesProvider implements TypeScriptLibrariesProvider {
+    private readonly _standardLibraryUri;
+    private readonly _isCaseSensitive;
+    constructor(standardLibraryUri: Uri);
+    getStandardLibraryUri(): Uri;
+    readFileSync(uri: Uri): string | undefined;
+    fileExistsSync(uri: Uri): boolean;
+    directoryExistsSync(uri: Uri): boolean;
+    isCaseSensitive(): boolean;
+}

package/build/types/generated/BuiltInSystemPackages.d.ts

@@ -0,0 +1,3 @@
+import { ReadonlyFileSystemTree } from '../project/FileSystemTree.js';
+export declare const builtInSystemPackagesFileSystemTree: ReadonlyFileSystemTree;
+export declare const builtInSystemPackagesDirectory: import("../project/FileSystemTree.js").Directory;

package/build/types/old/Executor.d.ts

@@ -0,0 +1,14 @@
+import { Analyzer, TsInteropInputs } from '../analysis/index.js';
+import { Uri } from '../common/index.js';
+import { Compilation } from '../project/index.js';
+import { PhysicalFileSystem } from '../executor/PhysicalFileSystem.js';
+export declare class Executor {
+    readonly fileSystem: PhysicalFileSystem;
+    readonly outputUri: Uri;
+    readonly compilation: Compilation;
+    readonly programUri: Uri;
+    readonly analyzer: Analyzer;
+    constructor(compilation: Compilation, tsInteropInputs: TsInteropInputs, outputUri: Uri);
+    setup(): void;
+    createPackageJsonFile(): Promise<void>;
+}

package/build/types/old/JavaScriptEmitter.d.ts

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

package/build/types/old/JavaScriptEmittingVisitor.d.ts

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

package/build/types/old/NzonParser.d.ts

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

package/build/types/old/NzonScanner.d.ts

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

package/build/types/old/NzonSyntax.d.ts

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

package/build/types/old/RemoteWorkspaceFileSystem.d.ts

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

package/build/types/parser/CharacterCodes.d.ts

@@ -0,0 +1,21 @@
+export declare const enum CharacterCodes {
+    Minus = 45,
+    _ = 95,
+    _0 = 48,
+    _1 = 49,
+    _9 = 57,
+    A = 65,
+    F = 70,
+    Z = 90,
+    a = 97,
+    f = 102,
+    z = 122,
+    Ё = 1025,
+    ё = 1105,
+    А = 1040,
+    Е = 1045,
+    Я = 1071,
+    а = 1072,
+    е = 1077,
+    я = 1103
+}

package/build/types/parser/ConvertTokenKind.d.ts

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

package/build/types/parser/KeywordDictionary.d.ts

@@ -0,0 +1,12 @@
+import { PackageDialect, PackageLocale } from '../common/index.js';
+import { KeywordKind } from '../tree/KeywordKind.js';
+export type KeywordDictionary = Map<string, KeywordPart>;
+export type KeywordKindDictionary = Map<KeywordKind, Array<string>>;
+export declare class KeywordPart {
+    value: string;
+    keywordKind: KeywordKind;
+    subsequentParts?: KeywordDictionary;
+    constructor(value: string);
+}
+export declare function getOrCreateKeywordDictionary(locale: PackageLocale, dialect: PackageDialect): KeywordDictionary;
+export declare function getOrCreateKeywordKindDictionary(locale: PackageLocale, dialect: PackageDialect): KeywordKindDictionary;

package/build/types/parser/ParseNumber.d.ts

@@ -0,0 +1,5 @@
+export declare function parseIntegerLiteral(value: string): number;
+export declare function parseLatinHexInteger(text: string): number;
+export declare function parseCyrillicHexInteger(text: string): number;
+export declare function parseDecimalInteger(text: string): number;
+export declare function parseBinaryInteger(text: string): number;

package/build/types/parser/Parser.d.ts

@@ -0,0 +1,7 @@
+import { PackageLocale } from '../common/index.js';
+import * as tree from '../tree/green/index.js';
+export declare class Parser {
+    private readonly _parser;
+    constructor(text: string, locale?: PackageLocale);
+    parse(): tree.SourceFile;
+}

package/build/types/parser/ParserDiagnostic.d.ts

@@ -0,0 +1,7 @@
+import { Range } from '../common/index.js';
+import { DiagnosticData } from '../diagnostic/DiagnosticData.js';
+export declare class ParserDiagnostic {
+    readonly data: DiagnosticData;
+    readonly range: Range;
+    constructor(data: DiagnosticData, range: Range);
+}

package/build/types/parser/ReservedIdentifierDictionary.d.ts

@@ -0,0 +1,12 @@
+import { PackageLocale } from '../common/index.js';
+export declare const enum ReservedIdentifierKind {
+    Result = 0,
+    Param = 1,
+    Value = 2
+}
+export declare const reservedIdentifiersByLocale: {
+    [T in PackageLocale]: {
+        [T in ReservedIdentifierKind]: string;
+    };
+};
+export declare const reservedIdentifiersKindByValue: { [T in PackageLocale]: ReadonlyMap<string, ReservedIdentifierKind>; };

package/build/types/parser/Scanner.d.ts

@@ -0,0 +1,60 @@
+import { TokenKind } from './TokenKind.js';
+export declare const enum Notation {
+    Artel = 0,
+    Nzon = 1
+}
+export interface ScannerOptions {
+    notation?: Notation;
+    startPosition?: number;
+    length?: number;
+    skipWhitespace?: boolean;
+}
+export declare class Token {
+    readonly kind: TokenKind;
+    readonly value: string;
+    readonly startPosition: number;
+    readonly unterminated: boolean;
+    constructor(kind: TokenKind, value: string, startPosition: number, unterminated: boolean);
+}
+export declare class Scanner {
+    readonly text: string;
+    private token;
+    private notation;
+    private skipWhitespace;
+    private endPosition;
+    private currentPosition;
+    private braceBalance;
+    private textTemplateBraceBalanceStack;
+    private readonly uniqueTokenValues;
+    constructor(text: string, options?: ScannerOptions);
+    getToken(): Token;
+    lookAhead(callback: () => boolean): boolean;
+    tryScan(callback: () => boolean): boolean;
+    nextToken(): Token;
+    private tryScanOrLookAhead;
+    private isCloseBraceEndingTextTemplate;
+    private scanCharOrTextOrTextTemplateElement;
+    private isSingleCharOrEscapedChar;
+    private scanWhitespaceAndTabs;
+    private scanNumber;
+    private scanDigitSequence;
+    private scanLatinHexDigitSequence;
+    private scanCyrillicHexDigitSequence;
+    private scanBinaryDigitSequence;
+    private scanMeasureUnits;
+    private scanSingleLineComment;
+    private scanIdentifier;
+    private scanQuotedIdentifier;
+    static isWhitespaceOrTab(char: string): boolean;
+    static isLineBreak(char: string): boolean;
+    static isLetter(char: number): boolean;
+    static isDigit(char: number): boolean;
+    static isLatinHexDigit(char: number): boolean;
+    static isCyrillicHexDigit(char: number): boolean;
+    static isBinaryDigit(char: number): boolean;
+    static isDigitOrDigitSeparator(char: number): boolean;
+    static isIdentifierStart(char: number): boolean;
+    static isIdentifierPart(char: number): boolean;
+    static isMeasureUnit(char: number): boolean;
+    static isPlainIdentifier(textWithoutQuotes: string): boolean;
+}

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

@@ -0,0 +1,73 @@
+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,
+    Ampersand = 16,
+    AmpersandAmpersand = 17,
+    AmpersandEquals = 18,
+    Asterisk = 19,
+    AsteriskAsterisk = 20,
+    AsteriskEquals = 21,
+    BackQuote = 22,
+    Bar = 23,
+    BarBar = 24,
+    Caret = 25,
+    RightBrace = 26,
+    RightParenthesis = 27,
+    RightSquareBracket = 28,
+    Colon = 29,
+    Comma = 30,
+    CommercialAt = 31,
+    Dot = 32,
+    DoublePeriod = 33,
+    Ellipsis = 34,
+    EqualsEquals = 35,
+    EqualsRightAngle = 36,
+    Exclamation = 37,
+    ExclamationEquals = 38,
+    RightAngle = 39,
+    RightAngleEquals = 40,
+    HashSign = 41,
+    LeftAngle = 42,
+    LeftAngleEquals = 43,
+    LeftAngleMinus = 44,
+    Minus = 45,
+    MinusMinus = 46,
+    MinusEquals = 47,
+    MinusRightAngle = 48,
+    LeftBrace = 49,
+    LeftParenthesis = 50,
+    LeftSquareBracket = 51,
+    Plus = 52,
+    PlusPlus = 53,
+    PlusEquals = 54,
+    Question = 55,
+    QuestionQuestion = 56,
+    Semicolon = 57,
+    Slash = 58,
+    SlashEquals = 59,
+    Tilde = 60,
+    TildeTilde = 61,
+    Underscore = 62,
+    Equals = 63,
+    Percent = 64,
+    PercentPercent = 65,
+    BackSlash = 66,
+    BackSlashEquals = 67,
+    BackSlashBackSlash = 68,
+    Identifier = 69,
+    QuotedIdentifier = 70
+}

package/build/types/parser/UnescapeText.d.ts

@@ -0,0 +1,2 @@
+export declare function withoutQuotes(text: string): string;
+export declare function unescapeText(text: string, normalizeCRLF?: boolean): string;

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

@@ -0,0 +1,21 @@
+import { Uri } from '../common/index.js';
+import * as tree from '../tree/index.js';
+import { SourceFile } from './SourceFile.js';
+import { PackageName, ProgramPackage, SourcePackage } from './SourcePackage.js';
+export declare class Compilation {
+    readonly uri: Uri;
+    readonly mainPackage: ProgramPackage | undefined;
+    readonly userPackages: readonly SourcePackage[];
+    readonly libraryPackages: readonly SourcePackage[];
+    readonly allPackages: readonly SourcePackage[];
+    private _parsedSourceFiles;
+    private readonly _packageByUri;
+    private readonly _sourceFileByUri;
+    constructor(uri: Uri, mainPackage: ProgramPackage | undefined, userPackages: readonly SourcePackage[], libraryPackages: readonly SourcePackage[]);
+    getSourceFileByUri(uri: Uri): SourceFile | undefined;
+    getSourceFileByNode(node: tree.SourceFile): SourceFile;
+    getPackageByUri(uri: Uri): SourcePackage | undefined;
+    getPackageByName(name: PackageName): SourcePackage | undefined;
+    enumerateSourceFiles(): Iterable<SourceFile>;
+    private updateParsedSourceFiles;
+}

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

@@ -0,0 +1,104 @@
+import { CancellationToken, Uri } from '../common/index.js';
+import { Diagnostic, DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
+import { Compilation } from './Compilation.js';
+import * as fsTree from './FileSystemTree.js';
+import { PackageName, ProgramPackageConfiguration } from './SourcePackage.js';
+import { ConvertedConfiguration } from './configuration/ConfigurationConverter.js';
+export declare class CompilationLoader {
+    static readonly artelSystemPackageName: PackageName;
+    private readonly _rootDirectory;
+    private readonly _fileSystemTree;
+    private readonly _config;
+    private readonly _diagnostics;
+    private readonly _cancellationToken;
+    private _configurationsByPackageOrGroupUri;
+    private readonly _userPackages;
+    private readonly _libraryPackages;
+    private constructor();
+    static loadUsingSourcesProvider(uri: Uri, sourcesProvider: SourcesProvider, config: CompilationLoadConfig, diagnostics: DiagnosticAcceptor | undefined, workspaceUri?: Uri, namesOfDirectoriesToIgnore?: readonly string[], cancellationToken?: CancellationToken): Promise<{
+        loadResult: CompilationLoadResult;
+        fileSystemTree: fsTree.FileSystemTree;
+    }>;
+    static loadFromFileSystemTree(rootDirectory: fsTree.Directory, fileSystemTree: fsTree.ReadonlyFileSystemTree | undefined, config: CompilationLoadConfig, diagnostics: DiagnosticAcceptor | undefined, cancellationToken?: CancellationToken): Promise<CompilationLoadResult>;
+    /**
+     * Ищет папку с конфигурацией (папку '.артель') в переданной папке.
+     */
+    static findConfigurationDirectory(parentDirectory: fsTree.Directory): ConfigurationDirectoryInfo | undefined;
+    /**
+     * Проверяет, является ли папка конфигурационной.
+     *
+     * Папка является конфигурационной, если называется '.артель' и содержит хотя бы один файл.
+     */
+    static isConfigurationDirectory(directory: fsTree.Directory): boolean;
+    /**
+     * Проверяет, содержит ли папка конфигурационную папку (папку с именем '.артель').
+     */
+    static checkIfDirectoryContainsArtelConfiguration(directory: fsTree.Directory): boolean;
+    /**
+     * Проверяет, содержит ли папка конфигурационную папку (папку с именем '.артель').
+     */
+    static checkIfDirectoryContainsArtelConfigurationUsingSourcesProvider(uri: Uri, sourcesProvider: SourcesProvider): Promise<boolean>;
+    private static convertConfig;
+    private static loadArtelFiles;
+    private load;
+    private loadSystemPackages;
+    private loadPackagesFromAllAccessibleNodeModulesDirectories;
+    private loadAndAccumulatePackagesFromSingleNodeModulesDirectory;
+    private loadPackageGroupRecursively;
+    private loadDirectoryWithUnprocessedConfiguration;
+    private loadDirectoryWithProcessedConfiguration;
+    private loadPackage;
+    private loadPackageDirectoryAndAccumulateFilesRecursively;
+    private createOrReuseSourceFile;
+    private processOrReuseConfiguration;
+    private processConfiguration;
+}
+export declare class DirectoryEntry {
+    readonly uri: Uri;
+    readonly isFile: boolean;
+    get name(): string;
+    constructor(uri: Uri, isFile: boolean);
+}
+export interface SourcesProvider {
+    /**
+     * @param fileNameExtensions Интересуемые расширения файлов. Реализующая сторона может использовать данный
+     * набор расширений для оптимизации работы с файловой системой. Вызывающая сторона не должна полагаться
+     * на то, что расширения возвращённых файлов соответствуют перечисленным здесь расширениям.
+     */
+    readDirectory(uri: Uri, fileNameExtensions?: Set<string>): Promise<readonly DirectoryEntry[]>;
+    readFile(uri: Uri): Promise<string | undefined>;
+}
+export interface CompilationLoadConfig {
+    previousLoadResult?: CompilationLoadResult;
+    treatRootAsPackageIfConfigIsMissing?: boolean;
+    /**
+     * Позволяет предоставить конфигурацию для корневого пакета программы в случае отсутствия конфигурации (папки .артель).
+     */
+    getMainPackageConfigurationIfAbsent?: MainPackageConfigurationProvider;
+    compilationKind?: CompilationKind;
+    systemProjectDirectoriesOverride?: readonly fsTree.Directory[];
+    provideConfiguration?: ConfigurationProvider;
+    standardPackagesUri?: Uri;
+}
+export declare enum CompilationKind {
+    Regular = 0,
+    Configuration = 1
+}
+export type ConfigurationDirectoryInfo = {
+    directory: fsTree.Directory;
+    packageOrGroupUri: Uri;
+    jsonConfigurationFile: fsTree.File | undefined;
+};
+export declare class CompilationLoadResult {
+    readonly compilation: Compilation | undefined;
+    readonly configurationsByPackageOrGroupUri: ReadonlyMap<string, ProcessedConfigurationInfo>;
+    constructor(compilation: Compilation | undefined, configurationsByPackageOrGroupUri: ReadonlyMap<string, ProcessedConfigurationInfo>);
+}
+interface ProcessedConfigurationInfo {
+    processedConfiguration: ConvertedConfiguration | undefined;
+    diagnostics: readonly Diagnostic[];
+    configurationFileVersion: number;
+}
+export type MainPackageConfigurationProvider = () => Promise<ProgramPackageConfiguration>;
+export type ConfigurationProvider = (configurationDirectory: ConfigurationDirectoryInfo, isLoadedFromNodeModules: boolean, process: (configurationDirectory: ConfigurationDirectoryInfo) => Promise<ConvertedConfiguration | undefined>) => Promise<ConvertedConfiguration | undefined>;
+export {};

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

@@ -0,0 +1,70 @@
+import { ObservableObject } from 'reactronic';
+import { Uri } from '../common/index.js';
+export declare class FileSystemTree extends ObservableObject implements ReadonlyFileSystemTree {
+    private readonly _handleInconsistentRequestsWithoutErrors;
+    private readonly _deleteEmptyDirectories;
+    private readonly _rootByScheme;
+    private _version;
+    private _createdDirectoriesVersion;
+    private _deletedDirectoriesVersion;
+    get version(): number;
+    get createdDirectoriesVersion(): number;
+    get deletedDirectoriesVersion(): number;
+    constructor(handleInconsistentRequestsWithoutErrors?: boolean, deleteEmptyDirectories?: boolean);
+    addFile(uri: Uri, text: string): File;
+    addDirectory(uri: Uri): Directory;
+    getDirectory(uri: Uri): Directory | undefined;
+    getFile(uri: Uri): File | undefined;
+    getFileOrDirectory(uri: Uri): FileOrDirectory | undefined;
+    deleteFileOrDirectory(uri: Uri): void;
+    updateFile(uri: Uri, text: string): void;
+    addOrUpdateFile(uri: Uri, text: string): void;
+    dispose(): void;
+    private getOrCreateDirectoryWithAllAncestors;
+    private getOrCreateChildDirectory;
+    private getOrCreateChildFile;
+    private getFileOrDirectoryInternal;
+}
+export interface ReadonlyFileSystemTree {
+    get version(): number;
+    get createdDirectoriesVersion(): number;
+    get deletedDirectoriesVersion(): number;
+    getDirectory(uri: Uri): Directory | undefined;
+    getFile(uri: Uri): File | undefined;
+    getFileOrDirectory(uri: Uri): FileOrDirectory | undefined;
+}
+export type FileOrDirectory = File | Directory;
+export interface File extends IFileOrDirectory {
+    readonly kind: 'file';
+    readonly uri: Uri;
+    /**
+     * Название файла включая расширение, например "Программа.арт".
+     */
+    readonly name: string;
+    /**
+     * Расширение включая точку, например ".арт".
+     */
+    readonly extension: string;
+    readonly text: string;
+    readonly version: number;
+    readonly isDisposed: boolean;
+}
+export interface Directory extends IFileOrDirectory {
+    readonly kind: 'directory';
+    readonly uri: Uri;
+    readonly name: string;
+    /**
+     * Версия увеличивается при добавлении и удалении дочерних папок и файлов (только на текущем уровне вложенности).
+     */
+    readonly version: number;
+    readonly isDisposed: boolean;
+    getChildren(): Iterable<FileOrDirectory>;
+    getChild(name: string): FileOrDirectory | undefined;
+    enumerateDescendants(): Iterable<FileOrDirectory>;
+}
+interface IFileOrDirectory {
+    readonly uri: Uri;
+    readonly name: string;
+    readonly isDisposed: boolean;
+}
+export {};

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

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

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

@@ -0,0 +1,5 @@
+export declare class Position {
+    readonly line: number;
+    readonly character: number;
+    constructor(line: number, character: number);
+}

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

@@ -0,0 +1,21 @@
+import { Uri } from '../common/index.js';
+import * as tree from '../tree/index.js';
+import { SourcePackage } from './SourcePackage.js';
+import { TextFile } from './TextFile.js';
+export declare class SourceFile extends TextFile {
+    readonly name: string;
+    private _package;
+    private readonly _node;
+    get package(): SourcePackage;
+    private constructor();
+    static create(text: string, uri: Uri, name: string, version: number): SourceFile;
+    /**
+     * Данный метод должен вызываться только пакетом этого исходного файла.
+     */
+    setPackage(package_: SourcePackage): void;
+    createCopy(): SourceFile;
+    getSourceText(): string;
+    getSyntaxNode(): tree.SourceFile;
+    parse(): tree.SourceFile;
+    getSyntaxNodeIfParsed(): tree.SourceFile | undefined;
+}