ai-hero-cli 0.0.4 → 0.0.6

package/docs/tsconfig/jsxFactory.md

@@ -1,43 +0,0 @@
----
-display: 'JSX Factory'
-oneline: "Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'."
----
-
-Changes the function called in `.js` files when compiling JSX Elements using the classic JSX runtime.
-The most common change is to use `"h"` or `"preact.h"` instead of the default `"React.createElement"` if using `preact`.
-
-For example, this TSX file:
-
-```tsx
-import { h } from 'preact';
-
-const HelloWorld = () => <div>Hello</div>;
-```
-
-With `jsxFactory: "h"` looks like:
-
-```tsx twoslash
-// @showEmit
-// @showEmittedFile: index.js
-// @jsxFactory: h
-// @noErrors
-// @target: esnext
-// @module: commonjs
-
-import { h, Fragment } from 'preact';
-
-const HelloWorld = () => <div>Hello</div>;
-```
-
-This option can be used on a per-file basis too similar to [Babel's `/** @jsx h */` directive](https://babeljs.io/docs/en/babel-plugin-transform-react-jsx#custom).
-
-```tsx twoslash
-/** @jsx h */
-import { h } from 'preact';
-
-const HelloWorld = () => <div>Hello</div>;
-```
-
-The factory chosen will also affect where the `JSX` namespace is looked up (for type checking information) before falling back to the global one.
-
-If the factory is defined as `React.createElement` (the default), the compiler will check for `React.JSX` before checking for a global `JSX`. If the factory is defined as `h`, it will check for `h.JSX` before a global `JSX`.

package/docs/tsconfig/jsxFragmentFactory.md

@@ -1,69 +0,0 @@
----
-display: 'JSX Fragment Factory'
-oneline: "Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'."
----
-
-Specify the JSX fragment factory function to use when targeting react JSX emit with [`jsxFactory`](#jsxFactory) compiler option is specified, e.g. `Fragment`.
-
-For example with this TSConfig:
-
-```json tsconfig
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "module": "commonjs",
-    "jsx": "react",
-    "jsxFactory": "h",
-    "jsxFragmentFactory": "Fragment"
-  }
-}
-```
-
-This TSX file:
-
-```tsx
-import { h, Fragment } from 'preact';
-
-const HelloWorld = () => (
-  <>
-    <div>Hello</div>
-  </>
-);
-```
-
-Would look like:
-
-```tsx twoslash
-// @showEmit
-// @showEmittedFile: index.js
-// @jsxFactory: h
-// @jsxFragmentFactory: Fragment
-// @noErrors
-// @target: esnext
-// @module: commonjs
-
-import { h, Fragment } from 'preact';
-
-const HelloWorld = () => (
-  <>
-    <div>Hello</div>
-  </>
-);
-```
-
-This option can be used on a per-file basis too similar to [Babel's `/* @jsxFrag h */` directive](https://babeljs.io/docs/en/babel-plugin-transform-react-jsx#fragments).
-
-For example:
-
-```tsx twoslash
-/** @jsx h */
-/** @jsxFrag Fragment */
-
-import { h, Fragment } from 'preact';
-
-const HelloWorld = () => (
-  <>
-    <div>Hello</div>
-  </>
-);
-```

package/docs/tsconfig/jsxImportSource.md

@@ -1,95 +0,0 @@
----
-display: 'JSX Import Source'
-oneline: 'Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.'
----
-
-Declares the module specifier to be used for importing the `jsx` and `jsxs` factory functions when using [`jsx`](#jsx) as `"react-jsx"` or `"react-jsxdev"` which were introduced in TypeScript 4.1.
-
-With [React 17](https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html) the library supports a new form of JSX transformation via a separate import.
-
-For example with this code:
-
-```tsx
-import React from 'react';
-
-function App() {
-  return <h1>Hello World</h1>;
-}
-```
-
-Using this TSConfig:
-
-```json tsconfig
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "module": "commonjs",
-    "jsx": "react-jsx"
-  }
-}
-```
-
-The emitted JavaScript from TypeScript is:
-
-```tsx twoslash
-// @showEmit
-// @noErrors
-// @jsx: react-jsx
-// @module: commonjs
-// @target: esnext
-declare module JSX {
-  interface Element {}
-  interface IntrinsicElements {
-    [s: string]: any;
-  }
-}
-import React from 'react';
-
-function App() {
-  return <h1>Hello World</h1>;
-}
-```
-
-For example if you wanted to use `"jsxImportSource": "preact"`, you need a tsconfig like:
-
-```json tsconfig
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "module": "commonjs",
-    "jsx": "react-jsx",
-    "jsxImportSource": "preact",
-    "types": ["preact"]
-  }
-}
-```
-
-Which generates code like:
-
-```tsx twoslash
-// @showEmit
-// @jsxImportSource: preact
-// @types: preact
-// @jsx: react-jsx
-// @target: esnext
-// @module: commonjs
-// @noErrors
-
-export function App() {
-  return <h1>Hello World</h1>;
-}
-```
-
-Alternatively, you can use a per-file pragma to set this option, for example:
-
-```tsx
-/** @jsxImportSource preact */
-
-export function App() {
-  return <h1>Hello World</h1>;
-}
-```
-
-Would add `preact/jsx-runtime` as an import for the `_jsx` factory.
-
-_Note:_ In order for this to work like you would expect, your `tsx` file must include an `export` or `import` so that it is considered a module.

package/docs/tsconfig/keyofStringsOnly.md

@@ -1,8 +0,0 @@
----
-display: 'Keyof Strings Only'
-oneline: 'Make keyof only return strings instead of string, numbers or symbols. Legacy option.'
----
-
-This flag changes the `keyof` type operator to return `string` instead of `string | number` when applied to a type with a string index signature.
-
-This flag is used to help people keep this behavior from [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).

package/docs/tsconfig/lib.md

@@ -1,75 +0,0 @@
----
-display: 'Lib'
-oneline: 'Specify a set of bundled library declaration files that describe the target runtime environment.'
----
-
-TypeScript includes a default set of type definitions for built-in JS APIs (like `Math`), as well as type definitions for things found in browser environments (like `document`).
-TypeScript also includes APIs for newer JS features matching the [`target`](#target) you specify; for example the definition for `Map` is available if [`target`](#target) is `ES6` or newer.
-
-You may want to change these for a few reasons:
-
-- Your program doesn't run in a browser, so you don't want the `"dom"` type definitions
-- Your runtime platform provides certain JavaScript API objects (maybe through polyfills), but doesn't yet support the full syntax of a given ECMAScript version
-- You have polyfills or native implementations for some, but not all, of a higher level ECMAScript version
-
-In TypeScript 4.5, lib files can be overridden by npm modules, find out more [in the blog](https://devblogs.microsoft.com/typescript/announcing-typescript-4-5-beta/#supporting-lib-from-node_modules).
-
-### High Level libraries
-
-| Name         | Contents                                                                                                                                          |
-| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ES5`        | Core definitions for all ES5 functionality                                                                                                        |
-| `ES2015`     | Additional APIs available in ES2015 (also known as ES6) - `array.find`, `Promise`, `Proxy`, `Symbol`, `Map`, `Set`, `Reflect`, etc.               |
-| `ES6`        | Alias for "ES2015"                                                                                                                                |
-| `ES2016`     | Additional APIs available in ES2016 - `array.include`, etc.                                                                                       |
-| `ES7`        | Alias for "ES2016"                                                                                                                                |
-| `ES2017`     | Additional APIs available in ES2017 - `Object.entries`, `Object.values`, `Atomics`, `SharedArrayBuffer`, `date.formatToParts`, typed arrays, etc. |
-| `ES2018`     | Additional APIs available in ES2018 - `async` iterables, `promise.finally`, `Intl.PluralRules`, `regexp.groups`, etc.                             |
-| `ES2019`     | Additional APIs available in ES2019 - `array.flat`, `array.flatMap`, `Object.fromEntries`, `string.trimStart`, `string.trimEnd`, etc.             |
-| `ES2020`     | Additional APIs available in ES2020 - `string.matchAll`, etc.                                                                                     |
-| `ES2021`     | Additional APIs available in ES2021 - `promise.any`, `string.replaceAll` etc.                                                                     |
-| `ES2022`     | Additional APIs available in ES2022 - `array.at`, `RegExp.hasIndices`, etc.                                                                       |
-| `ES2023`     | Additional APIs available in ES2023 - `array.with`, `array.findLast`, `array.findLastIndex`, `array.toSorted`, `array.toReversed`, etc.           |
-| `ESNext`     | Additional APIs available in ESNext - This changes as the JavaScript specification evolves                                                        |
-| `DOM`        | [DOM](https://developer.mozilla.org/docs/Glossary/DOM) definitions - `window`, `document`, etc.                                                   |
-| `WebWorker`  | APIs available in [WebWorker](https://developer.mozilla.org/docs/Web/API/Web_Workers_API/Using_web_workers) contexts                              |
-| `ScriptHost` | APIs for the [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.Object`           |
-| `ES2019.String`           |
-| `ES2019.Symbol`           |
-| `ES2020.String`           |
-| `ES2020.Symbol.wellknown` |
-| `ES2021.Promise`          |
-| `ES2021.String`           |
-| `ES2021.WeakRef`          |
-| `ESNext.AsyncIterable`    |
-| `ESNext.Array`            |
-| `ESNext.Intl`             |
-| `ESNext.Symbol`           |
-
-This list may be out of date, you can see the full list in the [TypeScript source code](https://github.com/microsoft/TypeScript/tree/main/src/lib).

package/docs/tsconfig/libReplacement.md

@@ -1,22 +0,0 @@
----
-display: 'Lib Replacement'
-oneline: 'Enable substitution of default `lib` files with custom ones.'
----
-
-TypeScript 4.5 introduced the possibility of substituting the default `lib` files with custom ones.
-All built-in library files would first try to be resolved from packages named `@typescript/lib-*`.
-For example, you could lock your `dom` libraries onto a specific version of [the `@types/web` package](https://www.npmjs.com/package/@types/web?activeTab=readme) with the following `package.json`:
-
-```json
-{
-  "devDependencies": {
-    "@typescript/lib-dom": "npm:@types/web@0.0.199"
-  }
-}
-```
-
-When installed, a package called `@typescript/lib-dom` should exist, and TypeScript would always look there when searching for `lib.dom.d.ts`.
-
-The `--libReplacement` flag allows you to disable this behavior.
-If you're not using any `@typescript/lib-*` packages, you can now disable those package lookups with `--libReplacement false`.
-In the future, `--libReplacement false` may become the default, so if you currently rely on the behavior you should consider explicitly enabling it with `--libReplacement true`.

package/docs/tsconfig/listEmittedFiles.md

@@ -1,42 +0,0 @@
----
-display: 'List Emitted Files'
-oneline: 'Print the names of emitted files after a compilation.'
----
-
-Print names of generated files part of the compilation to the terminal.
-
-This flag is useful in two cases:
-
-- You want to transpile TypeScript as a part of a build chain in the terminal where the filenames are processed in the next command.
-- You are not sure that TypeScript has included a file you expected, as a part of debugging the [file inclusion settings](#Project_Files_0).
-
-For example:
-
-```
-example
-├── index.ts
-├── package.json
-└── tsconfig.json
-```
-
-With:
-
-```json tsconfig
-{
-  "compilerOptions": {
-    "declaration": true,
-    "listEmittedFiles": true
-  }
-}
-```
-
-Would echo paths like:
-
-```
-$ npm run tsc
-
-path/to/example/index.js
-path/to/example/index.d.ts
-```
-
-Normally, TypeScript would return silently on success.

package/docs/tsconfig/listFiles.md

@@ -1,40 +0,0 @@
----
-display: 'List Files'
-oneline: 'Print all of the files read during the compilation.'
----
-
-Print names of files part of the compilation. This is useful when you are not sure that TypeScript has
-included a file you expected.
-
-For example:
-
-```
-example
-├── index.ts
-├── package.json
-└── tsconfig.json
-```
-
-With:
-
-```json tsconfig
-{
-  "compilerOptions": {
-    "listFiles": true
-  }
-}
-```
-
-Would echo paths like:
-
-```
-$ 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
-```
-
-Note if using TypeScript 4.2, prefer [`explainFiles`](#explainFiles) which offers an explanation of why a file was added too.

package/docs/tsconfig/locale.md

@@ -1,26 +0,0 @@
----
-display: 'Locale'
-oneline: 'Set the language of the messaging from TypeScript. This does not affect emit.'
----
-
-TypeScript supports a number of languages, however this cannot be set via the `tsconfig.json`, only
-via the host environment or the CLI flag `--locale`. E.g. `tsc --locale ru`.
-
-### Locales supported as of 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` |

package/docs/tsconfig/mapRoot.md

@@ -1,18 +0,0 @@
----
-display: 'Map Root'
-oneline: 'Specify the location where debugger should locate map files instead of generated locations.'
----
-
-Specify the location where debugger should locate map files instead of generated locations.
-This string is treated verbatim inside the source-map, for example:
-
-```json tsconfig
-{
-  "compilerOptions": {
-    "sourceMap": true,
-    "mapRoot": "https://my-website.com/debug/sourcemaps/"
-  }
-}
-```
-
-Would declare that `index.js` will have sourcemaps at `https://my-website.com/debug/sourcemaps/index.js.map`.

package/docs/tsconfig/maxNodeModuleJsDepth.md

@@ -1,11 +0,0 @@
----
-display: 'Max Node Module JS Depth'
-oneline: 'Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with [`allowJs`](#allowJs).'
----
-
-The maximum dependency depth to search under `node_modules` and load JavaScript files.
-
-This flag can only be used when [`allowJs`](#allowJs) is enabled, and is used if you want to have TypeScript infer types for all of the JavaScript inside your `node_modules`.
-
-Ideally this should stay at 0 (the default), and `d.ts` files should be used to explicitly define the shape of modules.
-However, there are cases where you may want to turn this on at the expense of speed and potential accuracy.

package/docs/tsconfig/module.md

@@ -1,125 +0,0 @@
----
-display: 'Module'
-oneline: 'Specify what module code is generated.'
----
-
-Sets the module system for the program. See the [theory behind TypeScript’s `module` option](/docs/handbook/modules/theory.html#the-module-output-format) and [its reference page](/docs/handbook/modules/reference.html#the-module-compiler-option) for more information. You very likely want `"nodenext"` for modern Node.js projects and `preserve` or `esnext` for code that will be bundled.
-
-Changing `module` affects [`moduleResolution`](#moduleResolution) which [also has a reference page](/docs/handbook/modules/reference.html#the-moduleresolution-compiler-option).
-
-Here's some example output for this file:
-
-```ts twoslash
-// @filename: constants.ts
-export const valueOfPi = 3.142;
-// ---cut---
-// @filename: index.ts
-import { valueOfPi } from './constants';
-
-export const twoPi = valueOfPi * 2;
-```
-
-#### `CommonJS`
-
-```ts twoslash
-// @showEmit
-// @module: commonjs
-// @noErrors
-import { valueOfPi } from './constants';
-
-export const twoPi = valueOfPi * 2;
-```
-
-#### `UMD`
-
-```ts twoslash
-// @showEmit
-// @module: umd
-// @noErrors
-import { valueOfPi } from './constants';
-
-export const twoPi = valueOfPi * 2;
-```
-
-#### `AMD`
-
-```ts twoslash
-// @showEmit
-// @module: amd
-// @noErrors
-import { valueOfPi } from './constants';
-
-export const twoPi = valueOfPi * 2;
-```
-
-#### `System`
-
-```ts twoslash
-// @showEmit
-// @module: system
-// @noErrors
-import { valueOfPi } from './constants';
-
-export const twoPi = valueOfPi * 2;
-```
-
-#### `ESNext`
-
-```ts twoslash
-// @showEmit
-// @module: esnext
-// @noErrors
-import { valueOfPi } from './constants';
-
-export const twoPi = valueOfPi * 2;
-```
-
-#### `ES2015`/`ES6`/`ES2020`/`ES2022`
-
-```ts twoslash
-// @showEmit
-// @module: es2015
-// @noErrors
-import { valueOfPi } from './constants';
-
-export const twoPi = valueOfPi * 2;
-```
-
-In addition to the base functionality of `ES2015`/`ES6`, `ES2020` adds support for [dynamic `import`s](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import), and [`import.meta`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import.meta) while `ES2022` further adds support for [top level `await`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await#top_level_await).
-
-#### `node16`/`node18`/`nodenext`
-
-The `node16`, `node18`, and `nodenext` modes integrate with Node's [native ECMAScript Module support](https://nodejs.org/api/esm.html). 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](/docs/handbook/esm-node.html) and [Modules Reference](/docs/handbook/modules/reference.html#node16-node18-nodenext).
-
-- `node16` is available from TypeScript 4.7
-- `node18` is available from TypeScript 5.8 as a replacement for `node16`, with added support for import attributes.
-- `nodenext` is available from TypeScript 4.7, but its behavior changes with the latest stable versions of Node.js. As of TypeScript 5.8, `nodenext` supports `require` of ECMAScript modules.
-
-#### `preserve`
-
-In `--module preserve` ([added](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-4.html#support-for-require-calls-in---moduleresolution-bundler-and---module-preserve) 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 twoslash
-// @showEmit
-// @module: preserve
-// @noErrors
-import { valueOfPi } from './constants';
-import constants = require('./constants');
-
-export const piSquared = valueOfPi * constants.valueOfPi;
-```
-
-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.
-
-> Why care about TypeScript’s `module` emit with a bundler or with Bun, where you’re likely also setting `noEmit`? TypeScript’s type checking and module resolution behavior are affected by the module format that it _would_ emit. Setting `module` gives TypeScript information about how your bundler or runtime will process imports and exports, which ensures that the types you see on imported values accurately reflect what will happen at runtime or after bundling.
-
-#### `None`
-
-```ts twoslash
-// @showEmit
-// @module: none
-// @noErrors
-import { valueOfPi } from './constants';
-
-export const twoPi = valueOfPi * 2;
-```

package/docs/tsconfig/moduleDetection.md

@@ -1,15 +0,0 @@
----
-display: 'Module Detection'
-oneline: 'Specify what method is used to detect whether a file is a script or a module.'
----
-
-This setting controls how TypeScript determines whether a file is a
-[script or a module](/docs/handbook/modules/theory.html#scripts-and-modules-in-javascript).
-
-There are three choices:
-
-- `"auto"` (default) - TypeScript will not only look for import and export statements, but it will also check whether the `"type"` field in a `package.json` is set to `"module"` when running with [`module`](#module): `nodenext` or `node16`, and check whether the current file is a JSX file when running under [`jsx`](#jsx): `react-jsx`.
-
-- `"legacy"` - The same behavior as 4.6 and prior, usings import and export statements to determine whether a file is a module.
-
-- `"force"` - Ensures that every non-declaration file is treated as a module.

package/docs/tsconfig/moduleResolution.md

@@ -1,13 +0,0 @@
----
-display: 'Module Resolution'
-oneline: 'Specify how TypeScript looks up a file from a given module specifier.'
----
-
-Specify the module resolution strategy:
-
-- `'node16'` or `'nodenext'` for modern versions of Node.js. Node.js v12 and later supports both ECMAScript imports and CommonJS `require`, which resolve using different algorithms. These `moduleResolution` values, when combined with the corresponding [`module`](#module) values, picks the right algorithm for each resolution based on whether Node.js will see an `import` or `require` in the output JavaScript code.
-- `'node10'` (previously called `'node'`) for Node.js versions older than v10, which only support CommonJS `require`. You probably won't need to use `node10` in modern code.
-- `'bundler'` for use with bundlers. Like `node16` and `nodenext`, this mode supports package.json `"imports"` and `"exports"`, but unlike the Node.js resolution modes, `bundler` never requires file extensions on relative paths in imports.
-- `'classic'` was used in TypeScript before the release of 1.6. `classic` should not be used.
-
-There are reference pages explaining the [theory behind TypeScript’s module resolution](https://www.typescriptlang.org/docs/handbook/modules/theory.html#module-resolution) and the [details of each option](/docs/handbook/modules/reference.html#the-moduleresolution-compiler-option).

package/docs/tsconfig/moduleSuffixes.md

@@ -1,26 +0,0 @@
----
-display: 'Module Suffixes'
-oneline: 'List of file name suffixes to search when resolving a module.'
----
-
-Provides a way to override the default list of file name suffixes to search when resolving a module.
-
-```json tsconfig
-{
-  "compilerOptions": {
-    "moduleSuffixes": [".ios", ".native", ""]
-  }
-}
-```
-
-Given the above configuration, an import like the following:
-
-```ts
-import * as foo from './foo';
-```
-
-TypeScript will look for the relative files `./foo.ios.ts`, `./foo.native.ts`, and finally `./foo.ts`.
-
-Note the empty string `""` in [`moduleSuffixes`](#moduleSuffixes) which is necessary for TypeScript to also look-up `./foo.ts`.
-
-This feature can be useful for React Native projects where each target platform can use a separate tsconfig.json with differing `moduleSuffixes`.

package/docs/tsconfig/newLine.md

@@ -1,6 +0,0 @@
----
-display: 'New Line'
-oneline: 'Set the newline character for emitting files.'
----
-
-Specify the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix).

package/docs/tsconfig/noCheck.md

@@ -1,6 +0,0 @@
----
-display: 'noCheck'
-oneline: 'Disable full type checking (only critical parse and emit errors will be reported).'
----
-
-Disable full type checking (only critical parse and emit errors will be reported).

package/docs/tsconfig/noEmit.md

@@ -1,10 +0,0 @@
----
-display: 'No Emit'
-oneline: 'Disable emitting files from a compilation.'
----
-
-Do not emit compiler output files like JavaScript source code, source-maps or declarations.
-
-This makes room for another tool like [Babel](https://babeljs.io), or [swc](https://github.com/swc-project/swc) to handle converting the TypeScript file to a file which can run inside a JavaScript environment.
-
-You can then use TypeScript as a tool for providing editor integration, and as a source code type-checker.