指定要包含在程序中的文件允许列表。如果找不到任何文件，将会发生错误。

🌐 Specifies an allowlist of files to include in the program. An error occurs if any of the files can’t be found.

{
  "compilerOptions": {},
  "files": [
    "core.ts",
    "sys.ts",
    "types.ts",
    "scanner.ts",
    "parser.ts",
    "utilities.ts",
    "binder.ts",
    "checker.ts",
    "tsc.ts"
  ]
}

当你只有少量文件且不需要使用通配符来引用许多文件时，这很有用。如果你需要那样做，请使用include。

🌐 This is useful when you only have a small number of files and don’t need to use a glob to reference many files. If you need that then use include.

extends 的值是一个字符串，包含要继承的另一个配置文件的路径。该路径可能使用 Node.js 风格的解析方式。

🌐 The value of extends is a string which contains a path to another configuration file to inherit from. The path may use Node.js style resolution.

首先加载基础文件的配置，然后再由继承的配置文件中的配置覆盖。配置文件中所有的相对路径都将相对于它们所在的配置文件进行解析。

🌐 The configuration from the base file are loaded first, then overridden by those in the inheriting config file. All relative paths found in the configuration file will be resolved relative to the configuration file they originated in.

值得注意的是，继承的配置文件中的 files、include 和 exclude 会 覆盖 基础配置文件中的相应项，并且配置文件之间不允许出现循环引用。

🌐 It’s worth noting that files, include, and exclude from the inheriting config file overwrite those from the base config file, and that circularity between configuration files is not allowed.

目前，唯一一个不继承的顶层属性是 references。

🌐 Currently, the only top-level property that is excluded from inheritance is references.

示例

🌐 Example

configs/base.json:

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true
  }
}

tsconfig.json:

{
  "extends": "./configs/base",
  "files": ["main.ts", "supplemental.ts"]
}

tsconfig.nostrictnull.json:

{
  "extends": "./tsconfig",
  "compilerOptions": {
    "strictNullChecks": false
  }
}

在配置文件中找到的具有相对路径的属性（未从继承中排除）将相对于它们起源的配置文件进行解析。

🌐 Properties with relative paths found in the configuration file, which aren’t excluded from inheritance, will be resolved relative to the configuration file they originated in.

指定要包含在程序中的文件名或模式数组。这些文件名是相对于包含 tsconfig.json 文件的目录解析的。

🌐 Specifies an array of filenames or patterns to include in the program. These filenames are resolved relative to the directory containing the tsconfig.json file.

json
{
  "include": ["src/**/*", "tests/**/*"]
}

将包括：

🌐 Which would include:

.
├── scripts                ⨯
│   ├── lint.ts            ⨯
│   ├── update_deps.ts     ⨯
│   └── utils.ts           ⨯
├── src                    ✓
│   ├── client             ✓
│   │    ├── index.ts      ✓
│   │    └── utils.ts      ✓
│   ├── server             ✓
│   │    └── index.ts      ✓
├── tests                  ✓
│   ├── app.test.ts        ✓
│   ├── utils.ts           ✓
│   └── tests.d.ts         ✓
├── package.json
├── tsconfig.json
└── yarn.lock

include 和 exclude 支持通配符，用于创建全局匹配模式：

• * 匹配零个或多个字符（不包括目录分隔符）
• ? 匹配任意一个字符（不包括目录分隔符）
• **/ 匹配任意层级的任何目录

如果模式中的最后一个路径段不包含文件扩展名或通配符字符，则它会被视为一个目录，并且该目录中具有支持的扩展名的文件将被包括在内（例如，默认包括 .ts、.tsx 和 .d.ts，如果 allowJs 设置为 true，则还包括 .js 和 .jsx）。

🌐 If the last path segment in a pattern does not contain a file extension or wildcard character, then it is treated as a directory, and files with supported extensions inside that directory are included (e.g. .ts, .tsx, and .d.ts by default, with .js and .jsx if allowJs is set to true).

指定在解析 include 时应跳过的文件名或模式数组。

🌐 Specifies an array of filenames or patterns that should be skipped when resolving include.

重要：exclude 仅 会更改由于include设置而包含的文件。
通过 exclude 指定的文件仍然可能因为代码中的 import 语句、types 包含、/// <reference 指令，或被列在files清单中而成为你的代码库的一部分。

这并不是一种能够阻止文件被包含到代码库中的机制——它只是改变了include设置所查找到的内容。

🌐 It is not a mechanism that prevents a file from being included in the codebase - it simply changes what the include setting finds.

项目引用是一种将 TypeScript 程序拆分为更小部分的方法。使用项目引用可以大大提高构建和编辑器交互的速度，强制组件之间的逻辑分离，并以全新和改进的方式组织代码。

🌐 Project references are a way to structure your TypeScript programs into smaller pieces. Using Project References can greatly improve build and editor interaction times, enforce logical separation between components, and organize your code in new and improved ways.

你可以在手册的 项目引用 部分了解更多关于引用如何工作的内容

🌐 You can read more about how references works in the Project References section of the handbook

当：

🌐 When:

• undefined（默认）向编辑提供警告性建议
• true 不可达的代码将被忽略
• false 会引发关于不可达代码的编译器错误

这些警告仅与由于使用 JavaScript 语法而无法访问的代码有关，例如：

🌐 These warnings are only about code which is provably unreachable due to the use of JavaScript syntax, for example:

ts
function fn(n: number) {
  if (n > 5) {
    return true;
  } else {
    return false;
  }
  return true;
}

使用 "allowUnreachableCode": false：

🌐 With "allowUnreachableCode": false:

ts
function fn(n: number) {
  if (n > 5) {
    return true;
  } else {
    return false;
  }
  return true;
Unreachable code detected.7027Unreachable code detected.
}Try

这不会影响基于类型分析而看起来无法到达的代码的错误。

🌐 This does not affect errors on the basis of code which appears to be unreachable due to type analysis.

当：

🌐 When:

• undefined（默认）向编辑提供警告性建议
• true 未使用的标签将被忽略
• false 会引发关于未使用标签的编译器错误

标签在 JavaScript 中非常罕见，通常表示尝试编写对象字面量：

🌐 Labels are very rare in JavaScript and typically indicate an attempt to write an object literal:

ts
function verifyAge(age: number) {
  // Forgot 'return' statement
  if (age > 18) {
    verified: true;
Unused label.7028Unused label.
  }
}Try

确保你的文件在 ECMAScript 严格模式下被解析，并为每个源文件输出 “use strict”。

🌐 Ensures that your files are parsed in the ECMAScript strict mode, and emit “use strict” for each source file.

ES5 引入了 ECMAScript 严格模式，它通过对 JavaScript 引擎的运行时行为进行调整来提高性能，并且将一系列错误改为抛出而不是静默忽略。

启用 exactOptionalPropertyTypes 时，TypeScript 对具有 ? 前缀的 type 或 interfaces 属性的处理会应用更严格的规则。

🌐 With exactOptionalPropertyTypes enabled, TypeScript applies stricter rules around how it handles properties on type or interfaces which have a ? prefix.

例如，这个接口声明有一个属性，该属性可以是两个字符串之一：“dark”或“light”，或者该属性不应存在于对象中。

🌐 For example, this interface declares that there is a property which can be one of two strings: ‘dark’ or ‘light’ or it should not be in the object.

ts
interface UserDefaults {
  // The absence of a value represents 'system'
  colorThemeOverride?: "dark" | "light";
}

如果未启用此标志，你可以将 colorThemeOverride 设置为三个值之一：“dark”、“light” 和 undefined。

🌐 Without this flag enabled, there are three values which you can set colorThemeOverride to be: “dark”, “light” and undefined.

将值设置为 undefined 将使大多数 JavaScript 运行时对存在性的检查失败，这实际上是假的。然而，这并不完全准确；colorThemeOverride: undefined 不等同于 colorThemeOverride 未被定义。例如，"colorThemeOverride" in settings 使用 undefined 作为键时的行为与未定义时将不同。

🌐 Setting the value to undefined will allow most JavaScript runtime checks for the existence to fail, which is effectively falsy. However, this isn’t quite accurate; colorThemeOverride: undefined is not the same as colorThemeOverride not being defined. For example, "colorThemeOverride" in settings would have different behavior with undefined as the key compared to not being defined.

exactOptionalPropertyTypes 让 TypeScript 真正强制执行作为可选属性提供的定义：

ts
const settings = getUserSettings();
settings.colorThemeOverride = "dark";
settings.colorThemeOverride = "light";
 
// But not:
settings.colorThemeOverride = undefined;
Type 'undefined' is not assignable to type '"dark" | "light"' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the type of the target.2412Type 'undefined' is not assignable to type '"dark" | "light"' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the type of the target.Try

报告 switch 语句中存在的贯穿（fallthrough）错误。确保 switch 语句中的任何非空 case 都包含 break、return 或 throw。这意味着你不会意外发布 case 贯穿错误。

🌐 Report errors for fallthrough cases in switch statements. Ensures that any non-empty case inside a switch statement includes either break, return, or throw. This means you won’t accidentally ship a case fallthrough bug.

ts
const a: number = 6;
 
switch (a) {
  case 0:
Fallthrough case in switch.7029Fallthrough case in switch.
    console.log("even");
  case 1:
    console.log("odd");
    break;
}Try

在某些没有类型注解的情况下，当 TypeScript 无法推断变量类型时，会将变量的类型回退为 any。

🌐 In some cases where no type annotations are present, TypeScript will fall back to a type of any for a variable when it cannot infer the type.

这可能会导致一些错误被遗漏，例如：

🌐 This can cause some errors to be missed, for example:

ts
function fn(s) {
  // No error?
  console.log(s.subtr(3));
}
fn(42);Try

然而，开启 noImplicitAny 时，每当 TypeScript 本来会推断 any 时都会报错：

🌐 Turning on noImplicitAny however TypeScript will issue an error whenever it would have inferred any:

ts
function fn(s) {
Parameter 's' implicitly has an 'any' type.7006Parameter 's' implicitly has an 'any' type.
  console.log(s.subtr(3));
}Try

在使用继承的类时，当基类中的函数被重命名时，子类可能会与它重载的函数“不同步”。

🌐 When working with classes which use inheritance, it’s possible for a sub-class to get “out of sync” with the functions it overloads when they are renamed in the base class.

例如，假设你正在建模音乐专辑同步系统：

🌐 For example, imagine you are modeling a music album syncing system:

ts
class Album {
  download() {
    // Default behavior
  }
}
 
class SharedAlbum extends Album {
  download() {
    // Override to get info from many sources
  }
}Try

然后，当你添加对机器学习生成的播放列表的支持时，你将 Album 类重构为拥有一个“setup”函数，如下所示：

🌐 Then when you add support for machine-learning generated playlists, you refactor the Album class to have a ‘setup’ function instead:

ts
class Album {
  setup() {
    // Default behavior
  }
}
 
class MLAlbum extends Album {
  setup() {
    // Override to get info from algorithm
  }
}
 
class SharedAlbum extends Album {
  download() {
    // Override to get info from many sources
  }
}Try

在这种情况下，TypeScript 并没有发出任何警告，说明 SharedAlbum 上的 download 预期 要重写基类中的一个函数。

🌐 In this case, TypeScript has provided no warning that download on SharedAlbum expected to override a function in the base class.

使用 noImplicitOverride，你可以确保子类永远不会不同步，通过确保重写的函数包含关键字 override。

🌐 Using noImplicitOverride you can ensure that the sub-classes never go out of sync, by ensuring that functions which override include the keyword override.

以下示例启用了 noImplicitOverride，当缺少 override 时，你可以看到收到的错误：

🌐 The following example has noImplicitOverride enabled, and you can see the error received when override is missing:

ts
class Album {
  setup() {}
}
 
class MLAlbum extends Album {
  override setup() {}
}
 
class SharedAlbum extends Album {
  setup() {}
This member must have an 'override' modifier because it overrides a member in the base class 'Album'.4114This member must have an 'override' modifier because it overrides a member in the base class 'Album'.
}Try

启用后，TypeScript 将检查函数中的所有代码路径以确保它们返回值。

🌐 When enabled, TypeScript will check all code paths in a function to ensure they return a value.

ts
function lookupHeadphonesManufacturer(color: "blue" | "black"): string {
Function lacks ending return statement and return type does not include 'undefined'.2366Function lacks ending return statement and return type does not include 'undefined'.
  if (color === "blue") {
    return "beats";
  } else {
    ("bose");
  }
}Try

对类型隐含为 ‘any’ 的 ‘this’ 表达式引发错误。

🌐 Raise error on ‘this’ expressions with an implied ‘any’ type.

例如，下面的类返回一个函数，该函数尝试访问 this.width 和 this.height – 但是在 getAreaFunction 内部的函数中，this 的上下文不是 Rectangle 的实例。

🌐 For example, the class below returns a function which tries to access this.width and this.height – but the context for this inside the function inside getAreaFunction is not the instance of the Rectangle.

ts
class Rectangle {
  width: number;
  height: number;
 
  constructor(width: number, height: number) {
    this.width = width;
    this.height = height;
  }
 
  getAreaFunction() {
    return function () {
      return this.width * this.height;
'this' implicitly has type 'any' because it does not have a type annotation.
'this' implicitly has type 'any' because it does not have a type annotation.2683
2683'this' implicitly has type 'any' because it does not have a type annotation.
'this' implicitly has type 'any' because it does not have a type annotation.
    };
  }
}Try

此设置确保通过“点”（obj.key）语法和“索引”（obj["key"]）语法访问字段时，与类型中声明属性的方式保持一致。

🌐 This setting ensures consistency between accessing a field via the “dot” (obj.key) syntax, and “indexed” (obj["key"]) and the way which the property is declared in the type.

不启用此标志时，TypeScript 将允许你使用点语法访问未定义的字段：

🌐 Without this flag, TypeScript will allow you to use the dot syntax to access fields which are not defined:

ts
interface GameSettings {
  // Known up-front properties
  speed: "fast" | "medium" | "slow";
  quality: "high" | "low";
 
  // Assume anything unknown to the interface
  // is a string.
  [key: string]: string;
}
 
const settings = getSettings();
settings.speed;
          
(property) GameSettings.speed: "fast" | "medium" | "slow"
settings.quality;
           
(property) GameSettings.quality: "high" | "low"
 
// Unknown key accessors are allowed on
// this object, and are `string`
settings.username;
            
(index) GameSettings[string]: stringTry

打开标志将引发错误，因为未知字段使用点语法而不是索引语法。

🌐 Turning the flag on will raise an error because the unknown field uses dot syntax instead of indexed syntax.

ts
const settings = getSettings();
settings.speed;
settings.quality;
 
// This would need to be settings["username"];
settings.username;
Property 'username' comes from an index signature, so it must be accessed with ['username'].4111Property 'username' comes from an index signature, so it must be accessed with ['username'].
            
(index) GameSettings[string]: stringTry

此标志的目的是在你的调用语法中触发信号，表明你有多确定此属性存在。

🌐 The goal of this flag is to signal intent in your calling syntax about how certain you are this property exists.

TypeScript 有一种通过索引签名来描述具有未知键但已知值的对象的方法。

🌐 TypeScript has a way to describe objects which have unknown keys but known values on an object, via index signatures.

ts
interface EnvironmentVars {
  NAME: string;
  OS: string;
 
  // Unknown properties are covered by this index signature.
  [propName: string]: string;
}
 
declare const env: EnvironmentVars;
 
// Declared as existing
const sysName = env.NAME;
const os = env.OS;
      
const os: string
 
// Not declared, but because of the index
// signature, then it is considered a string
const nodeEnv = env.NODE_ENV;
        
const nodeEnv: stringTry

开启 noUncheckedIndexedAccess 将会向类型中任何未声明的字段添加 undefined。

🌐 Turning on noUncheckedIndexedAccess will add undefined to any un-declared field in the type.

ts
declare const env: EnvironmentVars;
 
// Declared as existing
const sysName = env.NAME;
const os = env.OS;
      
const os: string
 
// Not declared, but because of the index
// signature, then it is considered a string
const nodeEnv = env.NODE_ENV;
        
const nodeEnv: string | undefinedTry

报告未使用的局部变量的错误。

🌐 Report errors on unused local variables.

ts
const createKeyboard = (modelID: number) => {
  const defaultModelID = 23;
'defaultModelID' is declared but its value is never read.6133'defaultModelID' is declared but its value is never read.
  return { type: "keyboard", modelID };
};Try

报告函数中未使用的参数的错误。

🌐 Report errors on unused parameters in functions.

ts
const createDefaultKeyboard = (modelID: number) => {
'modelID' is declared but its value is never read.6133'modelID' is declared but its value is never read.
  const defaultModelID = 23;
  return { type: "keyboard", modelID: defaultModelID };
};Try

以下划线开头的参数声明（_）可以免于未使用参数的检查。例如：

🌐 Parameters declaration with names starting with an underscore (_) are exempt from the unused parameter checking. e.g.:

ts
const createDefaultKeyboard = (_modelID: number) => {
  return { type: "keyboard" };
};Try

strict 标志启用广泛的类型检查行为，从而提供对程序正确性的更强保证。开启此选项相当于启用下文所述的所有严格模式系列选项。然后，你可以根据需要关闭单个严格模式系列检查。

🌐 The strict flag enables a wide range of type checking behavior that results in stronger guarantees of program correctness. Turning this on is equivalent to enabling all of the strict mode family options, which are outlined below. You can then turn off individual strict mode family checks as needed.

TypeScript 的未来版本可能会在此标志下引入更严格的检查，因此升级 TypeScript 可能会导致程序中出现新的类型错误。在适当且可能的情况下，将添加相应的标志以禁用该行为。

🌐 Future versions of TypeScript may introduce additional stricter checking under this flag, so upgrades of TypeScript might result in new type errors in your program. When appropriate and possible, a corresponding flag will be added to disable that behavior.

设置后，TypeScript 将检查函数 call、bind 和 apply 的内置方法是否以底层函数的正确参数调用：

🌐 When set, TypeScript will check that the built-in methods of functions call, bind, and apply are invoked with correct argument for the underlying function:

ts
// With strictBindCallApply on
function fn(x: string) {
  return parseInt(x);
}
 
const n1 = fn.call(undefined, "10");
 
const n2 = fn.call(undefined, false);
Argument of type 'boolean' is not assignable to parameter of type 'string'.2345Argument of type 'boolean' is not assignable to parameter of type 'string'.Try

否则，这些函数接受任何参数，并将返回 any：

🌐 Otherwise, these functions accept any arguments and will return any:

ts
// With strictBindCallApply off
function fn(x: string) {
  return parseInt(x);
}
 
// Note: No error; return type is 'any'
const n = fn.call(undefined, false);Try

内置迭代器实例化时使用的是类型为 TReturn 的 undefined，而不是 any。

🌐 Built-in iterators are instantiated with a TReturn type of undefined instead of any.

启用后，此标志可更正确地检查函数参数。

🌐 When enabled, this flag causes functions parameters to be checked more correctly.

这是一个关闭 strictFunctionTypes 的基本示例：

🌐 Here’s a basic example with strictFunctionTypes off:

ts
function fn(x: string) {
  console.log("Hello, " + x.toLowerCase());
}
 
type StringOrNumberFunc = (ns: string | number) => void;
 
// Unsafe assignment
let func: StringOrNumberFunc = fn;
// Unsafe call - will crash
func(10);Try

当 strictFunctionTypes 开启 时，错误会被正确检测到：

🌐 With strictFunctionTypes on, the error is correctly detected:

ts
function fn(x: string) {
  console.log("Hello, " + x.toLowerCase());
}
 
type StringOrNumberFunc = (ns: string | number) => void;
 
// Unsafe assignment is prevented
let func: StringOrNumberFunc = fn;
Type '(x: string) => void' is not assignable to type 'StringOrNumberFunc'.
  Types of parameters 'x' and 'ns' are incompatible.
    Type 'string | number' is not assignable to type 'string'.
      Type 'number' is not assignable to type 'string'.2322Type '(x: string) => void' is not assignable to type 'StringOrNumberFunc'.
  Types of parameters 'x' and 'ns' are incompatible.
    Type 'string | number' is not assignable to type 'string'.
      Type 'number' is not assignable to type 'string'.Try

在开发此功能的过程中，我们发现了大量本质上不安全的类层次结构，包括 DOM 中的一些。因此，该设置仅适用于以 function 语法编写的函数，而不适用于以 method 语法编写的函数：

🌐 During development of this feature, we discovered a large number of inherently unsafe class hierarchies, including some in the DOM. Because of this, the setting only applies to functions written in function syntax, not to those in method syntax:

ts
type Methodish = {
  func(x: string | number): void;
};
 
function fn(x: string) {
  console.log("Hello, " + x.toLowerCase());
}
 
// Ultimately an unsafe assignment, but not detected
const m: Methodish = {
  func: fn,
};
m.func(10);Try

当 strictNullChecks 为 false 时，语言会忽略 null 和 undefined。这可能在运行时导致意外错误。

🌐 When strictNullChecks is false, null and undefined are effectively ignored by the language. This can lead to unexpected errors at runtime.

当 strictNullChecks 是 true 时，null 和 undefined 各自有不同的类型，如果你在需要具体值的地方使用它们，将会出现类型错误。

🌐 When strictNullChecks is true, null and undefined have their own distinct types and you’ll get a type error if you try to use them where a concrete value is expected.

例如，对于这段 TypeScript 代码，users.find 并不能保证实际上会找到一个用户，但你可以像它会找到一样编写代码：

🌐 For example with this TypeScript code, users.find has no guarantee that it will actually find a user, but you can write code as though it will:

ts
declare const loggedInUsername: string;
 
const users = [
  { name: "Oby", age: 12 },
  { name: "Heera", age: 32 },
];
 
const loggedInUser = users.find((u) => u.name === loggedInUsername);
console.log(loggedInUser.age);Try

将 strictNullChecks 设置为 true 会引发错误，因为在尝试使用 loggedInUser 之前，你尚未保证它的存在。

🌐 Setting strictNullChecks to true will raise an error that you have not made a guarantee that the loggedInUser exists before trying to use it.

ts
declare const loggedInUsername: string;
 
const users = [
  { name: "Oby", age: 12 },
  { name: "Heera", age: 32 },
];
 
const loggedInUser = users.find((u) => u.name === loggedInUsername);
console.log(loggedInUser.age);
'loggedInUser' is possibly 'undefined'.18048'loggedInUser' is possibly 'undefined'.Try

第二个例子失败了，因为数组的 find 函数看起来有点像这种简化:

🌐 The second example failed because the array’s find function looks a bit like this simplification:

ts
// When strictNullChecks: true
type Array = {
  find(predicate: (value: any, index: number) => boolean): S | undefined;
};
// When strictNullChecks: false the undefined is removed from the type system,
// allowing you to write code which assumes it always found a result
type Array = {
  find(predicate: (value: any, index: number) => boolean): S;
};

设置为 true 时，如果声明了类属性但未在构造函数中设置，则 TypeScript 会引发错误。

🌐 When set to true, TypeScript will raise an error when a class property was declared but not set in the constructor.

ts
class UserAccount {
  name: string;
  accountType = "user";
 
  email: string;
Property 'email' has no initializer and is not definitely assigned in the constructor.2564Property 'email' has no initializer and is not definitely assigned in the constructor.
  address: string | undefined;
 
  constructor(name: string) {
    this.name = name;
    // Note that this.email is not set
  }
}Try

在上述情况下：

🌐 In the above case:

• this.name 已被特别设置。
• this.accountType 为默认设置。
• this.email 未设置，会导致错误。
• this.address 被声明为可能是 undefined，这意味着它不必被设置。

在 TypeScript 4.0 中，新增了支持，可以将 catch 子句中变量的类型从 any 改为 unknown。允许出现如下代码:

🌐 In TypeScript 4.0, support was added to allow changing the type of the variable in a catch clause from any to unknown. Allowing for code like:

ts
try {
  // ...
} catch (err: unknown) {
  // We have to verify err is an
  // error before using it as one.
  if (err instanceof Error) {
    console.log(err.message);
  }
}Try

这种模式确保了错误处理代码更加全面，因为你不能提前保证被抛出的对象一定是 Error 子类。启用 useUnknownInCatchVariables 标志后，你就不需要额外的语法（: unknown）或 linter 规则来尝试强制执行这种行为。

🌐 This pattern ensures that error handling code becomes more comprehensive because you cannot guarantee that the object being thrown is a Error subclass ahead of time. With the flag useUnknownInCatchVariables enabled, then you do not need the additional syntax (: unknown) nor a linter rule to try enforce this behavior.

在 TypeScript 5.0 中，当导入路径以不是已知 JavaScript 或 TypeScript 文件扩展名的扩展名结尾时，编译器会查找该路径对应的声明文件，格式为 {file basename}.d.{extension}.ts。 例如，如果你在打包项目中使用 CSS 加载器，你可能希望为那些样式表编写（或生成）声明文件：

🌐 In TypeScript 5.0, when an import path ends in an extension that isn’t a known JavaScript or TypeScript file extension, the compiler will look for a declaration file for that path in the form of {file basename}.d.{extension}.ts. For example, if you are using a CSS loader in a bundler project, you might want to write (or generate) declaration files for those stylesheets:

css
/* app.css */
.cookie-banner {
  display: none;
}

ts
// app.d.css.ts
declare const css: {
  cookieBanner: string;
};
export default css;

ts
// App.tsx
import styles from "./app.css";
styles.cookieBanner; // string

默认情况下，这个导入会抛出一个错误，提示你 TypeScript 不理解这种文件类型，并且你的运行时可能不支持导入它。但是，如果你已经配置了运行时或打包工具来处理它，你可以使用新的 --allowArbitraryExtensions 编译器选项来抑制错误。

🌐 By default, this import will raise an error to let you know that TypeScript doesn’t understand this file type and your runtime might not support importing it. But if you’ve configured your runtime or bundler to handle it, you can suppress the error with the new --allowArbitraryExtensions compiler option.

请注意，从历史上看，通过添加名为 app.css.d.ts 的声明文件而不是 app.d.css.ts，通常可以实现类似的效果——然而，这只是通过 Node 对 CommonJS 的 require 解析规则实现的。严格来说，前者被解释为一个名为 app.css.js 的 JavaScript 文件的声明文件。由于在 Node 的 ESM 支持中，相对文件导入需要包含扩展名，因此在 --moduleResolution node16 或 nodenext 下的 ESM 文件中，我们的示例会在 TypeScript 中报错。

🌐 Note that historically, a similar effect has often been achievable by adding a declaration file named app.css.d.ts instead of app.d.css.ts - however, this just worked through Node’s require resolution rules for CommonJS. Strictly speaking, the former is interpreted as a declaration file for a JavaScript file named app.css.js. Because relative files imports need to include extensions in Node’s ESM support, TypeScript would error on our example in an ESM file under --moduleResolution node16 or nodenext.

欲了解更多信息，请阅读此功能的提案以及其对应的拉取请求。

🌐 For more information, read up the proposal for this feature and its corresponding pull request.

--allowImportingTsExtensions 允许 TypeScript 文件使用 TypeScript 特有的扩展名（如 .ts、.mts 或 .tsx）相互导入。

只有在启用 --noEmit 或 --emitDeclarationOnly 时才允许使用此标志，因为在 JavaScript 输出文件中这些导入路径在运行时无法解析。这里的期望是你的解析器（例如你的打包工具、运行时或其他工具）能够使 .ts 文件之间的这些导入正常工作。

🌐 This flag is only allowed when --noEmit or --emitDeclarationOnly is enabled, since these import paths would not be resolvable at runtime in JavaScript output files. The expectation here is that your resolver (e.g. your bundler, a runtime, or some other tool) is going to make these imports between .ts files work.

当设置为 true 时，allowUmdGlobalAccess 允许你在模块文件内部将 UMD 导出作为全局变量访问。模块文件是包含导入和/或导出的文件。如果没有这个标志，使用 UMD 模块的导出需要一个导入声明。

🌐 When set to true, allowUmdGlobalAccess lets you access UMD exports as globals from inside module files. A module file is a file that has imports and/or exports. Without this flag, using an export from a UMD module requires an import declaration.

此标志的一个示例用例是一个 Web 项目，你知道特定的库（如 jQuery 或 Lodash）在运行时始终可用，但你无法通过导入访问它。

🌐 An example use case for this flag would be a web project where you know the particular library (like jQuery or Lodash) will always be available at runtime, but you can’t access it with an import.

设置一个基础目录，用于解析裸模块名。例如，在目录结构中：

🌐 Sets a base directory from which to resolve bare specifier module names. For example, in the directory structure:

project
├── ex.ts
├── hello
│   └── world.ts
└── tsconfig.json

使用 "baseUrl": "./" 时，TypeScript 会从与 tsconfig.json 相同的文件夹开始查找文件：

🌐 With "baseUrl": "./", TypeScript will look for files starting at the same folder as the tsconfig.json:

ts
import { helloWorld } from "hello/world";
console.log(helloWorld);

该解析优先于来自 node_modules 的查找。

🌐 This resolution has higher priority than lookups from node_modules.

此功能旨在与浏览器中的 AMD 模块加载器配合使用，并不推荐在其他情况下使用。从 TypeScript 4.1 开始，使用 paths 时不再需要设置 baseUrl。

🌐 This feature was designed for use in conjunction with AMD module loaders in the browser, and is not recommended in any other context. As of TypeScript 4.1, baseUrl is no longer required to be set when using paths.

--customConditions 接受一个额外 条件 列表，当 TypeScript 从 package.json 的 exports 或 imports 字段解析时，这些条件应该成功。这些条件会被添加到解析器默认使用的任何现有条件中。

例如，当在 tsconfig.json 中如此设置此字段时：

🌐 For example, when this field is set in a tsconfig.json as so:

jsonc
{
  "compilerOptions": {
    "target": "es2022",
    "moduleResolution": "bundler",
    "customConditions": ["my-condition"]
  }
}

每当在 package.json 中引用 exports 或 imports 字段时，TypeScript 会考虑称为 my-condition 的条件。

🌐 Any time an exports or imports field is referenced in package.json, TypeScript will consider conditions called my-condition.

所以当从包含以下 package.json 的包导入时

🌐 So when importing from a package with the following package.json

jsonc
{
  // ...
  "exports": {
    ".": {
      "my-condition": "./foo.mjs",
      "node": "./bar.mjs",
      "import": "./baz.mjs",
      "require": "./biz.mjs"
    }
  }
}

TypeScript 会尝试查找与 foo.mjs 对应的文件。

🌐 TypeScript will try to look for files corresponding to foo.mjs.

此字段仅在 --moduleResolution 的 node16、nodenext 和 bundler 选项下有效。

🌐 This field is only valid under the node16, nodenext, and bundler options for --moduleResolution.

为程序设置模块系统。有关更多信息，请参阅 TypeScript module 选项的理论 和 参考页面。对于现代 Node.js 项目，你很可能需要使用 "nodenext"，而对于将要打包的代码，则需要使用 preserve 或 esnext。

🌐 Sets the module system for the program. See the theory behind TypeScript’s module option and its reference page for more information. You very likely want "nodenext" for modern Node.js projects and preserve or esnext for code that will be bundled.

更改 module 会影响 moduleResolution，其 也有一个参考页面。

🌐 Changing module affects moduleResolution which also has a reference page.

这是此文件的一些示例输出：

🌐 Here’s some example output for this file:

ts
// @filename: index.ts
import { valueOfPi } from "./constants";
 
export const twoPi = valueOfPi * 2;Try

CommonJS

ts
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.twoPi = void 0;
const constants_1 = require("./constants");
exports.twoPi = constants_1.valueOfPi * 2;
 Try

UMD

ts
(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define(["require", "exports", "./constants"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.twoPi = void 0;
    const constants_1 = require("./constants");
    exports.twoPi = constants_1.valueOfPi * 2;
});
 Try

AMD

ts
define(["require", "exports", "./constants"], function (require, exports, constants_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.twoPi = void 0;
    exports.twoPi = constants_1.valueOfPi * 2;
});
 Try

System

ts
System.register(["./constants"], function (exports_1, context_1) {
    "use strict";
    var constants_1, twoPi;
    var __moduleName = context_1 && context_1.id;
    return {
        setters: [
            function (constants_1_1) {
                constants_1 = constants_1_1;
            }
        ],
        execute: function () {
            exports_1("twoPi", twoPi = constants_1.valueOfPi * 2);
        }
    };
});
 Try

ESNext

ts
import { valueOfPi } from "./constants";
export const twoPi = valueOfPi * 2;
 Try

ES2015/ES6/ES2020/ES2022

ts
import { valueOfPi } from "./constants";
export const twoPi = valueOfPi * 2;
 Try

除了 ES2015/ES6 的基本功能之外，ES2020 还增加了对 动态 import 和 import.meta 的支持，而 ES2022 进一步增加了对 顶层 await 的支持。

🌐 In addition to the base functionality of ES2015/ES6, ES2020 adds support for dynamic imports, and import.meta while ES2022 further adds support for top level await.

node16/node18/node20/nodenext

node16、node18、node20 和 nodenext 模式与 Node 的 原生 ECMAScript 模块支持 集成。生成的 JavaScript 会根据文件扩展名以及最近的 package.json 中 type 设置的值使用 CommonJS 或 ES2020 输出。模块解析也有所不同。你可以在 手册 和 模块参考 中了解更多信息。

🌐 The node16, node18, node20, and nodenext modes integrate with Node’s native ECMAScript Module support. The emitted JavaScript uses either CommonJS or ES2020 output depending on the file extension and the value of the type setting in the nearest package.json. Module resolution also works differently. You can learn more in the handbook and Modules Reference.

• node16 从 TypeScript 4.7 开始可用
• node18 从 TypeScript 5.8 开始可用，用来替代 node16，并增加了对导入属性的支持。
• node20 增加了对 require(ESM) 的支持。
• nodenext 从 TypeScript 4.7 开始可用，但在最新稳定版本的 Node.js 中其行为有所变化。--module nodenext 意味着浮动的 --target esnext。

preserve

在 --module preserve（在 TypeScript 5.4 中新增）中，输入文件中编写的 ECMAScript 导入和导出会在输出中保留，而 CommonJS 风格的 import x = require("...") 和 export = ... 语句会作为 CommonJS 的 require 和 module.exports 输出。换句话说，每个单独的导入或导出语句的格式都会被保留，而不会被强制转换为整个编译（甚至整个文件）的单一格式。

🌐 In --module preserve (added in TypeScript 5.4), ECMAScript imports and exports written in input files are preserved in the output, and CommonJS-style import x = require("...") and export = ... statements are emitted as CommonJS require and module.exports. In other words, the format of each individual import or export statement is preserved, rather than being coerced into a single format for the whole compilation (or even a whole file).

ts
import { valueOfPi } from "./constants";
const constants = require("./constants");
export const piSquared = valueOfPi * constants.valueOfPi;
 Try

虽然在同一个文件中同时使用 import 和 require 调用的情况很少，但这种 module 模式最能反映大多数现代打包工具以及 Bun 运行时的功能。

🌐 While it’s rare to need to mix imports and require calls in the same file, this module mode best reflects the capabilities of most modern bundlers, as well as the Bun runtime.

为什么要关心 TypeScript 在使用打包工具或 Bun 时的 module 输出，尤其你可能还设置了 noEmit？TypeScript 的类型检查和模块解析行为会受到其 将要 输出的模块格式的影响。设置 module 可以向 TypeScript 提供信息，让它了解你的打包工具或运行时如何处理导入和导出，从而确保你在导入的值上看到的类型准确地反映了在运行时或打包后实际发生的情况。

None

ts
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.twoPi = void 0;
const constants_1 = require("./constants");
exports.twoPi = constants_1.valueOfPi * 2;
 Try

指定模块解析策略：

🌐 Specify the module resolution strategy:

• 'node16' 或 'nodenext' 适用于现代版本的 Node.js。Node.js v12 及更高版本同时支持 ECMAScript 导入和 CommonJS require，它们使用不同的算法进行解析。这些 moduleResolution 值与相应的 module 值结合时，会根据输出的 JavaScript 代码中 Node.js 是否会看到 import 或 require 来选择每个解析所使用的正确算法。
• 'node10'（之前称为 'node'）适用于早于 v10 的 Node.js 版本，这些版本仅支持 CommonJS require。在现代代码中，你可能不需要使用 node10。
• 'bundler' 用于与打包工具一起使用。像 node16 和 nodenext 一样，这种模式支持 package.json 中的 "imports" 和 "exports"，但与 Node.js 的解析模式不同，bundler 在导入相对路径时从不要求文件扩展名。
• 'classic' 在 TypeScript 1.6 发布之前被使用过。classic 不应该被使用。

有参考页面解释了 TypeScript 模块解析背后的理论 和 每个选项的详细信息。

🌐 There are reference pages explaining the theory behind TypeScript’s module resolution and the details of each option.

提供一种方法来覆盖解析模块时要搜索的默认文件名后缀列表。

🌐 Provides a way to override the default list of file name suffixes to search when resolving a module.

{
  "compilerOptions": {
    "moduleSuffixes": [".ios", ".native", ""]
  }
}

给定上述配置，导入如下：

🌐 Given the above configuration, an import like the following:

ts
import * as foo from "./foo";

TypeScript 将会查找相对文件 ./foo.ios.ts、./foo.native.ts，最后是 ./foo.ts。

🌐 TypeScript will look for the relative files ./foo.ios.ts, ./foo.native.ts, and finally ./foo.ts.

注意 moduleSuffixes 中的空字符串 ""，这是 TypeScript 查找 ./foo.ts 所必需的。

🌐 Note the empty string "" in moduleSuffixes which is necessary for TypeScript to also look-up ./foo.ts.

此功能对于 React Native 项目非常有用，因为每个目标平台都可以使用不同 moduleSuffixes 的独立 tsconfig.json。

🌐 This feature can be useful for React Native projects where each target platform can use a separate tsconfig.json with differing moduleSuffixes.

默认情况下，TypeScript 会检查初始文件集中用于 import 和 <reference 的指令，并将这些已解析的文件添加到你的程序中。

🌐 By default, TypeScript will examine the initial set of files for import and <reference directives and add these resolved files to your program.

如果设置了 noResolve，这个过程就不会发生。然而，仍然会检查 import 语句以确定它们是否解析为有效模块，因此你需要通过其他方式确保这一点。

🌐 If noResolve is set, this process doesn’t happen. However, import statements are still checked to see if they resolve to a valid module, so you’ll need to make sure this is satisfied by some other means.

在 JavaScript 中，可以在不实际从模块中导入任何值的情况下 import 一个模块。

🌐 In JavaScript it’s possible to import a module without actually importing any values from it.

ts
import "some-module";

这些导入通常被称为副作用导入，因为它们唯一有用的行为就是执行某些副作用（比如注册全局变量，或者向原型添加一个 polyfill）。

🌐 These imports are often called side effect imports because the only useful behavior they can provide is by executing some side effect (like registering a global variable, or adding a polyfill to a prototype).

默认情况下，TypeScript 不会检查这些导入是否有效。如果导入解析到有效的源文件，TypeScript 将加载并检查该文件。如果未找到源文件，TypeScript 将静默地忽略该导入。

🌐 By default, TypeScript will not check these imports for validity. If the import resolves to a valid source file, TypeScript will load and check the file. If no source file is found, TypeScript will silently ignore the import.

这是令人惊讶的行为，但它部分源于 JavaScript 生态系统中的建模模式。例如，这种语法也曾在打包工具中与特殊加载器一起使用，以加载 CSS 或其他资源。你的打包工具可能被配置成可以通过如下方式包含特定的 .css 文件：

🌐 This is surprising behavior, but it partially stems from modeling patterns in the JavaScript ecosystem. For example, this syntax has also been used with special loaders in bundlers to load CSS or other assets. Your bundler might be configured in such a way where you can include specific .css files by writing something like the following:

tsx
import "./button-component.css";
export function Button() {
  // ...
}

不过，这掩盖了副作用导入中的潜在拼写错误。

🌐 Still, this masks potential typos on side effect imports.

当启用 --noUncheckedSideEffectImports 时，如果 TypeScript 找不到副作用导入的源文件，将会报错。

🌐 When --noUncheckedSideEffectImports is enabled, TypeScript will error if it can’t find a source file for a side effect import.

ts
import "oops-this-module-does-not-exist";
//     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// error: Cannot find module 'oops-this-module-does-not-exist' or its corresponding
//        type declarations.

启用此选项时，一些原本可用的代码可能会出现错误，就像上面的 CSS 示例一样。 为了解决这个问题，那些只想为资源编写副作用 import 的用户可能更适合编写所谓的带有通配符指定符的环境模块声明。 它将放在全局文件中，看起来大致如下:

🌐 When enabling this option, some working code may now receive an error, like in the CSS example above. To work around this, users who want to just write side effect imports for assets might be better served by writing what’s called an ambient module declaration with a wildcard specifier. It would go in a global file and look something like the following:

ts
// ./src/globals.d.ts
// Recognize all CSS files as module imports.
declare module "*.css" {}

事实上，你的项目中可能已经有这样的文件了！ 例如，运行类似 vite init 的命令可能会创建一个类似的 vite-env.d.ts。

🌐 In fact, you might already have a file like this in your project! For example, running something like vite init might create a similar vite-env.d.ts.

一系列条目，将导入重新映射到相对于 baseUrl 的查找位置（如果已设置），否则相对于 tsconfig 文件本身。有关 paths 的更全面说明，请参阅 moduleResolution 参考页。

🌐 A series of entries which re-map imports to lookup locations relative to the baseUrl if set, or to the tsconfig file itself otherwise. There is a larger coverage of paths in the moduleResolution reference page.

paths 允许你声明 TypeScript 应该如何在你的 require/import 中解析导入。

{
  "compilerOptions": {
    "paths": {
      "jquery": ["./vendor/jquery/dist/jquery"]
    }
  }
}

这将允许你可以编写 import "jquery"，并在本地获得所有正确的类型提示。

🌐 This would allow you to be able to write import "jquery", and get all of the correct typing locally.

{
  "compilerOptions": {
    "paths": {
      "app/*": ["./src/app/*"],
      "config/*": ["./src/app/_config/*"],
      "environment/*": ["./src/environments/*"],
      "shared/*": ["./src/app/_shared/*"],
      "helpers/*": ["./src/helpers/*"],
      "tests/*": ["./src/tests/*"]
    }
  }
}

在这种情况下，你可以告诉 TypeScript 文件解析器支持多个自定义前缀来查找代码。

🌐 In this case, you can tell the TypeScript file resolver to support a number of custom prefixes to find code.

请注意，此功能不会更改 tsc 导出的导入路径，因此 paths 应仅用于告知 TypeScript 另一个工具具有此映射，并将在运行时或打包时使用它。

🌐 Note that this feature does not change how import paths are emitted by tsc, so paths should only be used to inform TypeScript that another tool has this mapping and will use it at runtime or when bundling.

允许导入扩展名为 .json 的模块，这是在 Node 项目中常见的做法。这包括根据静态 JSON 结构为 import 生成类型。

🌐 Allows importing modules with a .json extension, which is a common practice in node projects. This includes generating a type for the import based on the static JSON shape.

TypeScript 默认不支持解析 JSON 文件：

🌐 TypeScript does not support resolving JSON files by default:

ts
// @filename: settings.json
{
    "repo": "TypeScript",
    "dry": false,
    "debug": false
}
// @filename: index.ts
import settings from "./settings.json";
Cannot find module './settings.json' or its corresponding type declarations.2307Cannot find module './settings.json' or its corresponding type declarations.
 
settings.debug === true;
settings.dry === 2;Try

启用该选项允许导入 JSON，并验证该 JSON 文件中的类型。

🌐 Enabling the option allows importing JSON, and validating the types in that JSON file.

ts
// @filename: settings.json
{
    "repo": "TypeScript",
    "dry": false,
    "debug": false
}
// @filename: index.ts
import settings from "./settings.json";
 
settings.debug === true;
settings.dry === 2;
This comparison appears to be unintentional because the types 'boolean' and 'number' have no overlap.2367This comparison appears to be unintentional because the types 'boolean' and 'number' have no overlap.Try

--resolvePackageJsonExports 会强制 TypeScript 在从 node_modules 中的某个包读取内容时，查阅 package.json 文件的 exports 字段。

在 --moduleResolution 的 node16、nodenext 和 bundler 选项下，此选项默认设置为 true。

🌐 This option defaults to true under the node16, nodenext, and bundler options for --moduleResolution.

--resolvePackageJsonImports 强制 TypeScript 在执行从其祖级目录包含 package.json 的文件中以 # 开头的查找时，参考 package.json 文件的 imports 字段。

在 --moduleResolution 的 node16、nodenext 和 bundler 选项下，此选项默认设置为 true。

🌐 This option defaults to true under the node16, nodenext, and bundler options for --moduleResolution.

在输出文件中，将相对导入路径中的 .ts、.tsx、.mts 和 .cts 文件扩展名重写为它们的 JavaScript 等效项。

🌐 Rewrite .ts, .tsx, .mts, and .cts file extensions in relative import paths to their JavaScript equivalent in output files.

欲了解更多信息，请参阅 TypeScript 5.7 发布说明。

🌐 For more information, see the TypeScript 5.7 release notes.

默认：所有非声明输入文件的最长公共路径。如果设置了 composite，默认值则改为包含 tsconfig.json 文件的目录。

当 TypeScript 编译文件时，它会在输出目录中保留与输入目录中相同的目录结构。

🌐 When TypeScript compiles files, it keeps the same directory structure in the output directory as exists in the input directory.

例如，假设你有一些输入文件：

🌐 For example, let’s say you have some input files:

MyProj
├── tsconfig.json
├── core
│   ├── a.ts
│   ├── b.ts
│   ├── sub
│   │   ├── c.ts
├── types.d.ts

rootDir 的推断值是所有非声明输入文件的最长公共路径，在本例中为 core/。

🌐 The inferred value for rootDir is the longest common path of all non-declaration input files, which in this case is core/.

如果你的 outDir 是 dist，TypeScript 会写出这个树状结构：

🌐 If your outDir was dist, TypeScript would write this tree:

MyProj
├── dist
│   ├── a.js
│   ├── b.js
│   ├── sub
│   │   ├── c.js

但是，你可能打算将 core 作为输出目录结构的一部分。通过在 tsconfig.json 中设置 rootDir: "."，TypeScript 将写入如下树结构：

🌐 However, you may have intended for core to be part of the output directory structure. By setting rootDir: "." in tsconfig.json, TypeScript would write this tree:

MyProj
├── dist
│   ├── core
│   │   ├── a.js
│   │   ├── b.js
│   │   ├── sub
│   │   │   ├── c.js

重要的是，rootDir 不会影响哪些文件成为编译的一部分。 它不会与 include、exclude 或 files 的 tsconfig.json 设置产生交互。

🌐 Importantly, rootDir does not affect which files become part of the compilation. It has no interaction with the include, exclude, or files tsconfig.json settings.

请注意，TypeScript 永远不会将输出文件写入 outDir 之外的目录，也永远不会跳过生成文件。因此，rootDir 还强制要求所有需要生成的文件都必须位于 rootDir 路径下。

🌐 Note that TypeScript will never write an output file to a directory outside of outDir, and will never skip emitting a file. For this reason, rootDir also enforces that all files which need to be emitted are underneath the rootDir path.

例如，假设你有这棵树：

🌐 For example, let’s say you had this tree:

MyProj
├── tsconfig.json
├── core
│   ├── a.ts
│   ├── b.ts
├── helpers.ts

将 rootDir 指定为 core 并且将 include 指定为 * 是错误的，因为这样会创建一个文件（helpers.ts），该文件需要在 outDir 之外生成（即 ../helpers.js）。

🌐 It would be an error to specify rootDir as core and include as * because it creates a file (helpers.ts) that would need to be emitted outside the outDir (i.e. ../helpers.js).

使用 rootDirs，你可以告知编译器，有许多“虚拟”目录作为单一根目录存在。这允许编译器解析这些“虚拟”目录内的相对模块导入，就好像它们被合并为一个目录一样。

🌐 Using rootDirs, you can inform the compiler that there are many “virtual” directories acting as a single root. This allows the compiler to resolve relative module imports within these “virtual” directories, as if they were merged in to one directory.

例如：

🌐 For example:

 src
 └── views
     └── view1.ts (can import "./template1", "./view2`)
     └── view2.ts (can import "./template1", "./view1`)
 generated
 └── templates
         └── views
             └── template1.ts (can import "./view1", "./view2")

{
  "compilerOptions": {
    "rootDirs": ["src/views", "generated/templates/views"]
  }
}

这不会影响 TypeScript 如何生成 JavaScript，它只是模拟假设它们在运行时能够通过这些相对路径工作。

🌐 This does not affect how TypeScript emits JavaScript, it only emulates the assumption that they will be able to work via those relative paths at runtime.

rootDirs 可以用于为非 TypeScript 或 JavaScript 的文件提供一个独立的“类型层”，通过在另一个文件夹中为生成的 .d.ts 文件提供存放位置。这种技术对使用 import 的打包应用非常有用，即使这些文件不一定是代码：

sh
 src
 └── index.ts
 └── css
     └── main.css
     └── navigation.css
 generated
 └── css
     └── main.css.d.ts
     └── navigation.css.d.ts

{
  "compilerOptions": {
    "rootDirs": ["src", "generated"]
  }
}

这种技术允许你为非代码源文件预先生成类型。随后，基于源文件的位置，导入就能自然工作。 例如，./src/index.ts 可以导入文件 ./src/css/main.css，而 TypeScript 会通过生成的对应声明文件了解该文件类型的打包器行为。

🌐 This technique lets you generate types ahead of time for the non-code source files. Imports then work naturally based off the source file’s location. For example ./src/index.ts can import the file ./src/css/main.css and TypeScript will be aware of the bundler’s behavior for that filetype via the corresponding generated declaration file.

ts
// @filename: index.ts
import { appClass } from "./main.css";Try

默认情况下，所有 可见 的“@types”包都会被包含在你的编译中。任何包含文件夹中的 node_modules/@types 包都被视为 可见。例如，这意味着位于 ./node_modules/@types/、../node_modules/@types/、../../node_modules/@types/ 等文件夹中的包。

🌐 By default all visible ”@types” packages are included in your compilation. Packages in node_modules/@types of any enclosing folder are considered visible. For example, that means packages within ./node_modules/@types/, ../node_modules/@types/, ../../node_modules/@types/, and so on.

如果指定了 typeRoots，将 仅 包含 typeRoots 下的包。例如：

🌐 If typeRoots is specified, only packages under typeRoots will be included. For example:

{
  "compilerOptions": {
    "typeRoots": ["./typings", "./vendor/types"]
  }
}

这个配置文件将包括 ./typings 和 ./vendor/types 下的 所有 包，而不包括 ./node_modules/@types 中的任何包。所有路径都是相对于 tsconfig.json 的。

🌐 This config file will include all packages under ./typings and ./vendor/types, and no packages from ./node_modules/@types. All paths are relative to the tsconfig.json.

默认情况下，所有 可见 的“@types”包都会被包含在你的编译中。任何包含文件夹中的 node_modules/@types 包都被视为 可见。例如，这意味着位于 ./node_modules/@types/、../node_modules/@types/、../../node_modules/@types/ 等文件夹中的包。

🌐 By default all visible ”@types” packages are included in your compilation. Packages in node_modules/@types of any enclosing folder are considered visible. For example, that means packages within ./node_modules/@types/, ../node_modules/@types/, ../../node_modules/@types/, and so on.

如果指定了 types，则只有列出的包会包含在全局作用域中。例如：

🌐 If types is specified, only packages listed will be included in the global scope. For instance:

{
  "compilerOptions": {
    "types": ["node", "jest", "express"]
  }
}

此 tsconfig.json 文件将 仅 包含 ./node_modules/@types/node、./node_modules/@types/jest 和 ./node_modules/@types/express。node_modules/@types/* 下的其他包将不会被包含。

🌐 This tsconfig.json file will only include ./node_modules/@types/node, ./node_modules/@types/jest and ./node_modules/@types/express. Other packages under node_modules/@types/* will not be included.

这会产生什么影响？

🌐 What does this affect?

此选项不会影响 @types/* 在你的应用代码中的使用方式，例如，如果你有上面的 compilerOptions 示例，代码如下：

🌐 This option does not affect how @types/* are included in your application code, for example if you had the above compilerOptions example with code like:

ts
import * as moment from "moment";
moment().format("MMMM Do YYYY, h:mm:ss a");

moment 导入将具有完整类型定义。

🌐 The moment import would be fully typed.

当你设置了此选项时，如果不在 types 数组中包含某个模块，它会：

🌐 When you have this option set, by not including a module in the types array it:

• 不会将全局变量添加到你的项目中（例如 node 中的 process 或 Jest 中的 expect）
• 不会将导出显示为自动导入建议

此功能与typeRoots不同，它仅涉及指定你希望包含的确切类型，而typeRoots则支持指定你想要的特定文件夹。

🌐 This feature differs from typeRoots in that it is about specifying only the exact types you want included, whereas typeRoots supports saying you want particular folders.

为项目中的每个 TypeScript 或 JavaScript 文件生成 .d.ts 文件。这些 .d.ts 文件是类型定义文件，用于描述模块的外部 API。使用 .d.ts 文件，像 TypeScript 这样的工具可以为未定义类型的代码提供智能提示和准确的类型。

🌐 Generate .d.ts files for every TypeScript or JavaScript file inside your project. These .d.ts files are type definition files which describe the external API of your module. With .d.ts files, tools like TypeScript can provide intellisense and accurate types for un-typed code.

当将 declaration 设置为 true 时，使用此 TypeScript 代码运行编译器：

🌐 When declaration is set to true, running the compiler with this TypeScript code:

ts
export let helloWorld = "hi";Try

将生成一个像这样的 index.js 文件：

🌐 Will generate an index.js file like this:

ts
export let helloWorld = "hi";
 Try

对应的 helloWorld.d.ts：

🌐 With a corresponding helloWorld.d.ts:

ts
export declare let helloWorld: string;
 Try

在处理 JavaScript 的 .d.ts 文件时，你可能希望使用 emitDeclarationOnly 或使用 outDir 来确保 JavaScript 文件不会被覆盖。

🌐 When working with .d.ts files for JavaScript files you may want to use emitDeclarationOnly or use outDir to ensure that the JavaScript files are not overwritten.

提供一种配置声明文件触发根目录的方法。

🌐 Offers a way to configure the root directory for where declaration files are emitted.

example
├── index.ts
├── package.json
└── tsconfig.json

使用这个 tsconfig.json：

🌐 with this tsconfig.json:

{
  "compilerOptions": {
    "declaration": true,
    "declarationDir": "./types"
  }
}

会将 index.ts 的 d.ts 放在 types 文件夹中：

🌐 Would place the d.ts for the index.ts in a types folder:

example
├── index.js
├── index.ts
├── package.json
├── tsconfig.json
└── types
    └── index.d.ts

为 .d.ts 文件生成源映射，这些映射可以回到原始的 .ts 源文件。这将允许像 VS Code 这样的编辑器在使用类似“转到定义”的功能时跳转到原始的 .ts 文件。

🌐 Generates a source map for .d.ts files which map back to the original .ts source file. This will allow editors such as VS Code to go to the original .ts file when using features like Go to Definition.

如果你正在使用项目引用，则应该强烈考虑启用此功能。

🌐 You should strongly consider turning this on if you’re using project references.

降级是 TypeScript 用来表示将代码转译为旧版本 JavaScript 的术语。这个标志用于支持在较旧的 JavaScript 运行时中更准确地实现现代 JavaScript 遍历新概念的方法。

🌐 Downleveling is TypeScript’s term for transpiling to an older version of JavaScript. This flag is to enable support for a more accurate implementation of how modern JavaScript iterates through new concepts in older JavaScript runtimes.

ECMAScript 6 添加了几种新的迭代原语：for / of 循环（for (el of arr)）、数组展开（[a, ...b]）、参数展开（fn(...args)）以及 Symbol.iterator。 如果存在 Symbol.iterator 实现，downlevelIteration 允许在 ES5 环境中更准确地使用这些迭代原语。

🌐 ECMAScript 6 added several new iteration primitives: the for / of loop (for (el of arr)), Array spread ([a, ...b]), argument spread (fn(...args)), and Symbol.iterator. downlevelIteration allows for these iteration primitives to be used more accurately in ES5 environments if a Symbol.iterator implementation is present.

示例：对 for / of 的影响

🌐 Example: Effects on for / of

使用此 TypeScript 代码：

🌐 With this TypeScript code:

ts
const str = "Hello!";
for (const s of str) {
  console.log(s);
}Try

如果未启用 downlevelIteration，对任何对象的 for / of 循环都会降级为传统的 for 循环：

🌐 Without downlevelIteration enabled, a for / of loop on any object is downleveled to a traditional for loop:

ts
"use strict";
var str = "Hello!";
for (var _i = 0, str_1 = str; _i < str_1.length; _i++) {
    var s = str_1[_i];
    console.log(s);
}
 Try

这通常是人们所期望的，但它并不完全符合 ECMAScript 的迭代协议。 某些字符串，例如表情符号 (😜)，其 .length 值为 2（甚至更多！），但在 for-of 循环中应作为 1 个单位进行迭代。 有关更详细的说明，请参阅 Jonathan New 的这篇博客文章。

🌐 This is often what people expect, but it’s not 100% compliant with ECMAScript iteration protocol. Certain strings, such as emoji (😜), have a .length of 2 (or even more!), but should iterate as 1 unit in a for-of loop. See this blog post by Jonathan New for a longer explanation.

当启用 downlevelIteration 时，TypeScript 会使用一个辅助函数来检查是否存在 Symbol.iterator 的实现（无论是原生实现还是填充实现）。如果缺少该实现，将退回到基于索引的迭代方式。

🌐 When downlevelIteration is enabled, TypeScript will use a helper function that checks for a Symbol.iterator implementation (either native or polyfill). If this implementation is missing, you’ll fall back to index-based iteration.

ts
"use strict";
var __values = (this && this.__values) || function(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
var e_1, _a;
var str = "Hello!";
try {
    for (var str_1 = __values(str), str_1_1 = str_1.next(); !str_1_1.done; str_1_1 = str_1.next()) {
        var s = str_1_1.value;
        console.log(s);
    }
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
    try {
        if (str_1_1 && !str_1_1.done && (_a = str_1.return)) _a.call(str_1);
    }
    finally { if (e_1) throw e_1.error; }
}
 Try

你也可以通过 importHelpers 使用 tslib 来减少内联 JavaScript 的数量：

🌐 You can use tslib via importHelpers to reduce the amount of inline JavaScript too:

ts
"use strict";
var __values = (this && this.__values) || function(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
var e_1, _a;
var str = "Hello!";
try {
    for (var str_1 = __values(str), str_1_1 = str_1.next(); !str_1_1.done; str_1_1 = str_1.next()) {
        var s = str_1_1.value;
        console.log(s);
    }
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
    try {
        if (str_1_1 && !str_1_1.done && (_a = str_1.return)) _a.call(str_1);
    }
    finally { if (e_1) throw e_1.error; }
}
 Try

注意: 如果运行时没有 Symbol.iterator，启用 downlevelIteration 并不会提高合规性。

示例：对数组扩展的影响

🌐 Example: Effects on Array Spreads

这是一个数组展开：

🌐 This is an array spread:

js
// Make a new array whose elements are 1 followed by the elements of arr2
const arr = [1, ...arr2];

根据描述，降级到 ES5 听起来很容易：

🌐 Based on the description, it sounds easy to downlevel to ES5:

js
// The same, right?
const arr = [1].concat(arr2);

但是，在某些罕见情况下，这明显不同。

🌐 However, this is observably different in certain rare cases.

例如，如果源数组缺少一个或多个元素（存在空位），展开语法会将每个空位替换为 undefined，而 .concat 会保持它们不变。

🌐 For example, if a source array is missing one or more items (contains a hole), the spread syntax will replace each empty item with undefined, whereas .concat will leave them intact.

js
// Make an array where the element at index 1 is missing
let arrayWithHole = ["a", , "c"];
let spread = [...arrayWithHole];
let concatenated = [].concat(arrayWithHole);
console.log(arrayWithHole);
// [ 'a', <1 empty item>, 'c' ]
console.log(spread);
// [ 'a', undefined, 'c' ]
console.log(concatenated);
// [ 'a', <1 empty item>, 'c' ]

就像 for / of 一样，downlevelIteration 将使用 Symbol.iterator（如果存在）来更准确地模拟 ES 6 的行为。

🌐 Just as with for / of, downlevelIteration will use Symbol.iterator (if present) to more accurately emulate ES 6 behavior.

控制 TypeScript 在写出输出文件时是否发出 字节顺序标记 (BOM)。 一些运行时环境需要 BOM 才能正确解释 JavaScript 文件；而有些环境则要求文件中不能存在 BOM。 false 的默认值通常是最合适的，除非你有理由更改它。

🌐 Controls whether TypeScript will emit a byte order mark (BOM) when writing output files. Some runtime environments require a BOM to correctly interpret a JavaScript files; others require that it is not present. The default value of false is generally best unless you have a reason to change it.

只生成 .d.ts 文件；不要生成 .js 文件。

🌐 Only emit .d.ts files; do not emit .js files.

此设置在两种情况下很有用：

🌐 This setting is useful in two cases:

• 你正在使用 TypeScript 以外的转译器来生成 JavaScript。
• 你正在使用 TypeScript 仅为你的使用者生成 d.ts 文件。

对于某些降级操作，TypeScript 会使用一些辅助代码来处理诸如继承类、展开数组或对象以及异步操作等任务。默认情况下，这些辅助代码会被插入到使用它们的文件中。如果同一个辅助代码在许多不同的模块中被使用，这可能会导致代码重复。

🌐 For certain downleveling operations, TypeScript uses some helper code for operations like extending class, spreading arrays or objects, and async operations. By default, these helpers are inserted into files which use them. This can result in code duplication if the same helper is used in many different modules.

如果 importHelpers 标志开启，这些辅助函数将改为从 tslib 模块导入。你需要确保 tslib 模块能够在运行时被导入。这只影响模块；全局脚本文件不会尝试导入模块。

🌐 If the importHelpers flag is on, these helper functions are instead imported from the tslib module. You will need to ensure that the tslib module is able to be imported at runtime. This only affects modules; global script files will not attempt to import modules.

例如，使用此 TypeScript：

🌐 For example, with this TypeScript:

ts
export function fn(arr: number[]) {
  const arr2 = [1, ...arr];
}

开启 downlevelIteration 和 importHelpers 仍然是 false：

🌐 Turning on downlevelIteration and importHelpers is still false:

ts
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
};
export function fn(arr) {
    var arr2 = __spreadArray([1], __read(arr), false);
}
 Try

然后同时打开 downlevelIteration 和 importHelpers：

🌐 Then turning on both downlevelIteration and importHelpers:

ts
import { __read, __spreadArray } from "tslib";
export function fn(arr) {
    var arr2 = __spreadArray([1], __read(arr), false);
}
 Try

当你提供这些函数的自定义实现时，可以使用 noEmitHelpers。

🌐 You can use noEmitHelpers when you provide your own implementations of these functions.

设置后，TypeScript 将不会生成 .js.map 文件来提供源码映射，而是会将源码映射内容嵌入到 .js 文件中。虽然这会导致生成的 JS 文件更大，但在某些情况下可能会很方便。例如，你可能希望在不允许提供 .map 文件的 Web 服务器上调试 JS 文件。

🌐 When set, instead of writing out a .js.map file to provide source maps, TypeScript will embed the source map content in the .js files. Although this results in larger JS files, it can be convenient in some scenarios. For example, you might want to debug JS files on a webserver that doesn’t allow .map files to be served.

与 sourceMap 互斥。

🌐 Mutually exclusive with sourceMap.

例如，使用此 TypeScript：

🌐 For example, with this TypeScript:

ts
const helloWorld = "hi";
console.log(helloWorld);

转换为此 JavaScript：

🌐 Converts to this JavaScript:

ts
"use strict";
const helloWorld = "hi";
console.log(helloWorld);
 Try

然后启用用 inlineSourceMap 构建它，文件底部有一个注释，其中包含该文件的源映射。

🌐 Then enable building it with inlineSourceMap enabled there is a comment at the bottom of the file which includes a source-map for the file.

ts
"use strict";
const helloWorld = "hi";
console.log(helloWorld);
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDO0FBQ3hCLE9BQU8sQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFDLENBQUMifQ==Try

设置后，TypeScript 会将 .ts 文件的原始内容作为嵌入字符串包含在源映射中（使用源映射的 sourcesContent 属性）。 这通常在与 inlineSourceMap 相同的情况下非常有用。

🌐 When set, TypeScript will include the original content of the .ts file as an embedded string in the source map (using the source map’s sourcesContent property). This is often useful in the same cases as inlineSourceMap.

需要设置 sourceMap 或 inlineSourceMap 中的任意一个。

🌐 Requires either sourceMap or inlineSourceMap to be set.

例如，使用此 TypeScript：

🌐 For example, with this TypeScript:

ts
const helloWorld = "hi";
console.log(helloWorld);Try

默认情况下转换为此 JavaScript：

🌐 By default converts to this JavaScript:

ts
"use strict";
const helloWorld = "hi";
console.log(helloWorld);
 Try

然后启用使用 inlineSources 构建，并启用 inlineSourceMap，文件底部有一条注释，其中包含该文件的源映射。请注意，结尾与 inlineSourceMap 中的示例不同，因为源映射现在还包含原始源代码。

🌐 Then enable building it with inlineSources and inlineSourceMap enabled there is a comment at the bottom of the file which includes a source-map for the file. Note that the end is different from the example in inlineSourceMap because the source-map now contains the original source code also.

ts
"use strict";
const helloWorld = "hi";
console.log(helloWorld);
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDO0FBQ3hCLE9BQU8sQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJjb25zdCBoZWxsb1dvcmxkID0gXCJoaVwiO1xuY29uc29sZS5sb2coaGVsbG9Xb3JsZCk7Il19Try

指定调试器应查找映射文件的位置，而不是生成的位置。这个字符串在源映射中按原样处理，例如：

🌐 Specify the location where debugger should locate map files instead of generated locations. This string is treated verbatim inside the source-map, for example:

{
  "compilerOptions": {
    "sourceMap": true,
    "mapRoot": "https://my-website.com/debug/sourcemaps/"
  }
}

将声明 index.js 的源映射位于 https://my-website.com/debug/sourcemaps/index.js.map。

🌐 Would declare that index.js will have sourcemaps at https://my-website.com/debug/sourcemaps/index.js.map.

指定在输出文件时使用的行结束序列：‘CRLF’（DOS）或 ‘LF’（Unix）。

🌐 Specify the end of line sequence to be used when emitting files: ‘CRLF’ (dos) or ‘LF’ (unix).

不要触发编译器输出文件，如 JavaScript 源代码、源映射或声明。

🌐 Do not emit compiler output files like JavaScript source code, source-maps or declarations.

这为另一个工具（如 Babel 或 swc）提供了空间，用于将 TypeScript 文件转换为可以在 JavaScript 环境中运行的文件。

🌐 This makes room for another tool like Babel, or swc to handle converting the TypeScript file to a file which can run inside a JavaScript environment.

然后，你可以将 TypeScript 用作提供编辑器集成的工具，并用作源代码类型检查器。

🌐 You can then use TypeScript as a tool for providing editor integration, and as a source code type-checker.

与其通过 importHelpers 导入辅助函数，不如在全局作用域中为你使用的辅助函数提供实现，并完全关闭辅助函数的输出。

🌐 Instead of importing helpers with importHelpers, you can provide implementations in the global scope for the helpers you use and completely turn off emitting of helper functions.

例如，在 ES5 中使用这个 async 函数需要一个类似 await 的函数和一个类似 generator 的函数来运行：

🌐 For example, using this async function in ES5 requires a await-like function and generator-like function to run:

ts
const getAPI = async (url: string) => {
  // Get API
  return {};
};Try

这会创建相当多的 JavaScript：

🌐 Which creates quite a lot of JavaScript:

ts
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (g && (g = 0, op[0] && (_ = 0)), _) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var getAPI = function (url) { return __awaiter(void 0, void 0, void 0, function () {
    return __generator(this, function (_a) {
        // Get API
        return [2 /*return*/, {}];
    });
}); };
 Try