feat: translate tscofing infos into portuguese/br

packages/tsconfig-reference/copy/pt/options/incremental.md

@@ -0,0 +1,9 @@
+---
+display: "Incremental"
+oneline: "Salve arquivos .tsbuildinfo para permitir a compilação incremental de projetos"
+---
+
+Diz ao TypeScript para salvar informações sobre o grafo do projeto da última compilação em arquivos armazenados no disco.
+Este cria uma série de arquivos `.tsbuildinfo` na mesma pasta de sua saída de compilação. Eles não são usados por seu JavaScript em tempo de execução e pode ser excluído com segurança. Você pode ler mais sobre a bandeira no [3.4 notas de lançamento](/docs/handbook/release-notes/typescript-3-4.html#faster-subsequent-builds-with-the---incremental-flag).
+
+Para controlar em quais pastas você deseja que os arquivos sejam construídos, use a opção de configuração [`tsBuildInfoFile`](#tsBuildInfoFile).

packages/tsconfig-reference/copy/pt/options/inlineSourceMap.md

@@ -0,0 +1,34 @@
+---
+display: "Mapa de origem embutido"
+oneline: "Incluir arquivos de mapa de origem dentro do JavaScript emitido"
+---
+
+Quando definido, em vez de escrever um arquivo `.js.map` para fornecer mapas de origem, o TypeScript irá embutir o conteúdo do mapa de origem nos arquivos`.js`.
+Embora isso resulte em arquivos JS maiores, pode ser conveniente em alguns cenários.
+Por exemplo, você pode querer depurar arquivos JS em um servidor web que não permite que arquivos `.map` sejam servidos.
+
+Mutuamente exclusivo com [`sourceMap`](#sourceMap).
+
+Por exemplo, com este TypeScript:
+
+```ts
+const helloWorld = "hi";
+console.log(helloWorld);
+```
+
+Converte para este JavaScript:
+
+```ts twoslash
+// @showEmit
+const helloWorld = "hi";
+console.log(helloWorld);
+```
+
+Em seguida, habilite a construção com `inlineSourceMap` habilitado, há um comentário na parte inferior do arquivo que inclui um mapa de origem para o arquivo.
+
+```ts twoslash
+// @inlineSourceMap
+// @showEmit
+const helloWorld = "hi";
+console.log(helloWorld);
+```

packages/tsconfig-reference/copy/pt/options/inlineSources.md

@@ -0,0 +1,36 @@
+---
+display: "Inline Sources"
+oneline: "Incluir arquivos de mapa de origem dentro do JavaScript emitido"
+---
+
+Quando definido o TypeScript incluirá o conteúdo original do arquivo `.ts` como uma string incorporada no mapa de origem.
+Isso geralmente é util nos mesmos casos que `inlineSourceMap`.
+
+Requer `sourceMap` ou` inlineSourceMap` para ser definido.
+
+Por exemplo, com este TypeScript:
+
+```ts twoslash
+const helloWorld = "hi";
+console.log(helloWorld);
+```
+
+Por padrão, converte para este JavaScript:
+
+```ts twoslash
+// @showEmit
+const helloWorld = "hi";
+console.log(helloWorld);
+```
+
+Em seguida, habilite a compilação com `inlineSources` e` inlineSourceMap` habilitados, há um comentário na parte inferior do arquivo que inclui
+um mapa de origem para o arquivo.
+Observe que o final é diferente do exemplo em [`inlineSourceMap`](#inlineSourceMap) porque o mapa-fonte agora contém o código-fonte original também.
+
+```ts twoslash
+// @inlineSources
+// @inlineSourceMap
+// @showEmit
+const helloWorld = "hi";
+console.log(helloWorld);
+```

packages/tsconfig-reference/copy/pt/options/isolatedModules.md

@@ -0,0 +1,75 @@
+---
+display: "Isolated Modules"
+oneline: "Certifique-se de que cada arquivo pode ser transpilado com segurança, sem depender de outras importações"
+---
+
+Embora você possa usar o TypeScript para produzir código JavaScript a partir do código TypeScript, também é comum usar outros transpilers como [Babel](https://babeljs.io) para fazer isso.
+No entanto, outros transpilers operam apenas em um único arquivo por vez, o que significa que eles não podem aplicar transformações de código que dependem da compreensão de todo o sistema de tipos.
+Esta restrição também se aplica à API `ts.transpileModule` do TypeScript que é usada por algumas ferramentas de construção.
+
+Essas limitações podem causar problemas de tempo de execução com alguns recursos do TypeScript, como `const enum`s e`namespace`s.
+Definir o sinalizador `isolatedModules` diz ao TypeScript para avisá-lo se você escrever certo código que não pode ser interpretado corretamente por um processo de transpilação de arquivo único.
+
+Isso não altera o comportamento do seu código ou, de outra forma, altera o comportamento do processo de verificação e emissão do TypeScript
+
+Alguns exemplos de código que não funcionam quando `isolatedModules` está habilitado.
+
+#### Exportações de identificadores sem valor
+
+No TypeScript, você pode importar um _type_ e depois exportá-lo:
+
+```ts twoslash
+// @noErrors
+import { someType, someFunction } from "someModule";
+
+someFunction();
+
+export { someType, someFunction };
+```
+
+Como não há valor para `someType`, o`export` emitido não tentará exportá-lo (isso seria um erro de tempo de execução em JavaScript):
+
+```js
+export { someFunction };
+```
+
+Transpiladores de arquivo único não sabem se `someType` produz um valor ou não, então é um erro exportar um nome que se refere apenas a um tipo.
+
+#### Arquivos Non-Module
+
+Se `isolatedModules` estiver definido, todos os arquivos de implementação devem ser _modules_ (o que significa que tem alguma forma de`import` / `export`). Ocorre um erro se algum arquivo não for um módulo:
+
+```ts twoslash
+// @errors: 1208
+// @isolatedModules
+function fn() {}
+```
+
+Esta restrição não se aplica a arquivos `.d.ts`
+
+#### Referências a membros `const enum`
+
+No TypeScript, quando você faz referência a um membro `const enum`, a referência é substituída por seu valor real no JavaScript emitido. Alterando este TypeScript:
+
+```ts twoslash
+declare const enum Numbers {
+  Zero = 0,
+  One = 1,
+}
+console.log(Numbers.Zero + Numbers.One);
+```
+
+Para este JavaScript:
+
+```ts twoslash
+// @showEmit
+// @removeComments
+declare const enum Numbers {
+  Zero = 0,
+  One = 1,
+}
+console.log(Numbers.Zero + Numbers.One);
+```
+
+Sem o conhecimento dos valores desses membros, outros transpiladores não podem substituir as referências a `Number`, o que seria um erro de tempo de execução se deixado sozinho (uma vez que não há objeto `Numbers` em tempo de execução).
+Por causa disso, quando `isolatedModules` é definido, é um erro fazer referência a um membro ambiente `const enum`.

packages/tsconfig-reference/copy/pt/options/jsxFactory.md

@@ -0,0 +1,9 @@
+---
+display: "Fabrica JSX"
+oneline: "Controle a função emitida pelo JSX"
+---
+
+Altera a função chamada em arquivos `.js` ao compilar elementos JSX.
+A alteração mais comum é usar `"h"` ou `"preact.h"` ao invés do padrão `"React.createElement"` se estiver usando `preact`.
+
+Esta opção pode ser usada por arquivo muito semelhante a [directiva `/** @jsx h */` do Babel](https://babeljs.io/docs/en/babel-plugin-transform-react-jsx#custom).

packages/tsconfig-reference/copy/pt/options/keyofStringsOnly.md

@@ -0,0 +1,8 @@
+---
+display: "Keyof Strings Only"
+oneline: "Faça com que keyof retorne apenas strings em vez de strings ou números"
+---
+
+Este sinalizador muda o operador do tipo `keyof` para retornar` string` em vez de `string | number` quando aplicado a um tipo com uma assinatura de índice de string.
+
+Este sinalizador é usado para ajudar as pessoas a evitar esse comportamento de [before TypeScript 2.9's release](/docs/handbook/release-notes/typescript-2-9.html#support-number-and-symbol-named-properties-with-keyof-and-mapped-types).

packages/tsconfig-reference/copy/pt/options/lib.md

@@ -0,0 +1,69 @@
+---
+display: "Lib"
+oneline: "Inclua definições de tipo que você sabe que estão disponíveis em seu tempo de execução de JavaScript"
+---
+
+O TypeScript inclui um conjunto padrão de definições de tipo para APIs JS embutidas (como `Math`), bem como definições de tipo para coisas encontradas em ambientes de navegador (como `document`).
+TypeScript também inclui APIs para recursos JS mais recentes que correspondem ao `target` que você especifica; por exemplo, a definição para `Map` está disponível se `target` for `ES6` ou mais recente.
+
+Você pode querer alterá-los por alguns motivos:
+
+- Seu programa não roda em um navegador, então você não quer as definições do tipo `"dom"`
+- Sua plataforma de tempo de execução fornece certos objetos de API JavaScript (talvez por meio de polyfills), mas ainda não suporta a sintaxe completa de uma determinada versão ECMAScript
+- Você tem polyfills ou implementações nativas para alguns, mas não todos, de uma versão ECMAScript de nível superior
+
+### Bibliotecas de alto nível
+
+| Name         | Contents                                                                                                                                          |
+| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ES5`        | Definições básicas para todas as funcionalidades ES3 e ES5                                                                                                |
+| `ES2015`     | APIs adicionais disponíveis no ES2015 (também conhecido como ES6) - `array.find`, `Promise`, `Proxy`, `Symbol`, `Map`, `Set`, `Reflect`, etc.               |
+| `ES6`        | Alias for "ES2015"                                                                                                                                |
+| `ES2016`     | APIs adicionais disponíveis no ES2016 - `array.include`, etc.                                                                                       |
+| `ES7`        | Alias for "ES2016"                                                                                                                                |
+| `ES2017`     | APIs adicionais disponíveis no ES2017 - `Object.entries`, `Object.values`, `Atomics`, `SharedArrayBuffer`, `date.formatToParts`, typed arrays, etc. |
+| `ES2018`     | APIs adicionais disponíveis no ES2018 - `async` iterables, `promise.finally`, `Intl.PluralRules`, `rexexp.groups`, etc.                             |
+| `ES2019`     | APIs adicionais disponíveis no ES2019 - `array.flat`,` array.flatMap`, `Object.fromEntries`, `string.trimStart`, `string.trimEnd`, etc.             |
+| `ES2020`     | APIs adicionais disponíveis no ES2020 - `string.matchAll`, etc.                                                                                     |
+| `ESNext`     | APIs adicionais disponíveis no ESNext - Isso muda conforme a especificação do JavaScript evolui                                                       |
+| `DOM`        | [DOM](https://developer.mozilla.org/docs/Glossary/DOM) definitions - `window`, `document`, etc.                                                   |
+| `WebWorker`  | APIs disponíveis em [Web Worker](https://developer.mozilla.org/docs/Web/API/Web_Workers_API/Using_web_workers) contexts                              |
+| `ScriptHost` | APIs para o [Windows Script Hosting System](https://wikipedia.org/wiki/Windows_Script_Host)                                                      |
+
+### Individual library components
+
+| Name                      |
+| ------------------------- |
+| `DOM.Iterable`            |
+| `ES2015.Core`             |
+| `ES2015.Collection`       |
+| `ES2015.Generator`        |
+| `ES2015.Iterable`         |
+| `ES2015.Promise`          |
+| `ES2015.Proxy`            |
+| `ES2015.Reflect`          |
+| `ES2015.Symbol`           |
+| `ES2015.Symbol.WellKnown` |
+| `ES2016.Array.Include`    |
+| `ES2017.object`           |
+| `ES2017.Intl`             |
+| `ES2017.SharedMemory`     |
+| `ES2017.String`           |
+| `ES2017.TypedArrays`      |
+| `ES2018.Intl`             |
+| `ES2018.Promise`          |
+| `ES2018.RegExp`           |
+| `ES2019.Array`            |
+| `ES2019.Full`             |
+| `ES2019.Object`           |
+| `ES2019.String`           |
+| `ES2019.Symbol`           |
+| `ES2020.Full`             |
+| `ES2020.String`           |
+| `ES2020.Symbol.wellknown` |
+| `ESNext.AsyncIterable`    |
+| `ESNext.Array`            |
+| `ESNext.Intl`             |
+| `ESNext.Symbol`           |
+
+Esta lista pode estar desatualizada, você pode ver a lista completa no [TypeScript source code](https://github.com/microsoft/TypeScript/tree/master/lib).

packages/tsconfig-reference/copy/pt/options/listEmittedFiles.md

@@ -0,0 +1,42 @@
+---
+display: "Listar arquivos emitidos"
+oneline: "Imprime os nomes dos arquivos emitidos após uma compilação"
+---
+
+Imprime nomes de arquivos gerados parte da compilação para o terminal.
+
+Este sinalizador é útil em dois casos:
+
+- Você deseja transpilar o TypeScript como parte de uma cadeia de construção no terminal onde os nomes dos arquivos são processados no próximo comando.
+- Você não tem certeza de que o TypeScript incluiu um arquivo que você esperava, como parte da depuração das [configurações de inclusão de arquivo](#Project_Files_0).
+
+Por exemplo:
+
+```
+exemplo
+├── index.ts
+├── package.json
+└── tsconfig.json
+```
+
+Com:
+
+```json
+{
+  "compilerOptions": {
+    "declaration": true,
+    "listFiles": true
+  }
+}
+```
+
+Ecoaria caminhos como:
+
+```
+$ npm run tsc
+
+path/to/example/index.js
+path/to/example/index.d.ts
+```
+
+Normalmente, o TypeScript retornaria silenciosamente em caso de sucesso.

packages/tsconfig-reference/copy/pt/options/listFiles.md

@@ -0,0 +1,38 @@
+---
+display: "Lista de arquivos"
+oneline: "Imprime todos os arquivos lidos durante a compilação"
+---
+
+Imprime nomes de arquivos que fazem parte da compilação. Isso é útil quando você não tem certeza de que o TypeScript tem
+incluiu um arquivo que você esperava.
+
+Por exemplo:
+
+```
+exemplo
+├── index.ts
+├── package.json
+└── tsconfig.json
+```
+
+Com:
+
+```json
+{
+  "compilerOptions": {
+    "listFiles": true
+  }
+}
+```
+
+Ecoaria caminhos como::
+
+```
+$ npm run tsc
+path/to/example/node_modules/typescript/lib/lib.d.ts
+path/to/example/node_modules/typescript/lib/lib.es5.d.ts
+path/to/example/node_modules/typescript/lib/lib.dom.d.ts
+path/to/example/node_modules/typescript/lib/lib.webworker.importscripts.d.ts
+path/to/example/node_modules/typescript/lib/lib.scripthost.d.ts
+path/to/example/index.ts
+```

packages/tsconfig-reference/copy/pt/options/locale.md

@@ -0,0 +1,26 @@
+---
+display: "Locale"
+oneline: "Defina o idioma da saída tsc"
+---
+
+TypeScript suporta uma série de linguagens, no entanto, isso não pode ser definido por meio do `tsconfig.json`, apenas
+através do ambiente host ou da bandeira CLI `--locale`. Por exemplo. `tsc --locale ru`.
+
+### Localidades com suporte a partir de TypeScript 3.7
+
+| Name                  | Locale  |
+| --------------------- | ------- |
+| Brazilian Portuguese  | `pr-BR` |
+| Chinese (Simplified)  | `zh-TW` |
+| Chinese (Traditional) | `zh-CN` |
+| Czech                 | `cs-CZ` |
+| English (US)          | `en-US` |
+| French                | `fr-FR` |
+| German                | `de-DE` |
+| Italian               | `it-IT` |
+| Japanese              | `ja-JP` |
+| Korean                | `ko-KR` |
+| Polish                | `pl-PL` |
+| Russian               | `ru-RU` |
+| Spanish               | `es-ES` |
+| Turkish               | `tr-TR` |

packages/tsconfig-reference/copy/pt/options/mapRoot.md

@@ -0,0 +1,18 @@
+---
+display: "Raiz do mapa"
+oneline: "Defina uma raiz externa para mapas de origem"
+---
+
+Especifique o local onde o depurador deve localizar os arquivos de mapa em vez dos locais gerados.
+Esta string é tratada literalmente dentro do source-map, por exemplo:
+
+```json
+{
+  "compilerOptions": {
+    "sourceMap": true,
+    "mapRoot": "https://my-website.com/debug/sourcemaps/"
+  }
+}
+```
+
+Declararia que `index.js` terá mapas de origem em `https://my-website.com/debug/sourcemaps/index.js.map`.

packages/tsconfig-reference/copy/pt/options/maxNodeModuleJsDepth.md

@@ -0,0 +1,11 @@
+---
+display: "Profundidade JS do módulo de nó máximo"
+oneline: "Quão profundo o TypeScript deve executar a verificação de tipo em node_modules"
+---
+
+A profundidade máxima de dependência para pesquisar em `node_modules` e carregar arquivos JavaScript.
+
+Este sinalizador só pode ser usado quando [`allowJs`](#allowJs) está habilitado, e é usado se você quiser ter tipos de inferência TypeScript para todo o JavaScript dentro de seu `node_modules`.
+
+Idealmente, isso deve ficar em 0 (o padrão), e os arquivos `d.ts` devem ser usados para definir explicitamente a forma dos módulos.
+No entanto, há casos em que você pode querer ativar isso em detrimento da velocidade e da precisão potencial.