fodec 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Kris Papercut
+
+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,31 @@
+# Fodec
+
+## Installation
+
+```shell
+npm install -g fodec
+```
+
+## Initialization
+
+This command generates a `fodec.json` file. You can further edit this file and add elements to the `resources` array.
+
+```shell
+fodec init
+```
+
+## Key generation
+
+This command generates a `fodec.key` file for your project.
+
+```shell
+fodec gen
+```
+
+## Build
+
+This command performs a build based on the provided `fodec.json` and `fodec.key` files. The build process takes the specifications and keys defined in these files to build the final output.
+
+```shell
+fodec build
+```

package/bin/fodec.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+const {app} = require("../lib/cli/index.js");
+
+app.run().then((res) => {
+    if(!res) {
+        return;
+    }
+
+    process.stdout.write(res);
+    process.stdout.write("\n");
+}).catch((err) => {
+    process.stderr.write(err.message);
+});

package/lib/Fodec.d.ts

@@ -0,0 +1,8 @@
+export declare class Fodec {
+    protected key: string;
+    constructor(key: string);
+    transformText(str: string): string;
+    transformJson(data: any): Promise<any>;
+    transformFont(fontPath: string): Promise<string | ArrayBuffer | undefined>;
+    transformFontV1(fontPath: string): Promise<string | ArrayBuffer | undefined>;
+}

package/lib/Fodec.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fodec = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const fonteditor_core_1 = require("fonteditor-core");
+class Fodec {
+    constructor(key) {
+        this.key = key;
+    }
+    transformText(str) {
+        return str.split("").map((char) => {
+            const index = this.key.indexOf(char);
+            return index !== -1 ? this.key.charAt(index + 1 + (this.key.length - 1) / 2) : char;
+        }).join("");
+    }
+    async transformJson(data) {
+        return data;
+    }
+    async transformFont(fontPath) {
+        return this.transformFontV1(fontPath);
+    }
+    async transformFontV1(fontPath) {
+        const ext = path_1.default.extname(fontPath).slice(1);
+        if (ext !== "ttf") {
+            return;
+        }
+        const font = fonteditor_core_1.Font.create(await fs_1.promises.readFile(fontPath), {
+            type: ext
+        });
+        const { glyf: list, } = font.get();
+        const glyphs = [];
+        for (let i = 0; i < list.length; i++) {
+            const glyph = list[i];
+            const char = glyph.unicode
+                ? String.fromCharCode(glyph.unicode[0])
+                : null;
+            if (!char) {
+                glyphs.push(glyph);
+                continue;
+            }
+            if (this.key.indexOf(char) === -1) {
+                glyphs.push(glyph);
+                continue;
+            }
+            const index = this.key.indexOf(char);
+            const transformUnicode = this.key.charCodeAt((this.key.length - 1) / 2 + 1 + index);
+            const rand = list.find((item) => {
+                if (!item.unicode) {
+                    return;
+                }
+                return item.unicode[0] === transformUnicode;
+            });
+            if (!rand) {
+                glyphs.push(glyph);
+                continue;
+            }
+            glyphs.push({
+                ...glyph,
+                name: rand.name,
+                unicode: rand.unicode
+            });
+        }
+        font.set({
+            ...font.get(),
+            glyf: glyphs
+        });
+        return font.write({
+            type: ext
+        });
+    }
+}
+exports.Fodec = Fodec;

package/lib/cli/App.d.ts

@@ -0,0 +1,12 @@
+import { Cli } from "@kearisp/cli";
+import { Config } from "../types/Config";
+export declare class App {
+    protected cli: Cli;
+    constructor();
+    protected getConfig(): Promise<Config>;
+    protected getKey(): Promise<string>;
+    init(): Promise<void>;
+    generate(): Promise<void>;
+    build(): Promise<void>;
+    run(): Promise<any>;
+}

package/lib/cli/App.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+const cli_1 = require("@kearisp/cli");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@wocker/utils");
+const Fodec_1 = require("../Fodec");
+const generateKey_1 = require("../utils/generateKey");
+class App {
+    constructor() {
+        this.cli = new cli_1.Cli();
+        this.cli.command("init")
+            .action(() => this.init());
+        this.cli.command("gen")
+            .action(() => this.generate());
+        this.cli.command("build")
+            .action(() => this.build());
+    }
+    async getConfig() {
+        const configPath = "fodec.json";
+        if (!(0, fs_1.existsSync)(configPath)) {
+            throw new Error("Config not found");
+        }
+        const res = await fs_1.promises.readFile(configPath);
+        return JSON.parse(res.toString());
+    }
+    async getKey() {
+        const res = await fs_1.promises.readFile("fodec.key");
+        return res.toString();
+    }
+    async init() {
+        const configPath = "./fodec-2.json";
+        if ((0, fs_1.existsSync)(configPath)) {
+            throw new Error("Config already exists");
+        }
+        let config = {};
+        config.basePath = await (0, utils_1.promptText)({
+            required: true,
+            type: "string",
+            message: "Base Path:",
+            default: "src"
+        });
+        config.output = {
+            path: await (0, utils_1.promptText)({
+                required: true,
+                type: "string",
+                message: "Output path:",
+                default: "build"
+            })
+        };
+        config.alphabets = await (0, utils_1.promptSelect)({
+            multiple: true,
+            options: [
+                "cyrillic",
+                "latin"
+            ]
+        });
+        config.resources = [];
+        await fs_1.promises.writeFile(configPath, JSON.stringify(config, null, 4));
+    }
+    async generate() {
+        const { alphabets } = await this.getConfig();
+        const key = (0, generateKey_1.generateKey)({
+            alphabets
+        });
+        console.log(key);
+        await fs_1.promises.writeFile("fodec.key", key);
+    }
+    async build() {
+        const key = await this.getKey();
+        const { basePath = "./", output: { path: outPath = "./build" } = {}, fonts, resources } = await this.getConfig();
+        const fodec = new Fodec_1.Fodec(key);
+        for (const resource of resources) {
+            let res;
+            if (resource.type === "font") {
+                const transformedFont = await fodec.transformFont(path_1.default.join(basePath, resource.path));
+                if (!transformedFont || transformedFont instanceof ArrayBuffer) {
+                    continue;
+                }
+                res = transformedFont;
+            }
+            else if (resource.type === "json") {
+                const json = await fs_1.promises.readFile(path_1.default.join(basePath, resource.path));
+                const data = JSON.parse(json.toString());
+                res = JSON.stringify(data, (key, value) => {
+                    if (typeof value === "string") {
+                        return fodec.transformText(value);
+                    }
+                    return value;
+                }, 4);
+            }
+            if (res) {
+                const outFullPath = path_1.default.join(outPath, path_1.default.dirname(resource.output || resource.path));
+                (0, fs_1.mkdirSync)(outFullPath, {
+                    recursive: true
+                });
+                await fs_1.promises.writeFile(path_1.default.join(outPath, resource.output || resource.path), res);
+            }
+        }
+    }
+    async run() {
+        return this.cli.run(process.argv);
+    }
+}
+exports.App = App;

package/lib/cli/index.d.ts

@@ -0,0 +1,2 @@
+import { App } from "./App";
+export declare const app: App;

package/lib/cli/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.app = void 0;
+const App_1 = require("./App");
+exports.app = new App_1.App();

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { Fodec } from "./Fodec";

package/lib/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fodec = void 0;
+var Fodec_1 = require("./Fodec");
+Object.defineProperty(exports, "Fodec", { enumerable: true, get: function () { return Fodec_1.Fodec; } });

package/lib/types/Config.d.ts

@@ -0,0 +1,26 @@
+import { AlphabetType } from "./MapAlphabets";
+export type Config = {
+    basePath?: string;
+    output?: {
+        path: string;
+    };
+    alphabets: AlphabetType[];
+    fonts: {
+        name: string;
+        path: string;
+    }[];
+    resources: (FontResource | JsonResource)[];
+};
+type FontResource = {
+    type: "font";
+    format: string;
+    name: string;
+    path: string;
+    output?: string;
+};
+type JsonResource = {
+    type: "json";
+    path: string;
+    output?: string;
+};
+export {};

package/lib/types/Config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/MapAlphabets.d.ts

@@ -0,0 +1,27 @@
+export declare const MapAlphabets: {
+    latin: {
+        lowerStart: number;
+        lowerLength: number;
+        upperStart: number;
+        upperLength: number;
+    };
+    cyrillic: {
+        lowerStart: number;
+        lowerLength: number;
+        upperStart: number;
+        upperLength: number;
+    };
+    arabic: {
+        lowerStart: number;
+        lowerLength: number;
+        upperStart: number;
+        upperLength: number;
+    };
+    greek: {
+        lowerStart: number;
+        lowerLength: number;
+        upperStart: number;
+        upperLength: number;
+    };
+};
+export type AlphabetType = keyof typeof MapAlphabets;

package/lib/types/MapAlphabets.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapAlphabets = void 0;
+exports.MapAlphabets = {
+    latin: {
+        lowerStart: 0x61,
+        lowerLength: 26,
+        upperStart: 0x41,
+        upperLength: 26
+    },
+    cyrillic: {
+        lowerStart: 0x430,
+        lowerLength: 32,
+        upperStart: 0x410,
+        upperLength: 32
+    },
+    arabic: {
+        lowerStart: 0x0620,
+        lowerLength: 36,
+        upperStart: 0x0620,
+        upperLength: 36
+    },
+    greek: {
+        lowerStart: 0x03B1,
+        lowerLength: 25,
+        upperStart: 0x0391,
+        upperLength: 25
+    }
+};

package/lib/utils/generateKey.d.ts

@@ -0,0 +1,6 @@
+import { AlphabetType } from "../types/MapAlphabets";
+type Options = {
+    alphabets: AlphabetType[];
+};
+export declare const generateKey: (options: Options) => string;
+export {};

package/lib/utils/generateKey.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateKey = void 0;
+const shuffle_1 = require("./shuffle");
+const MapAlphabets_1 = require("../types/MapAlphabets");
+const generateKey = (options) => {
+    const { alphabets } = options;
+    return Object.keys(MapAlphabets_1.MapAlphabets).reduce((res, key) => {
+        if (!alphabets.includes(key)) {
+            return res;
+        }
+        const { lowerStart, lowerLength, upperStart, upperLength } = MapAlphabets_1.MapAlphabets[key];
+        const indexes = [
+            ...Array.from({ length: lowerLength }, (_, i) => lowerStart + i),
+            ...Array.from({ length: upperLength }, (_, i) => upperStart + i)
+        ];
+        const moved = indexes.slice();
+        (0, shuffle_1.shuffle)(moved);
+        return [
+            res[0] + String.fromCharCode(...indexes),
+            res[1] + String.fromCharCode(...moved)
+        ];
+    }, ["", ""]).join("\n");
+};
+exports.generateKey = generateKey;

package/lib/utils/shuffle.d.ts

@@ -0,0 +1 @@
+export declare const shuffle: (arr: unknown[]) => void;

package/lib/utils/shuffle.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shuffle = void 0;
+const shuffle = (arr) => {
+    for (let i = arr.length - 1; i > 0; i--) {
+        let j = Math.floor(Math.random() * (i + 1));
+        [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+};
+exports.shuffle = shuffle;

package/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "fodec",
+    "version": "1.0.0",
+    "author": "Kris Papercut <krispcut@gmail.com>",
+    "description": "",
+    "license": "MIT",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "directories": {
+        "cli": "./lib/cli"
+    },
+    "bin": {
+        "fodec": "./bin/fodec.js"
+    },
+    "scripts": {
+        "prepare": "npm run build",
+        "build": "tsc --build",
+        "watch": "tsc --watch",
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "homepage": "https://github.com/kearisp/fodec#readme",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/kearisp/fodec.git"
+    },
+    "bugs": {
+        "url": "https://github.com/kearisp/fodec/issues"
+    },
+    "dependencies": {
+        "@kearisp/cli": "^1.0.4",
+        "@wocker/utils": "^1.0.2",
+        "fonteditor-core": "^2.3.2",
+        "fs": "^0.0.1-security",
+        "path": "^0.12.7"
+    },
+    "devDependencies": {
+        "@types/node": "^20.11.5",
+        "typescript": "^5.3.3"
+    }
+}

package/src/Fodec.ts

@@ -0,0 +1,89 @@
+import Path from "path";
+import {promises as FS} from "fs";
+import {Font, TTF} from "fonteditor-core";
+
+
+export class Fodec {
+    public constructor(
+        protected key: string
+    ) {}
+
+    public transformText(str: string): string {
+        return str.split("").map((char) => {
+            const index = this.key.indexOf(char);
+
+            return index !== -1 ? this.key.charAt(index + 1 + (this.key.length - 1) / 2) : char;
+        }).join("");
+    }
+
+    public async transformJson(data: any) {
+        return data;
+    }
+
+    public async transformFont(fontPath: string) {
+        return this.transformFontV1(fontPath);
+    }
+
+    public async transformFontV1(fontPath: string) {
+        const ext = Path.extname(fontPath).slice(1);
+
+        if(ext !== "ttf") {
+            return;
+        }
+
+        const font = Font.create(await FS.readFile(fontPath), {
+            type: ext
+        });
+
+        const {glyf: list,} = font.get();
+        const glyphs: TTF.Glyph[] = [];
+
+        for(let i = 0; i < list.length; i++) {
+            const glyph = list[i];
+            const char = glyph.unicode
+                ? String.fromCharCode(glyph.unicode[0])
+                : null;
+
+            if(!char) {
+                glyphs.push(glyph);
+                continue;
+            }
+
+            if(this.key.indexOf(char) === -1) {
+                glyphs.push(glyph);
+                continue;
+            }
+
+            const index = this.key.indexOf(char);
+            const transformUnicode = this.key.charCodeAt((this.key.length - 1) / 2 + 1 + index);
+
+            const rand = list.find((item) => {
+                if(!item.unicode) {
+                    return;
+                }
+
+                return item.unicode[0] === transformUnicode;
+            });
+
+            if(!rand) {
+                glyphs.push(glyph);
+                continue;
+            }
+
+            glyphs.push({
+                ...glyph,
+                name: rand.name,
+                unicode: rand.unicode
+            });
+        }
+
+        font.set({
+            ...font.get(),
+            glyf: glyphs
+        });
+
+        return font.write({
+            type: ext
+        });
+    }
+}

package/src/cli/App.ts

@@ -0,0 +1,155 @@
+import {Cli} from "@kearisp/cli";
+import {promises as FS, existsSync, mkdirSync} from "fs";
+import Path from "path";
+import {promptText, promptSelect} from "@wocker/utils";
+import {Fodec} from "../Fodec";
+import {generateKey} from "../utils/generateKey";
+import {Config} from "../types/Config";
+
+
+export class App {
+    protected cli: Cli;
+
+    public constructor() {
+        this.cli = new Cli();
+
+        this.cli.command("init")
+            .action(() => this.init());
+
+        this.cli.command("gen")
+            .action(() => this.generate());
+
+        this.cli.command("build")
+            .action(() => this.build());
+    }
+
+    protected async getConfig(): Promise<Config> {
+        const configPath = "fodec.json";
+
+        if(!existsSync(configPath)) {
+            throw new Error("Config not found");
+        }
+
+        const res = await FS.readFile(configPath);
+
+        return JSON.parse(res.toString());
+    }
+
+    protected async getKey(): Promise<string> {
+        const res = await FS.readFile("fodec.key");
+
+        return res.toString();
+    }
+
+    public async init() {
+        const configPath = "./fodec-2.json";
+
+        if(existsSync(configPath)) {
+            throw new Error("Config already exists");
+        }
+
+        let config: Config = {} as Config;
+
+        config.basePath = await promptText({
+            required: true,
+            type: "string",
+            message: "Base Path:",
+            default: "src"
+        });
+
+        config.output = {
+            path: await promptText({
+                required: true,
+                type: "string",
+                message: "Output path:",
+                default: "build"
+            })
+        };
+
+        config.alphabets = await promptSelect({
+            multiple: true,
+            options: [
+                "cyrillic",
+                "latin"
+            ]
+        }) as Config["alphabets"];
+
+        config.resources = [];
+
+        await FS.writeFile(configPath, JSON.stringify(config, null, 4));
+    }
+
+    public async generate() {
+        const {alphabets} = await this.getConfig();
+
+        const key = generateKey({
+            alphabets
+        });
+
+        console.log(key);
+
+        await FS.writeFile("fodec.key", key);
+    }
+
+    public async build(): Promise<void> {
+        const key = await this.getKey();
+        const {
+            basePath = "./",
+            output: {
+                path: outPath = "./build"
+            } = {},
+            fonts,
+            resources
+        } = await this.getConfig();
+
+        const fodec = new Fodec(key);
+
+        for(const resource of resources) {
+            let res: any;
+
+            if(resource.type === "font") {
+                const transformedFont = await fodec.transformFont(
+                    Path.join(basePath, resource.path)
+                );
+
+                if(!transformedFont || transformedFont instanceof ArrayBuffer) {
+                    continue;
+                }
+
+                res = transformedFont;
+            }
+            else if(resource.type === "json") {
+                const json = await FS.readFile(
+                    Path.join(basePath, resource.path)
+                );
+
+                const data = JSON.parse(json.toString());
+
+                res = JSON.stringify(data, (key, value) => {
+                    if(typeof value === "string") {
+                        return fodec.transformText(value);
+                    }
+
+                    return value;
+                }, 4);
+            }
+
+            if(res) {
+                const outFullPath = Path.join(outPath, Path.dirname(resource.output || resource.path));
+
+                mkdirSync(outFullPath, {
+                    recursive: true
+                });
+
+                await FS.writeFile(
+                    Path.join(outPath, resource.output || resource.path),
+                    res
+                );
+            }
+        }
+    }
+
+    public async run() {
+        return this.cli.run(process.argv);
+    }
+}

package/src/cli/index.ts

@@ -0,0 +1,4 @@
+import {App} from "./App";
+
+
+export const app = new App();

package/src/index.ts

@@ -0,0 +1 @@
+export {Fodec} from "./Fodec";

package/src/types/Config.ts

@@ -0,0 +1,28 @@
+import {AlphabetType} from "./MapAlphabets";
+
+export type Config = {
+    basePath?: string;
+    output?: {
+        path: string;
+    };
+    alphabets: AlphabetType[];
+    fonts: {
+        name: string;
+        path: string;
+    }[];
+    resources: (FontResource | JsonResource)[];
+};
+
+type FontResource = {
+    type: "font",
+    format: string;
+    name: string;
+    path: string;
+    output?: string;
+};
+
+type JsonResource = {
+    type: "json",
+    path: string;
+    output?: string;
+};

package/src/types/MapAlphabets.ts

@@ -0,0 +1,28 @@
+export const MapAlphabets = {
+    latin: {
+        lowerStart: 0x61,
+        lowerLength: 26,
+        upperStart: 0x41,
+        upperLength: 26
+    },
+    cyrillic: {
+        lowerStart: 0x430,
+        lowerLength: 32,
+        upperStart: 0x410,
+        upperLength: 32
+    },
+    arabic: {
+        lowerStart: 0x0620,
+        lowerLength: 36,
+        upperStart: 0x0620,
+        upperLength: 36
+    },
+    greek: {
+        lowerStart: 0x03B1,
+        lowerLength: 25,
+        upperStart: 0x0391,
+        upperLength: 25
+    }
+};
+
+export type AlphabetType = keyof typeof MapAlphabets;

package/src/utils/generateKey.ts

@@ -0,0 +1,39 @@
+import {shuffle} from "./shuffle";
+import {MapAlphabets, AlphabetType} from "../types/MapAlphabets";
+
+
+type Options = {
+    alphabets: AlphabetType[];
+};
+
+export const generateKey = (options: Options): string => {
+    const {
+        alphabets
+    } = options;
+
+    return Object.keys(MapAlphabets).reduce((res: string[], key: string) => {
+        if(!alphabets.includes(key as AlphabetType)) {
+            return res;
+        }
+
+        const {
+            lowerStart,
+            lowerLength,
+            upperStart,
+            upperLength
+        } = MapAlphabets[key];
+
+        const indexes = [
+            ...Array.from({length: lowerLength}, (_, i) => lowerStart + i),
+            ...Array.from({length: upperLength}, (_, i) => upperStart + i)
+        ];
+        const moved = indexes.slice();
+
+        shuffle(moved);
+
+        return [
+            res[0] + String.fromCharCode(...indexes),
+            res[1] + String.fromCharCode(...moved)
+        ];
+    }, ["", ""]).join("\n");
+};

package/src/utils/shuffle.ts

@@ -0,0 +1,7 @@
+export const shuffle = (arr: unknown[]) => {
+    for(let i = arr.length - 1; i > 0; i--) {
+        let j = Math.floor(Math.random() * (i + 1));
+
+        [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+};

package/tsconfig.json

@@ -0,0 +1,37 @@
+{
+    "compilerOptions": {
+        "allowJs": true,
+        "allowSyntheticDefaultImports": true,
+        "baseUrl": ".",
+        "declaration": true,
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "isolatedModules": true,
+        "lib": [
+            "dom",
+            "dom.iterable",
+            "esnext"
+        ],
+        "module": "CommonJS",
+        "moduleResolution": "node",
+        "noEmit": false,
+        "noFallthroughCasesInSwitch": true,
+        "noImplicitAny": false,
+        "outDir": "./lib",
+        "resolveJsonModule": true,
+        "skipLibCheck": true,
+        "strict": true,
+        "target": "ES2020",
+        "typeRoots": [
+            "./node_modules/@types"
+        ]
+    },
+    "exclude": [
+        "node_modules",
+        "lib",
+        "./**/__tests__/*"
+    ],
+    "include": [
+        "src/**/*"
+    ]
+}