tsc-ts 0.0.10 → 0.1.1

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

@@ -18,10 +18,11 @@ export declare enum ScriptTarget {
     ES2023 = 10,
     ES2024 = 11,
     ES2025 = 12,
+    ES2026 = 13,
     ESNext = 99,
     JSON = 100,
     Latest = 99,
-    LatestStandard = 12
+    LatestStandard = 13
 }
 export declare enum ModuleKind {
     /** Not an option value: a resolution mode or implied format without a specific module kind. */
@@ -44,6 +45,10 @@ export declare enum ModuleKind {
     /** Emit imports and exports as written. */
     Preserve = 200
 }
+/** Whether `import defer` and `import.defer()` are allowed under a module kind. */
+export declare function supportsDeferredImports(moduleKind: ModuleKind): boolean;
+/** Whether `import source` and `import.source()` are allowed under a module kind. */
+export declare function supportsSourcePhaseImports(moduleKind: ModuleKind): boolean;
 export declare enum ModuleResolutionKind {
     /** @deprecated Accepted for parsing and validation only. */
     Classic = 1,
@@ -60,8 +65,8 @@ export declare enum ModuleDetectionKind {
 }
 export declare enum JsxEmit {
     Preserve = 1,
-    ReactNative = 2,
-    React = 3,
+    React = 2,
+    ReactNative = 3,
     ReactJSX = 4,
     ReactJSXDev = 5
 }
@@ -69,26 +74,6 @@ export declare enum NewLineKind {
     CRLF = 1,
     LF = 2
 }
-export declare enum WatchFileKind {
-    FixedPollingInterval = 1,
-    PriorityPollingInterval = 2,
-    DynamicPriorityPolling = 3,
-    FixedChunkSizePolling = 4,
-    UseFsEvents = 5,
-    UseFsEventsOnParentDirectory = 6
-}
-export declare enum WatchDirectoryKind {
-    UseFsEvents = 1,
-    FixedPollingInterval = 2,
-    DynamicPriorityPolling = 3,
-    FixedChunkSizePolling = 4
-}
-export declare enum PollingKind {
-    FixedInterval = 1,
-    PriorityInterval = 2,
-    DynamicPriority = 3,
-    FixedChunkSize = 4
-}
 /**
  * Compiler options, in tsgo's field order (which `--showConfig` follows).
  *
@@ -163,6 +148,8 @@ export interface CompilerOptions {
     outDir?: string;
     /** Substitutions are `undefined` where the config gave a non-array. */
     paths?: Map<string, string[] | undefined>;
+    /** Read only for `--showConfig`; plugins are not loaded. */
+    plugins?: PluginImport[];
     preserveConstEnums?: boolean;
     preserveSymlinks?: boolean;
     project?: string;
@@ -227,15 +214,6 @@ export interface CompilerOptions {
     quiet?: boolean;
     checkers?: number;
 }
-export interface WatchOptions {
-    watchInterval?: number;
-    watchFile?: WatchFileKind;
-    watchDirectory?: WatchDirectoryKind;
-    fallbackPolling?: PollingKind;
-    synchronousWatchDirectory?: boolean;
-    excludeDirectories?: string[];
-    excludeFiles?: string[];
-}
 export interface BuildOptions {
     dry?: boolean;
     force?: boolean;
@@ -258,6 +236,11 @@ export interface TypeAcquisition {
 export type OptionValue = boolean | number | string | string[] | null;
 /** A compiler option value as stored in `CompilerOptions`, except `paths`. */
 export type CompilerOptionValue = boolean | number | string | string[];
+/** An entry of `plugins`: its `name`, or `''` when it has no string name. */
+export declare class PluginImport {
+    readonly name: string;
+    constructor(name: string);
+}
 /** Compiler option names in field order. */
 export declare const compilerOptionNames: readonly string[];
 /** Sets compiler option `name` (a declaration name) from a parsed value. `null` and unknown names are ignored. */
@@ -268,7 +251,6 @@ export declare function setCompilerOption(options: CompilerOptions, name: string
  */
 export declare function mergeCompilerOptions(target: CompilerOptions, source: CompilerOptions, nulls: ReadonlySet<string> | undefined): CompilerOptions;
 export declare function getCompilerOption(options: CompilerOptions, name: string): CompilerOptionValue | undefined;
-export declare function setWatchOption(options: WatchOptions, name: string, value: OptionValue): void;
 export declare function setBuildOption(options: BuildOptions, name: string, value: OptionValue): void;
 export declare function setTypeAcquisitionOption(options: TypeAcquisition, name: string, value: OptionValue): void;
 export declare function getEmitScriptTarget(options: CompilerOptions): ScriptTarget;

package/dist/api/compiler/options.js

@@ -19,10 +19,11 @@ export var ScriptTarget;
     ScriptTarget[ScriptTarget["ES2023"] = 10] = "ES2023";
     ScriptTarget[ScriptTarget["ES2024"] = 11] = "ES2024";
     ScriptTarget[ScriptTarget["ES2025"] = 12] = "ES2025";
+    ScriptTarget[ScriptTarget["ES2026"] = 13] = "ES2026";
     ScriptTarget[ScriptTarget["ESNext"] = 99] = "ESNext";
     ScriptTarget[ScriptTarget["JSON"] = 100] = "JSON";
     ScriptTarget[ScriptTarget["Latest"] = 99] = "Latest";
-    ScriptTarget[ScriptTarget["LatestStandard"] = 12] = "LatestStandard";
+    ScriptTarget[ScriptTarget["LatestStandard"] = 13] = "LatestStandard";
 })(ScriptTarget || (ScriptTarget = {}));
 export var ModuleKind;
 (function (ModuleKind) {
@@ -47,6 +48,14 @@ export var ModuleKind;
     /** Emit imports and exports as written. */
     ModuleKind[ModuleKind["Preserve"] = 200] = "Preserve";
 })(ModuleKind || (ModuleKind = {}));
+/** Whether `import defer` and `import.defer()` are allowed under a module kind. */
+export function supportsDeferredImports(moduleKind) {
+    return moduleKind === ModuleKind.ESNext || moduleKind === ModuleKind.Preserve;
+}
+/** Whether `import source` and `import.source()` are allowed under a module kind. */
+export function supportsSourcePhaseImports(moduleKind) {
+    return moduleKind === ModuleKind.ESNext || moduleKind === ModuleKind.NodeNext || moduleKind === ModuleKind.Preserve;
+}
 export var ModuleResolutionKind;
 (function (ModuleResolutionKind) {
     /** @deprecated Accepted for parsing and validation only. */
@@ -66,8 +75,8 @@ export var ModuleDetectionKind;
 export var JsxEmit;
 (function (JsxEmit) {
     JsxEmit[JsxEmit["Preserve"] = 1] = "Preserve";
-    JsxEmit[JsxEmit["ReactNative"] = 2] = "ReactNative";
-    JsxEmit[JsxEmit["React"] = 3] = "React";
+    JsxEmit[JsxEmit["React"] = 2] = "React";
+    JsxEmit[JsxEmit["ReactNative"] = 3] = "ReactNative";
     JsxEmit[JsxEmit["ReactJSX"] = 4] = "ReactJSX";
     JsxEmit[JsxEmit["ReactJSXDev"] = 5] = "ReactJSXDev";
 })(JsxEmit || (JsxEmit = {}));
@@ -76,29 +85,13 @@ export var NewLineKind;
     NewLineKind[NewLineKind["CRLF"] = 1] = "CRLF";
     NewLineKind[NewLineKind["LF"] = 2] = "LF";
 })(NewLineKind || (NewLineKind = {}));
-export var WatchFileKind;
-(function (WatchFileKind) {
-    WatchFileKind[WatchFileKind["FixedPollingInterval"] = 1] = "FixedPollingInterval";
-    WatchFileKind[WatchFileKind["PriorityPollingInterval"] = 2] = "PriorityPollingInterval";
-    WatchFileKind[WatchFileKind["DynamicPriorityPolling"] = 3] = "DynamicPriorityPolling";
-    WatchFileKind[WatchFileKind["FixedChunkSizePolling"] = 4] = "FixedChunkSizePolling";
-    WatchFileKind[WatchFileKind["UseFsEvents"] = 5] = "UseFsEvents";
-    WatchFileKind[WatchFileKind["UseFsEventsOnParentDirectory"] = 6] = "UseFsEventsOnParentDirectory";
-})(WatchFileKind || (WatchFileKind = {}));
-export var WatchDirectoryKind;
-(function (WatchDirectoryKind) {
-    WatchDirectoryKind[WatchDirectoryKind["UseFsEvents"] = 1] = "UseFsEvents";
-    WatchDirectoryKind[WatchDirectoryKind["FixedPollingInterval"] = 2] = "FixedPollingInterval";
-    WatchDirectoryKind[WatchDirectoryKind["DynamicPriorityPolling"] = 3] = "DynamicPriorityPolling";
-    WatchDirectoryKind[WatchDirectoryKind["FixedChunkSizePolling"] = 4] = "FixedChunkSizePolling";
-})(WatchDirectoryKind || (WatchDirectoryKind = {}));
-export var PollingKind;
-(function (PollingKind) {
-    PollingKind[PollingKind["FixedInterval"] = 1] = "FixedInterval";
-    PollingKind[PollingKind["PriorityInterval"] = 2] = "PriorityInterval";
-    PollingKind[PollingKind["DynamicPriority"] = 3] = "DynamicPriority";
-    PollingKind[PollingKind["FixedChunkSize"] = 4] = "FixedChunkSize";
-})(PollingKind || (PollingKind = {}));
+/** An entry of `plugins`: its `name`, or `''` when it has no string name. */
+export class PluginImport {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
 /** Compiler option names in field order. */
 export const compilerOptionNames = [
     'allowJs',
@@ -168,6 +161,7 @@ export const compilerOptionNames = [
     'noUncheckedSideEffectImports',
     'outDir',
     'paths',
+    'plugins',
     'preserveConstEnums',
     'preserveSymlinks',
     'project',
@@ -707,6 +701,7 @@ export function mergeCompilerOptions(target, source, nulls) {
     target.noUncheckedSideEffectImports = merged(source.noUncheckedSideEffectImports, target.noUncheckedSideEffectImports, nulls, 'noUncheckedSideEffectImports');
     target.outDir = merged(source.outDir, target.outDir, nulls, 'outDir');
     target.paths = merged(source.paths, target.paths, nulls, 'paths');
+    target.plugins = merged(source.plugins, target.plugins, nulls, 'plugins');
     target.preserveConstEnums = merged(source.preserveConstEnums, target.preserveConstEnums, nulls, 'preserveConstEnums');
     target.preserveSymlinks = merged(source.preserveSymlinks, target.preserveSymlinks, nulls, 'preserveSymlinks');
     target.project = merged(source.project, target.project, nulls, 'project');
@@ -1040,34 +1035,6 @@ export function getCompilerOption(options, name) {
     }
     return undefined;
 }
-export function setWatchOption(options, name, value) {
-    switch (name) {
-        case 'watchInterval':
-            options.watchInterval = numberValue(value);
-            break;
-        case 'watchFile':
-            if (value !== null)
-                options.watchFile = numberValue(value);
-            break;
-        case 'watchDirectory':
-            if (value !== null)
-                options.watchDirectory = numberValue(value);
-            break;
-        case 'fallbackPolling':
-            if (value !== null)
-                options.fallbackPolling = numberValue(value);
-            break;
-        case 'synchronousWatchDirectory':
-            options.synchronousWatchDirectory = value === null ? undefined : value === true;
-            break;
-        case 'excludeDirectories':
-            options.excludeDirectories = stringList(value);
-            break;
-        case 'excludeFiles':
-            options.excludeFiles = stringList(value);
-            break;
-    }
-}
 export function setBuildOption(options, name, value) {
     if (value === null)
         return;

package/dist/api/compiler/output-paths.d.ts

@@ -28,7 +28,10 @@ export declare function getOutputJSFileName(inputFileName: string, options: Comp
 export declare function getOutputJSFileNameWorker(inputFileName: string, options: CompilerOptions, host: OutputPathsHost): string;
 /** The declaration output of `inputFileName`. */
 export declare function getOutputDeclarationFileNameWorker(inputFileName: string, options: CompilerOptions, host: OutputPathsHost): string;
-/** Like `getSourceFilePathInNewDir`, but with a case-folded prefix check. */
+/**
+ * `fileName` moved from `commonSourceDirectory` to `newDirectory`. The prefix check is case-folded when file names
+ * are case-insensitive; case folding keeps each code point's length, so the prefix is removed by its own length.
+ */
 export declare function getSourceFilePathInNewDirWorker(fileName: string, newDirectory: string, currentDirectory: string, commonSourceDirectory: string, useCaseSensitiveFileNames: boolean): string;
 export declare function getSourceMapFilePath(jsFilePath: string, options: CompilerOptions): string;
 /** The `.tsbuildinfo` file of an incremental build, or `''`. */

package/dist/api/compiler/output-paths.js

@@ -1,4 +1,4 @@
-import { changeExtension, combinePaths, comparePaths, containsPath, ensureTrailingDirectorySeparator, fileExtensionIs, fileExtensionIsOneOf, getAnyExtensionFromPath, getBaseFileName, getCanonicalFileName, getDirectoryPath, getNormalizedAbsolutePath, getPathComponents, getPathComponentsRelativeTo, getPathFromPathComponents, reducePathComponents, removeFileExtension, resolvePath, } from './path.js';
+import { changeExtension, combinePaths, comparePaths, ensureTrailingDirectorySeparator, fileExtensionIs, fileExtensionIsOneOf, getAnyExtensionFromPath, getBaseFileName, getCanonicalFileName, getDirectoryPath, getNormalizedAbsolutePath, getPathComponents, getPathComponentsRelativeTo, getPathFromPathComponents, reducePathComponents, removeFileExtension, resolvePath, } from './path.js';
 /** The files emitted for one source file; `''` for those not emitted. */
 export class OutputPaths {
     jsFilePath;
@@ -96,15 +96,10 @@ function getDeclarationEmitOutputFilePath(file, options, host) {
         : getSourceFilePathInNewDirWorker(file, outputDirectory, host.currentDirectory, host.commonSourceDirectory(), host.useCaseSensitiveFileNames);
     return removeFileExtension(path) + getDeclarationEmitExtensionForPath(path);
 }
-function getSourceFilePathInNewDir(fileName, newDirectory, currentDirectory, commonSourceDirectory, useCaseSensitiveFileNames) {
-    let sourceFilePath = getNormalizedAbsolutePath(fileName, currentDirectory);
-    const common = ensureTrailingDirectorySeparator(commonSourceDirectory);
-    if (containsPath(common, sourceFilePath, useCaseSensitiveFileNames, currentDirectory)) {
-        sourceFilePath = sourceFilePath.slice(common.length);
-    }
-    return combinePaths(newDirectory, sourceFilePath);
-}
-/** Like `getSourceFilePathInNewDir`, but with a case-folded prefix check. */
+/**
+ * `fileName` moved from `commonSourceDirectory` to `newDirectory`. The prefix check is case-folded when file names
+ * are case-insensitive; case folding keeps each code point's length, so the prefix is removed by its own length.
+ */
 export function getSourceFilePathInNewDirWorker(fileName, newDirectory, currentDirectory, commonSourceDirectory, useCaseSensitiveFileNames) {
     let sourceFilePath = getNormalizedAbsolutePath(fileName, currentDirectory);
     const common = getCanonicalFileName(commonSourceDirectory, useCaseSensitiveFileNames);
@@ -116,7 +111,7 @@ export function getSourceFilePathInNewDirWorker(fileName, newDirectory, currentD
 function getOwnEmitOutputFilePath(fileName, options, host, extension) {
     const withoutExtension = options.outDir === undefined
         ? removeFileExtension(fileName)
-        : removeFileExtension(getSourceFilePathInNewDir(fileName, options.outDir, host.currentDirectory, host.commonSourceDirectory(), host.useCaseSensitiveFileNames));
+        : removeFileExtension(getSourceFilePathInNewDirWorker(fileName, options.outDir, host.currentDirectory, host.commonSourceDirectory(), host.useCaseSensitiveFileNames));
     return withoutExtension + extension;
 }
 export function getSourceMapFilePath(jsFilePath, options) {

package/dist/api/compiler/package-json.d.ts

@@ -5,8 +5,8 @@
  * "Expected type of 'main' field in 'package.json' to be 'string', got 'number'".
  */
 import { type MessageWithArgs } from './diagnostics.js';
-export declare const typeScriptVersion = "7.0.2";
-export declare const typeScriptVersionMajorMinor = "7.0";
+export declare const typeScriptVersion = "7.1.0-beta";
+export declare const typeScriptVersionMajorMinor = "7.1";
 export type JsonType = 'null' | 'boolean' | 'number' | 'string' | 'array' | 'object';
 /** How an object in `exports` or `imports` is interpreted, from the first character of its keys. */
 export declare const enum JsonObjectKind {
@@ -143,7 +143,7 @@ export declare class PackageJsonInfoCache {
     constructor(currentDirectory: string, useCaseSensitiveFileNames: boolean);
     /**
      * Called before the cache is shared with other threads, which makes it immutable: from then on,
-     * each thread keeps the lookups it adds in a table of its own.
+     * each thread keeps the lookups it adds in a table of its own. A cache already shared is immutable.
      */
     prepareForSharing(): void;
     get(packageJsonPath: string): PackageJsonInfo | undefined;

package/dist/api/compiler/package-json.js

@@ -6,8 +6,8 @@
  */
 import { messageWithArgs } from './diagnostics.js';
 import { toPath } from './path.js';
-export const typeScriptVersion = '7.0.2';
-export const typeScriptVersionMajorMinor = '7.0';
+export const typeScriptVersion = '7.1.0-beta';
+export const typeScriptVersionMajorMinor = '7.1';
 const JSON_NULL = { type: 'null' };
 const JSON_TRUE = { type: 'boolean', value: true };
 const JSON_FALSE = { type: 'boolean', value: false };
@@ -414,30 +414,30 @@ export class PackageJson {
         const traces = this.versionTraces;
         const typesVersions = this.typesVersions;
         if (typesVersions === undefined) {
-            traces.push(messageWithArgs(1269 /* Diagnostics.X_package_json_does_not_have_a_0_field */, 'typesVersions'));
+            traces.push(messageWithArgs(1280 /* Diagnostics.X_package_json_does_not_have_a_0_field */, 'typesVersions'));
             return undefined;
         }
         if (typesVersions.type !== 'object') {
-            traces.push(messageWithArgs(1273 /* Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2 */, 'typesVersions', 'object', typesVersions.type));
+            traces.push(messageWithArgs(1284 /* Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2 */, 'typesVersions', 'object', typesVersions.type));
             return undefined;
         }
-        traces.push(messageWithArgs(1359 /* Diagnostics.X_package_json_has_a_typesVersions_field_with_version_specific_path_mappings */, 'typesVersions'));
+        traces.push(messageWithArgs(1370 /* Diagnostics.X_package_json_has_a_typesVersions_field_with_version_specific_path_mappings */, 'typesVersions'));
         for (const [key, value] of typesVersions.entries) {
             const range = parseVersionRange(key);
             if (range === undefined) {
-                traces.push(messageWithArgs(1362 /* Diagnostics.X_package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range */, key));
+                traces.push(messageWithArgs(1373 /* Diagnostics.X_package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range */, key));
                 continue;
             }
             if (!versionRangeMatches(range, TYPESCRIPT_VERSION))
                 continue;
             if (value.type !== 'object') {
-                traces.push(messageWithArgs(1273 /* Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2 */, "typesVersions['" + key + "']", 'object', value.type));
+                traces.push(messageWithArgs(1284 /* Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2 */, "typesVersions['" + key + "']", 'object', value.type));
                 return undefined;
             }
             // An empty key matches every version but, as in tsgo, yields no paths.
             return key === '' ? undefined : { version: key, paths: versionPathsFromJson(value) };
         }
-        traces.push(messageWithArgs(1360 /* Diagnostics.X_package_json_does_not_have_a_typesVersions_entry_that_matches_version_0 */, typeScriptVersionMajorMinor));
+        traces.push(messageWithArgs(1371 /* Diagnostics.X_package_json_does_not_have_a_typesVersions_entry_that_matches_version_0 */, typeScriptVersionMajorMinor));
         return undefined;
     }
 }
@@ -616,10 +616,11 @@ export class PackageJsonInfoCache {
     }
     /**
      * Called before the cache is shared with other threads, which makes it immutable: from then on,
-     * each thread keeps the lookups it adds in a table of its own.
+     * each thread keeps the lookups it adds in a table of its own. A cache already shared is immutable.
      */
     prepareForSharing() {
-        this.shared = true;
+        if (!this.shared)
+            this.shared = true;
     }
     get(packageJsonPath) {
         return this.lookup(toPath(packageJsonPath, this.currentDirectory, this.useCaseSensitiveFileNames));

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

@@ -1,4 +1,5 @@
 import { Block, CaseBlock, CatchClause, ExternalModuleIndicatorOptions, Identifier, ImportAttributes, ImportClause, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxOpeningElement, ModifierList, Node, NodeFlags, NodeList, ObjectLiteralExpression, ParseOptions, ScriptKind, SourceFile, TemplateHead, TemplateLiteralTypeSpan, TemplateSpan, ThisTypeNode, Token, Tristate, TypeParameterDeclaration, VariableDeclaration, VariableDeclarationList, type EntityName, type Expression, type Statement, type TypeNode } from './ast.js';
+import { IdentifierName } from './identifier-name.js';
 import { OperatorPrecedence } from './ast-utilities.js';
 import { Diagnostic, type DiagnosticMessage } from './diagnostics.js';
 import { JSDocParser } from './jsdoc.js';
@@ -46,22 +47,26 @@ declare const enum ListElement {
     ObjectBindingElement = 6,
     ClassElement = 7,
     HeritageClause = 8,
-    ExpressionWithTypeArguments = 9,
-    EnumMember = 10,
-    ImportSpecifier = 11,
-    ExportSpecifier = 12,
-    Type = 13,
-    ImportAttribute = 14,
-    TypeMember = 15,
-    TypeParameter = 16,
-    Parameter = 17,
+    /** A heritage clause of an interface declaration. */
+    InterfaceHeritageClause = 9,
+    ExpressionWithTypeArguments = 10,
+    /** An element of a type heritage clause: `implements` of a class, `extends` of an interface. */
+    TypeHeritageClauseElement = 11,
+    EnumMember = 12,
+    ImportSpecifier = 13,
+    ExportSpecifier = 14,
+    Type = 15,
+    ImportAttribute = 16,
+    TypeMember = 17,
+    TypeParameter = 18,
+    Parameter = 19,
     /** A parameter of a signature, using `signatureParameter*` state. */
-    SignatureParameter = 18,
-    TupleElement = 19,
-    JsxAttribute = 20,
-    ArgumentExpression = 21,
-    ArrayLiteralElement = 22,
-    ObjectLiteralElement = 23
+    SignatureParameter = 20,
+    TupleElement = 21,
+    JsxAttribute = 22,
+    ArgumentExpression = 23,
+    ArrayLiteralElement = 24,
+    ObjectLiteralElement = 25
 }
 export declare const enum ParseFlags {
     None = 0,
@@ -286,8 +291,13 @@ export declare class Parser extends ScannerErrorReporter {
     parseClassDeclarationOrExpression(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined, kind: SyntaxKind): Node;
     parseNameOfClassDeclarationOrExpression(): Identifier | undefined;
     isImplementsClause(): boolean;
-    parseHeritageClauses(): NodeList | undefined;
-    parseHeritageClause(): Node;
+    parseHeritageClauses(isInterface: boolean): NodeList | undefined;
+    parseHeritageClause(isInterface: boolean): Node;
+    /** A type reference when the element is an entity name with optional type arguments, otherwise the
+     * `ExpressionWithTypeArguments`, which the checker reports. */
+    parseTypeHeritageClauseElement(): Node;
+    /** The `QualifiedName` chain for an identifier or a chain of property accesses, spanning the same text. */
+    convertEntityNameExpressionToEntityName(node: Node): Node;
     parseExpressionWithTypeArguments(): Node;
     parseClassElement(): Node;
     parseClassStaticBlockDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Node;
@@ -309,6 +319,11 @@ export declare class Parser extends ScannerErrorReporter {
     parseModuleOrNamespaceDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined, nested: boolean, keyword: SyntaxKind): Node;
     parseImportDeclarationOrImportEqualsDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
     tokenAfterImportDefinitelyProducesImportDeclaration(): boolean;
+    /** In `import defer ___` or `import source ___`, whether `defer` or `source` is a phase modifier rather than the
+     * default import's name. */
+    shouldParseImportPhaseModifier(): boolean;
+    /** The phase modifier the current token's text spells, written without escapes, or `Unknown`. */
+    currentImportPhaseModifier(): SyntaxKind;
     /** In `import id ___`, whether the token makes this an ImportDeclaration rather than ImportEqualsDeclaration. */
     tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration(): boolean;
     parseImportEqualsDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined, identifier: Identifier, isTypeOnly: boolean): Node;
@@ -357,8 +372,11 @@ export declare class Parser extends ScannerErrorReporter {
     parseLiteralTypeNode(negative: boolean): TypeNode;
     parseTypeReference(): TypeNode;
     parseEntityNameOfTypeReference(): EntityName;
-    /** An entity name; `use` is for its first identifier, the qualified names' right sides are names. */
-    parseEntityName(allowReservedWords: boolean, diagnosticMessage: DiagnosticMessage | undefined, use?: IdentifierUse): EntityName;
+    /**
+     * An entity name; `use` is for its first identifier, the qualified names' right sides are names.
+     * Only a type query allows private names on the right (`typeof this.#x`).
+     */
+    parseEntityName(allowReservedWords: boolean, allowPrivateName: boolean, diagnosticMessage: DiagnosticMessage | undefined, use?: IdentifierUse): EntityName;
     parseRightSideOfDot(allowIdentifierNames: boolean, allowPrivateIdentifiers: boolean, allowUnicodeEscapeSequenceInIdentifierName: boolean): Node;
     /** `parseRightSideOfDot` without private identifiers. */
     parseRightSideOfDotIdentifier(allowIdentifierNames: boolean, allowUnicodeEscapeSequenceInIdentifierName: boolean): Identifier;
@@ -368,7 +386,7 @@ export declare class Parser extends ScannerErrorReporter {
      * A new identifier of the class `use` calls for. Callers create it after the identifier's token, so
      * for an element name the current token tells a shorthand property from an assignment or a method.
      */
-    newIdentifier(text: string, use?: IdentifierUse): Identifier;
+    newIdentifier(name: IdentifierName, use?: IdentifierUse): Identifier;
     /** Whether the current token ends an object literal element name that is not a shorthand property. */
     isElementNameEnd(): boolean;
     createMissingIdentifier(use?: IdentifierUse): Identifier;
@@ -503,6 +521,8 @@ export declare class Parser extends ScannerErrorReporter {
     parseAwaitExpression(): Expression;
     parseTypeAssertion(): Expression;
     parseLeftHandSideExpressionOrHigher(): Expression;
+    /** The name after `import.`; `defer` and `source` written with escapes are reported. */
+    parseImportMetaPropertyName(): Identifier;
     parseSuperExpression(): Expression;
     isTemplateStartOfTaggedTemplate(): boolean;
     tryParseTypeArgumentsInExpression(): NodeList | undefined;
@@ -608,4 +628,6 @@ export declare function forgetLazyJSDocFile(): void;
 export declare function getNodeAtPosition(file: SourceFile, position: number, includeJSDoc: boolean): Node;
 /** Whether `moduleName` names a Node.js core module, with or without the `node:` prefix. */
 export declare function isNodeCoreModule(moduleName: string): boolean;
+export declare const unprefixedNodeCoreModules: Set<string>;
+export declare const exclusivelyPrefixedNodeCoreModules: Set<string>;
 export {};