typescript 5.7.0-dev.20240927 → 5.7.0-dev.20240928

package/lib/_tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.7";
-var version = `${versionMajorMinor}.0-dev.20240927`;
+var version = `${versionMajorMinor}.0-dev.20240928`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3885,10 +3885,10 @@ var LanguageFeatureMinimumTarget = {
   ClassFields: 9 /* ES2022 */,
   PrivateNamesAndClassStaticBlocks: 9 /* ES2022 */,
   RegularExpressionFlagsHasIndices: 9 /* ES2022 */,
-  ShebangComments: 99 /* ESNext */,
+  ShebangComments: 10 /* ES2023 */,
+  RegularExpressionFlagsUnicodeSets: 11 /* ES2024 */,
   UsingAndAwaitUsing: 99 /* ESNext */,
-  ClassAndClassElementDecorators: 99 /* ESNext */,
-  RegularExpressionFlagsUnicodeSets: 99 /* ESNext */
+  ClassAndClassElementDecorators: 99 /* ESNext */
 };
 var commentPragmas = {
   "reference": {
@@ -6736,6 +6736,10 @@ var Diagnostics = {
   This_kind_of_expression_is_always_falsy: diag(2873, 1 /* Error */, "This_kind_of_expression_is_always_falsy_2873", "This kind of expression is always falsy."),
   This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found: diag(2874, 1 /* Error */, "This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found_2874", "This JSX tag requires '{0}' to be in scope, but it could not be found."),
   This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed: diag(2875, 1 /* Error */, "This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_fo_2875", "This JSX tag requires the module path '{0}' to exist, but none could be found. Make sure you have types for the appropriate package installed."),
+  This_relative_import_path_is_unsafe_to_rewrite_because_it_looks_like_a_file_name_but_actually_resolves_to_0: diag(2876, 1 /* Error */, "This_relative_import_path_is_unsafe_to_rewrite_because_it_looks_like_a_file_name_but_actually_resolv_2876", 'This relative import path is unsafe to rewrite because it looks like a file name, but actually resolves to "{0}".'),
+  This_import_uses_a_0_extension_to_resolve_to_an_input_TypeScript_file_but_will_not_be_rewritten_during_emit_because_it_is_not_a_relative_path: diag(2877, 1 /* Error */, "This_import_uses_a_0_extension_to_resolve_to_an_input_TypeScript_file_but_will_not_be_rewritten_duri_2877", "This import uses a '{0}' extension to resolve to an input TypeScript file, but will not be rewritten during emit because it is not a relative path."),
+  This_import_path_is_unsafe_to_rewrite_because_it_resolves_to_another_project_and_the_relative_path_between_the_projects_output_files_is_not_the_same_as_the_relative_path_between_its_input_files: diag(2878, 1 /* Error */, "This_import_path_is_unsafe_to_rewrite_because_it_resolves_to_another_project_and_the_relative_path_b_2878", "This import path is unsafe to rewrite because it resolves to another project, and the relative path between the projects' output files is not the same as the relative path between its input files."),
+  Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found: diag(2879, 1 /* Error */, "Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found_2879", "Using JSX fragments requires fragment factory '{0}' to be in scope, but it could not be found."),
   Import_declaration_0_is_using_private_name_1: diag(4e3, 1 /* Error */, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
   Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, 1 /* Error */, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
   Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, 1 /* Error */, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -7292,6 +7296,7 @@ var Diagnostics = {
   Searching_all_ancestor_node_modules_directories_for_fallback_extensions_Colon_0: diag(6418, 3 /* Message */, "Searching_all_ancestor_node_modules_directories_for_fallback_extensions_Colon_0_6418", "Searching all ancestor node_modules directories for fallback extensions: {0}."),
   Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_program_needs_to_report_errors: diag(6419, 3 /* Message */, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_program_needs_to_report_errors_6419", "Project '{0}' is out of date because buildinfo file '{1}' indicates that program needs to report errors."),
   Project_0_is_out_of_date_because_1: diag(6420, 3 /* Message */, "Project_0_is_out_of_date_because_1_6420", "Project '{0}' is out of date because {1}."),
+  Rewrite_ts_tsx_mts_and_cts_file_extensions_in_relative_import_paths_to_their_JavaScript_equivalent_in_output_files: diag(6421, 3 /* Message */, "Rewrite_ts_tsx_mts_and_cts_file_extensions_in_relative_import_paths_to_their_JavaScript_equivalent_i_6421", "Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files."),
   The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, 3 /* Message */, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"),
   The_expected_type_comes_from_this_index_signature: diag(6501, 3 /* Message */, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."),
   The_expected_type_comes_from_the_return_type_of_this_signature: diag(6502, 3 /* Message */, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."),
@@ -11817,6 +11822,9 @@ function isTypeOnlyExportDeclaration(node) {
 function isTypeOnlyImportOrExportDeclaration(node) {
   return isTypeOnlyImportDeclaration(node) || isTypeOnlyExportDeclaration(node);
 }
+function isPartOfTypeOnlyImportOrExportDeclaration(node) {
+  return findAncestor(node, isTypeOnlyImportOrExportDeclaration) !== void 0;
+}
 function isImportAttributeName(node) {
   return isStringLiteral(node) || isIdentifier(node);
 }
@@ -12074,13 +12082,16 @@ function isCallLikeOrFunctionLikeExpression(node) {
 }
 function isCallLikeExpression(node) {
   switch (node.kind) {
-    case 286 /* JsxOpeningElement */:
-    case 285 /* JsxSelfClosingElement */:
     case 213 /* CallExpression */:
     case 214 /* NewExpression */:
     case 215 /* TaggedTemplateExpression */:
     case 170 /* Decorator */:
+    case 286 /* JsxOpeningElement */:
+    case 285 /* JsxSelfClosingElement */:
+    case 289 /* JsxOpeningFragment */:
       return true;
+    case 226 /* BinaryExpression */:
+      return node.operatorToken.kind === 104 /* InstanceOfKeyword */;
     default:
       return false;
   }
@@ -12402,6 +12413,10 @@ function isJsxOpeningLikeElement(node) {
   const kind = node.kind;
   return kind === 286 /* JsxOpeningElement */ || kind === 285 /* JsxSelfClosingElement */;
 }
+function isJsxCallLike(node) {
+  const kind = node.kind;
+  return kind === 286 /* JsxOpeningElement */ || kind === 285 /* JsxSelfClosingElement */ || kind === 289 /* JsxOpeningFragment */;
+}
 function isCaseOrDefaultClause(node) {
   const kind = node.kind;
   return kind === 296 /* CaseClause */ || kind === 297 /* DefaultClause */;
@@ -12990,11 +13005,45 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize(
     AsyncIterator: new Map(Object.entries({
       es2015: emptyArray
     })),
+    ArrayBuffer: new Map(Object.entries({
+      es2024: [
+        "maxByteLength",
+        "resizable",
+        "resize",
+        "detached",
+        "transfer",
+        "transferToFixedLength"
+      ]
+    })),
     Atomics: new Map(Object.entries({
-      es2017: emptyArray
+      es2017: [
+        "add",
+        "and",
+        "compareExchange",
+        "exchange",
+        "isLockFree",
+        "load",
+        "or",
+        "store",
+        "sub",
+        "wait",
+        "notify",
+        "xor"
+      ],
+      es2024: [
+        "waitAsync"
+      ]
     })),
     SharedArrayBuffer: new Map(Object.entries({
-      es2017: emptyArray
+      es2017: [
+        "byteLength",
+        "slice"
+      ],
+      es2024: [
+        "growable",
+        "maxByteLength",
+        "grow"
+      ]
     })),
     AsyncIterable: new Map(Object.entries({
       es2018: emptyArray
@@ -13016,6 +13065,9 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize(
       ],
       es2018: [
         "dotAll"
+      ],
+      es2024: [
+        "unicodeSets"
       ]
     })),
     Reflect: new Map(Object.entries({
@@ -13062,6 +13114,9 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize(
       ],
       es2022: [
         "hasOwn"
+      ],
+      es2024: [
+        "groupBy"
       ]
     })),
     NumberConstructor: new Map(Object.entries({
@@ -13102,11 +13157,25 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize(
         "values"
       ]
     })),
+    MapConstructor: new Map(Object.entries({
+      es2024: [
+        "groupBy"
+      ]
+    })),
     Set: new Map(Object.entries({
       es2015: [
         "entries",
         "keys",
         "values"
+      ],
+      esnext: [
+        "union",
+        "intersection",
+        "difference",
+        "symmetricDifference",
+        "isSubsetOf",
+        "isSupersetOf",
+        "isDisjointFrom"
       ]
     })),
     PromiseConstructor: new Map(Object.entries({
@@ -13121,6 +13190,9 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize(
       ],
       es2021: [
         "any"
+      ],
+      es2024: [
+        "withResolvers"
       ]
     })),
     Symbol: new Map(Object.entries({
@@ -13187,7 +13259,7 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize(
       es2022: [
         "at"
       ],
-      esnext: [
+      es2024: [
         "isWellFormed",
         "toWellFormed"
       ]
@@ -13232,6 +13304,11 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize(
     SymbolConstructor: new Map(Object.entries({
       es2020: [
         "matchAll"
+      ],
+      esnext: [
+        "metadata",
+        "dispose",
+        "asyncDispose"
       ]
     })),
     DataView: new Map(Object.entries({
@@ -14404,6 +14481,8 @@ function getInvokedExpression(node) {
       return node.tagName;
     case 226 /* BinaryExpression */:
       return node.right;
+    case 289 /* JsxOpeningFragment */:
+      return node;
     default:
       return node.expression;
   }
@@ -14990,6 +15069,9 @@ function tryGetModuleSpecifierFromDeclaration(node) {
       Debug.assertNever(node);
   }
 }
+function shouldRewriteModuleSpecifier(specifier, compilerOptions) {
+  return !!compilerOptions.rewriteRelativeImportExtensions && pathIsRelative(specifier) && !isDeclarationFileName(specifier);
+}
 function getExternalModuleName(node) {
   switch (node.kind) {
     case 272 /* ImportDeclaration */:
@@ -17122,6 +17204,12 @@ function getLinesBetweenPositionAndNextNonWhitespaceCharacter(pos, stopPos, sour
   );
   return getLinesBetweenPositions(sourceFile, pos, Math.min(stopPos, nextPos));
 }
+function rangeContainsRange(r1, r2) {
+  return startEndContainsRange(r1.pos, r1.end, r2);
+}
+function startEndContainsRange(start, end, range) {
+  return start <= range.pos && end >= range.end;
+}
 function getPreviousNonWhitespacePosition(pos, stopPos = 0, sourceFile) {
   while (pos-- > stopPos) {
     if (!isWhiteSpaceLike(sourceFile.text.charCodeAt(pos))) {
@@ -17714,6 +17802,12 @@ function createComputedCompilerOptions(options) {
   return options;
 }
 var _computedOptions = createComputedCompilerOptions({
+  allowImportingTsExtensions: {
+    dependencies: ["rewriteRelativeImportExtensions"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.allowImportingTsExtensions || compilerOptions.rewriteRelativeImportExtensions);
+    }
+  },
   target: {
     dependencies: ["module"],
     computeValue: (compilerOptions) => {
@@ -17928,6 +18022,7 @@ var _computedOptions = createComputedCompilerOptions({
   }
 });
 var computedOptions = _computedOptions;
+var getAllowImportingTsExtensions = _computedOptions.allowImportingTsExtensions.computeValue;
 var getEmitScriptTarget = _computedOptions.target.computeValue;
 var getEmitModuleKind = _computedOptions.module.computeValue;
 var getEmitModuleResolutionKind = _computedOptions.moduleResolution.computeValue;
@@ -19702,6 +19797,46 @@ var nodeCoreModules = /* @__PURE__ */ new Set([
   ...unprefixedNodeCoreModulesList.map((name) => `node:${name}`),
   ...exclusivelyPrefixedNodeCoreModules
 ]);
+function forEachDynamicImportOrRequireCall(file, includeTypeSpaceImports, requireStringLiteralLikeArgument, cb) {
+  const isJavaScriptFile = isInJSFile(file);
+  const r = /import|require/g;
+  while (r.exec(file.text) !== null) {
+    const node = getNodeAtPosition(
+      file,
+      r.lastIndex,
+      /*includeJSDoc*/
+      includeTypeSpaceImports
+    );
+    if (isJavaScriptFile && isRequireCall(node, requireStringLiteralLikeArgument)) {
+      cb(node, node.arguments[0]);
+    } else if (isImportCall(node) && node.arguments.length >= 1 && (!requireStringLiteralLikeArgument || isStringLiteralLike(node.arguments[0]))) {
+      cb(node, node.arguments[0]);
+    } else if (includeTypeSpaceImports && isLiteralImportTypeNode(node)) {
+      cb(node, node.argument.literal);
+    } else if (includeTypeSpaceImports && isJSDocImportTag(node)) {
+      const moduleNameExpr = getExternalModuleName(node);
+      if (moduleNameExpr && isStringLiteral(moduleNameExpr) && moduleNameExpr.text) {
+        cb(node, moduleNameExpr);
+      }
+    }
+  }
+}
+function getNodeAtPosition(sourceFile, position, includeJSDoc) {
+  const isJavaScriptFile = isInJSFile(sourceFile);
+  let current = sourceFile;
+  const getContainingChild = (child) => {
+    if (child.pos <= position && (position < child.end || position === child.end && child.kind === 1 /* EndOfFileToken */)) {
+      return child;
+    }
+  };
+  while (true) {
+    const child = isJavaScriptFile && includeJSDoc && hasJSDocNodes(current) && forEach(current.jsDoc, getContainingChild) || forEachChild(current, getContainingChild);
+    if (!child) {
+      return current;
+    }
+    current = child;
+  }
+}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -24987,7 +25122,9 @@ function createEmitHelperFactory(context) {
     createClassPrivateFieldInHelper,
     // 'using' helpers
     createAddDisposableResourceHelper,
-    createDisposeResourcesHelper
+    createDisposeResourcesHelper,
+    // --rewriteRelativeImportExtensions helpers
+    createRewriteRelativeImportExtensionsHelper
   };
   function getUnscopedHelperName(name) {
     return setEmitFlags(factory2.createIdentifier(name), 8192 /* HelperName */ | 4 /* AdviseOnEmitNode */);
@@ -25476,6 +25613,15 @@ function createEmitHelperFactory(context) {
       [envBinding]
     );
   }
+  function createRewriteRelativeImportExtensionsHelper(expression) {
+    context.requestEmitHelper(rewriteRelativeImportExtensionsHelper);
+    return factory2.createCallExpression(
+      getUnscopedHelperName("__rewriteRelativeImportExtension"),
+      /*typeArguments*/
+      void 0,
+      context.getCompilerOptions().jsx === 1 /* Preserve */ ? [expression, factory2.createTrue()] : [expression]
+    );
+  }
 }
 function compareEmitHelpers(x, y) {
   if (x === y) return 0 /* EqualTo */;
@@ -25981,6 +26127,20 @@ var disposeResourcesHelper = {
             return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
         });`
 };
+var rewriteRelativeImportExtensionsHelper = {
+  name: "typescript:rewriteRelativeImportExtensions",
+  importName: "__rewriteRelativeImportExtension",
+  scoped: false,
+  text: `
+        var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+            if (typeof path === "string" && /^\\.\\.?\\//.test(path)) {
+                return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+                    return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+                });
+            }
+            return path;
+        };`
+};
 var asyncSuperHelper = {
   name: "typescript:async-super",
   scoped: true,
@@ -35827,6 +35987,7 @@ var libEntries = [
   ["es2021", "lib.es2021.d.ts"],
   ["es2022", "lib.es2022.d.ts"],
   ["es2023", "lib.es2023.d.ts"],
+  ["es2024", "lib.es2024.d.ts"],
   ["esnext", "lib.esnext.d.ts"],
   // Host only
   ["dom", "lib.dom.d.ts"],
@@ -35849,6 +36010,7 @@ var libEntries = [
   ["es2015.symbol.wellknown", "lib.es2015.symbol.wellknown.d.ts"],
   ["es2016.array.include", "lib.es2016.array.include.d.ts"],
   ["es2016.intl", "lib.es2016.intl.d.ts"],
+  ["es2017.arraybuffer", "lib.es2017.arraybuffer.d.ts"],
   ["es2017.date", "lib.es2017.date.d.ts"],
   ["es2017.object", "lib.es2017.object.d.ts"],
   ["es2017.sharedmemory", "lib.es2017.sharedmemory.d.ts"],
@@ -35881,12 +36043,18 @@ var libEntries = [
   ["es2022.error", "lib.es2022.error.d.ts"],
   ["es2022.intl", "lib.es2022.intl.d.ts"],
   ["es2022.object", "lib.es2022.object.d.ts"],
-  ["es2022.sharedmemory", "lib.es2022.sharedmemory.d.ts"],
   ["es2022.string", "lib.es2022.string.d.ts"],
   ["es2022.regexp", "lib.es2022.regexp.d.ts"],
   ["es2023.array", "lib.es2023.array.d.ts"],
   ["es2023.collection", "lib.es2023.collection.d.ts"],
   ["es2023.intl", "lib.es2023.intl.d.ts"],
+  ["es2024.arraybuffer", "lib.es2024.arraybuffer.d.ts"],
+  ["es2024.collection", "lib.es2024.collection.d.ts"],
+  ["es2024.object", "lib.es2024.object.d.ts"],
+  ["es2024.promise", "lib.es2024.promise.d.ts"],
+  ["es2024.regexp", "lib.es2024.regexp.d.ts"],
+  ["es2024.sharedmemory", "lib.es2024.sharedmemory.d.ts"],
+  ["es2024.string", "lib.es2024.string.d.ts"],
   ["esnext.array", "lib.es2023.array.d.ts"],
   ["esnext.collection", "lib.esnext.collection.d.ts"],
   ["esnext.symbol", "lib.es2019.symbol.d.ts"],
@@ -35895,13 +36063,13 @@ var libEntries = [
   ["esnext.disposable", "lib.esnext.disposable.d.ts"],
   ["esnext.bigint", "lib.es2020.bigint.d.ts"],
   ["esnext.string", "lib.es2022.string.d.ts"],
-  ["esnext.promise", "lib.esnext.promise.d.ts"],
+  ["esnext.promise", "lib.es2024.promise.d.ts"],
   ["esnext.weakref", "lib.es2021.weakref.d.ts"],
   ["esnext.decorators", "lib.esnext.decorators.d.ts"],
-  ["esnext.object", "lib.esnext.object.d.ts"],
+  ["esnext.object", "lib.es2024.object.d.ts"],
   ["esnext.array", "lib.esnext.array.d.ts"],
-  ["esnext.regexp", "lib.esnext.regexp.d.ts"],
-  ["esnext.string", "lib.esnext.string.d.ts"],
+  ["esnext.regexp", "lib.es2024.regexp.d.ts"],
+  ["esnext.string", "lib.es2024.string.d.ts"],
   ["esnext.iterator", "lib.esnext.iterator.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
   ["decorators.legacy", "lib.decorators.legacy.d.ts"]
@@ -36200,6 +36368,7 @@ var targetOptionDeclaration = {
     es2021: 8 /* ES2021 */,
     es2022: 9 /* ES2022 */,
     es2023: 10 /* ES2023 */,
+    es2024: 11 /* ES2024 */,
     esnext: 99 /* ESNext */
   })),
   affectsSourceFile: true,
@@ -36802,6 +36971,15 @@ var commandOptionsWithoutBuild = [
     defaultValueDescription: false,
     transpileOptionValue: void 0
   },
+  {
+    name: "rewriteRelativeImportExtensions",
+    type: "boolean",
+    affectsSemanticDiagnostics: true,
+    affectsBuildInfo: true,
+    category: Diagnostics.Modules,
+    description: Diagnostics.Rewrite_ts_tsx_mts_and_cts_file_extensions_in_relative_import_paths_to_their_JavaScript_equivalent_in_output_files,
+    defaultValueDescription: false
+  },
   {
     name: "resolvePackageJsonExports",
     type: "boolean",
@@ -40435,10 +40613,11 @@ function loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecor
   }
   return tryAddingExtensions(extensionless, extensions, extension, onlyRecordFailures, state);
 }
-function loadFileNameFromPackageJsonField(extensions, candidate, onlyRecordFailures, state) {
+function loadFileNameFromPackageJsonField(extensions, candidate, packageJsonValue, onlyRecordFailures, state) {
   if (extensions & 1 /* TypeScript */ && fileExtensionIsOneOf(candidate, supportedTSImplementationExtensions) || extensions & 4 /* Declaration */ && fileExtensionIsOneOf(candidate, supportedDeclarationExtensions)) {
     const result = tryFile(candidate, onlyRecordFailures, state);
-    return result !== void 0 ? { path: candidate, ext: tryExtractTSExtension(candidate), resolvedUsingTsExtension: void 0 } : void 0;
+    const ext = tryExtractTSExtension(candidate);
+    return result !== void 0 ? { path: candidate, ext, resolvedUsingTsExtension: packageJsonValue ? !endsWith(packageJsonValue, ext) : void 0 } : void 0;
   }
   if (state.isConfigLookup && extensions === 8 /* Json */ && fileExtensionIs(candidate, ".json" /* Json */)) {
     const result = tryFile(candidate, onlyRecordFailures, state);
@@ -40627,7 +40806,14 @@ function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFail
     }
   }
   const loader = (extensions2, candidate2, onlyRecordFailures2, state2) => {
-    const fromFile = loadFileNameFromPackageJsonField(extensions2, candidate2, onlyRecordFailures2, state2);
+    const fromFile = loadFileNameFromPackageJsonField(
+      extensions2,
+      candidate2,
+      /*packageJsonValue*/
+      void 0,
+      onlyRecordFailures2,
+      state2
+    );
     if (fromFile) {
       return noPackageId(fromFile);
     }
@@ -40983,6 +41169,7 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec
       return toSearchResult(withPackageId(scope, loadFileNameFromPackageJsonField(
         extensions,
         finalPath,
+        target,
         /*onlyRecordFailures*/
         false,
         state
@@ -41095,6 +41282,8 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec
                       return toSearchResult(withPackageId(scope, loadFileNameFromPackageJsonField(
                         extensions,
                         possibleInputWithInputExtension,
+                        /*packageJsonValue*/
+                        void 0,
                         /*onlyRecordFailures*/
                         false,
                         state
@@ -41457,7 +41646,7 @@ function resolveFromTypeRoot(moduleName, state) {
   }
 }
 function shouldAllowImportingTsExtension(compilerOptions, fromFileName) {
-  return !!compilerOptions.allowImportingTsExtensions || !!fromFileName && isDeclarationFileName(fromFileName);
+  return getAllowImportingTsExtensions(compilerOptions) || !!fromFileName && isDeclarationFileName(fromFileName);
 }
 function loadModuleFromGlobalCache(moduleName, projectName, compilerOptions, host, globalCache, packageJsonInfoCache) {
   const traceEnabled = isTraceEnabled(compilerOptions, host);
@@ -46421,6 +46610,15 @@ function createTypeChecker(host) {
     emptyArray
   );
   emptyJsxObjectType.objectFlags |= 2048 /* JsxAttributes */;
+  var emptyFreshJsxObjectType = createAnonymousType(
+    /*symbol*/
+    void 0,
+    emptySymbols,
+    emptyArray,
+    emptyArray,
+    emptyArray
+  );
+  emptyFreshJsxObjectType.objectFlags |= 2048 /* JsxAttributes */ | 8192 /* FreshLiteral */ | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
   var emptyTypeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
   emptyTypeLiteralSymbol.members = createSymbolTable();
   var emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, emptyArray, emptyArray, emptyArray);
@@ -48719,6 +48917,36 @@ function createTypeChecker(host) {
           const tsExtension = Debug.checkDefined(tryExtractTSExtension(moduleReference));
           error(errorNode, Diagnostics.An_import_path_can_only_end_with_a_0_extension_when_allowImportingTsExtensions_is_enabled, tsExtension);
         }
+      } else if (compilerOptions.rewriteRelativeImportExtensions && !(location.flags & 33554432 /* Ambient */) && !isDeclarationFileName(moduleReference) && !isLiteralImportTypeNode(location) && !isPartOfTypeOnlyImportOrExportDeclaration(location)) {
+        const shouldRewrite = shouldRewriteModuleSpecifier(moduleReference, compilerOptions);
+        if (!resolvedModule.resolvedUsingTsExtension && shouldRewrite) {
+          error(
+            errorNode,
+            Diagnostics.This_relative_import_path_is_unsafe_to_rewrite_because_it_looks_like_a_file_name_but_actually_resolves_to_0,
+            getRelativePathFromFile(getNormalizedAbsolutePath(currentSourceFile.fileName, host.getCurrentDirectory()), resolvedModule.resolvedFileName, hostGetCanonicalFileName(host))
+          );
+        } else if (resolvedModule.resolvedUsingTsExtension && !shouldRewrite && sourceFileMayBeEmitted(sourceFile, host)) {
+          error(
+            errorNode,
+            Diagnostics.This_import_uses_a_0_extension_to_resolve_to_an_input_TypeScript_file_but_will_not_be_rewritten_during_emit_because_it_is_not_a_relative_path,
+            getAnyExtensionFromPath(moduleReference)
+          );
+        } else if (resolvedModule.resolvedUsingTsExtension && shouldRewrite) {
+          const redirect = host.getResolvedProjectReferenceToRedirect(sourceFile.path);
+          if (redirect) {
+            const ignoreCase = !host.useCaseSensitiveFileNames();
+            const ownRootDir = host.getCommonSourceDirectory();
+            const otherRootDir = getCommonSourceDirectoryOfConfig(redirect.commandLine, ignoreCase);
+            const rootDirPath = getRelativePathFromDirectory(ownRootDir, otherRootDir, ignoreCase);
+            const outDirPath = getRelativePathFromDirectory(compilerOptions.outDir || ownRootDir, redirect.commandLine.options.outDir || otherRootDir, ignoreCase);
+            if (rootDirPath !== outDirPath) {
+              error(
+                errorNode,
+                Diagnostics.This_import_path_is_unsafe_to_rewrite_because_it_resolves_to_another_project_and_the_relative_path_between_the_projects_output_files_is_not_the_same_as_the_relative_path_between_its_input_files
+              );
+            }
+          }
+        }
       }
       if (sourceFile.symbol) {
         if (errorNode && resolvedModule.isExternalLibraryImport && !resolutionExtensionIsTSOrJson(resolvedModule.extension)) {
@@ -52536,7 +52764,7 @@ function createTypeChecker(host) {
           }
           return factory.updateImportTypeNode(
             node,
-            factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier(node, node.argument.literal)),
+            factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier2(node, node.argument.literal)),
             visitNode(node.attributes, visitExistingNodeTreeSymbols, isImportAttributes),
             visitNode(node.qualifier, visitExistingNodeTreeSymbols, isEntityName),
             visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode),
@@ -52690,7 +52918,7 @@ function createTypeChecker(host) {
         function getNameForJSDocFunctionParameter(p, index) {
           return p.name && isIdentifier(p.name) && p.name.escapedText === "this" ? "this" : getEffectiveDotDotDotForParameter(p) ? `args` : `arg${index}`;
         }
-        function rewriteModuleSpecifier(parent, lit) {
+        function rewriteModuleSpecifier2(parent, lit) {
           if (context.bundled || context.enclosingFile !== getSourceFileOfNode(lit)) {
             let name = lit.text;
             const nodeSymbol = getNodeLinks(node).resolvedSymbol;
@@ -72333,7 +72561,7 @@ function createTypeChecker(host) {
     return getContextualTypeForArgumentAtIndex(node, 0);
   }
   function getEffectiveFirstArgumentForJsxSignature(signature, node) {
-    return getJsxReferenceKind(node) !== 0 /* Component */ ? getJsxPropsTypeFromCallSignature(signature, node) : getJsxPropsTypeFromClassType(signature, node);
+    return isJsxOpeningFragment(node) || getJsxReferenceKind(node) !== 0 /* Component */ ? getJsxPropsTypeFromCallSignature(signature, node) : getJsxPropsTypeFromClassType(signature, node);
   }
   function getJsxPropsTypeFromCallSignature(sig, context) {
     let propsType = getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType);
@@ -72364,6 +72592,7 @@ function createTypeChecker(host) {
     return isTypeAny(instanceType) ? instanceType : getTypeOfPropertyOfType(instanceType, forcedLookupLocation);
   }
   function getStaticTypeOfReferencedJsxConstructor(context) {
+    if (isJsxOpeningFragment(context)) return getJSXFragmentType(context);
     if (isJsxIntrinsicTagName(context.tagName)) {
       const result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(context);
       const fakeSignature = createSignatureForJSXIntrinsic(context, result);
@@ -73012,8 +73241,6 @@ function createTypeChecker(host) {
     return node.initializer ? checkExpressionForMutableLocation(node.initializer, checkMode) : trueType;
   }
   function createJsxAttributesTypeFromAttributesProperty(openingLikeElement, checkMode = 0 /* Normal */) {
-    const attributes = openingLikeElement.attributes;
-    const contextualType = getContextualType(attributes, 0 /* None */);
     const allAttributesTable = strictNullChecks ? createSymbolTable() : void 0;
     let attributesTable = createSymbolTable();
     let spread = emptyJsxObjectType;
@@ -73022,96 +73249,105 @@ function createTypeChecker(host) {
     let explicitlySpecifyChildrenAttribute = false;
     let objectFlags = 2048 /* JsxAttributes */;
     const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(openingLikeElement));
-    for (const attributeDecl of attributes.properties) {
-      const member = attributeDecl.symbol;
-      if (isJsxAttribute(attributeDecl)) {
-        const exprType = checkJsxAttribute(attributeDecl, checkMode);
-        objectFlags |= getObjectFlags(exprType) & 458752 /* PropagatingFlags */;
-        const attributeSymbol = createSymbol(4 /* Property */ | member.flags, member.escapedName);
-        attributeSymbol.declarations = member.declarations;
-        attributeSymbol.parent = member.parent;
-        if (member.valueDeclaration) {
-          attributeSymbol.valueDeclaration = member.valueDeclaration;
-        }
-        attributeSymbol.links.type = exprType;
-        attributeSymbol.links.target = member;
-        attributesTable.set(attributeSymbol.escapedName, attributeSymbol);
-        allAttributesTable == null ? void 0 : allAttributesTable.set(attributeSymbol.escapedName, attributeSymbol);
-        if (getEscapedTextOfJsxAttributeName(attributeDecl.name) === jsxChildrenPropertyName) {
-          explicitlySpecifyChildrenAttribute = true;
-        }
-        if (contextualType) {
-          const prop = getPropertyOfType(contextualType, member.escapedName);
-          if (prop && prop.declarations && isDeprecatedSymbol(prop) && isIdentifier(attributeDecl.name)) {
-            addDeprecatedSuggestion(attributeDecl.name, prop.declarations, attributeDecl.name.escapedText);
+    const isJsxOpenFragment = isJsxOpeningFragment(openingLikeElement);
+    let attributesSymbol;
+    let attributeParent = openingLikeElement;
+    if (!isJsxOpenFragment) {
+      const attributes = openingLikeElement.attributes;
+      attributesSymbol = attributes.symbol;
+      attributeParent = attributes;
+      const contextualType = getContextualType(attributes, 0 /* None */);
+      for (const attributeDecl of attributes.properties) {
+        const member = attributeDecl.symbol;
+        if (isJsxAttribute(attributeDecl)) {
+          const exprType = checkJsxAttribute(attributeDecl, checkMode);
+          objectFlags |= getObjectFlags(exprType) & 458752 /* PropagatingFlags */;
+          const attributeSymbol = createSymbol(4 /* Property */ | member.flags, member.escapedName);
+          attributeSymbol.declarations = member.declarations;
+          attributeSymbol.parent = member.parent;
+          if (member.valueDeclaration) {
+            attributeSymbol.valueDeclaration = member.valueDeclaration;
+          }
+          attributeSymbol.links.type = exprType;
+          attributeSymbol.links.target = member;
+          attributesTable.set(attributeSymbol.escapedName, attributeSymbol);
+          allAttributesTable == null ? void 0 : allAttributesTable.set(attributeSymbol.escapedName, attributeSymbol);
+          if (getEscapedTextOfJsxAttributeName(attributeDecl.name) === jsxChildrenPropertyName) {
+            explicitlySpecifyChildrenAttribute = true;
+          }
+          if (contextualType) {
+            const prop = getPropertyOfType(contextualType, member.escapedName);
+            if (prop && prop.declarations && isDeprecatedSymbol(prop) && isIdentifier(attributeDecl.name)) {
+              addDeprecatedSuggestion(attributeDecl.name, prop.declarations, attributeDecl.name.escapedText);
+            }
+          }
+          if (contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(attributeDecl)) {
+            const inferenceContext = getInferenceContext(attributes);
+            Debug.assert(inferenceContext);
+            const inferenceNode = attributeDecl.initializer.expression;
+            addIntraExpressionInferenceSite(inferenceContext, inferenceNode, exprType);
+          }
+        } else {
+          Debug.assert(attributeDecl.kind === 293 /* JsxSpreadAttribute */);
+          if (attributesTable.size > 0) {
+            spread = getSpreadType(
+              spread,
+              createJsxAttributesTypeHelper(),
+              attributes.symbol,
+              objectFlags,
+              /*readonly*/
+              false
+            );
+            attributesTable = createSymbolTable();
+          }
+          const exprType = getReducedType(checkExpression(attributeDecl.expression, checkMode & 2 /* Inferential */));
+          if (isTypeAny(exprType)) {
+            hasSpreadAnyType = true;
+          }
+          if (isValidSpreadType(exprType)) {
+            spread = getSpreadType(
+              spread,
+              exprType,
+              attributes.symbol,
+              objectFlags,
+              /*readonly*/
+              false
+            );
+            if (allAttributesTable) {
+              checkSpreadPropOverrides(exprType, allAttributesTable, attributeDecl);
+            }
+          } else {
+            error(attributeDecl.expression, Diagnostics.Spread_types_may_only_be_created_from_object_types);
+            typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType;
           }
         }
-        if (contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(attributeDecl)) {
-          const inferenceContext = getInferenceContext(attributes);
-          Debug.assert(inferenceContext);
-          const inferenceNode = attributeDecl.initializer.expression;
-          addIntraExpressionInferenceSite(inferenceContext, inferenceNode, exprType);
-        }
-      } else {
-        Debug.assert(attributeDecl.kind === 293 /* JsxSpreadAttribute */);
+      }
+      if (!hasSpreadAnyType) {
         if (attributesTable.size > 0) {
           spread = getSpreadType(
             spread,
-            createJsxAttributesType(),
-            attributes.symbol,
-            objectFlags,
-            /*readonly*/
-            false
-          );
-          attributesTable = createSymbolTable();
-        }
-        const exprType = getReducedType(checkExpression(attributeDecl.expression, checkMode & 2 /* Inferential */));
-        if (isTypeAny(exprType)) {
-          hasSpreadAnyType = true;
-        }
-        if (isValidSpreadType(exprType)) {
-          spread = getSpreadType(
-            spread,
-            exprType,
+            createJsxAttributesTypeHelper(),
             attributes.symbol,
             objectFlags,
             /*readonly*/
             false
           );
-          if (allAttributesTable) {
-            checkSpreadPropOverrides(exprType, allAttributesTable, attributeDecl);
-          }
-        } else {
-          error(attributeDecl.expression, Diagnostics.Spread_types_may_only_be_created_from_object_types);
-          typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType;
         }
       }
     }
-    if (!hasSpreadAnyType) {
-      if (attributesTable.size > 0) {
-        spread = getSpreadType(
-          spread,
-          createJsxAttributesType(),
-          attributes.symbol,
-          objectFlags,
-          /*readonly*/
-          false
-        );
-      }
-    }
-    const parent = openingLikeElement.parent.kind === 284 /* JsxElement */ ? openingLikeElement.parent : void 0;
-    if (parent && parent.openingElement === openingLikeElement && getSemanticJsxChildren(parent.children).length > 0) {
+    const parent = openingLikeElement.parent;
+    if ((isJsxElement(parent) && parent.openingElement === openingLikeElement || isJsxFragment(parent) && parent.openingFragment === openingLikeElement) && getSemanticJsxChildren(parent.children).length > 0) {
       const childrenTypes = checkJsxChildren(parent, checkMode);
       if (!hasSpreadAnyType && jsxChildrenPropertyName && jsxChildrenPropertyName !== "") {
         if (explicitlySpecifyChildrenAttribute) {
-          error(attributes, Diagnostics._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, unescapeLeadingUnderscores(jsxChildrenPropertyName));
+          error(attributeParent, Diagnostics._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, unescapeLeadingUnderscores(jsxChildrenPropertyName));
         }
-        const contextualType2 = getApparentTypeOfContextualType(
+        const contextualType = isJsxOpeningElement(openingLikeElement) ? getApparentTypeOfContextualType(
           openingLikeElement.attributes,
           /*contextFlags*/
           void 0
-        );
-        const childrenContextualType = contextualType2 && getTypeOfPropertyOfContextualType(contextualType2, jsxChildrenPropertyName);
+        ) : void 0;
+        const childrenContextualType = contextualType && getTypeOfPropertyOfContextualType(contextualType, jsxChildrenPropertyName);
         const childrenPropSymbol = createSymbol(4 /* Property */, jsxChildrenPropertyName);
         childrenPropSymbol.links.type = childrenTypes.length === 1 ? childrenTypes[0] : childrenContextualType && someType(childrenContextualType, isTupleLikeType) ? createTupleType(childrenTypes) : createArrayType(getUnionType(childrenTypes));
         childrenPropSymbol.valueDeclaration = factory.createPropertySignature(
@@ -73123,14 +73359,14 @@ function createTypeChecker(host) {
           /*type*/
           void 0
         );
-        setParent(childrenPropSymbol.valueDeclaration, attributes);
+        setParent(childrenPropSymbol.valueDeclaration, attributeParent);
         childrenPropSymbol.valueDeclaration.symbol = childrenPropSymbol;
         const childPropMap = createSymbolTable();
         childPropMap.set(jsxChildrenPropertyName, childrenPropSymbol);
         spread = getSpreadType(
           spread,
-          createAnonymousType(attributes.symbol, childPropMap, emptyArray, emptyArray, emptyArray),
-          attributes.symbol,
+          createAnonymousType(attributesSymbol, childPropMap, emptyArray, emptyArray, emptyArray),
+          attributesSymbol,
           objectFlags,
           /*readonly*/
           false
@@ -73143,14 +73379,17 @@ function createTypeChecker(host) {
     if (typeToIntersect && spread !== emptyJsxObjectType) {
       return getIntersectionType([typeToIntersect, spread]);
     }
-    return typeToIntersect || (spread === emptyJsxObjectType ? createJsxAttributesType() : spread);
-    function createJsxAttributesType() {
+    return typeToIntersect || (spread === emptyJsxObjectType ? createJsxAttributesTypeHelper() : spread);
+    function createJsxAttributesTypeHelper() {
       objectFlags |= 8192 /* FreshLiteral */;
-      const result = createAnonymousType(attributes.symbol, attributesTable, emptyArray, emptyArray, emptyArray);
-      result.objectFlags |= objectFlags | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
-      return result;
+      return createJsxAttributesType(objectFlags, attributesSymbol, attributesTable);
     }
   }
+  function createJsxAttributesType(objectFlags, attributesSymbol, attributesTable) {
+    const result = createAnonymousType(attributesSymbol, attributesTable, emptyArray, emptyArray, emptyArray);
+    result.objectFlags |= objectFlags | 8192 /* FreshLiteral */ | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
+    return result;
+  }
   function checkJsxChildren(node, checkMode) {
     const childrenTypes = [];
     for (const child of node.children) {
@@ -73456,10 +73695,10 @@ function createTypeChecker(host) {
     }
     checkJsxPreconditions(node);
     markJsxAliasReferenced(node);
+    const sig = getResolvedSignature(node);
+    checkDeprecatedSignature(sig, node);
     if (isNodeOpeningLikeElement) {
       const jsxOpeningLikeNode = node;
-      const sig = getResolvedSignature(jsxOpeningLikeNode);
-      checkDeprecatedSignature(sig, node);
       const elementTypeConstraint = getJsxElementTypeTypeAt(jsxOpeningLikeNode);
       if (elementTypeConstraint !== void 0) {
         const tagName = jsxOpeningLikeNode.tagName;
@@ -74483,6 +74722,7 @@ function createTypeChecker(host) {
     return !!(t.flags & (16384 /* Void */ | 32768 /* Undefined */ | 2 /* Unknown */ | 1 /* Any */));
   }
   function hasCorrectArity(node, args, signature, signatureHelpTrailingComma = false) {
+    if (isJsxOpeningFragment(node)) return true;
     let argCount;
     let callIsIncomplete = false;
     let effectiveParameterCount = getParameterCount(signature);
@@ -74756,9 +74996,9 @@ function createTypeChecker(host) {
     }
     return 2 /* Mixed */;
   }
-  function checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer) {
+  function checkApplicableSignatureForJsxCallLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer) {
     const paramType = getEffectiveFirstArgumentForJsxSignature(signature, node);
-    const attributesType = checkExpressionWithContextualType(
+    const attributesType = isJsxOpeningFragment(node) ? createJsxAttributesTypeFromAttributesProperty(node) : checkExpressionWithContextualType(
       node.attributes,
       paramType,
       /*inferenceContext*/
@@ -74770,8 +75010,8 @@ function createTypeChecker(host) {
       checkAttributesType,
       paramType,
       relation,
-      reportErrors2 ? node.tagName : void 0,
-      node.attributes,
+      reportErrors2 ? isJsxOpeningFragment(node) ? node : node.tagName : void 0,
+      isJsxOpeningFragment(node) ? void 0 : node.attributes,
       /*headMessage*/
       void 0,
       containingMessageChain,
@@ -74842,10 +75082,11 @@ function createTypeChecker(host) {
         return true;
       }
       if (reportErrors2) {
-        const diag2 = createDiagnosticForNode(node.tagName, Diagnostics.Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3, entityNameToString(node.tagName), absoluteMinArgCount, entityNameToString(factory2), maxParamCount);
-        const tagNameDeclaration = (_a = getSymbolAtLocation(node.tagName)) == null ? void 0 : _a.valueDeclaration;
+        const tagName = node.tagName;
+        const diag2 = createDiagnosticForNode(tagName, Diagnostics.Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3, entityNameToString(tagName), absoluteMinArgCount, entityNameToString(factory2), maxParamCount);
+        const tagNameDeclaration = (_a = getSymbolAtLocation(tagName)) == null ? void 0 : _a.valueDeclaration;
         if (tagNameDeclaration) {
-          addRelatedInfo(diag2, createDiagnosticForNode(tagNameDeclaration, Diagnostics._0_is_declared_here, entityNameToString(node.tagName)));
+          addRelatedInfo(diag2, createDiagnosticForNode(tagNameDeclaration, Diagnostics._0_is_declared_here, entityNameToString(tagName)));
         }
         if (errorOutputContainer && errorOutputContainer.skipLogging) {
           (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag2);
@@ -74863,8 +75104,8 @@ function createTypeChecker(host) {
   }
   function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors2, containingMessageChain, inferenceContext) {
     const errorOutputContainer = { errors: void 0, skipLogging: true };
-    if (isJsxOpeningLikeElement(node)) {
-      if (!checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer)) {
+    if (isJsxCallLike(node)) {
+      if (!checkApplicableSignatureForJsxCallLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer)) {
         Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "jsx should have errors when reporting errors");
         return errorOutputContainer.errors || emptyArray;
       }
@@ -74964,6 +75205,9 @@ function createTypeChecker(host) {
     return result;
   }
   function getEffectiveCallArguments(node) {
+    if (isJsxOpeningFragment(node)) {
+      return [createSyntheticExpression(node, emptyFreshJsxObjectType)];
+    }
     if (node.kind === 215 /* TaggedTemplateExpression */) {
       const template = node.template;
       const args2 = [createSyntheticExpression(template, getGlobalTemplateStringsArrayType())];
@@ -75248,25 +75492,32 @@ function createTypeChecker(host) {
     const isTaggedTemplate = node.kind === 215 /* TaggedTemplateExpression */;
     const isDecorator2 = node.kind === 170 /* Decorator */;
     const isJsxOpeningOrSelfClosingElement = isJsxOpeningLikeElement(node);
+    const isJsxOpenFragment = isJsxOpeningFragment(node);
     const isInstanceof = node.kind === 226 /* BinaryExpression */;
     const reportErrors2 = !isInferencePartiallyBlocked && !candidatesOutArray;
+    let candidatesForArgumentError;
+    let candidateForArgumentArityError;
+    let candidateForTypeArgumentError;
+    let result;
+    let argCheckMode = 0 /* Normal */;
+    let candidates = [];
     let typeArguments;
-    if (!isDecorator2 && !isInstanceof && !isSuperCall(node)) {
+    if (!isDecorator2 && !isInstanceof && !isSuperCall(node) && !isJsxOpenFragment) {
       typeArguments = node.typeArguments;
       if (isTaggedTemplate || isJsxOpeningOrSelfClosingElement || node.expression.kind !== 108 /* SuperKeyword */) {
         forEach(typeArguments, checkSourceElement);
       }
     }
-    const candidates = candidatesOutArray || [];
+    candidates = candidatesOutArray || [];
     reorderCandidates(signatures, candidates, callChainFlags);
-    Debug.assert(candidates.length, "Revert #54442 and add a testcase with whatever triggered this");
+    if (!isJsxOpenFragment) {
+      Debug.assert(candidates.length, "Revert #54442 and add a testcase with whatever triggered this");
+    }
     const args = getEffectiveCallArguments(node);
     const isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters;
-    let argCheckMode = !isDecorator2 && !isSingleNonGenericCandidate && some(args, isContextSensitive) ? 4 /* SkipContextSensitive */ : 0 /* Normal */;
-    let candidatesForArgumentError;
-    let candidateForArgumentArityError;
-    let candidateForTypeArgumentError;
-    let result;
+    if (!isDecorator2 && !isSingleNonGenericCandidate && some(args, isContextSensitive)) {
+      argCheckMode = 4 /* SkipContextSensitive */;
+    }
     const signatureHelpTrailingComma = !!(checkMode & 16 /* IsForSignatureHelp */) && node.kind === 213 /* CallExpression */ && node.arguments.hasTrailingComma;
     if (candidates.length > 1) {
       result = chooseOverload(candidates, subtypeRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma);
@@ -75386,7 +75637,7 @@ function createTypeChecker(host) {
           true,
           headMessage
         );
-      } else {
+      } else if (!isJsxOpenFragment) {
         const signaturesWithCorrectTypeArgumentArity = filter(signatures, (s) => hasCorrectTypeArgumentArity(s, typeArguments));
         if (signaturesWithCorrectTypeArgumentArity.length === 0) {
           diagnostics.add(getTypeArgumentArityError(node, signatures, typeArguments, headMessage));
@@ -76034,24 +76285,52 @@ function createTypeChecker(host) {
       0 /* None */
     );
   }
+  function getJSXFragmentType(node) {
+    const sourceFileLinks = getNodeLinks(getSourceFileOfNode(node));
+    if (sourceFileLinks.jsxFragmentType !== void 0) return sourceFileLinks.jsxFragmentType;
+    const jsxFragmentFactoryName = getJsxNamespace(node);
+    const jsxFactoryRefErr = diagnostics ? Diagnostics.Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found : void 0;
+    const jsxFactorySymbol = getJsxNamespaceContainerForImplicitImport(node) ?? resolveName(
+      node,
+      jsxFragmentFactoryName,
+      111551 /* Value */,
+      /*nameNotFoundMessage*/
+      jsxFactoryRefErr,
+      /*isUse*/
+      true
+    );
+    if (jsxFactorySymbol === void 0) return sourceFileLinks.jsxFragmentType = errorType;
+    if (jsxFactorySymbol.escapedName === ReactNames.Fragment) return sourceFileLinks.jsxFragmentType = getTypeOfSymbol(jsxFactorySymbol);
+    const resolvedAlias = (jsxFactorySymbol.flags & 2097152 /* Alias */) === 0 ? jsxFactorySymbol : resolveAlias(jsxFactorySymbol);
+    const reactExports = jsxFactorySymbol && getExportsOfSymbol(resolvedAlias);
+    const typeSymbol = reactExports && getSymbol(reactExports, ReactNames.Fragment, 2 /* BlockScopedVariable */);
+    const type = typeSymbol && getTypeOfSymbol(typeSymbol);
+    return sourceFileLinks.jsxFragmentType = type === void 0 ? errorType : type;
+  }
   function resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode) {
-    if (isJsxIntrinsicTagName(node.tagName)) {
-      const result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node);
-      const fakeSignature = createSignatureForJSXIntrinsic(node, result);
-      checkTypeAssignableToAndOptionallyElaborate(checkExpressionWithContextualType(
-        node.attributes,
-        getEffectiveFirstArgumentForJsxSignature(fakeSignature, node),
-        /*inferenceContext*/
-        void 0,
-        0 /* Normal */
-      ), result, node.tagName, node.attributes);
-      if (length(node.typeArguments)) {
-        forEach(node.typeArguments, checkSourceElement);
-        diagnostics.add(createDiagnosticForNodeArray(getSourceFileOfNode(node), node.typeArguments, Diagnostics.Expected_0_type_arguments_but_got_1, 0, length(node.typeArguments)));
+    const isJsxOpenFragment = isJsxOpeningFragment(node);
+    let exprTypes;
+    if (!isJsxOpenFragment) {
+      if (isJsxIntrinsicTagName(node.tagName)) {
+        const result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node);
+        const fakeSignature = createSignatureForJSXIntrinsic(node, result);
+        checkTypeAssignableToAndOptionallyElaborate(checkExpressionWithContextualType(
+          node.attributes,
+          getEffectiveFirstArgumentForJsxSignature(fakeSignature, node),
+          /*inferenceContext*/
+          void 0,
+          0 /* Normal */
+        ), result, node.tagName, node.attributes);
+        if (length(node.typeArguments)) {
+          forEach(node.typeArguments, checkSourceElement);
+          diagnostics.add(createDiagnosticForNodeArray(getSourceFileOfNode(node), node.typeArguments, Diagnostics.Expected_0_type_arguments_but_got_1, 0, length(node.typeArguments)));
+        }
+        return fakeSignature;
       }
-      return fakeSignature;
+      exprTypes = checkExpression(node.tagName);
+    } else {
+      exprTypes = getJSXFragmentType(node);
     }
-    const exprTypes = checkExpression(node.tagName);
     const apparentType = getApparentType(exprTypes);
     if (isErrorType(apparentType)) {
       return resolveErrorCall(node);
@@ -76067,7 +76346,11 @@ function createTypeChecker(host) {
       return resolveUntypedCall(node);
     }
     if (signatures.length === 0) {
-      error(node.tagName, Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, getTextOfNode(node.tagName));
+      if (isJsxOpenFragment) {
+        error(node, Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, getTextOfNode(node));
+      } else {
+        error(node.tagName, Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, getTextOfNode(node.tagName));
+      }
       return resolveErrorCall(node);
     }
     return resolveCall(node, signatures, candidatesOutArray, checkMode, 0 /* None */);
@@ -76109,6 +76392,7 @@ function createTypeChecker(host) {
         return resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode);
       case 170 /* Decorator */:
         return resolveDecorator(node, candidatesOutArray, checkMode);
+      case 289 /* JsxOpeningFragment */:
       case 286 /* JsxOpeningElement */:
       case 285 /* JsxSelfClosingElement */:
         return resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode);
@@ -87328,6 +87612,8 @@ function createTypeChecker(host) {
         return ["__propKey"];
       case 16777216 /* AddDisposableResourceAndDisposeResources */:
         return ["__addDisposableResource", "__disposeResources"];
+      case 33554432 /* RewriteRelativeImportExtension */:
+        return ["__rewriteRelativeImportExtension"];
       default:
         return Debug.fail("Unrecognized helper");
     }
@@ -88892,6 +89178,10 @@ var JsxNames;
   JsxNames2.IntrinsicClassAttributes = "IntrinsicClassAttributes";
   JsxNames2.LibraryManagedAttributes = "LibraryManagedAttributes";
 })(JsxNames || (JsxNames = {}));
+var ReactNames;
+((ReactNames2) => {
+  ReactNames2.Fragment = "Fragment";
+})(ReactNames || (ReactNames = {}));
 function getIterationTypesKeyFromIterationTypeKind(typeKind) {
   switch (typeKind) {
     case 0 /* Yield */:
@@ -88917,7 +89207,7 @@ function createBasicNodeBuilderModuleSpecifierResolutionHost(host) {
       var _a;
       return (_a = host.getPackageJsonInfoCache) == null ? void 0 : _a.call(host);
     },
-    useCaseSensitiveFileNames: maybeBind(host, host.useCaseSensitiveFileNames),
+    useCaseSensitiveFileNames: () => host.useCaseSensitiveFileNames(),
     redirectTargetsMap: host.redirectTargetsMap,
     getProjectReferenceRedirect: (fileName) => host.getProjectReferenceRedirect(fileName),
     isSourceOfProjectReferenceRedirect: (fileName) => host.isSourceOfProjectReferenceRedirect(fileName),
@@ -91192,6 +91482,13 @@ function isSimpleParameter(node) {
 function isSimpleParameterList(nodes) {
   return every(nodes, isSimpleParameter);
 }
+function rewriteModuleSpecifier(node, compilerOptions) {
+  if (!node || !isStringLiteral(node) || !shouldRewriteModuleSpecifier(node.text, compilerOptions)) {
+    return node;
+  }
+  const updatedText = changeExtension(node.text, getOutputExtension(node.text, compilerOptions));
+  return updatedText !== node.text ? setOriginalNode(setTextRange(factory.createStringLiteral(updatedText, node.singleQuote), node), node) : node;
+}
 
 // src/compiler/transformers/destructuring.ts
 function flattenDestructuringAssignment(node, visitor, context, level, needsValue, createAssignmentCallback) {
@@ -93510,7 +93807,14 @@ function transformTypeScript(context) {
       return void 0;
     }
     if (!node.exportClause || isNamespaceExport(node.exportClause)) {
-      return node;
+      return factory2.updateExportDeclaration(
+        node,
+        node.modifiers,
+        node.isTypeOnly,
+        node.exportClause,
+        node.moduleSpecifier,
+        node.attributes
+      );
     }
     const allowEmpty = !!compilerOptions.verbatimModuleSyntax;
     const exportClause = visitNode(
@@ -93549,8 +93853,10 @@ function transformTypeScript(context) {
       return void 0;
     }
     if (isExternalModuleImportEqualsDeclaration(node)) {
-      const isReferenced = shouldEmitAliasDeclaration(node);
-      return isReferenced ? visitEachChild(node, visitor, context) : void 0;
+      if (!shouldEmitAliasDeclaration(node)) {
+        return void 0;
+      }
+      return visitEachChild(node, visitor, context);
     }
     if (!shouldEmitImportEqualsDeclaration(node)) {
       return void 0;
@@ -108120,6 +108426,7 @@ function transformModule(context) {
   const moduleInfoMap = [];
   let currentSourceFile;
   let currentModuleInfo;
+  let importsAndRequiresToRewriteOrShim;
   const noSubstitution = [];
   let needUMDDynamicImportHelper;
   return chainBundle(context, transformSourceFile);
@@ -108130,6 +108437,20 @@ function transformModule(context) {
     currentSourceFile = node;
     currentModuleInfo = collectExternalModuleInfo(context, node);
     moduleInfoMap[getOriginalNodeId(node)] = currentModuleInfo;
+    if (compilerOptions.rewriteRelativeImportExtensions) {
+      forEachDynamicImportOrRequireCall(
+        node,
+        /*includeTypeSpaceImports*/
+        false,
+        /*requireStringLiteralLikeArgument*/
+        false,
+        (node2) => {
+          if (!isStringLiteralLike(node2.arguments[0]) || shouldRewriteModuleSpecifier(node2.arguments[0].text, compilerOptions)) {
+            importsAndRequiresToRewriteOrShim = append(importsAndRequiresToRewriteOrShim, node2);
+          }
+        }
+      );
+    }
     const transformModule2 = getTransformModuleDelegate(moduleKind);
     const updated = transformModule2(node);
     currentSourceFile = void 0;
@@ -108601,7 +108922,7 @@ function transformModule(context) {
     }
   }
   function visitorWorker(node, valueIsDiscarded) {
-    if (!(node.transformFlags & (8388608 /* ContainsDynamicImport */ | 4096 /* ContainsDestructuringAssignment */ | 268435456 /* ContainsUpdateExpressionForIdentifier */))) {
+    if (!(node.transformFlags & (8388608 /* ContainsDynamicImport */ | 4096 /* ContainsDestructuringAssignment */ | 268435456 /* ContainsUpdateExpressionForIdentifier */)) && !(importsAndRequiresToRewriteOrShim == null ? void 0 : importsAndRequiresToRewriteOrShim.length)) {
       return node;
     }
     switch (node.kind) {
@@ -108618,8 +108939,14 @@ function transformModule(context) {
       case 355 /* PartiallyEmittedExpression */:
         return visitPartiallyEmittedExpression(node, valueIsDiscarded);
       case 213 /* CallExpression */:
+        const needsRewrite = node === firstOrUndefined(importsAndRequiresToRewriteOrShim);
+        if (needsRewrite) {
+          importsAndRequiresToRewriteOrShim.shift();
+        }
         if (isImportCall(node) && host.shouldTransformImportCall(currentSourceFile)) {
-          return visitImportCallExpression(node);
+          return visitImportCallExpression(node, needsRewrite);
+        } else if (needsRewrite) {
+          return shimOrRewriteImportOrRequireCall(node);
         }
         break;
       case 226 /* BinaryExpression */:
@@ -108911,13 +109238,27 @@ function transformModule(context) {
     }
     return visitEachChild(node, visitor, context);
   }
-  function visitImportCallExpression(node) {
+  function shimOrRewriteImportOrRequireCall(node) {
+    return factory2.updateCallExpression(
+      node,
+      node.expression,
+      /*typeArguments*/
+      void 0,
+      visitNodes2(node.arguments, (arg) => {
+        if (arg === node.arguments[0]) {
+          return isStringLiteralLike(arg) ? rewriteModuleSpecifier(arg, compilerOptions) : emitHelpers().createRewriteRelativeImportExtensionsHelper(arg);
+        }
+        return visitor(arg);
+      }, isExpression)
+    );
+  }
+  function visitImportCallExpression(node, rewriteOrShim) {
     if (moduleKind === 0 /* None */ && languageVersion >= 7 /* ES2020 */) {
       return visitEachChild(node, visitor, context);
     }
     const externalModuleName = getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver, compilerOptions);
     const firstArgument = visitNode(firstOrUndefined(node.arguments), visitor, isExpression);
-    const argument = externalModuleName && (!firstArgument || !isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument;
+    const argument = externalModuleName && (!firstArgument || !isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument && rewriteOrShim ? isStringLiteral(firstArgument) ? rewriteModuleSpecifier(firstArgument, compilerOptions) : emitHelpers().createRewriteRelativeImportExtensionsHelper(firstArgument) : firstArgument;
     const containsLexicalThis = !!(node.transformFlags & 16384 /* ContainsLexicalThis */);
     switch (compilerOptions.module) {
       case 2 /* AMD */:
@@ -109248,7 +109589,7 @@ function transformModule(context) {
     const moduleName = getExternalModuleNameLiteral(factory2, importNode, currentSourceFile, host, resolver, compilerOptions);
     const args = [];
     if (moduleName) {
-      args.push(moduleName);
+      args.push(rewriteModuleSpecifier(moduleName, compilerOptions));
     }
     return factory2.createCallExpression(
       factory2.createIdentifier("require"),
@@ -111344,6 +111685,7 @@ function transformECMAScriptModule(context) {
   context.enableEmitNotification(307 /* SourceFile */);
   context.enableSubstitution(80 /* Identifier */);
   const noSubstitution = /* @__PURE__ */ new Set();
+  let importsAndRequiresToRewriteOrShim;
   let helperNameSubstitutions;
   let currentSourceFile;
   let importRequireStatements;
@@ -111355,7 +111697,22 @@ function transformECMAScriptModule(context) {
     if (isExternalModule(node) || getIsolatedModules(compilerOptions)) {
       currentSourceFile = node;
       importRequireStatements = void 0;
+      if (compilerOptions.rewriteRelativeImportExtensions && (currentSourceFile.flags & 4194304 /* PossiblyContainsDynamicImport */ || isInJSFile(node))) {
+        forEachDynamicImportOrRequireCall(
+          node,
+          /*includeTypeSpaceImports*/
+          false,
+          /*requireStringLiteralLikeArgument*/
+          false,
+          (node2) => {
+            if (!isStringLiteralLike(node2.arguments[0]) || shouldRewriteModuleSpecifier(node2.arguments[0].text, compilerOptions)) {
+              importsAndRequiresToRewriteOrShim = append(importsAndRequiresToRewriteOrShim, node2);
+            }
+          }
+        );
+      }
       let result = updateExternalModule(node);
+      addEmitHelpers(result, context.readEmitHelpers());
       currentSourceFile = void 0;
       if (importRequireStatements) {
         result = factory2.updateSourceFile(
@@ -111397,14 +111754,52 @@ function transformECMAScriptModule(context) {
       case 278 /* ExportDeclaration */:
         const exportDecl = node;
         return visitExportDeclaration(exportDecl);
+      case 272 /* ImportDeclaration */:
+        return visitImportDeclaration(node);
+      case 213 /* CallExpression */:
+        if (node === (importsAndRequiresToRewriteOrShim == null ? void 0 : importsAndRequiresToRewriteOrShim[0])) {
+          return visitImportOrRequireCall(importsAndRequiresToRewriteOrShim.shift());
+        }
+        break;
+      default:
+        if ((importsAndRequiresToRewriteOrShim == null ? void 0 : importsAndRequiresToRewriteOrShim.length) && rangeContainsRange(node, importsAndRequiresToRewriteOrShim[0])) {
+          return visitEachChild(node, visitor, context);
+        }
     }
     return node;
   }
+  function visitImportDeclaration(node) {
+    if (!compilerOptions.rewriteRelativeImportExtensions) {
+      return node;
+    }
+    const updatedModuleSpecifier = rewriteModuleSpecifier(node.moduleSpecifier, compilerOptions);
+    if (updatedModuleSpecifier === node.moduleSpecifier) {
+      return node;
+    }
+    return factory2.updateImportDeclaration(
+      node,
+      node.modifiers,
+      node.importClause,
+      updatedModuleSpecifier,
+      node.attributes
+    );
+  }
+  function visitImportOrRequireCall(node) {
+    return factory2.updateCallExpression(
+      node,
+      node.expression,
+      node.typeArguments,
+      [
+        isStringLiteralLike(node.arguments[0]) ? rewriteModuleSpecifier(node.arguments[0], compilerOptions) : emitHelpers().createRewriteRelativeImportExtensionsHelper(node.arguments[0]),
+        ...node.arguments.slice(1)
+      ]
+    );
+  }
   function createRequireCall(importNode) {
     const moduleName = getExternalModuleNameLiteral(factory2, importNode, Debug.checkDefined(currentSourceFile), host, resolver, compilerOptions);
     const args = [];
     if (moduleName) {
-      args.push(moduleName);
+      args.push(rewriteModuleSpecifier(moduleName, compilerOptions));
     }
     if (getEmitModuleKind(compilerOptions) === 200 /* Preserve */) {
       return factory2.createCallExpression(
@@ -111549,11 +111944,16 @@ function transformECMAScriptModule(context) {
     return node;
   }
   function visitExportDeclaration(node) {
-    if (compilerOptions.module !== void 0 && compilerOptions.module > 5 /* ES2015 */) {
-      return node;
-    }
-    if (!node.exportClause || !isNamespaceExport(node.exportClause) || !node.moduleSpecifier) {
-      return node;
+    const updatedModuleSpecifier = rewriteModuleSpecifier(node.moduleSpecifier, compilerOptions);
+    if (compilerOptions.module !== void 0 && compilerOptions.module > 5 /* ES2015 */ || !node.exportClause || !isNamespaceExport(node.exportClause) || !node.moduleSpecifier) {
+      return !node.moduleSpecifier || updatedModuleSpecifier === node.moduleSpecifier ? node : factory2.updateExportDeclaration(
+        node,
+        node.modifiers,
+        node.isTypeOnly,
+        node.exportClause,
+        updatedModuleSpecifier,
+        node.attributes
+      );
     }
     const oldIdentifier = node.exportClause.name;
     const synthName = factory2.getGeneratedNameForNode(oldIdentifier);
@@ -111569,7 +111969,7 @@ function transformECMAScriptModule(context) {
           synthName
         )
       ),
-      node.moduleSpecifier,
+      updatedModuleSpecifier,
       node.attributes
     );
     setOriginalNode(importDecl, node.exportClause);
@@ -112728,7 +113128,7 @@ function transformDeclarations(context) {
     }
     return setCommentRange(updated, getCommentRange(original));
   }
-  function rewriteModuleSpecifier(parent, input) {
+  function rewriteModuleSpecifier2(parent, input) {
     if (!input) return void 0;
     resultHasExternalModuleIndicator = resultHasExternalModuleIndicator || parent.kind !== 267 /* ModuleDeclaration */ && parent.kind !== 205 /* ImportType */;
     if (isStringLiteralLike(input)) {
@@ -112750,7 +113150,7 @@ function transformDeclarations(context) {
         decl.modifiers,
         decl.isTypeOnly,
         decl.name,
-        factory2.updateExternalModuleReference(decl.moduleReference, rewriteModuleSpecifier(decl, specifier))
+        factory2.updateExternalModuleReference(decl.moduleReference, rewriteModuleSpecifier2(decl, specifier))
       );
     } else {
       const oldDiag = getSymbolAccessibilityDiagnostic;
@@ -112766,7 +113166,7 @@ function transformDeclarations(context) {
         decl,
         decl.modifiers,
         decl.importClause,
-        rewriteModuleSpecifier(decl, decl.moduleSpecifier),
+        rewriteModuleSpecifier2(decl, decl.moduleSpecifier),
         tryGetResolutionModeOverride(decl.attributes)
       );
     }
@@ -112782,7 +113182,7 @@ function transformDeclarations(context) {
           /*namedBindings*/
           void 0
         ),
-        rewriteModuleSpecifier(decl, decl.moduleSpecifier),
+        rewriteModuleSpecifier2(decl, decl.moduleSpecifier),
         tryGetResolutionModeOverride(decl.attributes)
       );
     }
@@ -112800,7 +113200,7 @@ function transformDeclarations(context) {
           visibleDefaultBinding,
           namedBindings
         ),
-        rewriteModuleSpecifier(decl, decl.moduleSpecifier),
+        rewriteModuleSpecifier2(decl, decl.moduleSpecifier),
         tryGetResolutionModeOverride(decl.attributes)
       ) : void 0;
     }
@@ -112815,7 +113215,7 @@ function transformDeclarations(context) {
           visibleDefaultBinding,
           bindingList && bindingList.length ? factory2.updateNamedImports(decl.importClause.namedBindings, bindingList) : void 0
         ),
-        rewriteModuleSpecifier(decl, decl.moduleSpecifier),
+        rewriteModuleSpecifier2(decl, decl.moduleSpecifier),
         tryGetResolutionModeOverride(decl.attributes)
       );
     }
@@ -112828,7 +113228,7 @@ function transformDeclarations(context) {
         decl.modifiers,
         /*importClause*/
         void 0,
-        rewriteModuleSpecifier(decl, decl.moduleSpecifier),
+        rewriteModuleSpecifier2(decl, decl.moduleSpecifier),
         tryGetResolutionModeOverride(decl.attributes)
       );
     }
@@ -113142,7 +113542,7 @@ function transformDeclarations(context) {
           if (!isLiteralImportTypeNode(input)) return cleanup(input);
           return cleanup(factory2.updateImportTypeNode(
             input,
-            factory2.updateLiteralTypeNode(input.argument, rewriteModuleSpecifier(input, input.argument.literal)),
+            factory2.updateLiteralTypeNode(input.argument, rewriteModuleSpecifier2(input, input.argument.literal)),
             input.attributes,
             input.qualifier,
             visitNodes2(input.typeArguments, visitDeclarationSubtree, isTypeNode),
@@ -113195,7 +113595,7 @@ function transformDeclarations(context) {
           input.modifiers,
           input.isTypeOnly,
           input.exportClause,
-          rewriteModuleSpecifier(input, input.moduleSpecifier),
+          rewriteModuleSpecifier2(input, input.moduleSpecifier),
           tryGetResolutionModeOverride(input.attributes)
         );
       }
@@ -113445,7 +113845,7 @@ function transformDeclarations(context) {
           return cleanup(updateModuleDeclarationAndKeyword(
             input,
             mods,
-            isExternalModuleAugmentation(input) ? rewriteModuleSpecifier(input, input.name) : input.name,
+            isExternalModuleAugmentation(input) ? rewriteModuleSpecifier2(input, input.name) : input.name,
             body
           ));
         } else {
@@ -122092,7 +122492,21 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       );
     }
     if (file.flags & 4194304 /* PossiblyContainsDynamicImport */ || isJavaScriptFile) {
-      collectDynamicImportOrRequireOrJsDocImportCalls(file);
+      forEachDynamicImportOrRequireCall(
+        file,
+        /*includeTypeSpaceImports*/
+        true,
+        /*requireStringLiteralLikeArgument*/
+        true,
+        (node, moduleSpecifier) => {
+          setParentRecursive(
+            node,
+            /*incremental*/
+            false
+          );
+          imports = append(imports, moduleSpecifier);
+        }
+      );
     }
     file.imports = imports || emptyArray;
     file.moduleAugmentations = moduleAugmentations || emptyArray;
@@ -122140,63 +122554,6 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         }
       }
     }
-    function collectDynamicImportOrRequireOrJsDocImportCalls(file2) {
-      const r = /import|require/g;
-      while (r.exec(file2.text) !== null) {
-        const node = getNodeAtPosition(file2, r.lastIndex);
-        if (isJavaScriptFile && isRequireCall(
-          node,
-          /*requireStringLiteralLikeArgument*/
-          true
-        )) {
-          setParentRecursive(
-            node,
-            /*incremental*/
-            false
-          );
-          imports = append(imports, node.arguments[0]);
-        } else if (isImportCall(node) && node.arguments.length >= 1 && isStringLiteralLike(node.arguments[0])) {
-          setParentRecursive(
-            node,
-            /*incremental*/
-            false
-          );
-          imports = append(imports, node.arguments[0]);
-        } else if (isLiteralImportTypeNode(node)) {
-          setParentRecursive(
-            node,
-            /*incremental*/
-            false
-          );
-          imports = append(imports, node.argument.literal);
-        } else if (isJavaScriptFile && isJSDocImportTag(node)) {
-          const moduleNameExpr = getExternalModuleName(node);
-          if (moduleNameExpr && isStringLiteral(moduleNameExpr) && moduleNameExpr.text) {
-            setParentRecursive(
-              node,
-              /*incremental*/
-              false
-            );
-            imports = append(imports, moduleNameExpr);
-          }
-        }
-      }
-    }
-    function getNodeAtPosition(sourceFile, position) {
-      let current = sourceFile;
-      const getContainingChild = (child) => {
-        if (child.pos <= position && (position < child.end || position === child.end && child.kind === 1 /* EndOfFileToken */)) {
-          return child;
-        }
-      };
-      while (true) {
-        const child = isJavaScriptFile && hasJSDocNodes(current) && forEach(current.jsDoc, getContainingChild) || forEachChild(current, getContainingChild);
-        if (!child) {
-          return current;
-        }
-        current = child;
-      }
-    }
   }
   function getLibFileFromReference(ref) {
     var _a2;
@@ -123021,7 +123378,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         createDiagnosticForOptionName(Diagnostics.Option_verbatimModuleSyntax_cannot_be_used_when_module_is_set_to_UMD_AMD_or_System, "verbatimModuleSyntax");
       }
     }
-    if (options.allowImportingTsExtensions && !(options.noEmit || options.emitDeclarationOnly)) {
+    if (options.allowImportingTsExtensions && !(options.noEmit || options.emitDeclarationOnly || options.rewriteRelativeImportExtensions)) {
       createOptionValueDiagnostic("allowImportingTsExtensions", Diagnostics.Option_allowImportingTsExtensions_can_only_be_used_when_either_noEmit_or_emitDeclarationOnly_is_set);
     }
     const moduleResolution = getEmitModuleResolutionKind(options);