tsc-ts 0.0.4 → 0.0.5

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

@@ -0,0 +1,240 @@
+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;
+}
+export declare class Symbol implements ProgramLifetime {
+    flags: SymbolFlags;
+    checkFlags: CheckFlags;
+    readonly name: string;
+    declarations: Node[];
+    valueDeclaration: 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);
+    private rareFieldsOrNew;
+    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;
+/** 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,228 @@
+/** Fields of Symbol that few symbols set (about one in twenty), allocated on first write. */
+export class SymbolRareFields {
+    members = undefined;
+    exports = undefined;
+    exportSymbol = undefined;
+}
+export class Symbol {
+    flags;
+    checkFlags;
+    name;
+    declarations;
+    valueDeclaration;
+    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.checkFlags = 0 /* CheckFlags.None */;
+        this.name = name;
+        this.declarations = noDeclarations;
+        this.valueDeclaration = undefined;
+        this.parent = undefined;
+        this.rareFields = undefined;
+        this.id = idsAtCreation ? takeSymbolId() : 0;
+    }
+    rareFieldsOrNew() {
+        let group = this.rareFields;
+        if (group === undefined) {
+            group = new SymbolRareFields();
+            this.rareFields = group;
+        }
+        return group;
+    }
+    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 declarations = symbol.declarations;
+    if (declarations.length === 0)
+        symbol.declarations = [node];
+    else
+        declarations.push(node);
+}
+/**
+ * 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;

package/dist/api/compiler/symlinks.js

@@ -0,0 +1,114 @@
+// Symlinked directories a program found through module resolution, such as packages linked by
+// pnpm or workspaces, so module specifiers can name a file by the path it was imported through.
+import { ensureTrailingDirectorySeparator, getCanonicalFileName, getNormalizedAbsolutePath, getPathComponents, getPathFromPathComponents, toPath, } from './path.js';
+/** The real directory of a symlink, with a trailing `/`: as `realpath` spells it, and as a path. */
+export class KnownDirectoryLink {
+    real;
+    realPath;
+    constructor(real, realPath) {
+        this.real = real;
+        this.realPath = realPath;
+    }
+}
+/** A directory symlink a resolution implies: as spelled, as a path (trailing `/`), and its real directory. */
+class ImpliedDirectoryLink {
+    symlink;
+    symlinkPath;
+    real;
+    constructor(symlink, symlinkPath, real) {
+        this.symlink = symlink;
+        this.symlinkPath = symlinkPath;
+        this.real = real;
+    }
+}
+export class KnownSymlinks {
+    currentDirectory;
+    useCaseSensitiveFileNames;
+    /** Real directories by symlink path; keys have a trailing `/`. */
+    directories = new Map();
+    /** Symlinks, as spelled, by real directory path; keys have a trailing `/`. */
+    directoriesByRealpath = new Map();
+    /**
+     * 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.
+     */
+    implied = new Map();
+    constructor(currentDirectory, useCaseSensitiveFileNames) {
+        this.currentDirectory = currentDirectory;
+        this.useCaseSensitiveFileNames = useCaseSensitiveFileNames;
+    }
+    hasDirectory(symlinkPath) {
+        return this.directories.has(ensureTrailingDirectorySeparator(symlinkPath));
+    }
+    /** The symlinks to the real directory `realPath`, which has a trailing `/`. */
+    getSymlinksOfDirectory(realPath) {
+        return this.directoriesByRealpath.get(realPath);
+    }
+    setDirectory(symlink, symlinkPath, real) {
+        if (!this.directories.has(symlinkPath)) {
+            let symlinks = this.directoriesByRealpath.get(real.realPath);
+            if (symlinks === undefined) {
+                symlinks = new Set();
+                this.directoriesByRealpath.set(real.realPath, symlinks);
+            }
+            symlinks.add(symlink);
+        }
+        this.directories.set(symlinkPath, real);
+    }
+    /** Records the directory symlink a resolution through `originalPath` to `resolvedFileName` implies. */
+    processResolution(originalPath, resolvedFileName) {
+        if (originalPath === '' || resolvedFileName === '')
+            return;
+        let byResolved = this.implied.get(originalPath);
+        if (byResolved === undefined) {
+            byResolved = new Map();
+            this.implied.set(originalPath, byResolved);
+        }
+        let link = byResolved.get(resolvedFileName);
+        if (link === undefined) {
+            link = this.impliedDirectoryLink(originalPath, resolvedFileName);
+            byResolved.set(resolvedFileName, link);
+        }
+        if (link !== null)
+            this.setDirectory(link.symlink, link.symlinkPath, link.real);
+    }
+    impliedDirectoryLink(originalPath, resolvedFileName) {
+        const common = this.guessDirectorySymlink(resolvedFileName, originalPath);
+        if (common === undefined)
+            return null;
+        const symlinkPath = toPath(common.original, this.currentDirectory, this.useCaseSensitiveFileNames);
+        if (containsIgnoredPath(symlinkPath))
+            return null;
+        return new ImpliedDirectoryLink(common.original, ensureTrailingDirectorySeparator(symlinkPath), new KnownDirectoryLink(ensureTrailingDirectorySeparator(common.resolved), ensureTrailingDirectorySeparator(toPath(common.resolved, this.currentDirectory, this.useCaseSensitiveFileNames))));
+    }
+    /** The longest directories of `resolved` and `original` whose remaining paths are equal. */
+    guessDirectorySymlink(resolved, original) {
+        const a = getPathComponents(getNormalizedAbsolutePath(resolved, this.currentDirectory));
+        const b = getPathComponents(getNormalizedAbsolutePath(original, this.currentDirectory));
+        let aLength = a.length;
+        let bLength = b.length;
+        while (aLength >= 2 &&
+            bLength >= 2 &&
+            !this.isNodeModulesOrScopedPackageDirectory(a[aLength - 2]) &&
+            !this.isNodeModulesOrScopedPackageDirectory(b[bLength - 2]) &&
+            getCanonicalFileName(a[aLength - 1], this.useCaseSensitiveFileNames) ===
+                getCanonicalFileName(b[bLength - 1], this.useCaseSensitiveFileNames)) {
+            aLength--;
+            bLength--;
+        }
+        if (aLength === a.length)
+            return undefined;
+        return {
+            resolved: getPathFromPathComponents(a.slice(0, aLength)),
+            original: getPathFromPathComponents(b.slice(0, bLength)),
+        };
+    }
+    isNodeModulesOrScopedPackageDirectory(name) {
+        return (name !== '' &&
+            (getCanonicalFileName(name, this.useCaseSensitiveFileNames) === 'node_modules' || name.startsWith('@')));
+    }
+}
+/** Paths inside `node_modules/.*` (such as pnpm's store), `.git` or editor lock files. */
+export function containsIgnoredPath(path) {
+    return path.includes('/node_modules/.') || path.includes('/.git') || path.includes('.#');
+}