tsc-ts 0.0.4 → 0.0.5

package/dist/api/library/checker.d.ts

@@ -0,0 +1,51 @@
+import { type Checker } from '../compiler/checker.js';
+import { type Symbol as CompilerSymbol } from '../compiler/symbol.js';
+import type { Expression, Identifier, Node, TypeNode } from './ast.js';
+import { SignatureKind, SymbolFlags, TypeFormatFlags } from './enums.generated.js';
+import type { IndexInfo, InterfaceType, Signature, Symbol, Type, TypeChecker, TypePredicate, TypeReference } from './types.js';
+/** `symbol`, with its id assigned: every symbol the API hands out has one. */
+export declare function publicSymbol(symbol: CompilerSymbol | undefined): Symbol | undefined;
+export declare function publicSymbols(symbols: readonly CompilerSymbol[]): readonly Symbol[];
+export declare class LibraryTypeChecker implements TypeChecker {
+    private readonly c;
+    constructor(c: Checker);
+    dispose(): void;
+    getSymbolAtLocation(location: Node): Symbol | undefined;
+    getTypeAtLocation(location: Node): Type | undefined;
+    getTypeOfSymbol(symbol: Symbol): Type | undefined;
+    getDeclaredTypeOfSymbol(symbol: Symbol): Type;
+    getTypeOfSymbolAtLocation(symbol: Symbol, location: Node): Type;
+    getTypeArguments(reference: TypeReference): readonly Type[];
+    /** The target of an alias; throws an InternalCompilerError for any other symbol, as TypeScript 7 does. */
+    getAliasedSymbol(symbol: Symbol): Symbol;
+    getPropertyOfType(t: Type, name: string): Symbol | undefined;
+    getPropertiesOfType(t: Type): readonly Symbol[];
+    getSignaturesOfType(t: Type, kind: SignatureKind): readonly Signature[];
+    getIndexInfosOfType(t: Type): readonly IndexInfo[];
+    getReturnTypeOfSignature(s: Signature): Type | undefined;
+    getTypePredicateOfSignature(s: Signature): TypePredicate | undefined;
+    getSignatureFromDeclaration(declaration: Node): Signature | undefined;
+    getResolvedSignature(call: Node): Signature | undefined;
+    getContextualType(expression: Expression): Type | undefined;
+    getShorthandAssignmentValueSymbol(location: Node): Symbol | undefined;
+    getTypeFromTypeNode(typeNode: TypeNode): Type | undefined;
+    getBaseTypeOfLiteralType(t: Type): Type | undefined;
+    getNonNullableType(t: Type): Type | undefined;
+    getBaseTypes(t: InterfaceType): readonly Type[];
+    getConstantValue(location: Node): string | number | undefined;
+    isArrayType(t: Type): boolean;
+    isTupleType(t: Type): boolean;
+    isArrayLikeType(t: Type): boolean;
+    isTypeAssignableTo(source: Type, target: Type): boolean;
+    resolveName(name: string, meaning: SymbolFlags, location?: Node, excludeGlobals?: boolean): Symbol | undefined;
+    /** The value an identifier names where it is: resolveName of its text, as TypeScript 7's API defines it. */
+    getResolvedSymbol(identifier: Identifier): Symbol | undefined;
+    typeToString(t: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
+    getAnyType(): Type;
+    getUnknownType(): Type;
+    getNeverType(): Type;
+    getStringType(): Type;
+    getNumberType(): Type;
+    getBigIntType(): Type;
+    getBooleanType(): Type;
+}

package/dist/api/library/checker.js

@@ -0,0 +1,318 @@
+// The TypeChecker of tsc-ts's public API: a checker of the program for queries, independent of the
+// checker that reports the program's diagnostics, as `tsc-ts --api` answers queries. Each method answers
+// as the `tsc-ts --api` request of the same name does.
+import { disposeChecker } from '../compiler/checker.js';
+import { getBaseTypes, getDeclaredTypeOfSymbol } from '../compiler/checker-declared-types.js';
+import { getNonNullableType } from '../compiler/checker-flow.js';
+import { getIndexInfosOfType, getPropertiesOfType, getPropertyOfType, getSignaturesOfType, isArrayLikeType, } from '../compiler/checker-members.js';
+import { getConstantValue, getShorthandAssignmentValueSymbol, getSymbolAtLocation, getTypeAtLocation, getTypeOfSymbolAtLocation, queryContextualType, queryResolvedSignature, querySignatureFromDeclaration, } from '../compiler/checker-services.js';
+import { getReturnTypeOfSignature, getTypePredicateOfSignature } from '../compiler/checker-signatures.js';
+import { getTypeOfSymbol } from '../compiler/checker-symbol-types.js';
+import { resolveAlias, resolveName } from '../compiler/checker-symbols.js';
+import { getBaseTypeOfLiteralType, getTypeArguments, isArrayType, isTupleType, } from '../compiler/checker-type-factory.js';
+import { getTypeFromTypeNode } from '../compiler/checker-type-nodes.js';
+import { typeToStringFromTypeNode } from '../compiler/node-builder.js';
+import { isTypeAssignableTo } from '../compiler/relations.js';
+import { getSymbolId, } from '../compiler/symbol.js';
+import { typeToString } from '../compiler/type-printer.js';
+import { SignatureKind, SymbolFlags, TypeFormatFlags } from './enums.generated.js';
+import { internalError } from './errors.js';
+// The API's objects are tsc-ts's own: these name the conversions between the public and compiler types.
+const node = (n) => n;
+const nodeOrUndefined = (n) => n;
+const type = (t) => t;
+const signature = (s) => s;
+const compilerSymbol = (s) => s;
+const publicType = (t) => t;
+const publicTypes = (types) => types.slice();
+const publicSignature = (s) => s;
+/** `symbol`, with its id assigned: every symbol the API hands out has one. */
+export function publicSymbol(symbol) {
+    if (symbol === undefined)
+        return undefined;
+    getSymbolId(symbol);
+    return symbol;
+}
+export function publicSymbols(symbols) {
+    const result = [];
+    for (const symbol of symbols)
+        result.push(publicSymbol(symbol));
+    return result;
+}
+/** The flags of typeToString without flags, as TypeScript 7's API uses them. */
+const defaultTypeFormatFlags = TypeFormatFlags.AllowUniqueESSymbolType | TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
+export class LibraryTypeChecker {
+    c;
+    constructor(c) {
+        this.c = c;
+    }
+    dispose() {
+        disposeChecker(this.c);
+    }
+    getSymbolAtLocation(location) {
+        try {
+            return publicSymbol(getSymbolAtLocation(this.c, node(location)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getTypeAtLocation(location) {
+        try {
+            return publicType(getTypeAtLocation(this.c, node(location)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getTypeOfSymbol(symbol) {
+        try {
+            return publicType(getTypeOfSymbol(this.c, compilerSymbol(symbol)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getDeclaredTypeOfSymbol(symbol) {
+        try {
+            return publicType(getDeclaredTypeOfSymbol(this.c, compilerSymbol(symbol)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getTypeOfSymbolAtLocation(symbol, location) {
+        try {
+            return publicType(getTypeOfSymbolAtLocation(this.c, compilerSymbol(symbol), node(location)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getTypeArguments(reference) {
+        try {
+            return publicTypes(getTypeArguments(this.c, type(reference)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    /** The target of an alias; throws an InternalCompilerError for any other symbol, as TypeScript 7 does. */
+    getAliasedSymbol(symbol) {
+        try {
+            if ((symbol.flags & SymbolFlags.Alias) === 0)
+                throw new Error('Should only get alias here');
+            return publicSymbol(resolveAlias(this.c, compilerSymbol(symbol)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getPropertyOfType(t, name) {
+        try {
+            return publicSymbol(getPropertyOfType(this.c, type(t), name));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getPropertiesOfType(t) {
+        try {
+            return publicSymbols(getPropertiesOfType(this.c, type(t)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getSignaturesOfType(t, kind) {
+        try {
+            const signatures = getSignaturesOfType(this.c, type(t), kind === SignatureKind.Call ? 0 /* CompilerSignatureKind.Call */ : 1 /* CompilerSignatureKind.Construct */);
+            return signatures.slice();
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getIndexInfosOfType(t) {
+        try {
+            return getIndexInfosOfType(this.c, type(t)).slice();
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getReturnTypeOfSignature(s) {
+        try {
+            return publicType(getReturnTypeOfSignature(this.c, signature(s)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getTypePredicateOfSignature(s) {
+        try {
+            const predicate = getTypePredicateOfSignature(this.c, signature(s));
+            if (predicate === undefined)
+                return undefined;
+            return {
+                kind: predicate.kind,
+                parameterIndex: predicate.parameterIndex,
+                parameterName: predicate.parameterName === '' ? undefined : predicate.parameterName,
+                type: publicType(predicate.type),
+            };
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getSignatureFromDeclaration(declaration) {
+        try {
+            return publicSignature(querySignatureFromDeclaration(this.c, node(declaration)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getResolvedSignature(call) {
+        try {
+            return publicSignature(queryResolvedSignature(this.c, node(call)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getContextualType(expression) {
+        try {
+            return publicType(queryContextualType(this.c, node(expression)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getShorthandAssignmentValueSymbol(location) {
+        try {
+            return publicSymbol(getShorthandAssignmentValueSymbol(this.c, node(location)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getTypeFromTypeNode(typeNode) {
+        try {
+            return publicType(getTypeFromTypeNode(this.c, node(typeNode)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getBaseTypeOfLiteralType(t) {
+        try {
+            return publicType(getBaseTypeOfLiteralType(this.c, type(t)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getNonNullableType(t) {
+        try {
+            return publicType(getNonNullableType(this.c, type(t)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getBaseTypes(t) {
+        try {
+            return publicTypes(getBaseTypes(this.c, type(t)));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getConstantValue(location) {
+        try {
+            return getConstantValue(this.c, node(location));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    isArrayType(t) {
+        try {
+            return isArrayType(this.c, type(t));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    isTupleType(t) {
+        try {
+            return isTupleType(type(t));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    isArrayLikeType(t) {
+        try {
+            return isArrayLikeType(this.c, type(t));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    isTypeAssignableTo(source, target) {
+        try {
+            return isTypeAssignableTo(this.c, type(source), type(target));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    resolveName(name, meaning, location, excludeGlobals = false) {
+        try {
+            return publicSymbol(resolveName(this.c, nodeOrUndefined(location), name, meaning, undefined, false, excludeGlobals));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    /** The value an identifier names where it is: resolveName of its text, as TypeScript 7's API defines it. */
+    getResolvedSymbol(identifier) {
+        if (identifier.text === '')
+            return undefined;
+        return this.resolveName(identifier.text, SymbolFlags.Value | SymbolFlags.ExportValue, identifier);
+    }
+    typeToString(t, enclosingDeclaration, flags) {
+        try {
+            const enclosing = nodeOrUndefined(enclosingDeclaration);
+            const formatFlags = flags === undefined || flags === 0 ? defaultTypeFormatFlags : flags;
+            return (typeToStringFromTypeNode(this.c, type(t), enclosing, formatFlags) ??
+                typeToString(this.c, type(t), enclosing, formatFlags));
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getAnyType() {
+        return this.c.anyType;
+    }
+    getUnknownType() {
+        return this.c.unknownType;
+    }
+    getNeverType() {
+        return this.c.neverType;
+    }
+    getStringType() {
+        return this.c.stringType;
+    }
+    getNumberType() {
+        return this.c.numberType;
+    }
+    getBigIntType() {
+        return this.c.bigintType;
+    }
+    getBooleanType() {
+        return this.c.booleanType;
+    }
+}

package/dist/api/library/diagnostics.d.ts

@@ -0,0 +1,13 @@
+import type { SourceFile } from '../compiler/ast.js';
+import { type Diagnostic as CompilerDiagnostic } from '../compiler/diagnostics.js';
+import type { CheckedProgram } from '../compiler/program-checker.js';
+import type { Diagnostic } from './types.js';
+export type DiagnosticKind = 'config' | 'program' | 'global' | 'syntactic' | 'bind' | 'semantic' | 'suggestion' | 'declaration';
+/** A diagnostic as plain data, with its text in the default locale and its chain and related information. */
+export declare function diagnosticOf(d: CompilerDiagnostic): Diagnostic;
+/**
+ * The diagnostics of one kind for `file`, or for every file of the program without one. Global
+ * diagnostics are those of no file, after the semantic diagnostics of every file, as tsgo's API returns
+ * them. Declaration diagnostics are empty, as tsgo's API returns them.
+ */
+export declare function programDiagnostics(checked: CheckedProgram, kind: DiagnosticKind, file: SourceFile | undefined): readonly CompilerDiagnostic[];

package/dist/api/library/diagnostics.js

@@ -0,0 +1,50 @@
+// The diagnostics of programs, as tsc-ts's public API and `tsc-ts --api` return them.
+import { sortAndDeduplicateDiagnostics } from '../compiler/program.js';
+/** A diagnostic as plain data, with its text in the default locale and its chain and related information. */
+export function diagnosticOf(d) {
+    return {
+        fileName: d.file?.fileName,
+        pos: d.pos,
+        end: d.end,
+        code: d.code,
+        category: d.category,
+        text: d.localize(0 /* Locale.Default */),
+        reportsUnnecessary: d.reportsUnnecessary,
+        reportsDeprecated: d.reportsDeprecated,
+        messageChain: d.messageChain.map(diagnosticOf),
+        relatedInformation: d.relatedInformation.map(diagnosticOf),
+    };
+}
+/**
+ * The diagnostics of one kind for `file`, or for every file of the program without one. Global
+ * diagnostics are those of no file, after the semantic diagnostics of every file, as tsgo's API returns
+ * them. Declaration diagnostics are empty, as tsgo's API returns them.
+ */
+export function programDiagnostics(checked, kind, file) {
+    const program = checked.program;
+    switch (kind) {
+        case 'config':
+            return program.getConfigFileParsingDiagnostics();
+        case 'program':
+            return program.getProgramDiagnostics();
+        case 'global': {
+            checked.getSemanticDiagnostics(undefined);
+            const all = [
+                ...program.getConfigFileParsingDiagnostics(),
+                ...program.getProgramDiagnostics(),
+                ...checked.getGlobalDiagnostics(),
+            ];
+            return sortAndDeduplicateDiagnostics(all).filter((d) => d.file === undefined);
+        }
+        case 'syntactic':
+            return program.getSyntacticDiagnostics(file);
+        case 'bind':
+            return checked.getBindDiagnostics(file);
+        case 'semantic':
+            return checked.getSemanticDiagnostics(file);
+        case 'suggestion':
+            return checked.getSuggestionDiagnostics(file);
+        case 'declaration':
+            return [];
+    }
+}

package/dist/api/library/disk.d.ts

@@ -0,0 +1,13 @@
+export interface DirectoryEntries {
+    files: string[];
+    directories: string[];
+}
+export interface FileStat {
+    isDirectory: boolean;
+    size: number;
+    mtimeMs: number;
+}
+export declare function diskReadFile(path: string): string | undefined;
+export declare function diskStat(path: string): FileStat | undefined;
+export declare function diskEntries(path: string): DirectoryEntries;
+export declare function diskRealpath(path: string): string;

package/dist/api/library/disk.js

@@ -0,0 +1,66 @@
+// The disk, as tsc-ts's public API and `tsc-ts --api` read it where a host doesn't answer.
+import { readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+// Reads a text file, decoding UTF-16 byte order marks and dropping a UTF-8 one.
+export function diskReadFile(path) {
+    let bytes;
+    try {
+        bytes = readFileSync(path);
+    }
+    catch {
+        return undefined;
+    }
+    if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe)
+        return new TextDecoder('utf-16le').decode(bytes.subarray(2));
+    if (bytes.length >= 2 && bytes[0] === 0xfe && bytes[1] === 0xff)
+        return utf16be(bytes.subarray(2));
+    if (bytes.length >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf)
+        bytes = bytes.subarray(3);
+    return new TextDecoder().decode(bytes);
+}
+function utf16be(bytes) {
+    const swapped = new Uint8Array(bytes.length & ~1);
+    for (let i = 0; i + 1 < bytes.length; i += 2) {
+        swapped[i] = bytes[i + 1];
+        swapped[i + 1] = bytes[i];
+    }
+    return new TextDecoder('utf-16le').decode(swapped);
+}
+export function diskStat(path) {
+    try {
+        const s = statSync(path);
+        return { isDirectory: s.isDirectory(), size: s.size, mtimeMs: s.mtimeMs };
+    }
+    catch {
+        return undefined;
+    }
+}
+// Lists a directory, following symbolic links and skipping broken ones.
+export function diskEntries(path) {
+    const files = [];
+    const directories = [];
+    let names;
+    try {
+        names = readdirSync(path);
+    }
+    catch {
+        return { files, directories };
+    }
+    for (const name of names.sort()) {
+        const stat = diskStat(path + '/' + name);
+        if (stat === undefined)
+            continue;
+        if (stat.isDirectory)
+            directories.push(name);
+        else
+            files.push(name);
+    }
+    return { files, directories };
+}
+export function diskRealpath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+}

package/dist/api/library/errors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A failure inside tsc-ts while it answered an API call: an exception the compiler threw, as tsgo panics.
+ * `cause` is the exception. The program's checker may be inconsistent after one; dispose of the program.
+ */
+export declare class InternalCompilerError extends Error {
+    constructor(cause: unknown);
+}
+/** A call on a program, or on its checker, after `dispose()`. */
+export declare class DisposedProgramError extends Error {
+    constructor();
+}
+/** `e` as an InternalCompilerError; errors of using a disposed program are rethrown as they are. */
+export declare function internalError(e: unknown): Error;

package/dist/api/library/errors.js

@@ -0,0 +1,24 @@
+// Errors of tsc-ts's public API.
+/**
+ * A failure inside tsc-ts while it answered an API call: an exception the compiler threw, as tsgo panics.
+ * `cause` is the exception. The program's checker may be inconsistent after one; dispose of the program.
+ */
+export class InternalCompilerError extends Error {
+    constructor(cause) {
+        super('panic: ' + (cause instanceof Error ? cause.message : String(cause)), { cause });
+        this.name = 'InternalCompilerError';
+    }
+}
+/** A call on a program, or on its checker, after `dispose()`. */
+export class DisposedProgramError extends Error {
+    constructor() {
+        super('the program is disposed');
+        this.name = 'DisposedProgramError';
+    }
+}
+/** `e` as an InternalCompilerError; errors of using a disposed program are rethrown as they are. */
+export function internalError(e) {
+    if (e instanceof InternalCompilerError || e instanceof DisposedProgramError)
+        return e;
+    return new InternalCompilerError(e);
+}

package/dist/api/library/host.d.ts

@@ -0,0 +1,24 @@
+import { type ExternalModuleIndicatorOptions, type SourceFile } from '../compiler/ast.js';
+import { CompilerHost } from '../compiler/file-loader.js';
+import { DirectoryEntries, FileSystem } from '../compiler/file-system.js';
+import type { ProgramHost } from './types.js';
+/**
+ * The host's answers, and the disk's where a callback is missing or answers undefined, as `tsc-ts --api`
+ * reads through its client's callbacks. `readFile` answering null means the file doesn't exist.
+ */
+export declare class HostFileSystem extends FileSystem {
+    private readonly host;
+    constructor(host: ProgramHost);
+    fileExists(path: string): boolean;
+    directoryExists(path: string): boolean;
+    readFile(path: string): string | undefined;
+    getAccessibleEntries(path: string): DirectoryEntries;
+    realpath(path: string): string;
+}
+/**
+ * The compiler host of a program of tsc-ts's public API. A file that parse threads prepared, reading the disk, is
+ * taken only when the host gives the same text for it; the program parses the host's text otherwise.
+ */
+export declare class LibraryCompilerHost extends CompilerHost {
+    getSourceFile(fileName: string, path: string, externalModuleIndicatorOptions: ExternalModuleIndicatorOptions): SourceFile | undefined;
+}

package/dist/api/library/host.js

@@ -0,0 +1,52 @@
+// The file system a program of tsc-ts's public API reads through its host.
+import { diskEntries, diskReadFile, diskRealpath, diskStat } from './disk.js';
+import { ParseOptions } from '../compiler/ast.js';
+import { CompilerHost } from '../compiler/file-loader.js';
+import { DirectoryEntries, FileSystem } from '../compiler/file-system.js';
+import { takePreparedFile } from '../compiler/parallel-parse.js';
+import { parseSourceFile } from '../compiler/parser.js';
+/**
+ * The host's answers, and the disk's where a callback is missing or answers undefined, as `tsc-ts --api`
+ * reads through its client's callbacks. `readFile` answering null means the file doesn't exist.
+ */
+export class HostFileSystem extends FileSystem {
+    host;
+    constructor(host) {
+        super(host.useCaseSensitiveFileNames());
+        this.host = host;
+    }
+    fileExists(path) {
+        const answer = this.host.fileExists?.(path);
+        return answer ?? diskStat(path)?.isDirectory === false;
+    }
+    directoryExists(path) {
+        const answer = this.host.directoryExists?.(path);
+        return answer ?? diskStat(path)?.isDirectory === true;
+    }
+    readFile(path) {
+        const answer = this.host.readFile?.(path);
+        if (answer === null)
+            return undefined;
+        return answer ?? diskReadFile(path);
+    }
+    getAccessibleEntries(path) {
+        const entries = this.host.getAccessibleEntries?.(path) ?? diskEntries(path);
+        return new DirectoryEntries(entries.files.slice(), entries.directories.slice(), undefined);
+    }
+    realpath(path) {
+        return this.host.realpath?.(path) ?? diskRealpath(path);
+    }
+}
+/**
+ * The compiler host of a program of tsc-ts's public API. A file that parse threads prepared, reading the disk, is
+ * taken only when the host gives the same text for it; the program parses the host's text otherwise.
+ */
+export class LibraryCompilerHost extends CompilerHost {
+    getSourceFile(fileName, path, externalModuleIndicatorOptions) {
+        const text = this.readFile(fileName);
+        if (text === undefined)
+            return undefined;
+        return (takePreparedFile(fileName, path, externalModuleIndicatorOptions, text) ??
+            parseSourceFile(fileName, text, new ParseOptions(path, 0 /* ScriptKind.Unknown */, externalModuleIndicatorOptions)));
+    }
+}

package/dist/api/library/index.d.ts

@@ -2,7 +2,11 @@ export * from './ast.js';
 export * from './enums.generated.js';
 export type { CompilerOptions } from './compiler-options.generated.js';
 export { symbolName } from './symbols.js';
-export type { __String, BigIntLiteralType, BooleanLiteralType, ConditionalType, CreateProgramOptions, Diagnostic, FileSystemEntries, FreshableType, IndexedAccessType, IndexInfo, IndexType, InterfaceType, IntersectionType, IntrinsicType, LiteralType, NumberLiteralType, ObjectType, ParsedConfigFile, Program, ProgramHost, Signature, SourceFileMetadata, StringLiteralType, StringMappingType, SubstitutionType, Symbol, TemplateLiteralType, TupleType, Type, TypeChecker, TypeParameter, TypePredicate, TypeReference, UnionOrIntersectionType, UnionType, } from './types.js';
+export { createProgram, createProgramFromConfigFile, getPreEmitDiagnostics, parseConfigFile } from './program.js';
+export { DisposedProgramError, InternalCompilerError } from './errors.js';
+export { parseSourceFile, type ParseSourceFileOptions } from './parse.js';
+export { canHaveModifiers, flattenDiagnosticMessageText, forEachChild, getCombinedModifierFlags, getCombinedNodeFlags, getJSDoc, getLineAndCharacterOfPosition, getLineStarts, getModifiers, getPositionOfLineAndCharacter, getSourceFileOfNode, getTextOfNode, tokenStartOfNode, tokenToString, walkPreorder, } from './nodes.js';
+export type { __String, BigIntLiteralType, BooleanLiteralType, ConditionalType, CreateProgramOptions, Diagnostic, FileSystemEntries, FreshableType, IndexedAccessType, IndexInfo, IndexType, InterfaceType, IntersectionType, IntrinsicType, LiteralType, NumberLiteralType, ObjectType, ParsedConfigFile, Program, ProgramHost, Signature, SourceFileMetadata, StringLiteralType, StringMappingType, SubstitutionType, Symbol, TemplateLiteralType, TupleType, TupleTypeReference, Type, TypeChecker, TypeParameter, TypePredicate, TypeReference, UnionOrIntersectionType, UnionType, } from './types.js';
 /** The kind of an index signature's key, as TypeScript 5 numbers it. */
 export declare enum IndexKind {
     String = 0,

package/dist/api/library/index.js

@@ -3,6 +3,10 @@
 export * from './ast.js';
 export * from './enums.generated.js';
 export { symbolName } from './symbols.js';
+export { createProgram, createProgramFromConfigFile, getPreEmitDiagnostics, parseConfigFile } from './program.js';
+export { DisposedProgramError, InternalCompilerError } from './errors.js';
+export { parseSourceFile } from './parse.js';
+export { canHaveModifiers, flattenDiagnosticMessageText, forEachChild, getCombinedModifierFlags, getCombinedNodeFlags, getJSDoc, getLineAndCharacterOfPosition, getLineStarts, getModifiers, getPositionOfLineAndCharacter, getSourceFileOfNode, getTextOfNode, tokenStartOfNode, tokenToString, walkPreorder, } from './nodes.js';
 /** The kind of an index signature's key, as TypeScript 5 numbers it. */
 export var IndexKind;
 (function (IndexKind) {