pluribuild 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Alexander Tkačenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# pluribuild
+
+Build multiple entry points into multiple output files with a single command.
+
+Run `npx pluribuild` to build:
+- `entries/<name>/src/index.ts(x)` into `dist/<name>/index.js`;
+- `entries/<name>/x.ts(x)` into `dist/<name>/x.js` (`index` as `x` is fine, too).
+
+Run `npx pluribuild <dir>` to point to a parent directory other than `entries`.
+
+Add `--dev` to the command to enable rebuilds on code changes. Add `--minify=off` to turn off minification.

package/dist/index.cjs

@@ -0,0 +1,77 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+    key = keys[i];
+    if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: ((k) => from[k]).bind(null, key),
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+
+let esbuild = require("esbuild");
+esbuild = __toESM(esbuild);
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+
+function toEntryPoint(toName) {
+  return (path) => {
+    let name = toName(path);
+    if (!name) throw new Error(`Invalid entry point name: "${path}"`);
+    name = name.replace(/\.\w+$/, "");
+    return [name, {
+      in: path,
+      out: name
+    }];
+  };
+}
+
+function getDefaultEntryPoints(dir = "entries") {
+  let entryPoints = new Map([...(0, node_fs.globSync)(`${dir}/[!_]*/src/index.{ts,tsx}`).map(toEntryPoint((path) => {
+    let p = path.split(node_path.sep);
+    return `${p.at(-3)}/${p.at(-1)}`;
+  })), ...(0, node_fs.globSync)(`${dir}/[!_]*/[!_]*.{ts,tsx}`).map(toEntryPoint((path) => path.split(node_path.sep).slice(-2).join("/")))]);
+  return Array.from(entryPoints.values());
+}
+
+async function build({ entryPoints, dev, dir, ...options } = {}) {
+  let e = entryPoints ?? getDefaultEntryPoints(dir);
+  if (Object.keys(e).length === 0) {
+    console.warn("No entry points");
+    return;
+  }
+  let buildOptions = {
+    entryPoints: e,
+    outdir: "dist",
+    bundle: true,
+    splitting: true,
+    format: "esm",
+    jsx: "automatic",
+    loader: {
+      ".png": "dataurl",
+      ".svg": "dataurl",
+      ".html": "text",
+      ".txt": "text"
+    },
+    minify: true,
+    ...options
+  };
+  if (dev) await (await esbuild.default.context(buildOptions)).watch();
+  await esbuild.default.build(buildOptions);
+}
+
+exports.build = build;
+exports.getDefaultEntryPoints = getDefaultEntryPoints;
+exports.toEntryPoint = toEntryPoint;

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import { BuildOptions as BuildOptions$1 } from "esbuild";
+
+type BuildOptions = BuildOptions$1 & {
+  /** Directory containing entry points. */dir?: string; /** Development mode. Enables rebuilds on code changes. */
+  dev?: boolean;
+};
+
+declare function build({
+  entryPoints,
+  dev,
+  dir,
+  ...options
+}?: BuildOptions): Promise<void>;
+
+type EntryPoint = {
+  in: string;
+  out: string;
+};
+
+declare function getDefaultEntryPoints(dir?: string): EntryPoint[];
+
+declare function toEntryPoint(toName: (path: string) => string | undefined): (path: string) => [string, EntryPoint];
+
+export { BuildOptions, EntryPoint, build, getDefaultEntryPoints, toEntryPoint };

package/dist/index.mjs

@@ -0,0 +1,51 @@
+import esbuild from "esbuild";
+import { globSync } from "node:fs";
+import { sep } from "node:path";
+
+function toEntryPoint(toName) {
+  return (path) => {
+    let name = toName(path);
+    if (!name) throw new Error(`Invalid entry point name: "${path}"`);
+    name = name.replace(/\.\w+$/, "");
+    return [name, {
+      in: path,
+      out: name
+    }];
+  };
+}
+
+function getDefaultEntryPoints(dir = "entries") {
+  let entryPoints = new Map([...globSync(`${dir}/[!_]*/src/index.{ts,tsx}`).map(toEntryPoint((path) => {
+    let p = path.split(sep);
+    return `${p.at(-3)}/${p.at(-1)}`;
+  })), ...globSync(`${dir}/[!_]*/[!_]*.{ts,tsx}`).map(toEntryPoint((path) => path.split(sep).slice(-2).join("/")))]);
+  return Array.from(entryPoints.values());
+}
+
+async function build({ entryPoints, dev, dir, ...options } = {}) {
+  let e = entryPoints ?? getDefaultEntryPoints(dir);
+  if (Object.keys(e).length === 0) {
+    console.warn("No entry points");
+    return;
+  }
+  let buildOptions = {
+    entryPoints: e,
+    outdir: "dist",
+    bundle: true,
+    splitting: true,
+    format: "esm",
+    jsx: "automatic",
+    loader: {
+      ".png": "dataurl",
+      ".svg": "dataurl",
+      ".html": "text",
+      ".txt": "text"
+    },
+    minify: true,
+    ...options
+  };
+  if (dev) await (await esbuild.context(buildOptions)).watch();
+  await esbuild.build(buildOptions);
+}
+
+export { build, getDefaultEntryPoints, toEntryPoint };

package/dist/run.mjs

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/args-json/dist/index.cjs
+var require_dist = __commonJS({
+  "node_modules/args-json/dist/index.cjs"(exports) {
+    Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+    function getDefaultInput() {
+      return typeof process === "undefined" ? [] : process.argv;
+    }
+    var offValues = /* @__PURE__ */ new Set([
+      "0",
+      "false",
+      "null",
+      "undefined",
+      "off"
+    ]);
+    function isOff(x) {
+      return offValues.has(String(x));
+    }
+    function isExplicitlyOff(x) {
+      return isOff(x) && String(x) !== "undefined";
+    }
+    function isKey2(x) {
+      return x.startsWith("-") && x.length === 2 && x !== "--" || x.startsWith("--") && x.length > 2;
+    }
+    var onValues = /* @__PURE__ */ new Set([
+      "1",
+      "true",
+      "on"
+    ]);
+    function isOn(x) {
+      return onValues.has(String(x));
+    }
+    function normalizeInput(input) {
+      let source = input ?? getDefaultInput();
+      let result = [];
+      for (let s of source) {
+        if (s.startsWith("-") && s.includes("=")) {
+          let key = s.slice(0, s.indexOf("="));
+          if (isKey2(key)) {
+            result.push(key, s.slice(key.length + 1));
+            continue;
+          }
+        }
+        result.push(s);
+      }
+      return result;
+    }
+    var Args2 = class {
+      _input;
+      constructor(input) {
+        this._input = normalizeInput(input);
+      }
+      hasKey(x) {
+        return isKey2(x) && this._input.includes(x);
+      }
+      isOn(key) {
+        let args3 = this._input;
+        let k = args3.indexOf(key);
+        return k !== -1 && (k === args3.length - 1 || isKey2(args3[k + 1]) || isOn(args3[k + 1]));
+      }
+      isOff(key) {
+        let args3 = this._input;
+        let k = args3.indexOf(key);
+        return k === -1 || isOff(args3[k + 1]);
+      }
+      isExplicitlyOff(key) {
+        let args3 = this._input;
+        let k = args3.indexOf(key);
+        return k !== -1 && isExplicitlyOff(args3[k + 1]);
+      }
+      getValue(key, fallback) {
+        let args3 = this._input;
+        let keys = Array.isArray(key) ? key : [key];
+        for (let k of keys) {
+          let i = args3.indexOf(k);
+          if (i !== -1 && args3[i + 1] && !isKey2(args3[i + 1])) return args3[i + 1];
+        }
+        return fallback;
+      }
+      getValues(key, fallback) {
+        let args3 = this._input;
+        let keys = Array.isArray(key) ? key : [key];
+        let values = [];
+        for (let k of keys) {
+          let i = args3.indexOf(k);
+          while (i !== -1 && args3[i + 1] && !isKey2(args3[i + 1])) values.push(args3[++i]);
+        }
+        return values.length === 0 ? fallback : values;
+      }
+    };
+    var args2 = new Args2();
+    function getValue(key, fallback) {
+      if (fallback === void 0) return args2.getValue(key);
+      return args2.getValue(key, fallback);
+    }
+    function getValues(key, fallback) {
+      if (fallback === void 0) return args2.getValues(key);
+      return args2.getValues(key, fallback);
+    }
+    function hasKey(x) {
+      return args2.hasKey(x);
+    }
+    function split(x) {
+      let words = [], word = "";
+      let hasOpenSingleQuote = false;
+      let hasOpenDoubleQuote = false;
+      for (let i = 0; i < x.length; i++) {
+        let c = x[i];
+        if (/^\s/.test(c) && !hasOpenSingleQuote && !hasOpenDoubleQuote) {
+          if (word) words.push(word);
+          word = "";
+          continue;
+        }
+        if (c === "'" && x[i - 1] !== "\\") hasOpenSingleQuote = !hasOpenSingleQuote;
+        if (c === '"' && x[i - 1] !== "\\") hasOpenDoubleQuote = !hasOpenDoubleQuote;
+        word += c;
+      }
+      if (word) words.push(word);
+      return words;
+    }
+    function toCamelCase(x) {
+      let s = x.replace(/^[-_.\s~+]|[-_.\s~+]$/g, "");
+      if (!/[-_.\s~+]/.test(s)) return s.slice(0, 1).toLowerCase() + s.slice(1);
+      return s.toLowerCase().replace(/[-_.\s~+](\S)/g, (_, match) => match.toUpperCase());
+    }
+    function toKey(x) {
+      if (x === void 0 || !isKey2(x)) return;
+      if (x.startsWith("-") && x.length === 2) return toCamelCase(x.slice(1));
+      if (x.startsWith("--") && x.length > 2) return toCamelCase(x.slice(2));
+    }
+    function parseArgs(input, map) {
+      let normalizedInput;
+      let normalizedMap;
+      if (input === void 0) normalizedInput = getDefaultInput();
+      else if (typeof input === "string") normalizedInput = split(input);
+      else if (Array.isArray(input)) normalizedInput = input.map((x) => String(x));
+      else if (input !== null && typeof input === "object") {
+        normalizedInput = getDefaultInput();
+        normalizedMap = input;
+      } else normalizedInput = [];
+      normalizedInput = normalizedInput.flatMap((item) => {
+        let normalizedItem = item.trim();
+        let k = normalizedItem.indexOf("=");
+        if (k === -1) return normalizedItem;
+        let key2 = normalizedItem.slice(0, k);
+        let value = normalizedItem.slice(k + 1);
+        if (!isKey2(key2)) return normalizedItem;
+        return [key2, value];
+      });
+      if (map) normalizedMap = map;
+      let key = "";
+      let parsedArgs = {};
+      for (let rawValue of normalizedInput) {
+        rawValue = rawValue.trim();
+        if (rawValue.startsWith('"') && rawValue.endsWith('"')) rawValue = rawValue.slice(1, -1);
+        else if (rawValue.startsWith("'") && rawValue.endsWith("'")) rawValue = rawValue.slice(1, -1);
+        let parsedKey = toKey(rawValue);
+        if (parsedKey !== void 0) {
+          let nextKey = normalizedMap?.[parsedKey] ?? parsedKey;
+          if (key && nextKey !== key && parsedArgs[key] === void 0) parsedArgs[key] = true;
+          key = nextKey;
+          continue;
+        }
+        let parsedValue;
+        if (rawValue) try {
+          parsedValue = JSON.parse(rawValue);
+        } catch {
+          parsedValue = rawValue;
+        }
+        else parsedValue = true;
+        let prevValue = parsedArgs[key];
+        let value;
+        if (prevValue === void 0) value = key === "" ? [parsedValue] : parsedValue;
+        else if (Array.isArray(prevValue)) value = [...prevValue, parsedValue];
+        else value = [prevValue, parsedValue];
+        parsedArgs[key] = value;
+      }
+      if (key && parsedArgs[key] === void 0) parsedArgs[key] = true;
+      return parsedArgs;
+    }
+    exports.Args = Args2;
+    exports.args = args2;
+    exports.getValue = getValue;
+    exports.getValues = getValues;
+    exports.hasKey = hasKey;
+    exports.isExplicitlyOff = isExplicitlyOff;
+    exports.isKey = isKey2;
+    exports.isOff = isOff;
+    exports.isOn = isOn;
+    exports.parseArgs = parseArgs;
+  }
+});
+
+// src/run.ts
+var import_args_json = __toESM(require_dist(), 1);
+
+// src/build.ts
+import esbuild from "esbuild";
+
+// src/getDefaultEntryPoints.ts
+import { globSync } from "node:fs";
+import { sep } from "node:path";
+
+// src/toEntryPoint.ts
+function toEntryPoint(toName) {
+  return (path) => {
+    let name = toName(path);
+    if (!name) throw new Error(`Invalid entry point name: "${path}"`);
+    name = name.replace(/\.\w+$/, "");
+    return [
+      name,
+      {
+        in: path,
+        out: name
+      }
+    ];
+  };
+}
+
+// src/getDefaultEntryPoints.ts
+function getDefaultEntryPoints(dir = "entries") {
+  let entryPoints = new Map([
+    // entries/x/src/index.ts -> dist/x/index.js
+    ...globSync(`${dir}/[!_]*/src/index.{ts,tsx}`).map(
+      toEntryPoint((path) => {
+        let p = path.split(sep);
+        return `${p.at(-3)}/${p.at(-1)}`;
+      })
+    ),
+    // entries/x/index.ts -> dist/x/index.js (overrides entries/x/src/index.ts, if present)
+    // entries/x/y.ts -> dist/x/y.js
+    ...globSync(`${dir}/[!_]*/[!_]*.{ts,tsx}`).map(
+      toEntryPoint((path) => path.split(sep).slice(-2).join("/"))
+    )
+  ]);
+  return Array.from(entryPoints.values());
+}
+
+// src/build.ts
+async function build({
+  entryPoints,
+  dev,
+  dir,
+  ...options2
+} = {}) {
+  let e = entryPoints ?? getDefaultEntryPoints(dir);
+  if (Object.keys(e).length === 0) {
+    console.warn("No entry points");
+    return;
+  }
+  let buildOptions = {
+    entryPoints: e,
+    outdir: "dist",
+    bundle: true,
+    splitting: true,
+    format: "esm",
+    jsx: "automatic",
+    loader: {
+      ".png": "dataurl",
+      ".svg": "dataurl",
+      ".html": "text",
+      ".txt": "text"
+    },
+    minify: true,
+    ...options2
+  };
+  if (dev) {
+    let ctx = await esbuild.context(buildOptions);
+    await ctx.watch();
+  }
+  await esbuild.build(buildOptions);
+}
+
+// src/run.ts
+var args = new import_args_json.Args();
+var options = {
+  dev: args.hasKey("--dev"),
+  minify: !args.isExplicitlyOff("--minify")
+};
+var rawArgs = process.argv.slice(2);
+if (rawArgs.length !== 0 && !(0, import_args_json.isKey)(rawArgs[0])) options.dir = rawArgs[0];
+for (let [k, v] of Object.entries(options)) {
+  if (v === void 0) delete options[k];
+}
+build(options);

package/index.ts

@@ -0,0 +1,5 @@
+export * from "./src/BuildOptions.ts";
+export * from "./src/build.ts";
+export * from "./src/EntryPoint.ts";
+export * from "./src/getDefaultEntryPoints.ts";
+export * from "./src/toEntryPoint.ts";

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "pluribuild",
+  "version": "0.1.0",
+  "description": "Build multiple entry points into multiple output files with a single command",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "compile-bin": "esbuild src/run.ts --bundle --outfile=dist/run.mjs --platform=node --format=esm --external:esbuild",
+    "preversion": "npx npm-run-all shape compile-bin",
+    "shape": "npx codeshape",
+    "typecheck": "npx codeshape typecheck"
+  },
+  "bin": {
+    "pluribuild": "./dist/run.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/axtk/pluribuild.git"
+  },
+  "keywords": [
+    "build",
+    "entry points"
+  ],
+  "author": "axtk",
+  "license": "MIT",
+  "dependencies": {
+    "args-json": "^1.4.3",
+    "esbuild": "^0.28.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.2"
+  }
+}

package/src/BuildOptions.ts

@@ -0,0 +1,8 @@
+import type { BuildOptions as EsbuildOptions } from "esbuild";
+
+export type BuildOptions = EsbuildOptions & {
+  /** Directory containing entry points. */
+  dir?: string;
+  /** Development mode. Enables rebuilds on code changes. */
+  dev?: boolean;
+};

package/src/EntryPoint.ts

@@ -0,0 +1,4 @@
+export type EntryPoint = {
+  in: string;
+  out: string;
+};

package/src/build.ts

@@ -0,0 +1,41 @@
+import esbuild, { type BuildOptions as EsbuildOptions } from "esbuild";
+import type { BuildOptions } from "./BuildOptions.ts";
+import { getDefaultEntryPoints } from "./getDefaultEntryPoints.ts";
+
+export async function build({
+  entryPoints,
+  dev,
+  dir,
+  ...options
+}: BuildOptions = {}) {
+  let e = entryPoints ?? getDefaultEntryPoints(dir);
+
+  if (Object.keys(e).length === 0) {
+    console.warn("No entry points");
+    return;
+  }
+
+  let buildOptions: EsbuildOptions = {
+    entryPoints: e,
+    outdir: "dist",
+    bundle: true,
+    splitting: true,
+    format: "esm",
+    jsx: "automatic",
+    loader: {
+      ".png": "dataurl",
+      ".svg": "dataurl",
+      ".html": "text",
+      ".txt": "text",
+    },
+    minify: true,
+    ...options,
+  };
+
+  if (dev) {
+    let ctx = await esbuild.context(buildOptions);
+    await ctx.watch();
+  }
+
+  await esbuild.build(buildOptions);
+}

package/src/getDefaultEntryPoints.ts

@@ -0,0 +1,22 @@
+import { globSync } from "node:fs";
+import { sep } from "node:path";
+import { toEntryPoint } from "./toEntryPoint.ts";
+
+export function getDefaultEntryPoints(dir = "entries") {
+  let entryPoints = new Map([
+    // entries/x/src/index.ts -> dist/x/index.js
+    ...globSync(`${dir}/[!_]*/src/index.{ts,tsx}`).map(
+      toEntryPoint((path) => {
+        let p = path.split(sep);
+        return `${p.at(-3)}/${p.at(-1)}`;
+      }),
+    ),
+    // entries/x/index.ts -> dist/x/index.js (overrides entries/x/src/index.ts, if present)
+    // entries/x/y.ts -> dist/x/y.js
+    ...globSync(`${dir}/[!_]*/[!_]*.{ts,tsx}`).map(
+      toEntryPoint((path) => path.split(sep).slice(-2).join("/")),
+    ),
+  ]);
+
+  return Array.from(entryPoints.values());
+}

package/src/run.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { Args, isKey } from "args-json";
+import type { BuildOptions } from "./BuildOptions.ts";
+import { build } from "./build.ts";
+
+let args = new Args();
+
+let options: BuildOptions = {
+  dev: args.hasKey("--dev"),
+  minify: !args.isExplicitlyOff("--minify"),
+};
+
+let rawArgs = process.argv.slice(2);
+if (rawArgs.length !== 0 && !isKey(rawArgs[0])) options.dir = rawArgs[0];
+
+for (let [k, v] of Object.entries(options)) {
+  if (v === undefined) delete options[k as keyof BuildOptions];
+}
+
+build(options);

package/src/toEntryPoint.ts

@@ -0,0 +1,18 @@
+import type { EntryPoint } from "./EntryPoint.ts";
+
+export function toEntryPoint(toName: (path: string) => string | undefined) {
+  return (path: string): [string, EntryPoint] => {
+    let name = toName(path);
+
+    if (!name) throw new Error(`Invalid entry point name: "${path}"`);
+    name = name.replace(/\.\w+$/, "");
+
+    return [
+      name,
+      {
+        in: path,
+        out: name,
+      },
+    ];
+  };
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "include": ["./index.ts", "src"],
+  "compilerOptions": {
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "types": ["node"],
+    "target": "esnext",
+    "outDir": "dist",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true
+  }
+}