@rsbuild/core 1.0.0 → 1.0.1-beta.0

package/compiled/css-loader/license

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+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/compiled/css-loader/noSourceMaps.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function (i) {
+  return i[1];
+};

package/compiled/css-loader/package.json

@@ -0,0 +1 @@
+{"name":"css-loader","author":"Tobias Koppers @sokra","version":"7.1.2","funding":{"type":"opencollective","url":"https://opencollective.com/webpack"},"license":"MIT","types":"index.d.ts","type":"commonjs"}

package/compiled/css-loader/semver.js

@@ -0,0 +1 @@
+module.exports.satisfies = () => true;

package/compiled/css-loader/sourceMaps.js

@@ -0,0 +1,16 @@
+"use strict";
+
+module.exports = function (item) {
+  var content = item[1];
+  var cssMapping = item[3];
+  if (!cssMapping) {
+    return content;
+  }
+  if (typeof btoa === "function") {
+    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));
+    var data = "sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(base64);
+    var sourceMapping = "/*# ".concat(data, " */");
+    return [content].concat([sourceMapping]).join("\n");
+  }
+  return [content].join("\n");
+};

package/compiled/dotenv/{lib/main.d.ts → index.d.ts}

@@ -1,33 +1,36 @@
-// TypeScript Version: 3.0
 /// <reference types="node" />
-import type { URL } from 'node:url';
+import { URL } from 'url';
+
+// TypeScript Version: 3.0
+
 
-export interface DotenvParseOutput {
+interface DotenvParseOutput {
   [name: string]: string;
 }
 
 /**
  * Parses a string or buffer in the .env file format into an object.
  *
- * See https://docs.dotenv.org
+ * See https://dotenvx.com/docs
  *
  * @param src - contents to be parsed. example: `'DB_HOST=localhost'`
- * @param options - additional options. example: `{ debug: true }`
  * @returns an object with keys and values based on `src`. example: `{ DB_HOST : 'localhost' }`
  */
-export function parse<T extends DotenvParseOutput = DotenvParseOutput>(
+declare function parse<T extends DotenvParseOutput = DotenvParseOutput>(
   src: string | Buffer
 ): T;
 
-export interface DotenvConfigOptions {
+interface DotenvConfigOptions {
   /**
    * Default: `path.resolve(process.cwd(), '.env')`
    *
    * Specify a custom path if your file containing environment variables is located elsewhere.
+   * Can also be an array of strings, specifying multiple paths.
    *
    * example: `require('dotenv').config({ path: '/custom/path/to/.env' })`
+   * example: `require('dotenv').config({ path: ['/path/to/first.env', '/path/to/second.env'] })`
    */
-  path?: string | URL;
+  path?: string | string[] | URL;
 
   /**
    * Default: `utf8`
@@ -70,17 +73,17 @@ export interface DotenvConfigOptions {
    *
    * Pass the DOTENV_KEY directly to config options. Defaults to looking for process.env.DOTENV_KEY environment variable. Note this only applies to decrypting .env.vault files. If passed as null or undefined, or not passed at all, dotenv falls back to its traditional job of parsing a .env file.
    *
-   * example: `require('dotenv').config({ DOTENV_KEY: 'dotenv://:key_1234…@dotenv.org/vault/.env.vault?environment=production' })`
+   * example: `require('dotenv').config({ DOTENV_KEY: 'dotenv://:key_1234…@dotenvx.com/vault/.env.vault?environment=production' })`
    */
   DOTENV_KEY?: string;
 }
 
-export interface DotenvConfigOutput {
+interface DotenvConfigOutput {
   error?: Error;
   parsed?: DotenvParseOutput;
 }
 
-export interface DotenvPopulateOptions {
+interface DotenvPopulateOptions {
   /**
    * Default: `false`
    *
@@ -100,40 +103,36 @@ export interface DotenvPopulateOptions {
   override?: boolean;
 }
 
-export interface DotenvPopulateOutput {
-  error?: Error;
-}
-
-export interface DotenvPopulateInput {
+interface DotenvPopulateInput {
   [name: string]: string;
 }
 
 /**
  * Loads `.env` file contents into process.env by default. If `DOTENV_KEY` is present, it smartly attempts to load encrypted `.env.vault` file contents into process.env.
  *
- * See https://docs.dotenv.org
+ * See https://dotenvx.com/docs
  *
  * @param options - additional options. example: `{ path: './custom/path', encoding: 'latin1', debug: true, override: false }`
  * @returns an object with a `parsed` key if successful or `error` key if an error occurred. example: { parsed: { KEY: 'value' } }
  *
  */
-export function config(options?: DotenvConfigOptions): DotenvConfigOutput;
+declare function config(options?: DotenvConfigOptions): DotenvConfigOutput;
 
 /**
  * Loads `.env` file contents into process.env.
  *
- * See https://docs.dotenv.org
+ * See https://dotenvx.com/docs
  *
  * @param options - additional options. example: `{ path: './custom/path', encoding: 'latin1', debug: true, override: false }`
  * @returns an object with a `parsed` key if successful or `error` key if an error occurred. example: { parsed: { KEY: 'value' } }
  *
  */
-export function configDotenv(options?: DotenvConfigOptions): DotenvConfigOutput;
+declare function configDotenv(options?: DotenvConfigOptions): DotenvConfigOutput;
 
 /**
  * Loads `source` json contents into `target` like process.env.
  *
- * See https://docs.dotenv.org
+ * See https://dotenvx.com/docs
  *
  * @param processEnv - the target JSON object. in most cases use process.env but you can also pass your own JSON object
  * @param parsed - the source JSON object
@@ -141,16 +140,18 @@ export function configDotenv(options?: DotenvConfigOptions): DotenvConfigOutput;
  * @returns {void}
  *
  */
-export function populate(processEnv: DotenvPopulateInput, parsed: DotenvPopulateInput, options?: DotenvConfigOptions): DotenvPopulateOutput;
+declare function populate(processEnv: DotenvPopulateInput, parsed: DotenvPopulateInput, options?: DotenvConfigOptions): void;
 
 /**
  * Decrypt ciphertext
  *
- * See https://docs.dotenv.org
+ * See https://dotenvx.com/docs
  *
  * @param encrypted - the encrypted ciphertext string
  * @param keyStr - the decryption key string
  * @returns {string}
  *
  */
-export function decrypt(encrypted: string, keyStr: string): string;
+declare function decrypt(encrypted: string, keyStr: string): string;
+
+export { type DotenvConfigOptions, type DotenvConfigOutput, type DotenvParseOutput, type DotenvPopulateInput, type DotenvPopulateOptions, config, configDotenv, decrypt, parse, populate };

package/compiled/dotenv/index.js

@@ -1 +1,336 @@
-(()=>{var e={194:(e,t,r)=>{const o=r(147);const n=r(17);const s=r(37);const c=r(113);const a=r(684);const i=a.version;const u=/(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;function parse(e){const t={};let r=e.toString();r=r.replace(/\r\n?/gm,"\n");let o;while((o=u.exec(r))!=null){const e=o[1];let r=o[2]||"";r=r.trim();const n=r[0];r=r.replace(/^(['"`])([\s\S]*)\1$/gm,"$2");if(n==='"'){r=r.replace(/\\n/g,"\n");r=r.replace(/\\r/g,"\r")}t[e]=r}return t}function _parseVault(e){const t=_vaultPath(e);const r=l.configDotenv({path:t});if(!r.parsed){throw new Error(`MISSING_DATA: Cannot parse ${t} for an unknown reason`)}const o=_dotenvKey(e).split(",");const n=o.length;let s;for(let e=0;e<n;e++){try{const t=o[e].trim();const n=_instructions(r,t);s=l.decrypt(n.ciphertext,n.key);break}catch(t){if(e+1>=n){throw t}}}return l.parse(s)}function _log(e){console.log(`[dotenv@${i}][INFO] ${e}`)}function _warn(e){console.log(`[dotenv@${i}][WARN] ${e}`)}function _debug(e){console.log(`[dotenv@${i}][DEBUG] ${e}`)}function _dotenvKey(e){if(e&&e.DOTENV_KEY&&e.DOTENV_KEY.length>0){return e.DOTENV_KEY}if(process.env.DOTENV_KEY&&process.env.DOTENV_KEY.length>0){return process.env.DOTENV_KEY}return""}function _instructions(e,t){let r;try{r=new URL(t)}catch(e){if(e.code==="ERR_INVALID_URL"){throw new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenv.org/vault/.env.vault?environment=development")}throw e}const o=r.password;if(!o){throw new Error("INVALID_DOTENV_KEY: Missing key part")}const n=r.searchParams.get("environment");if(!n){throw new Error("INVALID_DOTENV_KEY: Missing environment part")}const s=`DOTENV_VAULT_${n.toUpperCase()}`;const c=e.parsed[s];if(!c){throw new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${s} in your .env.vault file.`)}return{ciphertext:c,key:o}}function _vaultPath(e){let t=n.resolve(process.cwd(),".env");if(e&&e.path&&e.path.length>0){t=e.path}return t.endsWith(".vault")?t:`${t}.vault`}function _resolveHome(e){return e[0]==="~"?n.join(s.homedir(),e.slice(1)):e}function _configVault(e){_log("Loading env from encrypted .env.vault");const t=l._parseVault(e);let r=process.env;if(e&&e.processEnv!=null){r=e.processEnv}l.populate(r,t,e);return{parsed:t}}function configDotenv(e){let t=n.resolve(process.cwd(),".env");let r="utf8";const s=Boolean(e&&e.debug);if(e){if(e.path!=null){t=_resolveHome(e.path)}if(e.encoding!=null){r=e.encoding}}try{const n=l.parse(o.readFileSync(t,{encoding:r}));let s=process.env;if(e&&e.processEnv!=null){s=e.processEnv}l.populate(s,n,e);return{parsed:n}}catch(e){if(s){_debug(`Failed to load ${t} ${e.message}`)}return{error:e}}}function config(e){const t=_vaultPath(e);if(_dotenvKey(e).length===0){return l.configDotenv(e)}if(!o.existsSync(t)){_warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${t}. Did you forget to build it?`);return l.configDotenv(e)}return l._configVault(e)}function decrypt(e,t){const r=Buffer.from(t.slice(-64),"hex");let o=Buffer.from(e,"base64");const n=o.slice(0,12);const s=o.slice(-16);o=o.slice(12,-16);try{const e=c.createDecipheriv("aes-256-gcm",r,n);e.setAuthTag(s);return`${e.update(o)}${e.final()}`}catch(e){const t=e instanceof RangeError;const r=e.message==="Invalid key length";const o=e.message==="Unsupported state or unable to authenticate data";if(t||r){const e="INVALID_DOTENV_KEY: It must be 64 characters long (or more)";throw new Error(e)}else if(o){const e="DECRYPTION_FAILED: Please check your DOTENV_KEY";throw new Error(e)}else{console.error("Error: ",e.code);console.error("Error: ",e.message);throw e}}}function populate(e,t,r={}){const o=Boolean(r&&r.debug);const n=Boolean(r&&r.override);if(typeof t!=="object"){throw new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate")}for(const r of Object.keys(t)){if(Object.prototype.hasOwnProperty.call(e,r)){if(n===true){e[r]=t[r]}if(o){if(n===true){_debug(`"${r}" is already defined and WAS overwritten`)}else{_debug(`"${r}" is already defined and was NOT overwritten`)}}}else{e[r]=t[r]}}}const l={configDotenv:configDotenv,_configVault:_configVault,_parseVault:_parseVault,config:config,decrypt:decrypt,parse:parse,populate:populate};e.exports.configDotenv=l.configDotenv;e.exports._configVault=l._configVault;e.exports._parseVault=l._parseVault;e.exports.config=l.config;e.exports.decrypt=l.decrypt;e.exports.parse=l.parse;e.exports.populate=l.populate;e.exports=l},684:e=>{"use strict";e.exports=require("./package.json")},113:e=>{"use strict";e.exports=require("crypto")},147:e=>{"use strict";e.exports=require("fs")},37:e=>{"use strict";e.exports=require("os")},17:e=>{"use strict";e.exports=require("path")}};var t={};function __nccwpck_require__(r){var o=t[r];if(o!==undefined){return o.exports}var n=t[r]={exports:{}};var s=true;try{e[r](n,n.exports,__nccwpck_require__);s=false}finally{if(s)delete t[r]}return n.exports}if(typeof __nccwpck_require__!=="undefined")__nccwpck_require__.ab=__dirname+"/";var r=__nccwpck_require__(194);module.exports=r})();
+(() => {
+  var __webpack_modules__ = {
+    396: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      const fs = __nccwpck_require__(147);
+      const path = __nccwpck_require__(17);
+      const os = __nccwpck_require__(37);
+      const crypto = __nccwpck_require__(113);
+      const packageJson = __nccwpck_require__(684);
+      const version = packageJson.version;
+      const LINE =
+        /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+      function parse(src) {
+        const obj = {};
+        let lines = src.toString();
+        lines = lines.replace(/\r\n?/gm, "\n");
+        let match;
+        while ((match = LINE.exec(lines)) != null) {
+          const key = match[1];
+          let value = match[2] || "";
+          value = value.trim();
+          const maybeQuote = value[0];
+          value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2");
+          if (maybeQuote === '"') {
+            value = value.replace(/\\n/g, "\n");
+            value = value.replace(/\\r/g, "\r");
+          }
+          obj[key] = value;
+        }
+        return obj;
+      }
+      function _parseVault(options) {
+        const vaultPath = _vaultPath(options);
+        const result = DotenvModule.configDotenv({ path: vaultPath });
+        if (!result.parsed) {
+          const err = new Error(
+            `MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`,
+          );
+          err.code = "MISSING_DATA";
+          throw err;
+        }
+        const keys = _dotenvKey(options).split(",");
+        const length = keys.length;
+        let decrypted;
+        for (let i = 0; i < length; i++) {
+          try {
+            const key = keys[i].trim();
+            const attrs = _instructions(result, key);
+            decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+            break;
+          } catch (error) {
+            if (i + 1 >= length) {
+              throw error;
+            }
+          }
+        }
+        return DotenvModule.parse(decrypted);
+      }
+      function _log(message) {
+        console.log(`[dotenv@${version}][INFO] ${message}`);
+      }
+      function _warn(message) {
+        console.log(`[dotenv@${version}][WARN] ${message}`);
+      }
+      function _debug(message) {
+        console.log(`[dotenv@${version}][DEBUG] ${message}`);
+      }
+      function _dotenvKey(options) {
+        if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+          return options.DOTENV_KEY;
+        }
+        if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+          return process.env.DOTENV_KEY;
+        }
+        return "";
+      }
+      function _instructions(result, dotenvKey) {
+        let uri;
+        try {
+          uri = new URL(dotenvKey);
+        } catch (error) {
+          if (error.code === "ERR_INVALID_URL") {
+            const err = new Error(
+              "INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development",
+            );
+            err.code = "INVALID_DOTENV_KEY";
+            throw err;
+          }
+          throw error;
+        }
+        const key = uri.password;
+        if (!key) {
+          const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        const environment = uri.searchParams.get("environment");
+        if (!environment) {
+          const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+        const ciphertext = result.parsed[environmentKey];
+        if (!ciphertext) {
+          const err = new Error(
+            `NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`,
+          );
+          err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+          throw err;
+        }
+        return { ciphertext, key };
+      }
+      function _vaultPath(options) {
+        let possibleVaultPath = null;
+        if (options && options.path && options.path.length > 0) {
+          if (Array.isArray(options.path)) {
+            for (const filepath of options.path) {
+              if (fs.existsSync(filepath)) {
+                possibleVaultPath = filepath.endsWith(".vault")
+                  ? filepath
+                  : `${filepath}.vault`;
+              }
+            }
+          } else {
+            possibleVaultPath = options.path.endsWith(".vault")
+              ? options.path
+              : `${options.path}.vault`;
+          }
+        } else {
+          possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
+        }
+        if (fs.existsSync(possibleVaultPath)) {
+          return possibleVaultPath;
+        }
+        return null;
+      }
+      function _resolveHome(envPath) {
+        return envPath[0] === "~"
+          ? path.join(os.homedir(), envPath.slice(1))
+          : envPath;
+      }
+      function _configVault(options) {
+        _log("Loading env from encrypted .env.vault");
+        const parsed = DotenvModule._parseVault(options);
+        let processEnv = process.env;
+        if (options && options.processEnv != null) {
+          processEnv = options.processEnv;
+        }
+        DotenvModule.populate(processEnv, parsed, options);
+        return { parsed };
+      }
+      function configDotenv(options) {
+        const dotenvPath = path.resolve(process.cwd(), ".env");
+        let encoding = "utf8";
+        const debug = Boolean(options && options.debug);
+        if (options && options.encoding) {
+          encoding = options.encoding;
+        } else {
+          if (debug) {
+            _debug("No encoding is specified. UTF-8 is used by default");
+          }
+        }
+        let optionPaths = [dotenvPath];
+        if (options && options.path) {
+          if (!Array.isArray(options.path)) {
+            optionPaths = [_resolveHome(options.path)];
+          } else {
+            optionPaths = [];
+            for (const filepath of options.path) {
+              optionPaths.push(_resolveHome(filepath));
+            }
+          }
+        }
+        let lastError;
+        const parsedAll = {};
+        for (const path of optionPaths) {
+          try {
+            const parsed = DotenvModule.parse(
+              fs.readFileSync(path, { encoding }),
+            );
+            DotenvModule.populate(parsedAll, parsed, options);
+          } catch (e) {
+            if (debug) {
+              _debug(`Failed to load ${path} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        let processEnv = process.env;
+        if (options && options.processEnv != null) {
+          processEnv = options.processEnv;
+        }
+        DotenvModule.populate(processEnv, parsedAll, options);
+        if (lastError) {
+          return { parsed: parsedAll, error: lastError };
+        } else {
+          return { parsed: parsedAll };
+        }
+      }
+      function config(options) {
+        if (_dotenvKey(options).length === 0) {
+          return DotenvModule.configDotenv(options);
+        }
+        const vaultPath = _vaultPath(options);
+        if (!vaultPath) {
+          _warn(
+            `You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`,
+          );
+          return DotenvModule.configDotenv(options);
+        }
+        return DotenvModule._configVault(options);
+      }
+      function decrypt(encrypted, keyStr) {
+        const key = Buffer.from(keyStr.slice(-64), "hex");
+        let ciphertext = Buffer.from(encrypted, "base64");
+        const nonce = ciphertext.subarray(0, 12);
+        const authTag = ciphertext.subarray(-16);
+        ciphertext = ciphertext.subarray(12, -16);
+        try {
+          const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+          aesgcm.setAuthTag(authTag);
+          return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+        } catch (error) {
+          const isRange = error instanceof RangeError;
+          const invalidKeyLength = error.message === "Invalid key length";
+          const decryptionFailed =
+            error.message ===
+            "Unsupported state or unable to authenticate data";
+          if (isRange || invalidKeyLength) {
+            const err = new Error(
+              "INVALID_DOTENV_KEY: It must be 64 characters long (or more)",
+            );
+            err.code = "INVALID_DOTENV_KEY";
+            throw err;
+          } else if (decryptionFailed) {
+            const err = new Error(
+              "DECRYPTION_FAILED: Please check your DOTENV_KEY",
+            );
+            err.code = "DECRYPTION_FAILED";
+            throw err;
+          } else {
+            throw error;
+          }
+        }
+      }
+      function populate(processEnv, parsed, options = {}) {
+        const debug = Boolean(options && options.debug);
+        const override = Boolean(options && options.override);
+        if (typeof parsed !== "object") {
+          const err = new Error(
+            "OBJECT_REQUIRED: Please check the processEnv argument being passed to populate",
+          );
+          err.code = "OBJECT_REQUIRED";
+          throw err;
+        }
+        for (const key of Object.keys(parsed)) {
+          if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+            if (override === true) {
+              processEnv[key] = parsed[key];
+            }
+            if (debug) {
+              if (override === true) {
+                _debug(`"${key}" is already defined and WAS overwritten`);
+              } else {
+                _debug(`"${key}" is already defined and was NOT overwritten`);
+              }
+            }
+          } else {
+            processEnv[key] = parsed[key];
+          }
+        }
+      }
+      const DotenvModule = {
+        configDotenv,
+        _configVault,
+        _parseVault,
+        config,
+        decrypt,
+        parse,
+        populate,
+      };
+      module.exports.configDotenv = DotenvModule.configDotenv;
+      module.exports._configVault = DotenvModule._configVault;
+      module.exports._parseVault = DotenvModule._parseVault;
+      module.exports.config = DotenvModule.config;
+      module.exports.decrypt = DotenvModule.decrypt;
+      module.exports.parse = DotenvModule.parse;
+      module.exports.populate = DotenvModule.populate;
+      module.exports = DotenvModule;
+    },
+    684: (module) => {
+      "use strict";
+      module.exports = require("./package.json");
+    },
+    113: (module) => {
+      "use strict";
+      module.exports = require("crypto");
+    },
+    147: (module) => {
+      "use strict";
+      module.exports = require("fs");
+    },
+    37: (module) => {
+      "use strict";
+      module.exports = require("os");
+    },
+    17: (module) => {
+      "use strict";
+      module.exports = require("path");
+    },
+  };
+  var __webpack_module_cache__ = {};
+  function __nccwpck_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (cachedModule !== undefined) {
+      return cachedModule.exports;
+    }
+    var module = (__webpack_module_cache__[moduleId] = { exports: {} });
+    var threw = true;
+    try {
+      __webpack_modules__[moduleId](
+        module,
+        module.exports,
+        __nccwpck_require__,
+      );
+      threw = false;
+    } finally {
+      if (threw) delete __webpack_module_cache__[moduleId];
+    }
+    return module.exports;
+  }
+  if (typeof __nccwpck_require__ !== "undefined")
+    __nccwpck_require__.ab = __dirname + "/";
+  var __webpack_exports__ = __nccwpck_require__(396);
+  module.exports = __webpack_exports__;
+})();

package/compiled/dotenv/package.json

@@ -1 +1 @@
-{"name":"dotenv","version":"16.3.1","funding":"https://github.com/motdotla/dotenv?sponsor=1","license":"BSD-2-Clause","types":"lib/main.d.ts"}
+{"name":"dotenv","version":"16.4.5","funding":"https://dotenvx.com","license":"BSD-2-Clause","types":"index.d.ts","type":"commonjs"}

package/compiled/dotenv-expand/index.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="node" />
+// TypeScript Version: 3.0
+
+interface DotenvPopulateInput {
+  [name: string]: string;
+}
+
+interface DotenvParseInput {
+  [name: string]: string;
+}
+
+interface DotenvParseOutput {
+  [name: string]: string;
+}
+
+interface DotenvExpandOptions {
+  error?: Error;
+
+  /**
+   * Default: `process.env`
+   *
+   * Specify an object to write your secrets to. Defaults to process.env environment variables.
+   *
+   * example: `const processEnv = {}; require('dotenv').config({ processEnv: processEnv })`
+   */
+  processEnv?: DotenvPopulateInput;
+
+  /**
+   * Default: `object`
+   *
+   * Object coming from dotenv's parsed result.
+   */
+  parsed?: DotenvParseInput;
+}
+
+interface DotenvExpandOutput {
+  error?: Error;
+  parsed?: DotenvParseOutput;
+}
+
+/**
+ * Adds variable expansion on top of dotenv.
+ *
+ * See https://docs.dotenv.org
+ *
+ * @param options - additional options. example: `{ processEnv: {}, error: null, parsed: { { KEY: 'value' } }`
+ * @returns an object with a `parsed` key if successful or `error` key if an error occurred. example: { parsed: { KEY: 'value' } }
+ *
+ */
+declare function expand(options?: DotenvExpandOptions): DotenvExpandOutput
+
+export { type DotenvExpandOptions, type DotenvExpandOutput, type DotenvParseInput, type DotenvParseOutput, type DotenvPopulateInput, expand };