tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/symbol.d.ts

@@ -0,0 +1,282 @@
+import type { ProgramLifetime } from '@scriptc/types';
+import type { Node } from './ast.js';
+import type { __String, Symbol as PublicSymbol } from '../library/types.js';
+export declare const enum SymbolFlags {
+    None = 0,
+    /** A `var` or parameter. */
+    FunctionScopedVariable = 1,
+    /** A `let` or `const`. */
+    BlockScopedVariable = 2,
+    /** A property or enum member. */
+    Property = 4,
+    EnumMember = 8,
+    Function = 16,
+    Class = 32,
+    Interface = 64,
+    ConstEnum = 128,
+    RegularEnum = 256,
+    /** An instantiated namespace. */
+    ValueModule = 512,
+    /** A namespace with only types. */
+    NamespaceModule = 1024,
+    /** A type literal or mapped type. */
+    TypeLiteral = 2048,
+    ObjectLiteral = 4096,
+    Method = 8192,
+    Constructor = 16384,
+    GetAccessor = 32768,
+    SetAccessor = 65536,
+    /** A call, construct or index signature. */
+    Signature = 131072,
+    TypeParameter = 262144,
+    TypeAlias = 524288,
+    /** The local half of an exported value; see `Binder.declareModuleMember`. */
+    ExportValue = 1048576,
+    /** An alias for another symbol, e.g. an import. */
+    Alias = 2097152,
+    /** A class's `prototype` property. */
+    Prototype = 4194304,
+    /** `export *` declarations. */
+    ExportStar = 8388608,
+    Optional = 16777216,
+    /** Created by the checker. */
+    Transient = 33554432,
+    /** A JavaScript assignment that declares a property, e.g. `fn.prop = 1`. */
+    Assignment = 67108864,
+    /** CommonJS `module` or `module.exports`. */
+    ModuleExports = 134217728,
+    /** A namespace whose only values are const enums. */
+    ConstEnumOnlyModule = 268435456,
+    /** A JavaScript `this.x` property that a method of the same name replaces. */
+    ReplaceableByMethod = 536870912,
+    /** Marks a lookup in the global scope. */
+    GlobalLookup = 1073741824,
+    All = 1073741823,
+    Enum = 384,
+    Variable = 3,
+    Value = 111551,
+    Type = 788968,
+    Namespace = 1920,
+    Module = 1536,
+    Accessor = 98304,
+    FunctionScopedVariableExcludes = 111550,
+    BlockScopedVariableExcludes = 111551,
+    ParameterExcludes = 111551,
+    PropertyExcludes = 13243,
+    EnumMemberExcludes = 900095,
+    FunctionExcludes = 110991,
+    /** Class-interface merging is checked by the checker. */
+    ClassExcludes = 899503,
+    InterfaceExcludes = 788872,
+    RegularEnumExcludes = 899327,
+    ConstEnumExcludes = 899967,
+    ValueModuleExcludes = 110735,
+    NamespaceModuleExcludes = 0,
+    MethodExcludes = 103359,
+    GetAccessorExcludes = 46011,
+    SetAccessorExcludes = 78779,
+    AccessorExcludes = 111547,
+    TypeParameterExcludes = 526824,
+    TypeAliasExcludes = 788968,
+    AliasExcludes = 2097152,
+    ModuleMember = 2623475,
+    ExportHasLocal = 944,
+    BlockScoped = 418,
+    PropertyOrAccessor = 98308,
+    ClassMember = 106500,
+    ExportSupportsDefaultModifier = 112,
+    ExportDoesNotSupportDefaultModifier = -113,
+    /** What the language service classifies semantically. */
+    Classifiable = 2885600,
+    LateBindingContainer = 6256
+}
+/** Flags of transient symbols created by the checker. */
+export declare const enum CheckFlags {
+    None = 0,
+    Instantiated = 1,
+    /** A property of a union or intersection type. */
+    SyntheticProperty = 2,
+    SyntheticMethod = 4,
+    Readonly = 8,
+    /** In some but not all constituents. */
+    ReadPartial = 16,
+    /** In some constituents, and only an index signature in others. */
+    WritePartial = 32,
+    HasNonUniformType = 64,
+    HasLiteralType = 128,
+    ContainsPublic = 256,
+    ContainsProtected = 512,
+    ContainsPrivate = 1024,
+    ContainsStatic = 2048,
+    /** Late-bound from a computed property name. */
+    Late = 4096,
+    ReverseMapped = 8192,
+    OptionalParameter = 16384,
+    RestParameter = 32768,
+    /** The type is computed on demand. */
+    DeferredType = 65536,
+    HasNeverType = 131072,
+    Mapped = 262144,
+    StripOptional = 524288,
+    Unresolved = 1048576,
+    IsDiscriminantComputed = 2097152,
+    IsDiscriminant = 4194304,
+    /** Created from an index signature. */
+    IndexSymbol = 8388608,
+    Synthetic = 6,
+    NonUniformAndLiteral = 192,
+    Partial = 48
+}
+/** Fields of Symbol that few symbols set (about one in twenty), allocated on first write. */
+export declare class SymbolRareFields implements ProgramLifetime {
+    members: SymbolTable | undefined;
+    exports: SymbolTable | undefined;
+    exportSymbol: Symbol | undefined;
+    /** All declarations of a symbol that has more than one (`getDeclarations`). */
+    declarations: Node[] | undefined;
+    /** The value declaration where it is not the first declaration (`Symbol.valueDeclaration`). */
+    valueDeclaration: Node | undefined;
+}
+export declare class Symbol implements ProgramLifetime {
+    flags: SymbolFlags;
+    /** The check flags, and `valueDeclarationIsFirst`. */
+    private bits;
+    readonly name: string;
+    /**
+     * The first declaration. A symbol with more keeps all of them in its rare fields; read them with
+     * `declarationCount`, `declarationAt` and `getDeclarations`. Written only through `setFirst`,
+     * which keeps the value declaration.
+     */
+    declaration: Node | undefined;
+    parent: Symbol | undefined;
+    private rareFields;
+    /** Assigned on first use by `getSymbolId`, or at creation while threads share the program; 0 until then. */
+    id: number;
+    constructor(flags: SymbolFlags, name: string);
+    get checkFlags(): CheckFlags;
+    set checkFlags(flags: CheckFlags);
+    /** Makes `node` the first declaration, keeping the value declaration. */
+    setFirst(node: Node | undefined): void;
+    /**
+     * The declaration of the symbol's value. Almost always the first declaration, which a bit of `bits`
+     * says; any other is kept in the rare fields.
+     */
+    get valueDeclaration(): Node | undefined;
+    set valueDeclaration(node: Node | undefined);
+    private rareFieldsOrNew;
+    /**
+     * The declarations, for tsc-ts/api's `Symbol.declarations`. The compiler reads `declaration`,
+     * `declarationCount` and `declarationAt`: for a single declaration this builds a list on each read.
+     */
+    get declarations(): readonly Node[];
+    /** All declarations where there are more than one, else undefined. */
+    get moreDeclarations(): Node[] | undefined;
+    set moreDeclarations(value: Node[] | undefined);
+    get members(): SymbolTable | undefined;
+    set members(value: SymbolTable | undefined);
+    get exports(): SymbolTable | undefined;
+    set exports(value: SymbolTable | undefined);
+    /** For the local symbol of an exported declaration, the exported symbol. */
+    get exportSymbol(): Symbol | undefined;
+    set exportSymbol(value: Symbol | undefined);
+    /** The name in its escaped form, the key of member and export tables (`escapeSymbolName`). */
+    get escapedName(): string;
+    getParent(): Symbol | undefined;
+    /** The export symbol, or the symbol itself if it has none. */
+    getExportSymbol(): Symbol;
+    /** The members, by escaped name. */
+    getMembers(): Map<__String, PublicSymbol>;
+    /** The exports, by escaped name. */
+    getExports(): Map<__String, PublicSymbol>;
+    /** Whether this is the symbol of an external module, named by its quoted path. */
+    isExternalModule(): boolean;
+    /** The flags of this symbol and its export symbol. */
+    combinedLocalAndExportSymbolFlags(): SymbolFlags;
+}
+export type SymbolTable = Map<string, Symbol>;
+/** Symbols get their ids when they are created from now on (see `idsAtCreation`). */
+export declare function assignSymbolIdsAtCreation(): void;
+/** Whether symbols get their ids when they are created (`assignSymbolIdsAtCreation`). */
+export declare function symbolIdsAtCreation(): boolean;
+/**
+ * Takes symbol ids in chunks from `counter[0]`, shared by the threads that bind together; with
+ * `undefined`, goes back to a plain counter above every id handed out.
+ */
+export declare function shareSymbolIds(counter: Int32Array | undefined): void;
+/** The last symbol id handed out on this thread. */
+export declare function lastSymbolIdValue(): number;
+/** Continues symbol ids above `last` (a checker thread starts above the program it checks). */
+export declare function reserveSymbolIds(last: number): void;
+/** Appends `node` to the declarations of `symbol`. */
+export declare function addDeclaration(symbol: Symbol, node: Node): void;
+/** The number of declarations of `symbol`. */
+export declare function declarationCount(symbol: Symbol): number;
+/** The declaration of `symbol` at `index`, which is below `declarationCount(symbol)`. */
+export declare function declarationAt(symbol: Symbol, index: number): Node;
+/**
+ * The declarations of `symbol`, in order. A symbol with one declaration gets a new list each call;
+ * hot paths read `declaration`, `declarationCount` and `declarationAt` instead.
+ */
+export declare function getDeclarations(symbol: Symbol): readonly Node[];
+/** Whether `node` is a declaration of `symbol`. */
+export declare function hasDeclaration(symbol: Symbol, node: Node): boolean;
+/** Gives `target` the declarations of `source`; a list of several is shared, as the list was before. */
+export declare function copyDeclarations(target: Symbol, source: Symbol): void;
+/** Replaces the declarations of `symbol` with `declarations`, which it keeps when they are more than one. */
+export declare function setDeclarations(symbol: Symbol, declarations: readonly Node[]): void;
+/** A program-wide id, assigned to each symbol when first requested. */
+export declare function getSymbolId(symbol: Symbol): number;
+/** The exports table of `symbol`, created if missing. */
+export declare function getExports(symbol: Symbol): SymbolTable;
+/** The members table of `symbol`, created if missing. */
+export declare function getMembers(symbol: Symbol): SymbolTable;
+/**
+ * Starts internal symbol names. A noncharacter, so it never starts an identifier and is
+ * vanishingly unlikely in a string-literal property name.
+ */
+export declare const internalSymbolNamePrefix = "\uFFFE";
+export declare const enum InternalSymbolName {
+    /** Call signatures. */
+    Call = "\uFFFEcall",
+    /** Constructor implementations. */
+    Constructor = "\uFFFEconstructor",
+    /** Construct signatures. */
+    New = "\uFFFEnew",
+    /** Index signatures. */
+    Index = "\uFFFEindex",
+    /** `export *` declarations. */
+    ExportStar = "\uFFFEexport",
+    /** The global scope's self-reference. */
+    Global = "\uFFFEglobal",
+    /** A missing name. */
+    Missing = "\uFFFEmissing",
+    /** An anonymous type literal. */
+    Type = "\uFFFEtype",
+    /** An anonymous object literal. */
+    Object = "\uFFFEobject",
+    /** An anonymous JSX attributes object literal. */
+    JSXAttributes = "\uFFFEjsxAttributes",
+    /** An unnamed class expression. */
+    Class = "\uFFFEclass",
+    /** An unnamed function expression. */
+    Function = "\uFFFEfunction",
+    /** A computed property name that isn't a literal. */
+    Computed = "\uFFFEcomputed",
+    /** Late-bound JavaScript assignment declarations. */
+    AssignmentDeclaration = "\uFFFEassignment",
+    InstantiationExpression = "\uFFFEinstantiationExpression",
+    ImportAttributes = "\uFFFEimportAttributes",
+    ExportEquals = "export=",
+    Default = "default",
+    This = "this",
+    ModuleExports = "module.exports"
+}
+/** `name` with a leading internal prefix replaced by `__`. */
+export declare function escapeInternalSymbolName(name: string): string;
+/** `name` with every internal prefix replaced by `__`. */
+export declare function escapeAllInternalSymbolNames(name: string): string;
+/**
+ * The escaped `__String` form of a symbol name: internal names get `__`, and names that
+ * already start with `__` get one more `_`.
+ */
+export declare function escapeSymbolName(name: string): string;

package/dist/api/compiler/symbol.js

@@ -0,0 +1,339 @@
+/** Fields of Symbol that few symbols set (about one in twenty), allocated on first write. */
+export class SymbolRareFields {
+    members = undefined;
+    exports = undefined;
+    exportSymbol = undefined;
+    /** All declarations of a symbol that has more than one (`getDeclarations`). */
+    declarations = undefined;
+    /** The value declaration where it is not the first declaration (`Symbol.valueDeclaration`). */
+    valueDeclaration = undefined;
+}
+/** In `Symbol.bits`, above the check flags: the value declaration is the first declaration. */
+const valueDeclarationIsFirst = 1 << 30;
+export class Symbol {
+    flags;
+    /** The check flags, and `valueDeclarationIsFirst`. */
+    bits;
+    name;
+    /**
+     * The first declaration. A symbol with more keeps all of them in its rare fields; read them with
+     * `declarationCount`, `declarationAt` and `getDeclarations`. Written only through `setFirst`,
+     * which keeps the value declaration.
+     */
+    declaration;
+    parent;
+    rareFields;
+    /** Assigned on first use by `getSymbolId`, or at creation while threads share the program; 0 until then. */
+    id;
+    constructor(flags, name) {
+        this.flags = flags;
+        this.bits = 0;
+        this.name = name;
+        this.declaration = undefined;
+        this.parent = undefined;
+        this.rareFields = undefined;
+        this.id = idsAtCreation ? takeSymbolId() : 0;
+    }
+    get checkFlags() {
+        return (this.bits & ~valueDeclarationIsFirst);
+    }
+    set checkFlags(flags) {
+        this.bits = (this.bits & valueDeclarationIsFirst) | flags;
+    }
+    /** Makes `node` the first declaration, keeping the value declaration. */
+    setFirst(node) {
+        if ((this.bits & valueDeclarationIsFirst) !== 0 && node !== this.declaration) {
+            // The value declaration stays what it was.
+            this.rareFieldsOrNew().valueDeclaration = this.declaration;
+            this.bits &= ~valueDeclarationIsFirst;
+        }
+        this.declaration = node;
+    }
+    /**
+     * The declaration of the symbol's value. Almost always the first declaration, which a bit of `bits`
+     * says; any other is kept in the rare fields.
+     */
+    get valueDeclaration() {
+        if ((this.bits & valueDeclarationIsFirst) !== 0)
+            return this.declaration;
+        const group = this.rareFields;
+        return group === undefined ? undefined : group.valueDeclaration;
+    }
+    set valueDeclaration(node) {
+        const group = this.rareFields;
+        if (node !== undefined && node === this.declaration) {
+            this.bits |= valueDeclarationIsFirst;
+            if (group !== undefined)
+                group.valueDeclaration = undefined;
+            return;
+        }
+        this.bits &= ~valueDeclarationIsFirst;
+        if (node !== undefined || group !== undefined)
+            this.rareFieldsOrNew().valueDeclaration = node;
+    }
+    rareFieldsOrNew() {
+        let group = this.rareFields;
+        if (group === undefined) {
+            group = new SymbolRareFields();
+            this.rareFields = group;
+        }
+        return group;
+    }
+    /**
+     * The declarations, for tsc-ts/api's `Symbol.declarations`. The compiler reads `declaration`,
+     * `declarationCount` and `declarationAt`: for a single declaration this builds a list on each read.
+     */
+    get declarations() {
+        return getDeclarations(this);
+    }
+    /** All declarations where there are more than one, else undefined. */
+    get moreDeclarations() {
+        const group = this.rareFields;
+        return group === undefined ? undefined : group.declarations;
+    }
+    set moreDeclarations(value) {
+        if (value === undefined && this.rareFields === undefined)
+            return;
+        this.rareFieldsOrNew().declarations = value;
+    }
+    get members() {
+        const group = this.rareFields;
+        return group === undefined ? undefined : group.members;
+    }
+    set members(value) {
+        if (value === undefined && this.rareFields === undefined)
+            return;
+        this.rareFieldsOrNew().members = value;
+    }
+    get exports() {
+        const group = this.rareFields;
+        return group === undefined ? undefined : group.exports;
+    }
+    set exports(value) {
+        if (value === undefined && this.rareFields === undefined)
+            return;
+        this.rareFieldsOrNew().exports = value;
+    }
+    /** For the local symbol of an exported declaration, the exported symbol. */
+    get exportSymbol() {
+        const group = this.rareFields;
+        return group === undefined ? undefined : group.exportSymbol;
+    }
+    set exportSymbol(value) {
+        if (value === undefined && this.rareFields === undefined)
+            return;
+        this.rareFieldsOrNew().exportSymbol = value;
+    }
+    // TypeScript 7's API (tsc-ts/api). The symbols it hands out have their ids assigned.
+    /** The name in its escaped form, the key of member and export tables (`escapeSymbolName`). */
+    get escapedName() {
+        return escapeSymbolName(this.name);
+    }
+    getParent() {
+        const parent = this.parent;
+        if (parent !== undefined)
+            getSymbolId(parent);
+        return parent;
+    }
+    /** The export symbol, or the symbol itself if it has none. */
+    getExportSymbol() {
+        const exported = this.exportSymbol ?? this;
+        getSymbolId(exported);
+        return exported;
+    }
+    /** The members, by escaped name. */
+    getMembers() {
+        return byEscapedName(this.members);
+    }
+    /** The exports, by escaped name. */
+    getExports() {
+        return byEscapedName(this.exports);
+    }
+    /** Whether this is the symbol of an external module, named by its quoted path. */
+    isExternalModule() {
+        return (this.flags & 1536 /* SymbolFlags.Module */) !== 0 && this.name.charCodeAt(0) === 0x22;
+    }
+    /** The flags of this symbol and its export symbol. */
+    combinedLocalAndExportSymbolFlags() {
+        const exportSymbol = this.exportSymbol;
+        return exportSymbol === undefined ? this.flags : this.flags | exportSymbol.flags;
+    }
+}
+let nextSymbolId = 0;
+// A program shared between threads (parallel-check.ts) is never written, so its symbols get their ids
+// when they are created rather than on first use.
+let idsAtCreation = false;
+// While several threads bind one program (parallel-parse.ts), each takes symbol ids in chunks from a
+// shared counter; ids up to `symbolIdLimit` belong to this thread.
+let symbolIdLimit = Number.POSITIVE_INFINITY;
+let symbolIdCounter = undefined;
+const symbolIdChunk = 4096;
+/** Symbols get their ids when they are created from now on (see `idsAtCreation`). */
+export function assignSymbolIdsAtCreation() {
+    idsAtCreation = true;
+}
+/** Whether symbols get their ids when they are created (`assignSymbolIdsAtCreation`). */
+export function symbolIdsAtCreation() {
+    return idsAtCreation;
+}
+function takeSymbolId() {
+    // `| 0`: ids stay far below 2^31, and native builds then store `id` as an int32.
+    return (nextSymbolId < symbolIdLimit ? ++nextSymbolId : takeSymbolIdChunk()) | 0;
+}
+function takeSymbolIdChunk() {
+    const base = Atomics.add(symbolIdCounter, 0, symbolIdChunk);
+    nextSymbolId = base + 1;
+    symbolIdLimit = base + symbolIdChunk;
+    return nextSymbolId;
+}
+/**
+ * Takes symbol ids in chunks from `counter[0]`, shared by the threads that bind together; with
+ * `undefined`, goes back to a plain counter above every id handed out.
+ */
+export function shareSymbolIds(counter) {
+    if (counter !== undefined) {
+        symbolIdCounter = counter;
+        symbolIdLimit = nextSymbolId;
+        return;
+    }
+    if (symbolIdCounter !== undefined) {
+        const top = Atomics.load(symbolIdCounter, 0);
+        if (top > nextSymbolId)
+            nextSymbolId = top;
+    }
+    symbolIdCounter = undefined;
+    symbolIdLimit = Number.POSITIVE_INFINITY;
+}
+/** The last symbol id handed out on this thread. */
+export function lastSymbolIdValue() {
+    return nextSymbolId;
+}
+/** Continues symbol ids above `last` (a checker thread starts above the program it checks). */
+export function reserveSymbolIds(last) {
+    if (last > nextSymbolId)
+        nextSymbolId = last;
+}
+/**
+ * The declarations of a symbol without any: shared, so never modified. Add declarations with
+ * `addDeclaration`, which gives the symbol its own array on the first one.
+ */
+const noDeclarations = [];
+/** Appends `node` to the declarations of `symbol`. */
+export function addDeclaration(symbol, node) {
+    const first = symbol.declaration;
+    if (first === undefined) {
+        symbol.setFirst(node);
+        return;
+    }
+    const more = symbol.moreDeclarations;
+    if (more !== undefined)
+        more.push(node);
+    else
+        symbol.moreDeclarations = [first, node];
+}
+/** The number of declarations of `symbol`. */
+export function declarationCount(symbol) {
+    if (symbol.declaration === undefined)
+        return 0;
+    const more = symbol.moreDeclarations;
+    return more !== undefined ? more.length : 1;
+}
+/** The declaration of `symbol` at `index`, which is below `declarationCount(symbol)`. */
+export function declarationAt(symbol, index) {
+    return index === 0 ? symbol.declaration : symbol.moreDeclarations[index];
+}
+/**
+ * The declarations of `symbol`, in order. A symbol with one declaration gets a new list each call;
+ * hot paths read `declaration`, `declarationCount` and `declarationAt` instead.
+ */
+export function getDeclarations(symbol) {
+    const first = symbol.declaration;
+    if (first === undefined)
+        return noDeclarations;
+    const more = symbol.moreDeclarations;
+    return more !== undefined ? more : [first];
+}
+/** Whether `node` is a declaration of `symbol`. */
+export function hasDeclaration(symbol, node) {
+    const first = symbol.declaration;
+    if (first === undefined)
+        return false;
+    if (first === node)
+        return true;
+    const more = symbol.moreDeclarations;
+    return more !== undefined && more.indexOf(node) >= 0;
+}
+/** Gives `target` the declarations of `source`; a list of several is shared, as the list was before. */
+export function copyDeclarations(target, source) {
+    target.setFirst(source.declaration);
+    target.moreDeclarations = source.moreDeclarations;
+}
+/** Replaces the declarations of `symbol` with `declarations`, which it keeps when they are more than one. */
+export function setDeclarations(symbol, declarations) {
+    symbol.setFirst(declarations.length !== 0 ? declarations[0] : undefined);
+    symbol.moreDeclarations = declarations.length > 1 ? declarations : undefined;
+}
+/**
+ * The symbols of `table` by escaped name, with their ids assigned, as tsc-ts's public API types them: the map's
+ * values are typed as the public Symbol, so a native build returns it as the map that interface declares.
+ */
+function byEscapedName(table) {
+    const result = new Map();
+    if (table !== undefined)
+        for (const symbol of table.values()) {
+            getSymbolId(symbol);
+            result.set(escapeSymbolName(symbol.name), symbol);
+        }
+    return result;
+}
+/** A program-wide id, assigned to each symbol when first requested. */
+export function getSymbolId(symbol) {
+    let id = symbol.id;
+    if (id === 0) {
+        id = takeSymbolId();
+        symbol.id = id;
+    }
+    return id;
+}
+/** The exports table of `symbol`, created if missing. */
+export function getExports(symbol) {
+    let exports = symbol.exports;
+    if (exports === undefined) {
+        exports = new Map();
+        symbol.exports = exports;
+    }
+    return exports;
+}
+/** The members table of `symbol`, created if missing. */
+export function getMembers(symbol) {
+    let members = symbol.members;
+    if (members === undefined) {
+        members = new Map();
+        symbol.members = members;
+    }
+    return members;
+}
+/**
+ * Starts internal symbol names. A noncharacter, so it never starts an identifier and is
+ * vanishingly unlikely in a string-literal property name.
+ */
+export const internalSymbolNamePrefix = '￾';
+/** `name` with a leading internal prefix replaced by `__`. */
+export function escapeInternalSymbolName(name) {
+    return name.startsWith(internalSymbolNamePrefix) ? '__' + name.substring(1) : name;
+}
+/** `name` with every internal prefix replaced by `__`. */
+export function escapeAllInternalSymbolNames(name) {
+    return name.indexOf(internalSymbolNamePrefix) < 0 ? name : name.replaceAll(internalSymbolNamePrefix, '__');
+}
+/**
+ * The escaped `__String` form of a symbol name: internal names get `__`, and names that
+ * already start with `__` get one more `_`.
+ */
+export function escapeSymbolName(name) {
+    if (name.startsWith(internalSymbolNamePrefix))
+        return '__' + name.substring(1);
+    if (name.startsWith('__'))
+        return '_' + name;
+    return name;
+}

package/dist/api/compiler/symlinks.d.ts

@@ -0,0 +1,32 @@
+/** The real directory of a symlink, with a trailing `/`: as `realpath` spells it, and as a path. */
+export declare class KnownDirectoryLink {
+    readonly real: string;
+    readonly realPath: string;
+    constructor(real: string, realPath: string);
+}
+export declare class KnownSymlinks {
+    readonly currentDirectory: string;
+    readonly useCaseSensitiveFileNames: boolean;
+    /** Real directories by symlink path; keys have a trailing `/`. */
+    private readonly directories;
+    /** Symlinks, as spelled, by real directory path; keys have a trailing `/`. */
+    private readonly directoriesByRealpath;
+    /**
+     * The directory symlink each resolution implies (`null` for none), by original path and resolved
+     * file name: many files resolve the same module through the same symlink.
+     */
+    private readonly implied;
+    constructor(currentDirectory: string, useCaseSensitiveFileNames: boolean);
+    hasDirectory(symlinkPath: string): boolean;
+    /** The symlinks to the real directory `realPath`, which has a trailing `/`. */
+    getSymlinksOfDirectory(realPath: string): ReadonlySet<string> | undefined;
+    setDirectory(symlink: string, symlinkPath: string, real: KnownDirectoryLink): void;
+    /** Records the directory symlink a resolution through `originalPath` to `resolvedFileName` implies. */
+    processResolution(originalPath: string, resolvedFileName: string): void;
+    private impliedDirectoryLink;
+    /** The longest directories of `resolved` and `original` whose remaining paths are equal. */
+    private guessDirectorySymlink;
+    private isNodeModulesOrScopedPackageDirectory;
+}
+/** Paths inside `node_modules/.*` (such as pnpm's store), `.git` or editor lock files. */
+export declare function containsIgnoredPath(path: string): boolean;