tsc-ts 0.0.3 → 0.0.5

package/dist/api/library/ast.generated.js

@@ -0,0 +1,3 @@
+// Generated by scripts/generate-api.mjs from typescript-go _scripts/ast.json (TypeScript 7.0.2).
+// TypeScript is Copyright Microsoft Corporation, licensed under Apache-2.0. Do not edit.
+export {};

package/dist/api/library/ast.js

@@ -0,0 +1,5 @@
+// The hand-written node types of tsc-ts's public API; the node interfaces are generated in
+// ast.generated.ts (scripts/generate-api.mjs). They describe tsc-ts's own nodes, which the API hands
+// out as they are: every node has its kind, flags, position and parent, and its children in the fields
+// TypeScript 7's AST names. Lists are NodeList objects.
+export * from './ast.generated.js';

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/compiler-options.generated.d.ts

@@ -0,0 +1,108 @@
+import type { JsxEmit } from './enums.generated.js';
+import type { ModuleDetectionKind } from './enums.generated.js';
+import type { ModuleKind } from './enums.generated.js';
+import type { ModuleResolutionKind } from './enums.generated.js';
+import type { NewLineKind } from './enums.generated.js';
+import type { ScriptTarget } from './enums.generated.js';
+export interface CompilerOptions {
+    allowJs?: boolean;
+    allowArbitraryExtensions?: boolean;
+    allowImportingTsExtensions?: boolean;
+    allowNonTsExtensions?: boolean;
+    allowUmdGlobalAccess?: boolean;
+    allowUnreachableCode?: boolean;
+    allowUnusedLabels?: boolean;
+    assumeChangesOnlyAffectDirectDependencies?: boolean;
+    checkJs?: boolean;
+    customConditions?: string[];
+    composite?: boolean;
+    emitDeclarationOnly?: boolean;
+    emitBOM?: boolean;
+    emitDecoratorMetadata?: boolean;
+    declaration?: boolean;
+    declarationDir?: string;
+    declarationMap?: boolean;
+    deduplicatePackages?: boolean;
+    disableSizeLimit?: boolean;
+    disableSourceOfProjectReferenceRedirect?: boolean;
+    disableSolutionSearching?: boolean;
+    disableReferencedProjectLoad?: boolean;
+    erasableSyntaxOnly?: boolean;
+    exactOptionalPropertyTypes?: boolean;
+    experimentalDecorators?: boolean;
+    forceConsistentCasingInFileNames?: boolean;
+    isolatedModules?: boolean;
+    isolatedDeclarations?: boolean;
+    ignoreConfig?: boolean;
+    ignoreDeprecations?: string;
+    importHelpers?: boolean;
+    inlineSourceMap?: boolean;
+    inlineSources?: boolean;
+    init?: boolean;
+    incremental?: boolean;
+    jsx?: JsxEmit;
+    jsxFactory?: string;
+    jsxFragmentFactory?: string;
+    jsxImportSource?: string;
+    lib?: string[];
+    libReplacement?: boolean;
+    locale?: string;
+    mapRoot?: string;
+    module?: ModuleKind;
+    moduleResolution?: ModuleResolutionKind;
+    moduleSuffixes?: string[];
+    moduleDetection?: ModuleDetectionKind;
+    newLine?: NewLineKind;
+    noEmit?: boolean;
+    noCheck?: boolean;
+    noErrorTruncation?: boolean;
+    noFallthroughCasesInSwitch?: boolean;
+    noImplicitAny?: boolean;
+    noImplicitThis?: boolean;
+    noImplicitReturns?: boolean;
+    noEmitHelpers?: boolean;
+    noLib?: boolean;
+    noPropertyAccessFromIndexSignature?: boolean;
+    noUncheckedIndexedAccess?: boolean;
+    noEmitOnError?: boolean;
+    noUnusedLocals?: boolean;
+    noUnusedParameters?: boolean;
+    noResolve?: boolean;
+    noImplicitOverride?: boolean;
+    noUncheckedSideEffectImports?: boolean;
+    outDir?: string;
+    paths?: Record<string, string[]>;
+    preserveConstEnums?: boolean;
+    preserveSymlinks?: boolean;
+    project?: string;
+    resolveJsonModule?: boolean;
+    resolvePackageJsonExports?: boolean;
+    resolvePackageJsonImports?: boolean;
+    removeComments?: boolean;
+    rewriteRelativeImportExtensions?: boolean;
+    reactNamespace?: string;
+    rootDir?: string;
+    rootDirs?: string[];
+    skipLibCheck?: boolean;
+    stableTypeOrdering?: boolean;
+    strict?: boolean;
+    strictBindCallApply?: boolean;
+    strictBuiltinIteratorReturn?: boolean;
+    strictFunctionTypes?: boolean;
+    strictNullChecks?: boolean;
+    strictPropertyInitialization?: boolean;
+    stripInternal?: boolean;
+    skipDefaultLibCheck?: boolean;
+    sourceMap?: boolean;
+    sourceRoot?: string;
+    suppressOutputPathCheck?: boolean;
+    target?: ScriptTarget;
+    traceResolution?: boolean;
+    tsBuildInfoFile?: string;
+    typeRoots?: string[];
+    types?: string[];
+    useDefineForClassFields?: boolean;
+    useUnknownInCatchVariables?: boolean;
+    verbatimModuleSyntax?: boolean;
+    maxNodeModuleJsDepth?: number;
+}

package/dist/api/library/compiler-options.generated.js

@@ -0,0 +1,3 @@
+// Generated by scripts/generate-api.mjs from typescript-go _packages/native-preview/src/api/compilerOptions.ts (TypeScript 7.0.2).
+// TypeScript is Copyright Microsoft Corporation, licensed under Apache-2.0. Do not edit.
+export {};

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;
+    }
+}