tsc-ts 0.0.4 → 0.0.5

package/src/library/nodes.ts

@@ -0,0 +1,232 @@
+// Node functions of tsc-ts's public API, with TypeScript 7's behavior.
+
+import {
+  getModifiers as compilerGetModifiers,
+  type Node as CompilerNode,
+  type ModifierList as CompilerModifierList,
+  type NodeList as CompilerNodeList,
+  NodeVisitor,
+  type SourceFile as CompilerSourceFile,
+} from '../compiler/ast.js';
+import { getTokenPosOfNode } from '../compiler/astnav.js';
+import {
+  getCombinedModifierFlags as compilerModifierFlags,
+  getCombinedNodeFlags as compilerNodeFlags,
+  getSourceFileOfNode as compilerSourceFileOfNode,
+} from '../compiler/binder-utilities.js';
+import { getJSDoc as compilerGetJSDoc } from '../compiler/parser.js';
+import { computeLineOfPosition, tokenToString as compilerTokenToString } from '../compiler/scanner.js';
+import { SyntaxKind as CompilerSyntaxKind } from '../compiler/syntax-kind.js';
+import type { JSDoc, LineAndCharacter, ModifierList, Node, NodeList, SourceFile } from './ast.js';
+import type { ModifierFlags, NodeFlags, SyntaxKind } from './enums.generated.js';
+import type { Diagnostic } from './types.js';
+
+const compilerNode = (node: Node): CompilerNode => node as unknown as CompilerNode;
+
+/** Visits the children of a node; stops at the first callback that answers a truthy value. */
+class CallbackVisitor extends NodeVisitor {
+  result: unknown = undefined;
+
+  constructor(
+    private readonly cbNode: (node: Node) => unknown,
+    private readonly cbNodes: ((nodes: NodeList) => unknown) | undefined,
+  ) {
+    super();
+  }
+
+  visitNode(node: CompilerNode): boolean {
+    const result = this.cbNode(node as unknown as Node);
+    if (!result) return false;
+    this.result = result;
+    return true;
+  }
+
+  visitList(list: CompilerNodeList): boolean {
+    if (this.cbNodes === undefined) return super.visitList(list);
+    const result = this.cbNodes(list as unknown as NodeList);
+    if (!result) return false;
+    this.result = result;
+    return true;
+  }
+
+  visitModifiers(list: CompilerModifierList): boolean {
+    return this.visitList(list);
+  }
+}
+
+/**
+ * Calls `cbNode` for each child of `node`, in source order, or `cbNodes` for each list of children when it
+ * is given; returns the first truthy value a callback answers. JSDoc is not visited (`getJSDoc`).
+ */
+export function forEachChild<T>(
+  node: Node,
+  cbNode: (node: Node) => T | undefined,
+  cbNodes?: (nodes: NodeList) => T | undefined,
+): T | undefined {
+  const visitor = new CallbackVisitor(cbNode, cbNodes);
+  compilerNode(node).forEachChild(visitor);
+  return visitor.result as T | undefined;
+}
+
+/** Collects the children of a node, in source order. */
+class ChildCollector extends NodeVisitor {
+  readonly children: CompilerNode[] = [];
+
+  visitNode(node: CompilerNode): boolean {
+    this.children.push(node);
+    return false;
+  }
+}
+
+/**
+ * Visits `root` and its descendants in preorder, with `depth` the number of levels below `root`, without
+ * recursion. The callback may answer 'skip' to leave a node's children unvisited, or 'stop' to end the walk.
+ */
+export function walkPreorder(root: Node, cb: (node: Node, depth: number) => void | 'skip' | 'stop'): void {
+  const stack: CompilerNode[] = [compilerNode(root)];
+  const depths: number[] = [0];
+  const collector = new ChildCollector();
+  // Declared outside the loop: scriptc compiles the node's conversion to the public Node from a variable there.
+  let node: CompilerNode;
+  while (stack.length > 0) {
+    node = stack.pop()!;
+    const depth = depths.pop()!;
+    const verdict = cb(node as unknown as Node, depth);
+    if (verdict === 'stop') return;
+    if (verdict === 'skip') continue;
+    collector.children.length = 0;
+    node.forEachChild(collector);
+    const children = collector.children;
+    for (let i = children.length - 1; i >= 0; i--) {
+      stack.push(children[i]!);
+      depths.push(depth + 1);
+    }
+  }
+}
+
+/**
+ * The start of the first token of `node`, after its leading trivia; with `includeJSDoc`, the start of its
+ * first JSDoc comment where it has one.
+ */
+export function tokenStartOfNode(node: Node, includeJSDoc = false): number {
+  const file = compilerSourceFileOfNode(compilerNode(node));
+  return getTokenPosOfNode(compilerNode(node), file, includeJSDoc);
+}
+
+/** The source file `node` is in: the root of its parents. */
+export function getSourceFileOfNode(node: Node): SourceFile {
+  let current = node;
+  while (current.parent !== undefined) current = current.parent;
+  return current as SourceFile;
+}
+
+/**
+ * The text of `node` in its source file, from the start of its first token (`tokenStartOfNode`) to its end:
+ * TypeScript's `node.getText()`.
+ */
+export function getTextOfNode(node: Node): string {
+  const file = compilerSourceFileOfNode(compilerNode(node));
+  return file.text.substring(getTokenPosOfNode(compilerNode(node), file, false), node.end);
+}
+
+/** The JSDoc comments of `node`, as the JSDoc nodes TypeScript 7 attaches to it (parsed on first use). */
+export function getJSDoc(node: Node): readonly JSDoc[] {
+  const file = compilerSourceFileOfNode(compilerNode(node));
+  return compilerGetJSDoc(file, compilerNode(node)) as unknown as readonly JSDoc[];
+}
+
+/** The modifiers of a declaration, decorators included, as TypeScript 7 keeps them. */
+export function getModifiers(node: Node): ModifierList | undefined {
+  return compilerGetModifiers(compilerNode(node)) as unknown as ModifierList | undefined;
+}
+
+/** Whether a node of this kind can have modifiers (TypeScript 7's CanHaveModifiers). */
+export function canHaveModifiers(node: Node): boolean {
+  switch (compilerNode(node).kind) {
+    case CompilerSyntaxKind.TypeParameter:
+    case CompilerSyntaxKind.Parameter:
+    case CompilerSyntaxKind.PropertySignature:
+    case CompilerSyntaxKind.PropertyDeclaration:
+    case CompilerSyntaxKind.MethodSignature:
+    case CompilerSyntaxKind.MethodDeclaration:
+    case CompilerSyntaxKind.Constructor:
+    case CompilerSyntaxKind.GetAccessor:
+    case CompilerSyntaxKind.SetAccessor:
+    case CompilerSyntaxKind.IndexSignature:
+    case CompilerSyntaxKind.ConstructorType:
+    case CompilerSyntaxKind.FunctionExpression:
+    case CompilerSyntaxKind.ArrowFunction:
+    case CompilerSyntaxKind.ClassExpression:
+    case CompilerSyntaxKind.VariableStatement:
+    case CompilerSyntaxKind.FunctionDeclaration:
+    case CompilerSyntaxKind.ClassDeclaration:
+    case CompilerSyntaxKind.InterfaceDeclaration:
+    case CompilerSyntaxKind.TypeAliasDeclaration:
+    case CompilerSyntaxKind.EnumDeclaration:
+    case CompilerSyntaxKind.ModuleDeclaration:
+    case CompilerSyntaxKind.ImportEqualsDeclaration:
+    case CompilerSyntaxKind.ImportDeclaration:
+    case CompilerSyntaxKind.JSImportDeclaration:
+    case CompilerSyntaxKind.ExportAssignment:
+    case CompilerSyntaxKind.ExportDeclaration:
+      return true;
+  }
+  return false;
+}
+
+/**
+ * The modifier flags of a declaration with those of the declarations it is part of: for a binding element,
+ * of the declaration of its outermost pattern; for a variable declaration, of its list and statement.
+ */
+export function getCombinedModifierFlags(node: Node): ModifierFlags {
+  return compilerModifierFlags(compilerNode(node)) as number as ModifierFlags;
+}
+
+/** The node flags of a declaration with those of the declarations it is part of, as getCombinedModifierFlags. */
+export function getCombinedNodeFlags(node: Node): NodeFlags {
+  return compilerNodeFlags(compilerNode(node)) as number as NodeFlags;
+}
+
+/** The UTF-16 offset at which each line of the file starts. */
+export function getLineStarts(file: SourceFile): readonly number[] {
+  return (file as unknown as CompilerSourceFile).lineStarts();
+}
+
+/** The 0-based line and character of a UTF-16 position in the file. */
+export function getLineAndCharacterOfPosition(file: SourceFile, position: number): LineAndCharacter {
+  const lineStarts = getLineStarts(file);
+  const line = computeLineOfPosition(lineStarts, position);
+  return { line, character: position - lineStarts[line]! };
+}
+
+/** The UTF-16 position of a 0-based line and character in the file. */
+export function getPositionOfLineAndCharacter(file: SourceFile, line: number, character: number): number {
+  return getLineStarts(file)[line]! + character;
+}
+
+/** The text of a punctuation or keyword token kind, or undefined for other kinds. */
+export function tokenToString(kind: SyntaxKind): string | undefined {
+  const text = compilerTokenToString(kind as number as CompilerSyntaxKind);
+  return text === '' ? undefined : text;
+}
+
+/**
+ * A diagnostic's text with its chain of messages, each on its own line, indented two spaces per level of
+ * the chain, as TypeScript prints them.
+ */
+export function flattenDiagnosticMessageText(
+  diagnostic: Diagnostic | string | undefined,
+  newLine: string,
+  indent = 0,
+): string {
+  if (diagnostic === undefined) return '';
+  if (typeof diagnostic === 'string') return diagnostic;
+  let result = '';
+  if (indent > 0) {
+    result += newLine;
+    for (let i = 0; i < indent; i++) result += '  ';
+  }
+  result += diagnostic.text;
+  for (const child of diagnostic.messageChain) result += flattenDiagnosticMessageText(child, newLine, indent + 1);
+  return result;
+}

package/src/library/options.ts

@@ -0,0 +1,449 @@
+// Compiler options of tsc-ts's public API and `tsc-ts --api`: tsc-ts's options as tsgo's API returns them,
+// and back.
+
+import type { CompilerOptions as CompilerOptionsValue } from '../compiler/options.js';
+import { getLibFileName } from '../compiler/program-utilities.js';
+
+/**
+ * Compiler options as `tsc-ts --api` returns them, in TypeScript-Go's field order: the public
+ * CompilerOptions, and the options tsgo's API returns besides those.
+ */
+export interface ApiCompilerOptions {
+  allowJs?: boolean;
+  allowArbitraryExtensions?: boolean;
+  allowImportingTsExtensions?: boolean;
+  allowNonTsExtensions?: boolean;
+  allowUmdGlobalAccess?: boolean;
+  allowUnreachableCode?: boolean;
+  allowUnusedLabels?: boolean;
+  assumeChangesOnlyAffectDirectDependencies?: boolean;
+  checkJs?: boolean;
+  customConditions?: string[];
+  composite?: boolean;
+  emitDeclarationOnly?: boolean;
+  emitBOM?: boolean;
+  emitDecoratorMetadata?: boolean;
+  declaration?: boolean;
+  declarationDir?: string;
+  declarationMap?: boolean;
+  deduplicatePackages?: boolean;
+  disableSizeLimit?: boolean;
+  disableSourceOfProjectReferenceRedirect?: boolean;
+  disableSolutionSearching?: boolean;
+  disableReferencedProjectLoad?: boolean;
+  erasableSyntaxOnly?: boolean;
+  exactOptionalPropertyTypes?: boolean;
+  experimentalDecorators?: boolean;
+  forceConsistentCasingInFileNames?: boolean;
+  isolatedModules?: boolean;
+  isolatedDeclarations?: boolean;
+  ignoreConfig?: boolean;
+  ignoreDeprecations?: string;
+  importHelpers?: boolean;
+  inlineSourceMap?: boolean;
+  inlineSources?: boolean;
+  init?: boolean;
+  incremental?: boolean;
+  jsx?: number;
+  jsxFactory?: string;
+  jsxFragmentFactory?: string;
+  jsxImportSource?: string;
+  lib?: string[];
+  libReplacement?: boolean;
+  locale?: string;
+  mapRoot?: string;
+  module?: number;
+  moduleResolution?: number;
+  moduleSuffixes?: string[];
+  moduleDetection?: number;
+  newLine?: number;
+  noEmit?: boolean;
+  noCheck?: boolean;
+  noErrorTruncation?: boolean;
+  noFallthroughCasesInSwitch?: boolean;
+  noImplicitAny?: boolean;
+  noImplicitThis?: boolean;
+  noImplicitReturns?: boolean;
+  noEmitHelpers?: boolean;
+  noLib?: boolean;
+  noPropertyAccessFromIndexSignature?: boolean;
+  noUncheckedIndexedAccess?: boolean;
+  noEmitOnError?: boolean;
+  noUnusedLocals?: boolean;
+  noUnusedParameters?: boolean;
+  noResolve?: boolean;
+  noImplicitOverride?: boolean;
+  noUncheckedSideEffectImports?: boolean;
+  outDir?: string;
+  paths?: Record<string, string[]>;
+  preserveConstEnums?: boolean;
+  preserveSymlinks?: boolean;
+  project?: string;
+  resolveJsonModule?: boolean;
+  resolvePackageJsonExports?: boolean;
+  resolvePackageJsonImports?: boolean;
+  removeComments?: boolean;
+  rewriteRelativeImportExtensions?: boolean;
+  reactNamespace?: string;
+  rootDir?: string;
+  rootDirs?: string[];
+  skipLibCheck?: boolean;
+  stableTypeOrdering?: boolean;
+  strict?: boolean;
+  strictBindCallApply?: boolean;
+  strictBuiltinIteratorReturn?: boolean;
+  strictFunctionTypes?: boolean;
+  strictNullChecks?: boolean;
+  strictPropertyInitialization?: boolean;
+  stripInternal?: boolean;
+  skipDefaultLibCheck?: boolean;
+  sourceMap?: boolean;
+  sourceRoot?: string;
+  suppressOutputPathCheck?: boolean;
+  target?: number;
+  traceResolution?: boolean;
+  tsBuildInfoFile?: string;
+  typeRoots?: string[];
+  types?: string[];
+  useDefineForClassFields?: boolean;
+  useUnknownInCatchVariables?: boolean;
+  verbatimModuleSyntax?: boolean;
+  maxNodeModuleJsDepth?: number;
+  allowSyntheticDefaultImports?: boolean;
+  alwaysStrict?: boolean;
+  baseUrl?: string;
+  downlevelIteration?: boolean;
+  esModuleInterop?: boolean;
+  outFile?: string;
+  configFilePath?: string;
+  noDtsResolution?: boolean;
+  pathsBasePath?: string;
+  diagnostics?: boolean;
+  extendedDiagnostics?: boolean;
+  generateCpuProfile?: string;
+  generateTrace?: string;
+  listEmittedFiles?: boolean;
+  listFiles?: boolean;
+  explainFiles?: boolean;
+  listFilesOnly?: boolean;
+  noEmitForJsFiles?: boolean;
+  preserveWatchOutput?: boolean;
+  pretty?: boolean;
+  version?: boolean;
+  watch?: boolean;
+  showConfig?: boolean;
+  build?: boolean;
+  help?: boolean;
+  all?: boolean;
+  pprofDir?: string;
+  singleThreaded?: boolean;
+  quiet?: boolean;
+  checkers?: number;
+}
+
+/** Compiler options as `tsc-ts --api` returns them: unset strings, enums and path mappings are undefined. */
+export function compilerOptionsOf(o: CompilerOptionsValue): ApiCompilerOptions {
+  return {
+    allowJs: o.allowJs,
+    allowArbitraryExtensions: o.allowArbitraryExtensions,
+    allowImportingTsExtensions: o.allowImportingTsExtensions,
+    allowNonTsExtensions: o.allowNonTsExtensions,
+    allowUmdGlobalAccess: o.allowUmdGlobalAccess,
+    allowUnreachableCode: o.allowUnreachableCode,
+    allowUnusedLabels: o.allowUnusedLabels,
+    assumeChangesOnlyAffectDirectDependencies: o.assumeChangesOnlyAffectDirectDependencies,
+    checkJs: o.checkJs,
+    customConditions: o.customConditions,
+    composite: o.composite,
+    emitDeclarationOnly: o.emitDeclarationOnly,
+    emitBOM: o.emitBOM,
+    emitDecoratorMetadata: o.emitDecoratorMetadata,
+    declaration: o.declaration,
+    declarationDir: text(o.declarationDir),
+    declarationMap: o.declarationMap,
+    deduplicatePackages: o.deduplicatePackages,
+    disableSizeLimit: o.disableSizeLimit,
+    disableSourceOfProjectReferenceRedirect: o.disableSourceOfProjectReferenceRedirect,
+    disableSolutionSearching: o.disableSolutionSearching,
+    disableReferencedProjectLoad: o.disableReferencedProjectLoad,
+    erasableSyntaxOnly: o.erasableSyntaxOnly,
+    exactOptionalPropertyTypes: o.exactOptionalPropertyTypes,
+    experimentalDecorators: o.experimentalDecorators,
+    forceConsistentCasingInFileNames: o.forceConsistentCasingInFileNames,
+    isolatedModules: o.isolatedModules,
+    isolatedDeclarations: o.isolatedDeclarations,
+    ignoreConfig: o.ignoreConfig,
+    ignoreDeprecations: text(o.ignoreDeprecations),
+    importHelpers: o.importHelpers,
+    inlineSourceMap: o.inlineSourceMap,
+    inlineSources: o.inlineSources,
+    init: o.init,
+    incremental: o.incremental,
+    jsx: enumValue(o.jsx),
+    jsxFactory: text(o.jsxFactory),
+    jsxFragmentFactory: text(o.jsxFragmentFactory),
+    jsxImportSource: text(o.jsxImportSource),
+    lib: o.lib,
+    libReplacement: o.libReplacement,
+    locale: text(o.locale),
+    mapRoot: text(o.mapRoot),
+    module: enumValue(o.module),
+    moduleResolution: enumValue(o.moduleResolution),
+    moduleSuffixes: o.moduleSuffixes,
+    moduleDetection: enumValue(o.moduleDetection),
+    newLine: enumValue(o.newLine),
+    noEmit: o.noEmit,
+    noCheck: o.noCheck,
+    noErrorTruncation: o.noErrorTruncation,
+    noFallthroughCasesInSwitch: o.noFallthroughCasesInSwitch,
+    noImplicitAny: o.noImplicitAny,
+    noImplicitThis: o.noImplicitThis,
+    noImplicitReturns: o.noImplicitReturns,
+    noEmitHelpers: o.noEmitHelpers,
+    noLib: o.noLib,
+    noPropertyAccessFromIndexSignature: o.noPropertyAccessFromIndexSignature,
+    noUncheckedIndexedAccess: o.noUncheckedIndexedAccess,
+    noEmitOnError: o.noEmitOnError,
+    noUnusedLocals: o.noUnusedLocals,
+    noUnusedParameters: o.noUnusedParameters,
+    noResolve: o.noResolve,
+    noImplicitOverride: o.noImplicitOverride,
+    noUncheckedSideEffectImports: o.noUncheckedSideEffectImports,
+    outDir: text(o.outDir),
+    paths: pathMappings(o.paths),
+    preserveConstEnums: o.preserveConstEnums,
+    preserveSymlinks: o.preserveSymlinks,
+    project: text(o.project),
+    resolveJsonModule: o.resolveJsonModule,
+    resolvePackageJsonExports: o.resolvePackageJsonExports,
+    resolvePackageJsonImports: o.resolvePackageJsonImports,
+    removeComments: o.removeComments,
+    rewriteRelativeImportExtensions: o.rewriteRelativeImportExtensions,
+    reactNamespace: text(o.reactNamespace),
+    rootDir: text(o.rootDir),
+    rootDirs: o.rootDirs,
+    skipLibCheck: o.skipLibCheck,
+    stableTypeOrdering: o.stableTypeOrdering,
+    strict: o.strict,
+    strictBindCallApply: o.strictBindCallApply,
+    strictBuiltinIteratorReturn: o.strictBuiltinIteratorReturn,
+    strictFunctionTypes: o.strictFunctionTypes,
+    strictNullChecks: o.strictNullChecks,
+    strictPropertyInitialization: o.strictPropertyInitialization,
+    stripInternal: o.stripInternal,
+    skipDefaultLibCheck: o.skipDefaultLibCheck,
+    sourceMap: o.sourceMap,
+    sourceRoot: text(o.sourceRoot),
+    suppressOutputPathCheck: o.suppressOutputPathCheck,
+    target: enumValue(o.target),
+    traceResolution: o.traceResolution,
+    tsBuildInfoFile: text(o.tsBuildInfoFile),
+    typeRoots: o.typeRoots,
+    types: o.types,
+    useDefineForClassFields: o.useDefineForClassFields,
+    useUnknownInCatchVariables: o.useUnknownInCatchVariables,
+    verbatimModuleSyntax: o.verbatimModuleSyntax,
+    maxNodeModuleJsDepth: o.maxNodeModuleJsDepth,
+    allowSyntheticDefaultImports: o.allowSyntheticDefaultImports,
+    alwaysStrict: o.alwaysStrict,
+    baseUrl: text(o.baseUrl),
+    downlevelIteration: o.downlevelIteration,
+    esModuleInterop: o.esModuleInterop,
+    outFile: text(o.outFile),
+    configFilePath: text(o.configFilePath),
+    noDtsResolution: o.noDtsResolution,
+    pathsBasePath: text(o.pathsBasePath),
+    diagnostics: o.diagnostics,
+    extendedDiagnostics: o.extendedDiagnostics,
+    generateCpuProfile: text(o.generateCpuProfile),
+    generateTrace: text(o.generateTrace),
+    listEmittedFiles: o.listEmittedFiles,
+    listFiles: o.listFiles,
+    explainFiles: o.explainFiles,
+    listFilesOnly: o.listFilesOnly,
+    noEmitForJsFiles: o.noEmitForJsFiles,
+    preserveWatchOutput: o.preserveWatchOutput,
+    pretty: o.pretty,
+    version: o.version,
+    watch: o.watch,
+    showConfig: o.showConfig,
+    build: o.build,
+    help: o.help,
+    all: o.all,
+    pprofDir: text(o.pprofDir),
+    singleThreaded: o.singleThreaded,
+    quiet: o.quiet,
+    checkers: o.checkers,
+  };
+}
+
+function text(value: string | undefined): string | undefined {
+  return value === '' ? undefined : value;
+}
+
+function enumValue(value: number | undefined): number | undefined {
+  return value === 0 ? undefined : value;
+}
+
+function pathMappings(paths: Map<string, string[] | undefined> | undefined): Record<string, string[]> | undefined {
+  if (paths === undefined) return undefined;
+  const mappings: Record<string, string[]> = {};
+  for (const [pattern, substitutions] of paths) mappings[pattern] = substitutions ?? [];
+  return mappings;
+}
+
+/**
+ * tsc-ts's compiler options for options in the form tsgo's API returns them (`compilerOptionsOf`). `lib`
+ * may name libraries as in tsconfig.json (`es2025`) or by file name (`lib.es2025.d.ts`).
+ */
+export function compilerOptionsFromApi(o: ApiCompilerOptions): CompilerOptionsValue {
+  return {
+    allowJs: o.allowJs,
+    allowArbitraryExtensions: o.allowArbitraryExtensions,
+    allowImportingTsExtensions: o.allowImportingTsExtensions,
+    allowNonTsExtensions: o.allowNonTsExtensions,
+    allowUmdGlobalAccess: o.allowUmdGlobalAccess,
+    allowUnreachableCode: o.allowUnreachableCode,
+    allowUnusedLabels: o.allowUnusedLabels,
+    assumeChangesOnlyAffectDirectDependencies: o.assumeChangesOnlyAffectDirectDependencies,
+    checkJs: o.checkJs,
+    customConditions: o.customConditions,
+    composite: o.composite,
+    emitDeclarationOnly: o.emitDeclarationOnly,
+    emitBOM: o.emitBOM,
+    emitDecoratorMetadata: o.emitDecoratorMetadata,
+    declaration: o.declaration,
+    declarationDir: o.declarationDir,
+    declarationMap: o.declarationMap,
+    deduplicatePackages: o.deduplicatePackages,
+    disableSizeLimit: o.disableSizeLimit,
+    disableSourceOfProjectReferenceRedirect: o.disableSourceOfProjectReferenceRedirect,
+    disableSolutionSearching: o.disableSolutionSearching,
+    disableReferencedProjectLoad: o.disableReferencedProjectLoad,
+    erasableSyntaxOnly: o.erasableSyntaxOnly,
+    exactOptionalPropertyTypes: o.exactOptionalPropertyTypes,
+    experimentalDecorators: o.experimentalDecorators,
+    forceConsistentCasingInFileNames: o.forceConsistentCasingInFileNames,
+    isolatedModules: o.isolatedModules,
+    isolatedDeclarations: o.isolatedDeclarations,
+    ignoreConfig: o.ignoreConfig,
+    ignoreDeprecations: o.ignoreDeprecations,
+    importHelpers: o.importHelpers,
+    inlineSourceMap: o.inlineSourceMap,
+    inlineSources: o.inlineSources,
+    init: o.init,
+    incremental: o.incremental,
+    jsx: o.jsx,
+    jsxFactory: o.jsxFactory,
+    jsxFragmentFactory: o.jsxFragmentFactory,
+    jsxImportSource: o.jsxImportSource,
+    lib: libFileNames(o.lib),
+    libReplacement: o.libReplacement,
+    locale: o.locale,
+    mapRoot: o.mapRoot,
+    module: o.module,
+    moduleResolution: o.moduleResolution,
+    moduleSuffixes: o.moduleSuffixes,
+    moduleDetection: o.moduleDetection,
+    newLine: o.newLine,
+    noEmit: o.noEmit,
+    noCheck: o.noCheck,
+    noErrorTruncation: o.noErrorTruncation,
+    noFallthroughCasesInSwitch: o.noFallthroughCasesInSwitch,
+    noImplicitAny: o.noImplicitAny,
+    noImplicitThis: o.noImplicitThis,
+    noImplicitReturns: o.noImplicitReturns,
+    noEmitHelpers: o.noEmitHelpers,
+    noLib: o.noLib,
+    noPropertyAccessFromIndexSignature: o.noPropertyAccessFromIndexSignature,
+    noUncheckedIndexedAccess: o.noUncheckedIndexedAccess,
+    noEmitOnError: o.noEmitOnError,
+    noUnusedLocals: o.noUnusedLocals,
+    noUnusedParameters: o.noUnusedParameters,
+    noResolve: o.noResolve,
+    noImplicitOverride: o.noImplicitOverride,
+    noUncheckedSideEffectImports: o.noUncheckedSideEffectImports,
+    outDir: o.outDir,
+    paths: pathMap(o.paths),
+    preserveConstEnums: o.preserveConstEnums,
+    preserveSymlinks: o.preserveSymlinks,
+    project: o.project,
+    resolveJsonModule: o.resolveJsonModule,
+    resolvePackageJsonExports: o.resolvePackageJsonExports,
+    resolvePackageJsonImports: o.resolvePackageJsonImports,
+    removeComments: o.removeComments,
+    rewriteRelativeImportExtensions: o.rewriteRelativeImportExtensions,
+    reactNamespace: o.reactNamespace,
+    rootDir: o.rootDir,
+    rootDirs: o.rootDirs,
+    skipLibCheck: o.skipLibCheck,
+    stableTypeOrdering: o.stableTypeOrdering,
+    strict: o.strict,
+    strictBindCallApply: o.strictBindCallApply,
+    strictBuiltinIteratorReturn: o.strictBuiltinIteratorReturn,
+    strictFunctionTypes: o.strictFunctionTypes,
+    strictNullChecks: o.strictNullChecks,
+    strictPropertyInitialization: o.strictPropertyInitialization,
+    stripInternal: o.stripInternal,
+    skipDefaultLibCheck: o.skipDefaultLibCheck,
+    sourceMap: o.sourceMap,
+    sourceRoot: o.sourceRoot,
+    suppressOutputPathCheck: o.suppressOutputPathCheck,
+    target: o.target,
+    traceResolution: o.traceResolution,
+    tsBuildInfoFile: o.tsBuildInfoFile,
+    typeRoots: o.typeRoots,
+    types: o.types,
+    useDefineForClassFields: o.useDefineForClassFields,
+    useUnknownInCatchVariables: o.useUnknownInCatchVariables,
+    verbatimModuleSyntax: o.verbatimModuleSyntax,
+    maxNodeModuleJsDepth: o.maxNodeModuleJsDepth,
+    allowSyntheticDefaultImports: o.allowSyntheticDefaultImports,
+    alwaysStrict: o.alwaysStrict,
+    baseUrl: o.baseUrl,
+    downlevelIteration: o.downlevelIteration,
+    esModuleInterop: o.esModuleInterop,
+    outFile: o.outFile,
+    configFilePath: o.configFilePath,
+    noDtsResolution: o.noDtsResolution,
+    pathsBasePath: o.pathsBasePath,
+    diagnostics: o.diagnostics,
+    extendedDiagnostics: o.extendedDiagnostics,
+    generateCpuProfile: o.generateCpuProfile,
+    generateTrace: o.generateTrace,
+    listEmittedFiles: o.listEmittedFiles,
+    listFiles: o.listFiles,
+    explainFiles: o.explainFiles,
+    listFilesOnly: o.listFilesOnly,
+    noEmitForJsFiles: o.noEmitForJsFiles,
+    preserveWatchOutput: o.preserveWatchOutput,
+    pretty: o.pretty,
+    version: o.version,
+    watch: o.watch,
+    showConfig: o.showConfig,
+    build: o.build,
+    help: o.help,
+    all: o.all,
+    pprofDir: o.pprofDir,
+    singleThreaded: o.singleThreaded,
+    quiet: o.quiet,
+    checkers: o.checkers,
+  };
+}
+
+function pathMap(paths: Record<string, string[]> | undefined): Map<string, string[] | undefined> | undefined {
+  if (paths === undefined) return undefined;
+  const map = new Map<string, string[] | undefined>();
+  for (const pattern of Object.keys(paths)) map.set(pattern, paths[pattern]!.slice());
+  return map;
+}
+
+function libFileNames(lib: string[] | undefined): string[] | undefined {
+  if (lib === undefined) return undefined;
+  const fileNames: string[] = [];
+  for (const name of lib) {
+    const fileName = getLibFileName(name);
+    fileNames.push(fileName !== '' ? fileName : name);
+  }
+  return fileNames;
+}