Error: Cannot find module 'env' about esbuild-envfile-plugin HOT 3 CLOSED

{
    "compilerOptions": {
        "module": "commonjs",
        "declaration": true,
        "removeComments": true,
        "emitDecoratorMetadata": true,
        "experimentalDecorators": true,
        "allowSyntheticDefaultImports": true,
        "target": "es2020",
        "sourceMap": true,
        "outDir": "./dist",
        "baseUrl": "./src",
        "incremental": true,

        "paths": {
            "app/*":        ["./*"],
            "api/*":        ["./*"],
            "lib/*":        ["./lib/*"],
            "src/*":        ["./*"],
            "exceptions/*": ["exceptions/*"],
            "filters/*":    ["filters/*"],
            "models/*":     ["models/pages/*"],
            "modules/*":    ["modules/*"],
            "utils/*":      ["./utils/*"],
        },

    },

    "ts-node": {
        "require": ["tsconfig-paths/register"]
    },

    "include": [
        "scripts",
        "src"
    ]
}

var fs = require("fs");
var path = require("path");
const dotenv = require('dotenv');
const esbuild = require('esbuild');

const NODE_ENV = (process.env.NODE_ENV || 'local');
const IS_DEV = NODE_ENV == "local";

const APP_BASE = './src';
const ENTRY_FILE = `index.js`;
const OUTPUT_DIR = './static';
const OUTPUT_FILE = 'index.js';
const TARGET = 'esnext';

console.log('build() ...');

// --------------------------------------------------------------------------------

// load in environment variables as global defines for the to use
dotenv.config({ path: `.env.${NODE_ENV}` })

const define = {};
for (const k in process.env) {
    // Bypass windows errors
    if (k === 'CommonProgramFiles(x86)' || k === 'ProgramFiles(x86)') {
        continue;
    }
    define[`process.env.${k}`] = JSON.stringify(process.env[k])
}

function build(entryFile, outFile) {
    esbuild.build({
        entryPoints: [entryFile],
        outfile: outFile,
        bundle: true,
        target: TARGET,
        logLevel: 'silent',
        loader: {},
        plugins: [copyPlugin],
        sourcemap: false,
        define
    })
        .then(r => { console.log(`Build ${entryFile} to ${outFile} succeeded.`) })
        .catch((e) => {
            console.log("Error building:", e.message);
            process.exit(1)
        })
}

let copyPlugin = {
    name: 'copy',
    setup(build) {
        const fse = require('fs-extra');

        //copy static folder to build
        let buildFile = path.resolve(`./${APP_BASE}/${ENTRY_FILE}`);
        let outFile = path.resolve(`${OUTPUT_DIR}/${OUTPUT_FILE}`);

        try {
            fse.copySync(buildFile, outFile, { overwrite: true });
            console.log(`Copied ${buildFile} to ${outFile}`);
        } catch (e) {
            console.error('error: ', e);
        }
    }
}

function mkDirSync(dir) {
    if (fs.existsSync(dir)) {
        return;
    }

    try {
        fs.mkdirSync(dir);
    } catch (err) {
        if (err.code == 'ENOENT') {
            mkdirSync(path.dirname(dir))
            mkdirSync(dir)
        }
    }
}

// make sure build directory exists
mkDirSync(OUTPUT_DIR);

build(`${APP_BASE}/${ENTRY_FILE}`, `${OUTPUT_DIR}/${OUTPUT_FILE}`);

{
    "compilerOptions": {
        "baseUrl": "./src",
        "outDir": "./build/",       // path to output directory
        "sourceMap": true,          // allow sourcemap support
        "strictNullChecks": true,   // enable strict null checks as a best practice
        "module": "commonjs",       // specifiy module code generation
        "target": "ES2018",         // specify ECMAScript target version
        "jsx": "react",             // use typescript to transpile jsx to js
        "allowJs": true,            // allow a partial TypeScript and JavaScript codebase
        "noImplicitThis": true,
        "noImplicitReturns": false,
        "noImplicitAny": false,
        "noUnusedLocals": true,
        "resolveJsonModule": true,
        "esModuleInterop": true,
        "skipLibCheck": true,

        // Not sure if either of these are necessary:
        "experimentalDecorators": true,
        "forceConsistentCasingInFileNames": true,

        "paths": {
            "app/*":        ["./*"],
            "src/*":        ["./*"],
            "components/*": ["components/*"],
            "pages/*":      ["components/pages/*"],
            "lib/*":        ["lib/*"],
            "models/*":     ["lib/models/*"],
            "utils/*":      ["lib/utils/*"],
            "services/*":   ["lib/services/*"],
            "stores/*":     ["lib/stores/*"],
            "style/*":      ["src/styles/*"],
            "static/*":     ["../static/*"],
            "shared/*":     ["../../shared/*"],
            "admin/*":      ["admin/*"]
        },
        "lib": [
            "dom",
            "dom.iterable",
            "esnext"
        ]
    },
    "include": [
        "./**/*",
        "../../shared/**/*",
        "../static/**/*"
    ],
    "exclude": [
        "../node_modules/**/*",
        "../build/*",
        "./styles/ng.reference/**/*"
    ]

}

var fs = require("fs");
var path = require("path");
const autoprefixer = require("autoprefixer");
const postCssPlugin = require("@deanc/esbuild-plugin-postcss");
const esbuild = require('esbuild');
const dotenv = require('dotenv');
const { mkDirSync } = require("./utils/fileUtils");
const { getNormalizedEnvVars } = require("./utils/envUtils");

// Config params (relative to where npm/script is called from):
const APP_BASE = './src';
const ENTRY_FILE = `index.jsx`;
const OUTPUT_DIR = './build';
const OUTPUT_FILE = 'app.js';
const TARGET = 'es2018';
const IS_DEV = process.env.NODE_ENV != 'production';
const NODE_ENV = (process.env.NODE_ENV || 'local');

dotenv.config({ path: `.env.${NODE_ENV}` })
const { define, defineNoQuotes } = getNormalizedEnvVars();

console.log('build.js node environment detected as: ' + NODE_ENV);

///////////////////////////////////////////////////////////////////////////////

function build(entryFile, outFile) {
    console.log('build() called:', entryFile, outFile);

    // make sure build directory existsSync
    mkDirSync(OUTPUT_DIR);

    esbuild.build({
        entryPoints: [entryFile],
        outfile: outFile,
        bundle: true,
        target: TARGET,
        logLevel: 'info',
        loader: { // built-in loaders: js, jsx, ts, tsx, css, json, text, base64, dataurl, file, binary
            '.ttf': 'file',
            '.otf': 'file',
            '.png': 'file',
            '.svg': 'file'
        },
        assetNames: 'static/[name].[hash]',
        plugins: [scssPlugin, copyPlugin, postCssPlugin({ plugins: [autoprefixer] })],
        sourcemap: IS_DEV ? true : false,
        define
    })
        .then(r => { console.log(`Build ${entryFile} to ${outFile} succeeded.`) })
        .catch((e) => {
            console.log("Error building:", e.message);
            process.exit(1)
        })
}

let scssPlugin = {
    name: 'scss',
    setup(build) {
        const fs = require('fs');
        const sass = require('node-sass');
        const path = require('path');
        //const aliasImporter = require("node-sass-alias-importer");

        build.onLoad({ filter: /\.(scss)$/ }, async (args) => {
            let filePath = path.resolve(args.path);
            let data = await fs.promises.readFile(filePath, 'utf8')
            let contents = '';
            try {
                if (data) {
                    let result = sass.renderSync({
                        data,
                        //includePaths: [], // todo: dynamically add global imports??
                        sourceComments: true,
                        sourceMap: true,
                        // importer: [
                        //     aliasImporter({
                        //       app: "./src",
                        //       styles: "./src/styles"
                        //     })
                        // ]
                    });
                    contents = result.css;
                }
                return {
                    contents: contents,
                    loader: 'css'
                };
            } catch (e) {
                throw new Error("\n\nError rendering SCSS file:\n  " + filePath + " => \n\n" + e.formatted);//, { path: filePath });
            }
        })
    }
};

let copyPlugin = {
    name: 'copy',
    setup(build) {
        const fse = require('fs-extra');

        // copy static folder to build.
        try {
            fse.copySync(path.resolve('./static'), path.resolve(`${OUTPUT_DIR}/static`), { overwrite: true });;
        } catch (e) {
            console.error('error: ', e);
        }
    }
}

build(`${APP_BASE}/${ENTRY_FILE}`, `${OUTPUT_DIR}/${OUTPUT_FILE}`);