@nimblescape/typescript 0.2.0 → 0.2.1

package/README.md

@@ -6,7 +6,7 @@ Node.js, in one step: `ts main.ts`. A program can use `prompt()`, `alert()`
 and `confirm()` as in the browser, without an import. A folder needs no
 `tsconfig.json` and no `package.json`.
 
-![VS Code with a terminal, in six scenes: npm installs @nimblescape/typescript globally; ts runs main.ts, and ts main.ts 3 gives the program the argument 3; ts broken.ts stops at a type error, and ts --check checks main.ts; ts --init and ts --init --browser write a tsconfig.json; ts --install-typescript installs the TypeScript of the newest VS Code, and ts --version prints the versions; ts --completion bash turns on the Tab completion of the options, and ts --help prints the help; a blue band above the window names each scene, and a label at the bottom names a pressed key and what it does](https://raw.githubusercontent.com/nimblescape/nimblescape-typescript/main/docs/images/ts.gif)
+![VS Code with a terminal, in six scenes: npm installs @nimblescape/typescript globally; ts runs main.ts, and ts main.ts 3 gives the program the argument 3; ts broken.ts stops at a type error, and ts --check checks main.ts; ts --init writes the tsconfig.json of a project of ts, with the entry of the plugin, and installs the types of Node.js after a question; ts --install-typescript installs the TypeScript of the newest VS Code, and ts --version prints the versions; ts --completion bash turns on the Tab completion of the options, and ts --help prints the help; a blue band above the window names each scene, and a label at the bottom names a pressed key and what it does](https://raw.githubusercontent.com/nimblescape/nimblescape-typescript/main/docs/images/ts.gif)
 
 `ts` is a small wrapper around `tsc` and `node`. Every error comes from
 `tsc` or from Node.js, and the only addition to Node.js is the three
@@ -37,14 +37,14 @@ comes first in these terminals.
 ts                   # runs main.ts of this folder
 ts dice.ts 3 6       # runs dice.ts with the arguments 3 and 6
 ts --check main.ts   # checks main.ts and runs nothing
+ts main.js           # runs a JavaScript file in the same way
 ```
 
 | Command | Effect |
 | --- | --- |
 | `ts [file] [arguments]` | Checks the file with `tsc`, compiles it and runs it with Node.js. Without a file, `ts` runs `main.ts` of the current folder. The words after the file are the arguments of the program (`process.argv`). When `tsc` finds an error, `ts` prints it and runs nothing. |
 | `ts --check [file]` | Checks the file and runs nothing. Without a file, `ts` checks `main.ts` of the current folder, and without `main.ts` the project of the `tsconfig.json` of the current folder. |
-| `ts --init` | Writes a `tsconfig.json` into the current folder: the file of `tsc --init`, with the settings for Node.js (`lib` `esnext` and the types of Node.js) and without `noUncheckedIndexedAccess`. It does not replace an existing `tsconfig.json`. |
-| `ts --init --browser` | Writes a `tsconfig.json` for code that runs in the browser: `lib` `esnext` and `dom`, and no types of Node.js. |
+| `ts --init` | Writes a `tsconfig.json` into the current folder: the file of `tsc --init`, with the settings for Node.js (`lib` `esnext`, the types of Node.js and `rewriteRelativeImportExtensions`), with the entry `"plugins": [{ "name": "nimblescape-typescript-plugin" }]`, which marks a project of `ts` (see [Projects with a tsconfig.json](#projects-with-a-tsconfigjson)), and without `noUncheckedIndexedAccess`. With TypeScript 7, it also writes a `package.json` with `"type": "module"` when the folder and the folders above have none (see [Limits](#limits)); with TypeScript 6, `ts` and the editor need none. When the folder cannot find the types of Node.js, `ts` asks to run `npm install --save-dev @types/node`. It replaces no existing file. |
 | `ts --install-typescript` | Installs the TypeScript of the newest VS Code globally with `npm install --global typescript@<version>`, without a question. |
 | `ts --completion <shell>` | Prints the Tab completion script for `bash`, `zsh` or `fish` (see [Tab completion](#tab-completion)). |
 | `ts --version`, `ts -v` | Prints the versions of `ts`, of the TypeScript that `ts` uses and of Node.js. |
@@ -53,6 +53,11 @@ ts --check main.ts   # checks main.ts and runs nothing
 The options stand before the file; every word after the file goes to the
 program, also a word that starts with `-`. `--` ends the options.
 
+A JavaScript file (`.js`, `.mjs` or `.cjs`) runs in the same way, also
+when a `tsconfig.json` does not allow JavaScript. `tsc` checks its syntax,
+and its types only when the file starts with the comment `// @ts-check`,
+as in Deno. A TypeScript file may import a JavaScript file.
+
 `ts` ends with the exit code of the program, or with the exit code of `tsc`
 after an error of the check. An error of the program names the line of the
 `.ts` file, because Node.js runs with the source maps of `tsc`.
@@ -69,9 +74,17 @@ after an error of the check. An error of the program names the line of the
 
 They read from the keyboard and wait, so the program stops until you press
 Enter. Input from a file or a pipe works too, for example
-`ts main.ts < input.txt`. Without a `tsconfig.json`, `tsc` knows their types.
-A project with its own `tsconfig.json` declares them itself, for example in
-a file `globals.d.ts`:
+`ts main.ts < input.txt`.
+
+`ts` knows their types in every project of `ts`, as Deno knows its own
+globals: the types are part of `ts`, and a project needs no file for them.
+In a project of `ts --init`, `ts` adds them to the settings of its
+`tsconfig.json`, unless the project has the types of the browser (`"lib"`
+with `"dom"`), which declare the three functions themselves. The VS Code extension
+[nimblescape TypeScript](https://marketplace.visualstudio.com/items?itemName=nimblescape.nimblescape-typescript)
+does the same in the editor. Plain `tsc` does not know them; a project that
+also has to pass plain `tsc` declares them in a file of its own, for example
+`globals.d.ts`:
 
 ```ts
 declare function prompt(message?: string, defaultValue?: string): string | null;
@@ -91,12 +104,31 @@ wins. Without one, `ts` uses the built-in defaults of `tsc` (for example
 | `lib` | `["esnext"]` | JavaScript without the browser: `document` and `window` are errors. |
 | `types` | `["node"]` and the types of `prompt()`, `alert()` and `confirm()` | `process`, `node:fs` and the other modules of Node.js. `ts` contains the types of Node.js. |
 | `skipLibCheck` | `true` | Checks your files, not the type files of the packages, as `tsc --init` sets it. |
+| `allowJs` | `true` | `ts` runs a JavaScript file, and a TypeScript file may import one. `checkJs` stays off, as in `tsc` and Deno. |
 | `rewriteRelativeImportExtensions` | `true` | An import names the `.ts` file, as Node.js needs it: `import { Dog } from "./dog.ts"`. |
 
 Without a `package.json`, every file is an ES module, as if the folder had a
-`package.json` with `"type": "module"`. With a `package.json`, its `type`
+`package.json` with `"type": "module"`, as in Deno. This also holds for a
+project of `ts --init`, in `ts` and in the editor; plain `tsc` reads such a
+file as CommonJS for `module` `nodenext`. With a `package.json`, its `type`
 decides, as in Node.js.
 
+## Projects with a tsconfig.json
+
+A `tsconfig.json` belongs to `ts` only when its `compilerOptions.plugins`
+names the editor plugin, as `ts --init` writes it:
+
+```json
+"plugins": [{ "name": "nimblescape-typescript-plugin" }]
+```
+
+Only such a project gets the types of `prompt()`, `alert()` and `confirm()`,
+and every file of it is an ES module without a `package.json`. `tsc` and
+Vite ignore the entry. Any other `tsconfig.json`, for example the one of a
+Vite project, is a standard project: `ts` checks it as `tsc` does, and the
+editor plugin leaves it to TypeScript. Delete the line, and the project of
+`ts --init` becomes a standard project.
+
 ## Which TypeScript
 
 `ts` contains no TypeScript. It uses the first of these:
@@ -149,11 +181,14 @@ bash-completion, and for zsh when `~/.zshrc` runs `compinit`.
 - TypeScript 7 cannot read the `package.json` that `ts` assumes: without a
   `package.json`, `ts` checks a file there with `module` `preserve` and
   `moduleResolution` `bundler`. The program runs the same.
-- With a `tsconfig.json`, TypeScript 7 does not add the declaration files of
-  the project (`.d.ts`) to the check of one file; TypeScript 6 does.
-- After `ts --init`, install the types of Node.js in the project:
-  `npm install --save-dev @types/node`.
 - `ts` runs no JSX and builds no libraries.
+- Plain `tsc` does not know `prompt()`, `alert()` and `confirm()`; see
+  [the functions prompt, alert and confirm](#the-functions-prompt-alert-and-confirm).
+  It also does not make every file an ES module without a `package.json`.
+- TypeScript 7 cannot read the `package.json` that `ts` assumes in a
+  project with a `tsconfig.json` either: there, the project needs a real
+  `package.json` with `"type": "module"`, which `ts --init` writes with
+  TypeScript 7.
 
 ---
 

package/dist/ts.js

@@ -33,7 +33,6 @@ var SHELLS = ["bash", "zsh", "fish"];
 var OPTIONS = [
   { name: "--check", description: "check the types only and run nothing" },
   { name: "--init", description: "write a tsconfig.json with the settings of tsc --init for Node.js" },
-  { name: "--browser", description: "with --init, the settings for code that runs in the browser" },
   { name: "--install-typescript", description: "install the TypeScript of the newest VS Code globally, without a question" },
   { name: "--completion", argument: "<shell>", values: SHELLS, description: "print the Tab completion script for bash, zsh or fish" },
   { name: "--version", short: "-v", description: "print the versions of ts, TypeScript and Node.js" },
@@ -43,7 +42,7 @@ function helpText(version) {
   const usage = [
     ["ts [file] [arguments]", "check, compile and run the file with Node.js (default main.ts)"],
     ["ts --check [file]", "check the file, or the project of the tsconfig.json of this folder"],
-    ["ts --init [--browser]", "write a tsconfig.json into this folder"],
+    ["ts --init", "write a tsconfig.json into this folder"],
     ["ts --install-typescript", "install TypeScript globally with npm"],
     ["ts --completion <shell>", "print the Tab completion script"]
   ];
@@ -56,7 +55,7 @@ function helpText(version) {
     return rows.map(([left, right]) => `  ${left.padEnd(width)}  ${right}`).join("\n");
   };
   return [
-    `ts ${version}: checks a TypeScript file with tsc, compiles it and runs it with Node.js.`,
+    `ts ${version}: checks a TypeScript or JavaScript file with tsc, compiles it and runs it with Node.js.`,
     "",
     "Usage:",
     column(usage),
@@ -72,7 +71,7 @@ function helpText(version) {
 
 // src/cli/args.ts
 function parseArguments(argv) {
-  const command = { check: false, init: false, browser: false, installTypeScript: false, version: false, help: false, args: [] };
+  const command = { check: false, init: false, installTypeScript: false, version: false, help: false, args: [] };
   const known = new Set(OPTIONS.flatMap((option) => [option.name, option.short].filter((name) => name !== void 0)));
   for (let i = 0; i < argv.length; i++) {
     const word = argv[i];
@@ -89,7 +88,6 @@ function parseArguments(argv) {
     if (!known.has(word)) return `Unknown option ${word}. See ts --help.`;
     if (word === "--check") command.check = true;
     else if (word === "--init") command.init = true;
-    else if (word === "--browser") command.browser = true;
     else if (word === "--install-typescript") command.installTypeScript = true;
     else if (word === "--version" || word === "-v") command.version = true;
     else if (word === "--help" || word === "-h") command.help = true;
@@ -98,7 +96,6 @@ function parseArguments(argv) {
       if (!SHELLS.includes(command.completion)) return `--completion needs one of: ${SHELLS.join(", ")}.`;
     }
   }
-  if (command.browser && !command.init) return "--browser works only with --init.";
   return command;
 }
 
@@ -109,15 +106,27 @@ var path3 = __toESM(require("node:path"));
 
 // src/defaults.ts
 var path = __toESM(require("node:path"));
+var PLUGIN_NAME = "nimblescape-typescript-plugin";
+function isTsProject(plugins) {
+  return Array.isArray(plugins) && plugins.some((entry) => typeof entry === "object" && entry !== null && entry.name === PLUGIN_NAME);
+}
 var GLOBALS_TYPES = "nimblescape-globals";
 var DEFAULT_COMPILER_OPTIONS = {
   module: "nodenext",
   lib: ["esnext"],
   types: ["node", GLOBALS_TYPES],
   skipLibCheck: true,
+  // ts runs a JavaScript file too, and a TypeScript file may import one.
+  allowJs: true,
   // A relative import may end with .ts, as Node.js requires for a .ts file; tsc writes .js into the output.
   rewriteRelativeImportExtensions: true
 };
+function hasBrowserTypes(lib) {
+  return lib === void 0 || lib.some((name) => /^(lib\.)?dom(\.|$)/i.test(name));
+}
+function isJavaScriptFile(file) {
+  return /\.[cm]?jsx?$/i.test(file);
+}
 var VIRTUAL_PACKAGE_JSON = '{"type":"module"}';
 function rootPackageJson(file) {
   return path.join(path.parse(path.resolve(file)).root, "package.json");
@@ -243,16 +252,23 @@ function packageRoot(environment = process.env) {
   return environment[TYPES_VARIABLE] || path3.resolve(__dirname, "..");
 }
 function typeRoots(folder, environment = process.env) {
+  const roots = projectTypeRoots(folder);
+  const own = packageRoot(environment);
+  roots.push(path3.join(own, "types"));
+  const node = packageFolder("@types/node", own);
+  if (node !== void 0 && !roots.includes(path3.dirname(node))) roots.push(path3.dirname(node));
+  return roots;
+}
+function globalsFile(environment = process.env) {
+  return path3.join(packageRoot(environment), "types", GLOBALS_TYPES, "index.d.ts");
+}
+function projectTypeRoots(folder) {
   const roots = [];
   for (let current = path3.resolve(folder); ; current = path3.dirname(current)) {
     const types = path3.join(current, "node_modules", "@types");
     if (fs2.existsSync(types)) roots.push(types);
     if (path3.dirname(current) === current) break;
   }
-  const own = packageRoot(environment);
-  roots.push(path3.join(own, "types"));
-  const node = packageFolder("@types/node", own);
-  if (node !== void 0 && !roots.includes(path3.dirname(node))) roots.push(path3.dirname(node));
   return roots;
 }
 function projectOfFile(file) {
@@ -260,7 +276,7 @@ function projectOfFile(file) {
   const folder = path3.dirname(absolute);
   const configFolder = findUp(folder, "tsconfig.json", fs2.existsSync);
   const root = findUp(folder, "package.json", fs2.existsSync);
-  const type = root === void 0 ? "module" : readManifest(root)?.type;
+  const type = root !== void 0 ? readManifest(root)?.type : configFolder === void 0 ? "module" : void 0;
   return {
     file: absolute,
     config: configFolder === void 0 ? void 0 : path3.join(configFolder, "tsconfig.json"),
@@ -268,11 +284,42 @@ function projectOfFile(file) {
     moduleType: type === "module" || type === "commonjs" ? type : void 0
   };
 }
-function declarationFiles(typescript, config) {
-  const read = typescript.readConfigFile(config, typescript.sys.readFile);
-  if (read.error) return [];
-  const parsed = typescript.parseJsonConfigFileContent(read.config, typescript.sys, path3.dirname(config), void 0, config);
-  return parsed.fileNames.filter((name) => /\.d\.[cm]?ts$/.test(name));
+function projectConfig(install2, typescript, config) {
+  const isDeclaration = (name) => /\.d\.[cm]?ts$/.test(name);
+  const strings = (value) => Array.isArray(value) ? value.filter((name) => typeof name === "string") : void 0;
+  const settings = (files, typeRoots2, lib, plugins) => ({
+    files,
+    declarations: files.filter(isDeclaration),
+    typeRoots: typeRoots2,
+    lib,
+    ts: isTsProject(plugins)
+  });
+  const broken = settings([], false, void 0, void 0);
+  if (typescript) {
+    const read = typescript.readConfigFile(config, typescript.sys.readFile);
+    if (read.error) return broken;
+    const parsed = typescript.parseJsonConfigFileContent(read.config, typescript.sys, path3.dirname(config), void 0, config);
+    return settings(parsed.fileNames, parsed.options.typeRoots !== void 0, parsed.options.lib, parsed.options.plugins);
+  }
+  const manifest = readManifest(install2.folder);
+  const bin = path3.join(install2.folder, manifest?.bin?.tsc ?? "bin/tsc");
+  const result = (0, import_node_child_process2.spawnSync)(process.execPath, [bin, "--showConfig", "--project", config], { encoding: "utf8" });
+  try {
+    const shown = JSON.parse(result.stdout);
+    const files = (strings(shown.files) ?? []).map((name) => path3.resolve(path3.dirname(config), name));
+    return settings(files, shown.compilerOptions?.typeRoots !== void 0, strings(shown.compilerOptions?.lib), shown.compilerOptions?.plugins);
+  } catch {
+    return broken;
+  }
+}
+function addedFiles(settings) {
+  return !settings.ts || hasBrowserTypes(settings.lib) ? [] : [globalsFile()];
+}
+function extendedTypeRoots(config, folder, settings) {
+  const own = projectTypeRoots(path3.dirname(config));
+  const found = projectTypeRoots(folder);
+  const missing = !settings.typeRoots && own.some((root) => !found.includes(root));
+  return missing ? { typeRoots: [.../* @__PURE__ */ new Set([...own, ...found])] } : {};
 }
 function loadTypeScript(install2) {
   if (install2.major >= 7) return void 0;
@@ -285,7 +332,10 @@ function outputFile(job) {
   const relative3 = path3.relative(path3.parse(file).root, file).replace(/\.([cm]?)tsx?$/, (_, kind) => `.${kind}js`);
   return path3.join(outFolder(job), relative3);
 }
-function temporaryConfig(job, typescript) {
+function jobSettings(job, typescript) {
+  return job.project.config === void 0 ? void 0 : projectConfig(job.typescript, typescript, job.project.config);
+}
+function temporaryConfig(job, typescript, settings = jobSettings(job, typescript)) {
   const { project } = job;
   const output = job.checkOnly ? { noEmit: true } : {
     noEmit: false,
@@ -300,12 +350,13 @@ function temporaryConfig(job, typescript) {
     composite: false,
     incremental: false
   };
-  if (project.config !== void 0) {
-    const declarations = typescript ? declarationFiles(typescript, project.config) : [];
+  if (project.config !== void 0 && settings !== void 0) {
+    const roots = extendedTypeRoots(project.config, job.folder, settings);
     return {
       extends: project.config,
-      compilerOptions: { ...output, rewriteRelativeImportExtensions: true },
-      files: [project.file, ...declarations.filter((name) => name !== project.file)],
+      // A JavaScript file runs also when the tsconfig.json does not allow JavaScript.
+      compilerOptions: { ...output, ...roots, rewriteRelativeImportExtensions: true, ...isJavaScriptFile(project.file) ? { allowJs: true } : {} },
+      files: [.../* @__PURE__ */ new Set([project.file, ...settings.declarations, ...addedFiles(settings)])],
       include: []
     };
   }
@@ -339,9 +390,10 @@ function runTsc(install2, typescript, args, file) {
 }
 function compile(job) {
   const typescript = loadTypeScript(job.typescript);
+  const settings = jobSettings(job, typescript);
   fs2.mkdirSync(job.folder, { recursive: true });
   const config = path3.join(job.folder, "tsconfig.json");
-  fs2.writeFileSync(config, `${JSON.stringify(temporaryConfig(job, typescript), null, 2)}
+  fs2.writeFileSync(config, `${JSON.stringify(temporaryConfig(job, typescript, settings), null, 2)}
 `);
   if (!job.checkOnly) {
     fs2.mkdirSync(outFolder(job), { recursive: true });
@@ -349,15 +401,27 @@ function compile(job) {
     if (type !== void 0) fs2.writeFileSync(path3.join(outFolder(job), "package.json"), `${JSON.stringify({ type })}
 `);
   }
-  const virtual = job.project.config === void 0 && job.project.packageRoot === void 0;
+  const virtual = job.project.packageRoot === void 0 && (settings === void 0 || settings.ts);
   return runTsc(job.typescript, typescript, ["--project", config], virtual ? job.project.file : void 0);
 }
-function checkProject(install2, config) {
+function checkProject(install2, config, folder) {
   const typescript = loadTypeScript(install2);
-  const settings = parseJsonc(fs2.readFileSync(config, "utf8"));
-  const references = Array.isArray(settings?.references) && settings.references.length > 0;
-  const args = references ? ["--build", config] : ["--project", config, "--noEmit"];
-  return runTsc(install2, typescript, args);
+  const settings = projectConfig(install2, typescript, config);
+  const virtual = settings.ts && findUp(path3.dirname(config), "package.json", fs2.existsSync) === void 0 ? config : void 0;
+  const references = parseJsonc(fs2.readFileSync(config, "utf8"))?.references;
+  if (Array.isArray(references) && references.length > 0) return runTsc(install2, typescript, ["--build", config], virtual);
+  const added = addedFiles(settings);
+  if (added.length === 0) return runTsc(install2, typescript, ["--project", config, "--noEmit"], virtual);
+  const temporary = path3.join(folder, "tsconfig.json");
+  const json = {
+    extends: config,
+    compilerOptions: { noEmit: true, ...extendedTypeRoots(config, folder, settings) },
+    files: [.../* @__PURE__ */ new Set([...settings.files, ...added])],
+    include: []
+  };
+  fs2.writeFileSync(temporary, `${JSON.stringify(json, null, 2)}
+`);
+  return runTsc(install2, typescript, ["--project", temporary], virtual);
 }
 
 // src/cli/completion.ts
@@ -430,6 +494,46 @@ var import_node_child_process3 = require("node:child_process");
 var fs3 = __toESM(require("node:fs"));
 var os = __toESM(require("node:os"));
 var path4 = __toESM(require("node:path"));
+
+// src/cli/ask.ts
+var import_node_fs = require("node:fs");
+var import_node_tty = require("node:tty");
+function canAsk() {
+  return (0, import_node_tty.isatty)(0) && (0, import_node_tty.isatty)(1);
+}
+function readLine() {
+  const bytes = [];
+  const buffer = new Uint8Array(1);
+  for (; ; ) {
+    let count;
+    try {
+      count = (0, import_node_fs.readSync)(0, buffer, 0, 1, null);
+    } catch (error) {
+      if (error.code === "EAGAIN") {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+        continue;
+      }
+      throw error;
+    }
+    if (count !== 1) break;
+    if (buffer[0] === 10) return new TextDecoder().decode(new Uint8Array(bytes)).replace(/\r$/, "");
+    bytes.push(buffer[0]);
+  }
+  return bytes.length > 0 ? new TextDecoder().decode(new Uint8Array(bytes)) : null;
+}
+function askYesNo(question) {
+  (0, import_node_fs.writeSync)(1, `${question} [Y/n] `);
+  const answer = (readLine() ?? "n").trim().toLowerCase();
+  return answer === "" || answer === "y" || answer === "yes";
+}
+function askText(question, fallback) {
+  (0, import_node_fs.writeSync)(1, `${question} [${fallback}] `);
+  const answer = (readLine() ?? "").trim();
+  return answer === "" ? fallback : answer;
+}
+
+// src/cli/init.ts
+var NODE_TYPES_COMMAND = ["npm", "install", "--save-dev", "@types/node"];
 function tscInit(install2) {
   const typescript = loadTypeScript(install2);
   if (!typescript) {
@@ -461,7 +565,7 @@ function tscInit(install2) {
   }, ["--init"]);
   return { text, output, code };
 }
-function adapt(text, browser) {
+function adapt(text) {
   const lines = text.split("\n");
   const removed = /^\s*"(noUncheckedIndexedAccess|declaration|declarationMap|jsx)":/;
   const out = [];
@@ -476,11 +580,16 @@ function adapt(text, browser) {
           break;
         }
       }
-      if (browser) {
-        out.push(`${indent}// For the browser (ts --init --browser):`, `${indent}"lib": ["esnext", "dom"],`, `${indent}"types": [],`);
-      } else {
-        out.push(`${indent}// For Node.js (ts --init), with npm install -D @types/node:`, `${indent}"lib": ["esnext"],`, `${indent}"types": ["node"],`);
-      }
+      out.push(
+        `${indent}// For Node.js (ts --init), with npm install -D @types/node:`,
+        `${indent}"lib": ["esnext"],`,
+        `${indent}"types": ["node"],`,
+        `${indent}// An import names the .ts file, as Node.js needs it; tsc writes .js:`,
+        `${indent}"rewriteRelativeImportExtensions": true,`,
+        `${indent}// A project of ts: ts and the editor know prompt(), alert() and confirm(),`,
+        `${indent}// and every file is an ES module:`,
+        `${indent}"plugins": [{ "name": "${PLUGIN_NAME}" }],`
+      );
       while (i + 1 < lines.length && /^\s*\/\/ ("lib"|"types"|and npm install)/.test(lines[i + 1])) i++;
       continue;
     }
@@ -488,7 +597,26 @@ function adapt(text, browser) {
   }
   return out.join("\n");
 }
-function init(install2, browser) {
+function writePackageJson() {
+  if (findUp(process.cwd(), "package.json", fs3.existsSync) !== void 0) return void 0;
+  fs3.writeFileSync(path4.join(process.cwd(), "package.json"), `${JSON.stringify({ type: "module" }, null, 2)}
+`);
+  return 'Created a new package.json with "type": "module", so every file is an ES module';
+}
+function ensureNodeTypes() {
+  if (packageFolder("@types/node", process.cwd()) !== void 0) return 0;
+  const command = NODE_TYPES_COMMAND.join(" ");
+  if (!canAsk()) {
+    console.log(`The types of Node.js (@types/node) are not installed. Run ${command} in this folder.`);
+    return 0;
+  }
+  console.log("The types of Node.js (@types/node) are not installed.");
+  if (!askYesNo(`Run ${command} now?`)) return 0;
+  console.log(`> ${command}`);
+  const [npm, ...args] = NODE_TYPES_COMMAND;
+  return (0, import_node_child_process3.spawnSync)(npm, args, { stdio: "inherit" }).status ?? 1;
+}
+function init(install2) {
   const target = path4.join(process.cwd(), "tsconfig.json");
   if (fs3.existsSync(target)) {
     console.error(`error TS5054: A 'tsconfig.json' file is already defined at: '${target}'.`);
@@ -499,52 +627,18 @@ function init(install2, browser) {
     process.stdout.write(result.output);
     return result.code || 1;
   }
-  fs3.writeFileSync(target, adapt(result.text, browser));
-  process.stdout.write(result.output);
-  return 0;
+  fs3.writeFileSync(target, adapt(result.text));
+  const line = install2.major >= 7 ? writePackageJson() : void 0;
+  const created = /^.*Created a new tsconfig\.json.*$/m;
+  if (line === void 0) process.stdout.write(result.output);
+  else process.stdout.write(created.test(result.output) ? result.output.replace(created, (text) => `${text}
+${line}`) : `${result.output}${line}
+`);
+  return ensureNodeTypes();
 }
 
 // src/cli/install.ts
 var import_node_child_process4 = require("node:child_process");
-
-// src/cli/ask.ts
-var import_node_fs = require("node:fs");
-var import_node_tty = require("node:tty");
-function canAsk() {
-  return (0, import_node_tty.isatty)(0) && (0, import_node_tty.isatty)(1);
-}
-function readLine() {
-  const bytes = [];
-  const buffer = new Uint8Array(1);
-  for (; ; ) {
-    let count;
-    try {
-      count = (0, import_node_fs.readSync)(0, buffer, 0, 1, null);
-    } catch (error) {
-      if (error.code === "EAGAIN") {
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
-        continue;
-      }
-      throw error;
-    }
-    if (count !== 1) break;
-    if (buffer[0] === 10) return new TextDecoder().decode(new Uint8Array(bytes)).replace(/\r$/, "");
-    bytes.push(buffer[0]);
-  }
-  return bytes.length > 0 ? new TextDecoder().decode(new Uint8Array(bytes)) : null;
-}
-function askYesNo(question) {
-  (0, import_node_fs.writeSync)(1, `${question} [Y/n] `);
-  const answer = (readLine() ?? "n").trim().toLowerCase();
-  return answer === "" || answer === "y" || answer === "yes";
-}
-function askText(question, fallback) {
-  (0, import_node_fs.writeSync)(1, `${question} [${fallback}] `);
-  const answer = (readLine() ?? "").trim();
-  return answer === "" ? fallback : answer;
-}
-
-// src/cli/install.ts
 var TIMEOUT = 4e3;
 async function fetchJson(url2, headers = {}) {
   const response = await fetch(url2, { headers, signal: AbortSignal.timeout(TIMEOUT) });
@@ -638,14 +732,15 @@ function ensurePackages(folder) {
   const missing = missingPackages(folder);
   if (!missing) return true;
   const command = `npm ${installArguments(missing.root).join(" ")}`;
-  const where = path5.relative(process.cwd(), missing.root) || ".";
+  const relative3 = path5.relative(process.cwd(), missing.root);
+  const where = relative3 === "" ? "in this folder" : `in ${relative3}`;
   const names2 = missing.missing.join(", ");
   if (!canAsk()) {
-    console.error(`The packages of this course are not installed (${names2}). Run ${command} in ${where}.`);
+    console.error(`The packages of this course are not installed (${names2}). Run ${command} ${where}.`);
     return false;
   }
   console.log(`The packages of this course are not installed (${names2}).`);
-  if (!askYesNo(`Run ${command} in ${where} now?`)) return false;
+  if (!askYesNo(`Run ${command} ${where} now?`)) return false;
   console.log(`> ${command}`);
   const result = (0, import_node_child_process5.spawnSync)("npm", installArguments(missing.root), { cwd: missing.root, stdio: "inherit" });
   return result.status === 0 && missingPackages(folder) === void 0;
@@ -807,7 +902,7 @@ async function main(argv) {
     return 2;
   }
   if (command.help) {
-    console.log(helpText("0.2.0"));
+    console.log(helpText("0.2.1"));
     return 0;
   }
   if (command.completion !== void 0) {
@@ -817,7 +912,7 @@ async function main(argv) {
   if (command.version) {
     const lookup = findTypeScript(process.cwd());
     const typescript2 = "found" in lookup ? describe(lookup.found) : "TypeScript: not installed";
-    console.log(`ts ${"0.2.0"}
+    console.log(`ts ${"0.2.1"}
 ${typescript2}
 Node.js ${process.version}`);
     return 0;
@@ -829,17 +924,24 @@ Node.js ${process.version}`);
   }
   if (command.init) {
     const typescript2 = await typeScriptFor(process.cwd());
-    return typescript2 ? init(typescript2, command.browser) : 1;
+    return typescript2 ? init(typescript2) : 1;
   }
   const file = entryFile(command.file);
   if (file === void 0) {
     if (command.check && fs6.existsSync("tsconfig.json")) {
       const typescript2 = await typeScriptFor(process.cwd());
-      return typescript2 ? checkProject(typescript2, path7.resolve("tsconfig.json")) : 1;
+      if (!typescript2) return 1;
+      const config = path7.resolve("tsconfig.json");
+      const runFolder = createRunFolder(projectOfFile(config));
+      try {
+        return checkProject(typescript2, config, runFolder.folder);
+      } finally {
+        removeRunFolder(runFolder);
+      }
     }
     console.error(`No ${ENTRY_FILES.join(" or ")} in this folder.
 `);
-    console.error(helpText("0.2.0"));
+    console.error(helpText("0.2.1"));
     return 1;
   }
   if (!fs6.existsSync(file)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimblescape/typescript",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "The command ts: checks a TypeScript file with tsc, compiles it and runs it with Node.js, with the global functions prompt(), alert() and confirm().",
   "license": "MIT",
   "author": {

package/types/nimblescape-globals/index.d.ts

@@ -4,8 +4,8 @@
 
 // The types of the polyfills of ts (src/runtime/polyfill.ts): prompt(), alert() and confirm() are global functions in
 // every program that ts runs, as in Deno and the browser. Without a tsconfig.json, ts and the editor plugin add this
-// type package ("types": ["node", "nimblescape-globals"]); a project with its own tsconfig.json declares them itself,
-// for example with a copy of these lines in a globals.d.ts.
+// type package ("types": ["node", "nimblescape-globals"]); with a tsconfig.json, they add this file to the files of
+// the project, unless the project has the types of the browser (lib dom), which declare the three functions.
 
 /**
  * Shows `message`, waits for one line of the keyboard and returns it without the line break. An empty line returns