tsc-ts 0.0.10 → 0.1.0

package/src/compiler/printer/printer.ts

@@ -375,6 +375,8 @@ const enum ListItem {
   ImportSpecifier,
   ExportSpecifier,
   ExpressionWithTypeArguments,
+  /** An `ExpressionWithTypeArguments` or a type reference in a heritage clause. */
+  HeritageClauseElement,
   JsxChild,
   JsxAttributeLike,
 }
@@ -606,7 +608,8 @@ export class Printer extends NameGeneratorHost {
 
   isFileLevelUniqueName(name: string): boolean {
     const file = this.currentSourceFile;
-    return file === undefined || isFileLevelUniqueName(file, name);
+    // The names of the source file as parsed, not as transformed.
+    return file === undefined || isFileLevelUniqueName(this.context.mostOriginal(file) as SourceFile, name);
   }
 
   private getLiteralTextOfNode(node: Node, sourceFile: SourceFile | undefined, flags: LiteralTextFlags): string {
@@ -1217,7 +1220,8 @@ export class Printer extends NameGeneratorHost {
     const state = this.enterNode(node);
     this.emitEntityName(node.left);
     this.write1('.');
-    this.emitIdentifierName(node.right);
+    if (node.right instanceof PrivateIdentifier) this.emitPrivateIdentifier(node.right);
+    else this.emitIdentifierName(node.right as Identifier);
     this.exitNode(node, state);
     return true;
   }
@@ -1914,10 +1918,11 @@ export class Printer extends NameGeneratorHost {
       this.emitOptionalToken(questionToken);
       if (questionToken.kind !== SyntaxKind.QuestionToken) this.write1('?');
     }
-    this.write1(': ');
-    // tsgo's printer fails on a mapped type without a type, too.
-    if (node.type === undefined) throw new Error('Mapped type without a type');
-    this.emitTypeNodeOutsideExtends(node.type);
+    // A mapped type written without a type, `{ [K in keyof T] }`, prints without one.
+    if (node.type !== undefined) {
+      this.write1(': ');
+      this.emitTypeNodeOutsideExtends(node.type);
+    }
     this.write1(';');
     if (node.members !== undefined && node.members.nodes.length > 0) {
       if (singleLine) this.space();
@@ -2948,8 +2953,8 @@ export class Printer extends NameGeneratorHost {
       case SyntaxKind.MetaProperty:
         if (node instanceof MetaProperty) {
           const state = this.enterNode(node);
-          this.emitToken(node.keywordToken, node.pos, node);
-          this.write1('.');
+          const pos = this.emitToken(node.keywordToken, node.pos, node);
+          this.emitToken(SyntaxKind.DotToken, pos, node);
           this.emitIdentifierName(node.name);
           this.exitNode(node, state);
           return true;
@@ -3311,6 +3316,10 @@ export class Printer extends NameGeneratorHost {
       this.emitIdentifierOrString(body.name, false);
       body = body.body;
     }
+    if (node.attributes !== undefined) {
+      this.write1(' with ');
+      this.emitTypeNode(node.attributes, TypePrecedence.NonArray);
+    }
     if (body === undefined) this.write1(';');
     else if (body instanceof ModuleBlock) {
       this.space();
@@ -3419,16 +3428,21 @@ export class Printer extends NameGeneratorHost {
       this.emitBindingIdentifier(bindings.name);
       this.exitNode(bindings, bindingsState);
     } else if (bindings instanceof NamedImports) {
-      const bindingsState = this.enterNode(bindings);
-      this.write1('{');
-      this.emitList(ListItem.ImportSpecifier, bindings, bindings.elements, ListFormat.NamedImportsOrExportsElements);
-      this.write1('}');
-      this.exitNode(bindings, bindingsState);
+      this.emitNamedImports(bindings);
     }
     this.exitNode(node, state);
     return true;
   }
 
+  private emitNamedImports(node: NamedImports): boolean {
+    const state = this.enterNode(node);
+    this.write1('{');
+    this.emitList(ListItem.ImportSpecifier, node, node.elements, ListFormat.NamedImportsOrExportsElements);
+    this.write1('}');
+    this.exitNode(node, state);
+    return true;
+  }
+
   /** Import and export specifiers. */
   private emitSpecifier(
     node: Node,
@@ -3871,7 +3885,7 @@ export class Printer extends NameGeneratorHost {
     this.space();
     this.emitToken(node.token, node.pos, node);
     this.space();
-    this.emitList(ListItem.ExpressionWithTypeArguments, node, node.types, ListFormat.HeritageClauseTypes);
+    this.emitList(ListItem.HeritageClauseElement, node, node.types, ListFormat.HeritageClauseTypes);
     this.exitNode(node, state);
     return true;
   }
@@ -4092,6 +4106,10 @@ export class Printer extends NameGeneratorHost {
       case ListItem.ExpressionWithTypeArguments:
         if (node instanceof ExpressionWithTypeArguments) return this.emitExpressionWithTypeArguments(node);
         break;
+      case ListItem.HeritageClauseElement:
+        if (node instanceof ExpressionWithTypeArguments) return this.emitExpressionWithTypeArguments(node);
+        if (node.kind === SyntaxKind.TypeReference) return this.emitTypeNodeWorker(node);
+        break;
       case ListItem.JsxChild:
         return this.emitJsxChild(node);
       case ListItem.JsxAttributeLike:
@@ -4391,6 +4409,9 @@ export class Printer extends NameGeneratorHost {
       case SyntaxKind.ImportClause:
         if (node instanceof ImportClause) return this.emitImportClause(node);
         break;
+      case SyntaxKind.NamedImports:
+        if (node instanceof NamedImports) return this.emitNamedImports(node);
+        break;
       case SyntaxKind.ImportSpecifier:
         return this.emitListItem(ListItem.ImportSpecifier, node);
       case SyntaxKind.ExportSpecifier:

package/src/compiler/printer/utilities.ts

@@ -31,7 +31,12 @@ import {
   PrivateIdentifier,
   getExpression,
 } from '../ast.js';
-import { OperatorPrecedence, getBinaryOperatorPrecedence } from '../ast-utilities.js';
+import {
+  OperatorPrecedence,
+  getBinaryOperatorPrecedence,
+  isJSDocTypeExpressionOrChild,
+  normalizeJSDocTypeSourceText,
+} from '../ast-utilities.js';
 import {
   CharacterCodes,
   isDigit,
@@ -687,7 +692,8 @@ export function getLiteralText(node: Node, sourceText: string | undefined, flags
 /** The source text of a node without leading trivia, as tsgo's GetSourceTextOfNodeFromSourceFile. */
 export function getSourceTextOfNode(sourceText: string, node: Node): string {
   if (node.pos === node.end && node.pos >= 0 && node.kind !== SyntaxKind.EndOfFile) return '';
-  const text = sourceText.substring(skipTrivia(sourceText, node.pos), node.end);
+  let text = sourceText.substring(skipTrivia(sourceText, node.pos), node.end);
+  if (isJSDocTypeExpressionOrChild(node)) text = normalizeJSDocTypeSourceText(text);
   if ((node.flags & NodeFlags.ReparserTransformedLiteral) !== 0) {
     if (node instanceof StringLiteral)
       return (node.tokenFlags & TokenFlags.SingleQuote) !== 0 ? "'" + text + "'" : '"' + text + '"';

package/src/compiler/program-checker.ts

@@ -9,7 +9,14 @@
  */
 import { type Node, ScriptKind, type SourceFile } from './ast.js';
 import { Checker, CheckerHost, disposeChecker } from './checker.js';
-import { createDiagnostic, Diagnostic, type DiagnosticMessage, Diagnostics, messageCode } from './diagnostics.js';
+import {
+  compareDiagnostics,
+  createDiagnostic,
+  Diagnostic,
+  type DiagnosticMessage,
+  Diagnostics,
+  messageCode,
+} from './diagnostics.js';
 import type { EmitResult } from './emitter.js';
 import type { CompilerOptions, ModuleKind } from './options.js';
 import type { ResolvedModule } from './module-resolution-types.js';
@@ -265,6 +272,12 @@ export class CheckedProgram {
    */
   referenceThreads = 1;
   readonly parallelGlobalDiagnostics: Diagnostic[] = [];
+  /**
+   * Whether the semantic diagnostics of a file include the global diagnostics its checker found while
+   * checking it, as an incremental program caches them (IncrementalProgram). Such a program doesn't report
+   * the global diagnostics found by checking otherwise (`reportsGlobalDiagnosticsOfChecking`, compile-program.ts).
+   */
+  globalsInFileDiagnostics = false;
   /**
    * The declaration diagnostics checker threads computed under `noEmit` (PlainProgram,
    * IncrementalProgram), by file index; `undefined` for files they did not. Set once every file is
@@ -403,11 +416,11 @@ export class CheckedProgram {
     return sortAndDeduplicateDiagnostics([...own, ...parallel]);
   }
 
-  /** Whether `file`'s bind and check diagnostics are reported. */
-  skipTypeChecking(file: SourceFile): boolean {
+  /** Whether `file`'s bind and check diagnostics are skipped; `ignoreNoCheck` leaves `noCheck` out. */
+  skipTypeChecking(file: SourceFile, ignoreNoCheck = false): boolean {
     const options = this.program.options;
     return (
-      options.noCheck === true ||
+      (!ignoreNoCheck && options.noCheck === true) ||
       (options.skipLibCheck === true && file.isDeclarationFile) ||
       (options.skipDefaultLibCheck === true && this.program.isSourceFileDefaultLibrary(file.path)) ||
       this.program.getProjectReferenceFromSource(file.path) !== undefined ||
@@ -436,7 +449,15 @@ export class CheckedProgram {
   private getBindAndCheckDiagnostics(file: SourceFile, checks?: readonly Diagnostic[]): Diagnostic[] {
     const options = this.program.options;
     const diagnostics = file.bindDiagnostics.slice();
-    for (const d of checks ?? this.checker.getDiagnostics(file)) diagnostics.push(d);
+    if (checks !== undefined) for (const d of checks) diagnostics.push(d);
+    else if (this.globalsInFileDiagnostics) {
+      const checker = this.checker;
+      const before = checker.getGlobalDiagnostics();
+      for (const d of checker.getDiagnostics(file)) diagnostics.push(d);
+      const after = checker.getGlobalDiagnostics();
+      if (after.length > before.length)
+        for (const d of after) if (!containsSortedDiagnostic(before, d)) diagnostics.push(d);
+    } else for (const d of this.checker.getDiagnostics(file)) diagnostics.push(d);
     if (isPlainJSFile(file, options)) {
       const result: Diagnostic[] = [];
       for (const d of diagnostics) if (plainJSErrors.has(d.code)) result.push(d);
@@ -467,6 +488,20 @@ export class CheckedProgram {
   }
 }
 
+/** Whether `sorted`, in `compareDiagnostics` order, has a diagnostic equal to `diagnostic`. */
+function containsSortedDiagnostic(sorted: readonly Diagnostic[], diagnostic: Diagnostic): boolean {
+  let low = 0;
+  let high = sorted.length - 1;
+  while (low <= high) {
+    const middle = (low + high) >>> 1;
+    const c = compareDiagnostics(sorted[middle]!, diagnostic);
+    if (c === 0) return true;
+    if (c < 0) low = middle + 1;
+    else high = middle - 1;
+  }
+  return false;
+}
+
 /** The `@ts-ignore` and `@ts-expect-error` comments of a file, by line. */
 class Directives {
   private readonly byLine = new Map<number, { pos: number; end: number; kind: CommentDirectiveKind }>();
@@ -488,6 +523,11 @@ class Directives {
     const lineStarts = this.file.diagnosticFile().getLineStarts();
     const result: Diagnostic[] = [];
     for (const diagnostic of diagnostics) {
+      // A global diagnostic, or one of another file, has no line here.
+      if (diagnostic.file === undefined || diagnostic.file.fileName !== this.file.fileName) {
+        result.push(diagnostic);
+        continue;
+      }
       let ignored = false;
       for (let line = computeLineOfPosition(lineStarts, diagnostic.pos) - 1; line >= 0; line--) {
         const directive = this.byLine.get(line);
@@ -564,6 +604,7 @@ const plainJSErrors = codesOf([
   Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement,
   Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement,
   Diagnostics.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration,
+  Diagnostics.A_deferred_import_must_specify_a_namespace_binding,
   Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context,
   Diagnostics.A_destructuring_declaration_must_have_an_initializer,
   Diagnostics.A_get_accessor_cannot_have_parameters,
@@ -632,6 +673,13 @@ const plainJSErrors = codesOf([
   Diagnostics.X_await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules,
   Diagnostics.Private_field_0_must_be_declared_in_an_enclosing_class,
   Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value,
+  Diagnostics.A_deferred_import_must_specify_a_namespace_binding,
+  Diagnostics.A_source_phase_import_must_specify_a_local_binding,
+  Diagnostics.Named_and_namespace_imports_are_not_allowed_in_a_source_phase_import,
+  Diagnostics.Optional_chaining_cannot_be_used_with_import_source,
+  Diagnostics.Source_phase_imports_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls,
+  Diagnostics.Source_phase_imports_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve,
+  Diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_import_Did_you_mean_meta_defer_or_source,
 ]);
 
 function codesOf(messages: readonly DiagnosticMessage[]): Set<number> {

package/src/compiler/program-utilities.ts

@@ -4,6 +4,7 @@
 import {
   ExportDeclaration,
   ExternalModuleIndicatorOptions,
+  Identifier,
   ImportAttribute,
   ImportAttributes,
   ImportClause,
@@ -19,7 +20,7 @@ import {
   type Node,
   type SourceFile,
 } from './ast.js';
-import { isImportCall, isRequireCall } from './ast-utilities.js';
+import { isImportCall, isRequireCall, isSourcePhaseImportCall } from './ast-utilities.js';
 import { libMap } from './option-declarations.js';
 import {
   getEmitModuleDetectionKind,
@@ -59,6 +60,8 @@ export function getDefaultLibFileName(options: CompilerOptions): string {
   switch (getEmitScriptTarget(options)) {
     case ScriptTarget.ESNext:
       return 'lib.esnext.full.d.ts';
+    case ScriptTarget.ES2026:
+      return 'lib.es2026.full.d.ts';
     case ScriptTarget.ES2025:
       return 'lib.es2025.full.d.ts';
     case ScriptTarget.ES2024:
@@ -115,6 +118,8 @@ export function scriptTargetName(target: ScriptTarget): string {
       return 'ES2024';
     case ScriptTarget.ES2025:
       return 'ES2025';
+    case ScriptTarget.ES2026:
+      return 'ES2026';
     case ScriptTarget.ESNext:
       return 'ESNext';
     case ScriptTarget.JSON:
@@ -316,21 +321,27 @@ function literalText(node: Node): string {
 
 /** The `resolution-mode` of `import type` attributes, or `None`. */
 export function getResolutionModeOverride(attributes: ImportAttributes | undefined): ModuleKind {
-  if (attributes === undefined) return ModuleKind.None;
-  const elements = attributes.attributes.nodes;
-  if (elements.length !== 1) return ModuleKind.None;
-  const attribute = elements[0]!;
-  if (!(attribute instanceof ImportAttribute)) return ModuleKind.None;
-  const name = attribute.name;
-  if (name === undefined || !isStringLiteralLike(name) || literalText(name) !== 'resolution-mode')
-    return ModuleKind.None;
-  if (!isStringLiteralLike(attribute.value)) return ModuleKind.None;
+  const attribute = resolutionModeAttribute(attributes);
+  if (attribute === undefined || !isStringLiteralLike(attribute.value)) return ModuleKind.None;
   const text = literalText(attribute.value);
   if (text === 'import') return ModuleKind.ESNext;
   if (text === 'require') return ModuleKind.CommonJS;
   return ModuleKind.None;
 }
 
+/** The `resolution-mode` attribute among import attributes, as tsgo's `GetResolutionModeOverride` finds it. */
+export function resolutionModeAttribute(attributes: ImportAttributes | undefined): ImportAttribute | undefined {
+  if (attributes === undefined) return undefined;
+  for (const attribute of attributes.attributes.nodes) {
+    if (!(attribute instanceof ImportAttribute)) continue;
+    const name = attribute.name;
+    if (name === undefined) continue;
+    const text = name instanceof Identifier ? name.text : literalText(name);
+    if (text === 'resolution-mode') return attribute;
+  }
+  return undefined;
+}
+
 /** The attributes of an import or export declaration or a JSDoc `@import`, if any. */
 function importOrExportAttributes(node: Node | undefined): ImportAttributes | undefined {
   if (node instanceof ImportDeclaration) return node.attributes;
@@ -404,6 +415,8 @@ export function getEmitSyntaxForUsageLocation(
   const fileEmitMode = getEmitModuleFormatOfFile(fileName, options, metadata);
   const call = walkUpParenthesizedExpressions(parent);
   if (call !== undefined && isImportCall(call)) {
+    // `import.source()` is never transformed to `require`.
+    if (isSourcePhaseImportCall(call)) return ModuleKind.ESNext;
     return shouldTransformImportCall(options, fileEmitMode) ? ModuleKind.CommonJS : ModuleKind.ESNext;
   }
   if (fileEmitMode === ModuleKind.CommonJS) return ModuleKind.CommonJS;

package/src/compiler/program.ts

@@ -85,6 +85,7 @@ import {
   pathIsRelative,
   toFileNameLowerCase,
   toPath,
+  isNetworkPathValue,
 } from './path.js';
 import {
   getDefaultResolutionModeForFile,
@@ -106,6 +107,7 @@ import {
   type SourceOutputAndProjectReference,
 } from './tsconfig.js';
 import { SyntaxKind } from './syntax-kind.js';
+import { isSourcePhaseImport } from './ast-utilities.js';
 import { KnownSymlinks } from './symlinks.js';
 import { mark } from './timeline.js';
 import { LanguageVariant } from './types.js';
@@ -294,6 +296,11 @@ export class Program implements OutputPathsHost {
     return this.processed.redirectTargets.get(path) ?? [];
   }
 
+  /** The nearest `package.json` lookup at or above `directory`. */
+  getPackageScopeForPath(directory: string): PackageJsonInfo | undefined {
+    return this.processed.resolver.getPackageScopeForPath(directory);
+  }
+
   /** The directory of the nearest `package.json` at or above `directory`, or `''`. */
   getNearestAncestorDirectoryWithPackageJson(directory: string): string {
     const scope = this.processed.resolver.getPackageScopeForPath(directory);
@@ -362,7 +369,8 @@ export class Program implements OutputPathsHost {
         )
           continue;
         const resolved = resolver.resolvePackageDirectory(dependency, packageJsonName, ModuleKind.CommonJS);
-        if (resolved !== undefined && resolved.resolvedFileName !== '')
+        // A dependency installed in place has no original path to map from.
+        if (resolved !== undefined && resolved.resolvedFileName !== '' && resolved.originalPath !== '')
           symlinks.processResolution(
             combinePaths(resolved.originalPath, 'package.json'),
             combinePaths(resolved.resolvedFileName, 'package.json'),
@@ -467,6 +475,8 @@ export class Program implements OutputPathsHost {
   }
 
   getResolvedModuleFromModuleSpecifier(file: SourceFile, specifier: Node): ResolvedModule | undefined {
+    // A source phase import loads no module declarations.
+    if (specifier.parent !== undefined && isSourcePhaseImport(specifier.parent)) return undefined;
     const text = specifierText(specifier);
     return this.getResolvedModule(file, text, this.getModeForUsageLocation(file, specifier));
   }
@@ -915,6 +925,8 @@ export class Program implements OutputPathsHost {
               Diagnostics.Non_relative_paths_are_not_allowed_Did_you_forget_a_leading_Slash,
               [],
             );
+          } else if (isNetworkPathValue(substitution, options.pathsBasePath ?? this.currentDirectory)) {
+            this.pathsValueDiagnostic(key, i, Diagnostics.Network_path_0_is_not_supported, [substitution]);
           }
         }
       }

package/src/compiler/pseudo-bigint.ts

@@ -60,3 +60,20 @@ export function parsePseudoBigInt(literal: string): string {
   }
   return result;
 }
+
+/** Compares two bigint values in decimal, each optionally prefixed with `-`, by numeric value. */
+export function comparePseudoBigInts(a: string, b: string): number {
+  const negative = a.charCodeAt(0) === CharacterCodes.minus;
+  const r = pseudoBigIntSign(a) - pseudoBigIntSign(b);
+  if (r !== 0) return r;
+  const digitsA = negative ? a.substring(1) : a;
+  const digitsB = negative ? b.substring(1) : b;
+  let magnitude = digitsA.length - digitsB.length;
+  if (magnitude === 0) magnitude = digitsA < digitsB ? -1 : digitsA > digitsB ? 1 : 0;
+  return negative ? -magnitude : magnitude;
+}
+
+function pseudoBigIntSign(value: string): number {
+  if (value.charCodeAt(0) === CharacterCodes.minus) return -1;
+  return value === '0' ? 0 : 1;
+}

package/src/compiler/regexp-checker.ts

@@ -9,7 +9,7 @@ import {
 } from './character-codes.js';
 import { Diagnostics } from './diagnostic-messages.js';
 import type { DiagnosticMessage } from './diagnostics.js';
-import type { Scanner } from './scanner.js';
+import { IdentifierVariant, type Scanner } from './scanner.js';
 import { getSpellingSuggestion } from './spelling.js';
 import { ScriptTarget } from './types.js';
 import {
@@ -243,13 +243,24 @@ class RegularExpressionChecker {
 
   // Disjunction ::= Alternative ('|' Alternative)*
   private scanDisjunction(isInGroup: boolean): void {
+    // The names any alternative defines. One alternative matches, so in a group they join the
+    // enclosing alternative's scope: `(?:(?<a>x))(?<a>z)` defines `a` twice.
+    let disjunctionNames: Set<string> | undefined;
     for (;;) {
       this.namedCapturingGroups.push(new Set<string>());
       this.scanAlternative(isInGroup);
-      this.namedCapturingGroups.pop();
-      if (this.char() !== CharacterCodes.bar) return;
+      const alternativeNames = this.namedCapturingGroups.pop()!;
+      if (alternativeNames.size > 0) {
+        if (disjunctionNames === undefined) disjunctionNames = new Set<string>();
+        for (const name of alternativeNames) disjunctionNames.add(name);
+      }
+      if (this.char() !== CharacterCodes.bar) break;
       this.scanner.pos = (this.scanner.pos + 1) | 0;
     }
+    if (isInGroup && disjunctionNames !== undefined && this.namedCapturingGroups.length > 0) {
+      const parentScope = this.namedCapturingGroups[this.namedCapturingGroups.length - 1]!;
+      for (const name of disjunctionNames) parentScope.add(name);
+    }
   }
 
   // Alternative ::= Term*
@@ -317,6 +328,14 @@ class RegularExpressionChecker {
                     noArgs,
                   );
               }
+              // Modifier characters make this `(?flags:` rather than a plain `(?:` group.
+              if (this.scanner.pos !== flagsStart && this.scanner.languageVersion() < ScriptTarget.ES2025)
+                this.error(
+                  Diagnostics.Regular_expression_pattern_modifiers_are_only_available_when_targeting_0_or_later,
+                  flagsStart,
+                  this.scanner.pos - flagsStart,
+                  ['es2025'],
+                );
               this.scanExpectedChar(CharacterCodes.colon);
               isPreviousTermQuantifiable = true;
             }
@@ -443,10 +462,8 @@ class RegularExpressionChecker {
           size,
           noArgs,
         );
-      else {
-        currentFlags |= flag;
-        this.scanner.checkRegularExpressionFlagAvailability(flag, this.scanner.pos, size);
-      }
+      // Modifiers need ES2025, later than any flag they can toggle, and the group reports that.
+      else currentFlags |= flag;
       this.scanner.pos = (this.scanner.pos + size) | 0;
     }
     return currentFlags;
@@ -545,9 +562,8 @@ class RegularExpressionChecker {
   private scanGroupName(isReference: boolean): void {
     const scanner = this.scanner;
     scanner.tokenStart = this.scanner.pos | 0;
-    scanner.scanIdentifier(0);
     const start = scanner.tokenStart;
-    if (this.scanner.pos === start) {
+    if (!scanner.scanIdentifier(0, IdentifierVariant.RegExpGroupName)) {
       this.error(Diagnostics.Expected_a_capturing_group_name, this.scanner.pos, 0, noArgs);
       return;
     }
@@ -562,6 +578,20 @@ class RegularExpressionChecker {
         noArgs,
       );
     } else {
+      // An earlier definition is in a mutually exclusive alternative. Below ES2018 the group is
+      // reported already.
+      const languageVersion = this.scanner.languageVersion();
+      if (
+        this.groupSpecifiers.has(name) &&
+        languageVersion >= ScriptTarget.ES2018 &&
+        languageVersion < ScriptTarget.ES2025
+      )
+        this.error(
+          Diagnostics.Duplicate_named_capturing_groups_are_only_available_when_targeting_0_or_later,
+          start,
+          this.scanner.pos - start,
+          ['es2025'],
+        );
       if (this.namedCapturingGroups.length > 0)
         this.namedCapturingGroups[this.namedCapturingGroups.length - 1]!.add(name);
       this.groupSpecifiers.add(name);
@@ -667,9 +697,6 @@ class RegularExpressionChecker {
           this.mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
           return this.mayContainStrings;
         }
-        this.error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, this.scanner.pos, 1, [
-          String.fromCharCode(ch),
-        ]);
         break;
       default:
         if (isCharacterComplement && this.mayContainStrings)
@@ -730,29 +757,26 @@ class RegularExpressionChecker {
         } else if (operand >= 0 && secondOperand >= 0 && operand > secondOperand) {
           this.error(Diagnostics.Range_out_of_order_in_character_class, start, this.scanner.pos - start, noArgs);
         }
-      } else if (ch === CharacterCodes.ampersand) {
+      } else if (
+        ch === CharacterCodes.ampersand &&
+        this.scanner.pos + 1 < this.end &&
+        this.charAt(this.scanner.pos + 1) === CharacterCodes.ampersand
+      ) {
         start = this.scanner.pos;
-        this.scanner.pos = (this.scanner.pos + 1) | 0;
+        this.scanner.pos = (this.scanner.pos + 2) | 0;
+        this.error(
+          Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead,
+          this.scanner.pos - 2,
+          2,
+          noArgs,
+        );
         if (this.char() === CharacterCodes.ampersand) {
-          this.scanner.pos = (this.scanner.pos + 1) | 0;
-          this.error(
-            Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead,
-            this.scanner.pos - 2,
-            2,
-            noArgs,
-          );
-          if (this.char() === CharacterCodes.ampersand) {
-            this.error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, this.scanner.pos, 1, [
-              String.fromCharCode(ch),
-            ]);
-            this.scanner.pos = (this.scanner.pos + 1) | 0;
-          }
-        } else {
-          this.error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, this.scanner.pos - 1, 1, [
+          this.error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, this.scanner.pos, 1, [
             String.fromCharCode(ch),
           ]);
+          this.scanner.pos = (this.scanner.pos + 1) | 0;
         }
-        operand = this.scanner.pos - start === 1 ? CharacterCodes.ampersand : ClassValue.String;
+        operand = ClassValue.String;
         continue;
       }
       if (this.isClassContentExit(this.char())) break;
@@ -768,6 +792,15 @@ class RegularExpressionChecker {
         operand = ClassValue.String;
       } else {
         operand = this.scanClassSetOperand();
+        // Each operand of a negated union must match single characters.
+        if (isCharacterComplement && this.mayContainStrings)
+          this.error(
+            Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class,
+            start,
+            this.scanner.pos - start,
+            noArgs,
+          );
+        expressionMayContainStrings = expressionMayContainStrings || this.mayContainStrings;
       }
     }
     this.mayContainStrings = !isCharacterComplement && expressionMayContainStrings;