tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/transformers/visitor-hooks.js

@@ -127,8 +127,12 @@ export class VisitorHooks {
         const factory = this.factory;
         if (updated === undefined)
             return factory.createBlock(declarations, true);
-        if (!(updated instanceof Block))
-            return factory.createBlock(this.context.mergeEnvironment([factory.createReturnStatement(updated)], declarations), false);
+        if (!(updated instanceof Block)) {
+            // The return statement takes the expression's range, so its comments are emitted once, before `return`.
+            this.context.addEmitFlags(updated, 384 /* EmitFlags.NoComments */);
+            const block = this.context.convertToFunctionBlock(updated, false);
+            return factory.updateBlock(block, this.context.mergeEnvironmentList(block.statements, declarations), block.multiLine);
+        }
         return factory.updateBlock(updated, this.context.mergeEnvironmentList(updated.statements, declarations), updated.multiLine);
     }
     visitTopLevelStatements(list) {

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

@@ -84,6 +84,11 @@ export declare class ParsedCommandLine implements OutputPathsHost {
     private outputDtsToReference;
     private commonSourceDirectoryValue;
     private referencePaths;
+    /**
+     * The config file's JSON, with what the configs it extends add to `files`, `include`, `exclude` and
+     * `compileOnSave`; `undefined` without a config file.
+     */
+    raw: JsonValue | undefined;
     constructor(options: CompilerOptions, typeAcquisition: TypeAcquisition | undefined, fileNames: readonly string[], projectReferences: readonly ProjectReference[], configFile: TsConfigSourceFile | undefined, errors: Diagnostic[], 
     /** The config's directory, or the current directory without a config. */
     currentDirectory: string, useCaseSensitiveFileNames: boolean, 
@@ -130,8 +135,11 @@ export declare function findTsConfigArrayElement(file: SourceFile | undefined, k
 export declare function findArrayElement(property: PropertyAssignment | undefined, value: string): StringLiteral | undefined;
 /** The text of a property name, or `undefined` for computed names that aren't literals. */
 export declare function propertyNameText(name: Node): string | undefined;
-/** Rejects specs ending in `**` (for `include`) and `..` after a `**`. */
-export declare function specToDiagnostic(spec: string, disallowTrailingRecursion: boolean): DiagnosticMessage | undefined;
+/**
+ * Rejects specs that resolve to a network root (`basePath` given), specs ending in `**` (for `include`) and `..`
+ * after a `**`. `?` is a wildcard in specs, so only UNC and device roots name a network path there.
+ */
+export declare function specToDiagnostic(spec: string, disallowTrailingRecursion: boolean, basePath?: string): DiagnosticMessage | undefined;
 /** Names of options given as `null` on the command line. */
 export declare function nullKeysOfCommandLine(raw: ReadonlyMap<string, OptionValue> | undefined): Set<string> | undefined;
 /** Reads config files with a file system, sharing parsed `extends` targets. */

package/dist/api/compiler/tsconfig.js

@@ -11,11 +11,11 @@ import { enumNamesList } from './command-line.js';
 import { compareCodePoints, createCompilerDiagnostic, Diagnostic, } from './diagnostics.js';
 import { isValidLocale } from './locale.js';
 import { ModuleResolutionHost, resolveConfig } from './module-resolution.js';
-import { compilerOptionsByName, OptionNameMap, typeAcquisitionDeclarations, } from './option-declarations.js';
-import { getAllowJS, getResolveJsonModule, mergeCompilerOptions, setCompilerOption, setTypeAcquisitionOption, } from './options.js';
+import { compilerOptionsByName, OptionNameMap, optionsForCompiler, typeAcquisitionDeclarations, } from './option-declarations.js';
+import { getAllowJS, getResolveJsonModule, mergeCompilerOptions, PluginImport, setCompilerOption, setTypeAcquisitionOption, } from './options.js';
 import { getBuildInfoFileName, getCommonSourceDirectory, getOutputDeclarationFileName, } from './output-paths.js';
 import { parseSourceFile } from './parser.js';
-import { changeExtension, combinePaths, containsPath, fileExtensionIs, fileExtensionIsOneOf, getBaseFileName, getCanonicalFileName, getDirectoryPath, getNormalizedAbsolutePath, getPathComponentsRelativeTo, getPathFromPathComponents, hasJSFileExtension, isDeclarationFileName, isRootedDiskPath, normalizePath, normalizeSlashes, toPath, } from './path.js';
+import { changeExtension, combinePaths, containsPath, fileExtensionIs, fileExtensionIsOneOf, getBaseFileName, getCanonicalFileName, getDirectoryPath, getNormalizedAbsolutePath, getPathComponentsRelativeTo, getPathFromPathComponents, hasJSFileExtension, isDeclarationFileName, isNetworkPathValue, isRootedDiskPath, normalizePath, normalizeSlashes, toPath, } from './path.js';
 import { skipTrivia } from './scanner.js';
 import { hasExtension, readDirectory, SpecMatcher, unlimitedDepth } from './vfs-match.js';
 export class JsonArray {
@@ -161,6 +161,11 @@ export class ParsedCommandLine {
     outputDtsToReference = undefined;
     commonSourceDirectoryValue = undefined;
     referencePaths = undefined;
+    /**
+     * The config file's JSON, with what the configs it extends add to `files`, `include`, `exclude` and
+     * `compileOnSave`; `undefined` without a config file.
+     */
+    raw = undefined;
     constructor(options, typeAcquisition, fileNames, projectReferences, configFile, errors, 
     /** The config's directory, or the current directory without a config. */
     currentDirectory, useCaseSensitiveFileNames, 
@@ -233,7 +238,7 @@ export class ParsedCommandLine {
             if (containsPath(root, file, this.useCaseSensitiveFileNames, this.currentDirectory))
                 continue;
             const absolute = getCanonicalFileName(getNormalizedAbsolutePath(file, this.currentDirectory), this.useCaseSensitiveFileNames);
-            this.errors.push(createCompilerDiagnostic(1234 /* Diagnostics.File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files */, absolute, root));
+            this.errors.push(createCompilerDiagnostic(1245 /* Diagnostics.File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files */, absolute, root));
         }
     }
     /** Maps each source of this project to its declaration output and back. */
@@ -313,15 +318,15 @@ function elementOptions(option) {
 }
 function unknownKeyMessage(parent) {
     if (parent === compilerOptionsDeclaration)
-        return 1121 /* Diagnostics.Unknown_compiler_option_0 */;
+        return 1128 /* Diagnostics.Unknown_compiler_option_0 */;
     if (parent === typeAcquisitionDeclaration)
-        return 1813 /* Diagnostics.Unknown_type_acquisition_option_0 */;
+        return 1833 /* Diagnostics.Unknown_type_acquisition_option_0 */;
     return undefined;
 }
 function unknownKeyDidYouMeanMessage(parent) {
     return parent === compilerOptionsDeclaration
-        ? 1123 /* Diagnostics.Unknown_compiler_option_0_Did_you_mean_1 */
-        : 1821 /* Diagnostics.Unknown_type_acquisition_option_0_Did_you_mean_1 */;
+        ? 1130 /* Diagnostics.Unknown_compiler_option_0_Did_you_mean_1 */
+        : 1841 /* Diagnostics.Unknown_type_acquisition_option_0_Did_you_mean_1 */;
 }
 function valueTypeName(option) {
     if (option.kind === 'list')
@@ -365,6 +370,29 @@ export function findPropertyAssignment(object, key, key2 = '') {
     }
     return undefined;
 }
+/**
+ * A diagnostic at property `propertyName` of the `index`th project reference: at its value, else at the
+ * reference, else a compiler diagnostic. As in tsgo, `index` counts the references the JSON value kept.
+ */
+function diagnosticAtProjectReferenceProperty(file, index, propertyName, message, ...args) {
+    let node;
+    const root = getTsConfigObjectLiteral(file);
+    if (root !== undefined)
+        for (const property of root.properties.nodes) {
+            if (!(property instanceof PropertyAssignment) || propertyNameText(property.name) !== 'references')
+                continue;
+            const initializer = property.initializer;
+            if (!(initializer instanceof ArrayLiteralExpression))
+                continue;
+            const elements = initializer.elements.nodes;
+            if (index >= elements.length || !(elements[index] instanceof ObjectLiteralExpression))
+                continue;
+            const element = elements[index];
+            node = findPropertyAssignment(element, propertyName)?.initializer ?? element;
+            break;
+        }
+    return diagnosticAtNode(file, node, message, ...args);
+}
 /** The string literal `value` in the array of the root property `key`. */
 export function findTsConfigArrayElement(file, key, value) {
     return findArrayElement(findPropertyAssignment(getTsConfigObjectLiteral(file), key), value);
@@ -402,12 +430,17 @@ export function propertyNameText(name) {
     return undefined;
 }
 // ---- Spec validation
-/** Rejects specs ending in `**` (for `include`) and `..` after a `**`. */
-export function specToDiagnostic(spec, disallowTrailingRecursion) {
+/**
+ * Rejects specs that resolve to a network root (`basePath` given), specs ending in `**` (for `include`) and `..`
+ * after a `**`. `?` is a wildcard in specs, so only UNC and device roots name a network path there.
+ */
+export function specToDiagnostic(spec, disallowTrailingRecursion, basePath) {
+    if (basePath !== undefined && getNormalizedAbsolutePath(spec, basePath).startsWith('//'))
+        return 1195 /* Diagnostics.Network_path_0_is_not_supported */;
     if (disallowTrailingRecursion) {
         const trimmed = spec.endsWith('/') ? spec.slice(0, -1) : spec;
         if (trimmed === '**' || trimmed.endsWith('/**')) {
-            return 1118 /* Diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0 */;
+            return 1125 /* Diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0 */;
         }
     }
     const wildcard = spec.startsWith('**/') ? 0 : spec.indexOf('/**/');
@@ -415,15 +448,15 @@ export function specToDiagnostic(spec, disallowTrailingRecursion) {
         return undefined;
     const lastDotDot = spec.endsWith('/..') ? spec.length : spec.lastIndexOf('/../');
     return lastDotDot > wildcard
-        ? 1140 /* Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0 */
+        ? 1147 /* Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0 */
         : undefined;
 }
-function validateSpecs(specs, disallowTrailingRecursion, file, key, errors) {
+function validateSpecs(specs, disallowTrailingRecursion, basePath, file, key, errors) {
     const result = [];
     for (const spec of specs) {
         if (typeof spec !== 'string')
             continue;
-        const message = specToDiagnostic(spec, disallowTrailingRecursion);
+        const message = specToDiagnostic(spec, disallowTrailingRecursion, basePath);
         if (message === undefined)
             result.push(spec);
         else
@@ -675,6 +708,8 @@ class ConfigFileConverter {
     options;
     typeAcquisition = {};
     extendedConfigPaths = undefined;
+    /** Names of compiler options written at the root instead of in `compilerOptions`. */
+    rootCompilerOptions = [];
     constructor(parser, file, basePath, configFileName, errors) {
         this.parser = parser;
         this.file = file;
@@ -707,7 +742,7 @@ class ConfigFileConverter {
                 }
             }
             const name = getBaseFileName(this.file.fileName) === 'jsconfig.json' ? 'jsconfig.json' : 'tsconfig.json';
-            this.errors.push(createCompilerDiagnostic(1166 /* Diagnostics.The_root_value_of_a_0_file_must_be_an_object */, name));
+            this.errors.push(diagnosticAtNode(this.file, root, 1173 /* Diagnostics.The_root_value_of_a_0_file_must_be_an_object */, name));
             return new JsonObject();
         }
         return this.convertObject(root, rootDeclaration);
@@ -728,24 +763,24 @@ class ConfigFileConverter {
                 if (expression instanceof NumericLiteral)
                     return Number(expression.text);
                 break;
-            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            case 226 /* SyntaxKind.PrefixUnaryExpression */:
                 if (expression instanceof PrefixUnaryExpression &&
                     expression.operator === 40 /* SyntaxKind.MinusToken */ &&
                     expression.operand instanceof NumericLiteral) {
                     return -Number(expression.operand.text);
                 }
                 break;
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            case 212 /* SyntaxKind.ObjectLiteralExpression */:
                 if (expression instanceof ObjectLiteralExpression)
                     return this.convertObject(expression, option);
                 break;
-            case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            case 211 /* SyntaxKind.ArrayLiteralExpression */:
                 if (expression instanceof ArrayLiteralExpression)
                     return this.convertArray(expression, option);
                 break;
         }
         this.errors.push(option !== undefined
-            ? diagnosticAtRange(this.file, expression, 1122 /* Diagnostics.Compiler_option_0_requires_a_value_of_type_1 */, option.name, valueTypeName(option))
+            ? diagnosticAtRange(this.file, expression, 1129 /* Diagnostics.Compiler_option_0_requires_a_value_of_type_1 */, option.name, valueTypeName(option))
             : diagnosticAtRange(this.file, expression, 264 /* Diagnostics.Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal */));
         return null;
     }
@@ -769,7 +804,7 @@ class ConfigFileConverter {
             }
             const postfix = propertyAssignmentPostfixToken(element);
             if (postfix !== undefined && postfix.kind === 57 /* SyntaxKind.QuestionToken */) {
-                this.errors.push(diagnosticAtRange(this.file, postfix, 1741 /* Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files */, '?'));
+                this.errors.push(diagnosticAtRange(this.file, postfix, 1761 /* Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files */, '?'));
             }
             const key = propertyNameText(element.name) ?? '';
             let option = key !== '' && known !== undefined ? known.get(key) : undefined;
@@ -810,8 +845,14 @@ class ConfigFileConverter {
             if (option === extendsDeclaration) {
                 this.extendedConfigPaths = this.parser.getExtendsConfigPaths(value, this.basePath, this.configFileName, property, property.initializer, this.file, this.errors);
             }
-            else if (option === undefined && key === 'excludes') {
-                this.errors.push(diagnosticAtNode(this.file, property.name, 1282 /* Diagnostics.Unknown_option_excludes_Did_you_mean_exclude */));
+            else if (option === undefined) {
+                if (key === 'excludes')
+                    this.errors.push(diagnosticAtNode(this.file, property.name, 1293 /* Diagnostics.Unknown_option_excludes_Did_you_mean_exclude */));
+                for (const compilerOption of optionsForCompiler)
+                    if (compilerOption.name === key) {
+                        this.rootCompilerOptions.push(property.name);
+                        break;
+                    }
             }
         }
     }
@@ -826,6 +867,15 @@ function setCompilerOptionFromJson(options, option, value) {
         options.paths = paths;
         return;
     }
+    if (option.name === 'plugins') {
+        if (!(value instanceof JsonArray))
+            return;
+        options.plugins = value.items.map((item) => {
+            const name = item instanceof JsonObject ? item.entries.get('name') : undefined;
+            return new PluginImport(typeof name === 'string' ? name : '');
+        });
+        return;
+    }
     setCompilerOption(options, option.name, toOptionValue(option, value));
 }
 function setTypeAcquisitionFromJson(options, option, value) {
@@ -871,7 +921,7 @@ export class ConfigParser {
         const fileName = getNormalizedAbsolutePath(configFileName, this.currentDirectory);
         const text = this.fs.readFile(fileName);
         if (text === undefined) {
-            errors.push(createCompilerDiagnostic(1158 /* Diagnostics.Cannot_read_file_0 */, fileName));
+            errors.push(createCompilerDiagnostic(1165 /* Diagnostics.Cannot_read_file_0 */, fileName));
             return undefined;
         }
         const path = toPath(fileName, this.currentDirectory, this.fs.useCaseSensitiveFileNames);
@@ -898,7 +948,7 @@ export class ConfigParser {
             const extendsValue = raw instanceof JsonObject ? (raw.entries.get('extends') ?? null) : null;
             if (files.items !== undefined && files.items.length === 0 && referenceCount === 0 && extendsValue === null) {
                 const filesProperty = findPropertyAssignment(getTsConfigObjectLiteral(file.sourceFile), 'files');
-                errors.push(diagnosticAtNode(file.sourceFile, filesProperty?.initializer, 1826 /* Diagnostics.The_files_list_in_config_file_0_is_empty */, configFileName !== '' ? configFileName : 'tsconfig.json'));
+                errors.push(diagnosticAtNode(file.sourceFile, filesProperty?.initializer, 1846 /* Diagnostics.The_files_list_in_config_file_0_is_empty */, configFileName !== '' ? configFileName : 'tsconfig.json'));
             }
         }
         let include = rawList(raw, 'include');
@@ -919,22 +969,28 @@ export class ConfigParser {
         let validatedIncludeBeforeSubstitution = [];
         let validatedInclude = [];
         if (include.items !== undefined) {
-            validatedIncludeBeforeSubstitution = validateSpecs(include.items, true, file.sourceFile, 'include', errors);
+            validatedIncludeBeforeSubstitution = validateSpecs(include.items, true, basePathForFileNames, file.sourceFile, 'include', errors);
             validatedInclude =
                 substituteConfigDirInList(validatedIncludeBeforeSubstitution, basePathForFileNames) ??
                     validatedIncludeBeforeSubstitution;
         }
         let validatedExclude = [];
         if (exclude.items !== undefined) {
-            validatedExclude = validateSpecs(exclude.items, false, file.sourceFile, 'exclude', errors);
+            validatedExclude = validateSpecs(exclude.items, false, basePathForFileNames, file.sourceFile, 'exclude', errors);
             validatedExclude = substituteConfigDirInList(validatedExclude, basePathForFileNames) ?? validatedExclude;
         }
         let validatedFilesBeforeSubstitution = [];
         let validatedFiles = [];
         if (files.items !== undefined) {
-            for (const spec of files.items)
-                if (typeof spec === 'string')
-                    validatedFilesBeforeSubstitution.push(spec);
+            for (const spec of files.items) {
+                if (typeof spec !== 'string')
+                    continue;
+                if (isNetworkPathValue(spec, basePathForFileNames)) {
+                    errors.push(diagnosticAtNode(file.sourceFile, findTsConfigArrayElement(file.sourceFile, 'files', spec), 1195 /* Diagnostics.Network_path_0_is_not_supported */, spec));
+                    continue;
+                }
+                validatedFilesBeforeSubstitution.push(spec);
+            }
             validatedFiles =
                 substituteConfigDirInList(validatedFilesBeforeSubstitution, basePathForFileNames) ??
                     validatedFilesBeforeSubstitution;
@@ -949,32 +1005,52 @@ export class ConfigParser {
             : [];
         const canReportNoInputFiles = !(raw instanceof JsonObject) || (!raw.entries.has('files') && !raw.entries.has('references'));
         if (this.expandFileNames && fileNames.length === 0 && canReportNoInputFiles) {
-            errors.push(createCompilerDiagnostic(1827 /* Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2 */, configFileName, jsonList(include.items), jsonList(exclude.items)));
+            errors.push(createCompilerDiagnostic(1847 /* Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2 */, configFileName, jsonList(include.items), jsonList(exclude.items)));
         }
         const projectReferences = [];
         if (references.items !== undefined) {
-            for (const reference of references.items) {
+            const items = references.items;
+            for (let index = 0; index < items.length; index++) {
+                const reference = items[index];
                 if (!(reference instanceof JsonObject))
                     continue;
                 const path = reference.entries.get('path');
-                const circular = reference.entries.get('circular');
-                if (typeof path !== 'string' || path === '')
+                if (typeof path !== 'string') {
+                    errors.push(diagnosticAtProjectReferenceProperty(file.sourceFile, index, 'path', 1129 /* Diagnostics.Compiler_option_0_requires_a_value_of_type_1 */, 'reference.path', 'string'));
+                    continue;
+                }
+                if (path === '') {
+                    errors.push(diagnosticAtProjectReferenceProperty(file.sourceFile, index, 'path', 1887 /* Diagnostics.Compiler_option_0_cannot_be_given_an_empty_string */, 'reference.path'));
+                    continue;
+                }
+                if (isNetworkPathValue(path, basePathForFileNames)) {
+                    errors.push(diagnosticAtProjectReferenceProperty(file.sourceFile, index, 'path', 1195 /* Diagnostics.Network_path_0_is_not_supported */, path));
                     continue;
+                }
+                const circular = reference.entries.get('circular');
+                if (circular !== undefined && typeof circular !== 'boolean')
+                    errors.push(diagnosticAtProjectReferenceProperty(file.sourceFile, index, 'circular', 1129 /* Diagnostics.Compiler_option_0_requires_a_value_of_type_1 */, 'reference.circular', 'boolean'));
                 projectReferences.push(new ProjectReference(getNormalizedAbsolutePath(path, basePathForFileNames), path, circular === true));
             }
         }
-        return new ParsedCommandLine(options, parsed.typeAcquisition, fileNames, projectReferences, file, errors, basePathForFileNames, cs, literalFiles.size);
+        const parsedCommandLine = new ParsedCommandLine(options, parsed.typeAcquisition, fileNames, projectReferences, file, errors, basePathForFileNames, cs, literalFiles.size);
+        parsedCommandLine.raw = raw;
+        return parsedCommandLine;
     }
     /** A config file's options with what it extends applied. */
     parseConfig(file, basePath, configFileName, resolutionStack, errors) {
         basePath = normalizeSlashes(basePath);
         const resolvedPath = toPath(configFileName, basePath, this.fs.useCaseSensitiveFileNames);
         if (resolutionStack.includes(resolvedPath)) {
-            errors.push(createCompilerDiagnostic(1825 /* Diagnostics.Circularity_detected_while_resolving_configuration_Colon_0 */));
+            errors.push(createCompilerDiagnostic(1845 /* Diagnostics.Circularity_detected_while_resolving_configuration_Colon_0 */));
             return new OwnConfig(null, undefined, undefined, undefined);
         }
         const converter = new ConfigFileConverter(this, file.sourceFile, basePath, configFileName, errors);
         const raw = converter.convertRoot();
+        // A compiler option at the root is reported once, unless there's a `compilerOptions` too.
+        const rootOption = converter.rootCompilerOptions.length > 0 ? converter.rootCompilerOptions[0] : undefined;
+        if (rootOption !== undefined && raw instanceof JsonObject && !raw.entries.has('compilerOptions'))
+            errors.push(diagnosticAtNode(file.sourceFile, rootOption, 1421 /* Diagnostics.X_0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file */, propertyNameText(rootOption) ?? ''));
         const own = new OwnConfig(raw, converter.options, converter.typeAcquisition, converter.extendedConfigPaths);
         const ownOptions = converter.options;
         // `paths` may be inherited, so remember which directory it is relative to.
@@ -1066,7 +1142,7 @@ export class ConfigParser {
     parseExtendedConfig(fileName, path, stack) {
         const text = this.fs.readFile(fileName);
         if (text === undefined) {
-            const error = createCompilerDiagnostic(1158 /* Diagnostics.Cannot_read_file_0 */, fileName);
+            const error = createCompilerDiagnostic(1165 /* Diagnostics.Cannot_read_file_0 */, fileName);
             const file = new TsConfigSourceFile(parseConfigText(fileName, path, ''));
             file.sourceFile.diagnostics = [error];
             return new ExtendedConfig(file, undefined, [error]);
@@ -1081,11 +1157,11 @@ export class ConfigParser {
     /** Converts a value of `option`, reporting invalid values at `valueExpression`. */
     convertOption(option, value, basePath, property, valueExpression, file, errors) {
         if (option.isCommandLineOnly === true) {
-            errors.push(diagnosticAtNode(file, property?.name, 1418 /* Diagnostics.Option_0_can_only_be_specified_on_command_line */, option.name));
+            errors.push(diagnosticAtNode(file, property?.name, 1429 /* Diagnostics.Option_0_can_only_be_specified_on_command_line */, option.name));
             return null;
         }
         if (!isOptionValue(option, value)) {
-            errors.push(diagnosticAtNode(file, valueExpression, 1122 /* Diagnostics.Compiler_option_0_requires_a_value_of_type_1 */, option.name, valueTypeName(option)));
+            errors.push(diagnosticAtNode(file, valueExpression, 1129 /* Diagnostics.Compiler_option_0_requires_a_value_of_type_1 */, option.name, valueTypeName(option)));
             return null;
         }
         const element = option.element;
@@ -1105,6 +1181,10 @@ export class ConfigParser {
         const validated = validateOptionValue(option, value, valueExpression, file, errors);
         if (validated === null || option.isFilePath !== true || typeof validated !== 'string')
             return validated;
+        if (isNetworkPathValue(validated, basePath)) {
+            errors.push(diagnosticAtNode(file, valueExpression, 1195 /* Diagnostics.Network_path_0_is_not_supported */, validated));
+            return null;
+        }
         let path = normalizeSlashes(validated);
         if (!startsWithConfigDirTemplate(path))
             path = getNormalizedAbsolutePath(path, basePath);
@@ -1156,12 +1236,16 @@ export class ConfigParser {
     }
     getExtendsConfigPath(extendedConfig, basePath, valueExpression, file, errors) {
         extendedConfig = normalizeSlashes(extendedConfig);
+        if (isNetworkPathValue(extendedConfig, basePath)) {
+            errors.push(diagnosticAtNode(file, valueExpression, 1195 /* Diagnostics.Network_path_0_is_not_supported */, extendedConfig));
+            return '';
+        }
         if (isRootedDiskPath(extendedConfig) || extendedConfig.startsWith('./') || extendedConfig.startsWith('../')) {
             let path = getNormalizedAbsolutePath(extendedConfig, basePath);
             if (!this.fs.fileExists(path) && !path.endsWith('.json')) {
                 path += '.json';
                 if (!this.fs.fileExists(path)) {
-                    errors.push(diagnosticAtNode(file, valueExpression, 1229 /* Diagnostics.File_0_not_found */, extendedConfig));
+                    errors.push(diagnosticAtNode(file, valueExpression, 1240 /* Diagnostics.File_0_not_found */, extendedConfig));
                     return '';
                 }
             }
@@ -1171,8 +1255,8 @@ export class ConfigParser {
         if (resolved.resolvedFileName !== '')
             return resolved.resolvedFileName;
         errors.push(extendedConfig === ''
-            ? diagnosticAtNode(file, valueExpression, 1867 /* Diagnostics.Compiler_option_0_cannot_be_given_an_empty_string */, 'extends')
-            : diagnosticAtNode(file, valueExpression, 1229 /* Diagnostics.File_0_not_found */, extendedConfig));
+            ? diagnosticAtNode(file, valueExpression, 1887 /* Diagnostics.Compiler_option_0_cannot_be_given_an_empty_string */, 'extends')
+            : diagnosticAtNode(file, valueExpression, 1240 /* Diagnostics.File_0_not_found */, extendedConfig));
         return '';
     }
     /** Root files: `files` as given, then `include` matches not excluded, then JSON files matched explicitly. */
@@ -1183,17 +1267,18 @@ export class ConfigParser {
         const wildcardJsonFiles = new Map();
         const supportedExtensions = getSupportedExtensions(options);
         const extensionsWithJson = getSupportedExtensionsWithJsonIfResolveJsonModule(options);
-        // Keys of literal files are the specs as written, as in tsgo.
+        // Literal files are keyed by path, so `a.ts` and `./a.ts` are one file, also when `include` matches it.
         for (const fileName of specs.validatedFilesSpec) {
-            literalFiles.set(getCanonicalFileName(fileName, cs), getNormalizedAbsolutePath(fileName, basePath));
+            const file = getNormalizedAbsolutePath(fileName, basePath);
+            literalFiles.set(getCanonicalFileName(file, cs), file);
         }
         if (onRootFile !== undefined)
             for (const fileName of literalFiles.values())
                 onRootFile(fileName);
         const includes = specs.validatedIncludeSpecs;
         if (includes.length > 0) {
-            // Matches go to `onRootFile` a directory at a time, without those that a file of the same name
-            // with a higher priority extension leaves out below.
+            // Matches go to `onRootFile` a directory at a time, without the literal files, which it has, and those that a
+            // file of the same name with a higher priority extension leaves out below.
             let directory = '';
             let pending = [];
             const flush = () => {
@@ -1202,9 +1287,12 @@ export class ConfigParser {
                 const siblings = new Map();
                 for (const file of pending)
                     siblings.set(getCanonicalFileName(file, cs), file);
-                for (const file of pending)
+                for (const file of pending) {
+                    if (literalFiles.has(getCanonicalFileName(file, cs)))
+                        continue;
                     if (!hasFileWithHigherPriorityExtension(file, supportedExtensions, literalFiles, siblings, cs))
                         onRootFile(file);
+                }
                 pending = [];
             };
             const onMatch = onRootFile === undefined
@@ -1289,7 +1377,7 @@ function validateOptionValue(option, value, valueExpression, file, errors) {
         }
     }
     else if (option.extraValidation === 'locale' && !isValidLocale(value)) {
-        errors.push(diagnosticAtNode(file, valueExpression, 1225 /* Diagnostics.Locale_must_be_an_IETF_BCP_47_language_tag_Examples_Colon_0_1 */, 'en', 'ja-jp'));
+        errors.push(diagnosticAtNode(file, valueExpression, 1236 /* Diagnostics.Locale_must_be_an_IETF_BCP_47_language_tag_Examples_Colon_0_1 */, 'en', 'ja-jp'));
         return null;
     }
     return value;
@@ -1300,7 +1388,7 @@ function convertEnumOption(option, value, valueExpression, file, errors) {
     const enumValue = option.values?.get(value.toLowerCase());
     if (enumValue !== undefined)
         return validateOptionValue(option, enumValue, valueExpression, file, errors);
-    errors.push(diagnosticAtNode(file, valueExpression, 1224 /* Diagnostics.Argument_for_0_option_must_be_Colon_1 */, '--' + option.name, enumNamesList(option)));
+    errors.push(diagnosticAtNode(file, valueExpression, 1235 /* Diagnostics.Argument_for_0_option_must_be_Colon_1 */, '--' + option.name, enumNamesList(option)));
     return null;
 }
 /** `path` relative to `currentDirectory` if absolute. */

package/dist/api/compiler/type-printer.js

@@ -18,16 +18,53 @@ function printSingleLine(b, node, neverAsciiEscape) {
 export function typeToString(c, t, enclosingDeclaration, flags) {
     // Without explicit flags, unique symbols print as such and aliases from other scopes are used.
     const formatFlags = flags ?? 1048576 /* NodeBuilderFlags.AllowUniqueESSymbolType */ | 16384 /* NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope */;
-    return typeToStringFromTypeNode(c, t, enclosingDeclaration, formatFlags) ?? '';
+    // Prints nested in a serialization depend on its depth (typeToStringFromTypeNode), so only the others are kept.
+    if (c.serializationLevel !== 0)
+        return typeToStringFromTypeNode(c, t, enclosingDeclaration, formatFlags) ?? '';
+    // The variance check in progress names the marker types (`sub-T`, `super-T`) after its type parameter.
+    const variance = c.varianceTypeParameter;
+    const key = String(t.id) +
+        ',' +
+        String(enclosingDeclaration === undefined ? 0 : enclosingDeclaration.id) +
+        ',' +
+        String(formatFlags) +
+        ',' +
+        String(variance === undefined ? 0 : variance.id);
+    const cached = c.typeStrings.get(key);
+    if (cached !== undefined)
+        return cached;
+    // A print that creates no types reads only types that exist and settled state, so printing again gives the same
+    // text and creates nothing; prints that create types run each time, as in tsgo, so type ids stay in tsgo's order.
+    const typeCount = c.typeCount;
+    const text = typeToStringFromTypeNode(c, t, enclosingDeclaration, formatFlags) ?? '';
+    if (c.typeCount === typeCount)
+        c.typeStrings.set(key, text);
+    return text;
 }
 /** `symbol` as text: the expression naming it, as seen from `enclosingDeclaration` if given. */
 export function symbolToString(c, symbol, enclosingDeclaration, internalFlags = 0 /* NodeBuilderInternalFlags.None */) {
+    // Kept as typeToString keeps type prints: outside serializations, when printing created no types.
+    const key = String(enclosingDeclaration === undefined ? 0 : enclosingDeclaration.id) + ',' + String(internalFlags);
+    const kept = c.serializationLevel === 0 ? c.symbolStrings.get(symbol) : undefined;
+    const cached = kept?.get(key);
+    if (cached !== undefined)
+        return cached;
+    const typeCount = c.typeCount;
     const b = new NodeBuilder(c, enclosingDeclaration, 70221824 /* NodeBuilderFlags.IgnoreErrors */, internalFlags, undefined);
-    return printSingleLine(b, symbolToExpression(b, symbol, 1073741823 /* SymbolFlags.All */), enclosingDeclaration !== undefined && enclosingDeclaration.kind === 307 /* SyntaxKind.SourceFile */);
+    const text = printSingleLine(b, symbolToExpression(b, symbol, 1073741823 /* SymbolFlags.All */), enclosingDeclaration !== undefined && enclosingDeclaration.kind === 308 /* SyntaxKind.SourceFile */);
+    if (c.serializationLevel === 0 && c.typeCount === typeCount) {
+        let byKey = kept;
+        if (byKey === undefined) {
+            byKey = new Map();
+            c.symbolStrings.set(symbol, byKey);
+        }
+        byKey.set(key, text);
+    }
+    return text;
 }
 /** `signature` as text: a call or construct signature without its trailing semicolon. */
 export function signatureToString(c, signature) {
-    const kind = (signature.flags & 4 /* SignatureFlags.Construct */) !== 0 ? 181 /* SyntaxKind.ConstructSignature */ : 180 /* SyntaxKind.CallSignature */;
+    const kind = (signature.flags & 4 /* SignatureFlags.Construct */) !== 0 ? 182 /* SyntaxKind.ConstructSignature */ : 181 /* SyntaxKind.CallSignature */;
     const b = new NodeBuilder(c, undefined, 70221824 /* NodeBuilderFlags.IgnoreErrors */ | 512 /* NodeBuilderFlags.WriteTypeParametersInQualifiedName */, 0 /* NodeBuilderInternalFlags.None */, undefined);
     b.pseudo = newPseudoChecker(c);
     const text = printSingleLine(b, b.signatureToSignatureDeclaration(signature, kind, undefined), true);

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

@@ -57,10 +57,11 @@ export declare const enum ScriptTarget {
     ES2023 = 10,
     ES2024 = 11,
     ES2025 = 12,
+    ES2026 = 13,
     ESNext = 99,
     JSON = 100,
     Latest = 99,
-    LatestStandard = 12
+    LatestStandard = 13
 }
 export declare const enum LanguageVariant {
     Standard = 0,