nitro-nightly 3.0.1-20260106-202835-5325b208 → 3.0.1-20260106-205209-b085a480

package/dist/_libs/commondir.mjs

@@ -1,22 +0,0 @@
-import { r as __require, t as __commonJSMin } from "../_rolldown.mjs";
-
-//#region node_modules/.pnpm/commondir@1.0.1/node_modules/commondir/index.js
-var require_commondir = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var path = __require("path");
-	module.exports = function(basedir, relfiles) {
-		if (relfiles) var files = relfiles.map(function(r) {
-			return path.resolve(basedir, r);
-		});
-		else var files = basedir;
-		var res = files.slice(1).reduce(function(ps, file) {
-			if (!file.match(/^([A-Za-z]:)?\/|\\/)) throw new Error("relative path without a basedir");
-			var xs = file.split(/\/+|\\+/);
-			for (var i = 0; ps[i] === xs[i] && i < Math.min(ps.length, xs.length); i++);
-			return ps.slice(0, i);
-		}, files[0].split(/\/+|\\+/));
-		return res.length > 1 ? res.join("/") : "/";
-	};
-}));
-
-//#endregion
-export { require_commondir as t };

package/dist/_libs/deepmerge.mjs

@@ -1,86 +0,0 @@
-import { t as __commonJSMin } from "../_rolldown.mjs";
-
-//#region node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js
-var require_cjs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var isMergeableObject = function isMergeableObject(value) {
-		return isNonNullObject(value) && !isSpecial(value);
-	};
-	function isNonNullObject(value) {
-		return !!value && typeof value === "object";
-	}
-	function isSpecial(value) {
-		var stringValue = Object.prototype.toString.call(value);
-		return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
-	}
-	var REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for ? Symbol.for("react.element") : 60103;
-	function isReactElement(value) {
-		return value.$$typeof === REACT_ELEMENT_TYPE;
-	}
-	function emptyTarget(val) {
-		return Array.isArray(val) ? [] : {};
-	}
-	function cloneUnlessOtherwiseSpecified(value, options) {
-		return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
-	}
-	function defaultArrayMerge(target, source, options) {
-		return target.concat(source).map(function(element) {
-			return cloneUnlessOtherwiseSpecified(element, options);
-		});
-	}
-	function getMergeFunction(key, options) {
-		if (!options.customMerge) return deepmerge;
-		var customMerge = options.customMerge(key);
-		return typeof customMerge === "function" ? customMerge : deepmerge;
-	}
-	function getEnumerableOwnPropertySymbols(target) {
-		return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
-			return Object.propertyIsEnumerable.call(target, symbol);
-		}) : [];
-	}
-	function getKeys(target) {
-		return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
-	}
-	function propertyIsOnObject(object, property) {
-		try {
-			return property in object;
-		} catch (_) {
-			return false;
-		}
-	}
-	function propertyIsUnsafe(target, key) {
-		return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
-	}
-	function mergeObject(target, source, options) {
-		var destination = {};
-		if (options.isMergeableObject(target)) getKeys(target).forEach(function(key) {
-			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
-		});
-		getKeys(source).forEach(function(key) {
-			if (propertyIsUnsafe(target, key)) return;
-			if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
-			else destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
-		});
-		return destination;
-	}
-	function deepmerge(target, source, options) {
-		options = options || {};
-		options.arrayMerge = options.arrayMerge || defaultArrayMerge;
-		options.isMergeableObject = options.isMergeableObject || isMergeableObject;
-		options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
-		var sourceIsArray = Array.isArray(source);
-		if (!(sourceIsArray === Array.isArray(target))) return cloneUnlessOtherwiseSpecified(source, options);
-		else if (sourceIsArray) return options.arrayMerge(target, source, options);
-		else return mergeObject(target, source, options);
-	}
-	deepmerge.all = function deepmergeAll(array, options) {
-		if (!Array.isArray(array)) throw new Error("first argument should be an array");
-		return array.reduce(function(prev, next) {
-			return deepmerge(prev, next, options);
-		}, {});
-	};
-	var deepmerge_1 = deepmerge;
-	module.exports = deepmerge_1;
-}));
-
-//#endregion
-export { require_cjs as t };

package/dist/_libs/dot-prop.mjs

@@ -1,138 +0,0 @@
-//#region node_modules/.pnpm/dot-prop@10.1.0/node_modules/dot-prop/index.js
-const isObject = (value) => {
-	const type = typeof value;
-	return value !== null && (type === "object" || type === "function");
-};
-const disallowedKeys = new Set([
-	"__proto__",
-	"prototype",
-	"constructor"
-]);
-const MAX_ARRAY_INDEX = 1e6;
-const isDigit = (character) => character >= "0" && character <= "9";
-function shouldCoerceToNumber(segment) {
-	if (segment === "0") return true;
-	if (/^[1-9]\d*$/.test(segment)) {
-		const parsedNumber = Number.parseInt(segment, 10);
-		return parsedNumber <= Number.MAX_SAFE_INTEGER && parsedNumber <= MAX_ARRAY_INDEX;
-	}
-	return false;
-}
-function processSegment(segment, parts) {
-	if (disallowedKeys.has(segment)) return false;
-	if (segment && shouldCoerceToNumber(segment)) parts.push(Number.parseInt(segment, 10));
-	else parts.push(segment);
-	return true;
-}
-function parsePath(path) {
-	if (typeof path !== "string") throw new TypeError(`Expected a string, got ${typeof path}`);
-	const parts = [];
-	let currentSegment = "";
-	let currentPart = "start";
-	let isEscaping = false;
-	let position = 0;
-	for (const character of path) {
-		position++;
-		if (isEscaping) {
-			currentSegment += character;
-			isEscaping = false;
-			continue;
-		}
-		if (character === "\\") {
-			if (currentPart === "index") throw new Error(`Invalid character '${character}' in an index at position ${position}`);
-			if (currentPart === "indexEnd") throw new Error(`Invalid character '${character}' after an index at position ${position}`);
-			isEscaping = true;
-			currentPart = currentPart === "start" ? "property" : currentPart;
-			continue;
-		}
-		switch (character) {
-			case ".":
-				if (currentPart === "index") throw new Error(`Invalid character '${character}' in an index at position ${position}`);
-				if (currentPart === "indexEnd") {
-					currentPart = "property";
-					break;
-				}
-				if (!processSegment(currentSegment, parts)) return [];
-				currentSegment = "";
-				currentPart = "property";
-				break;
-			case "[":
-				if (currentPart === "index") throw new Error(`Invalid character '${character}' in an index at position ${position}`);
-				if (currentPart === "indexEnd") {
-					currentPart = "index";
-					break;
-				}
-				if (currentPart === "property" || currentPart === "start") {
-					if ((currentSegment || currentPart === "property") && !processSegment(currentSegment, parts)) return [];
-					currentSegment = "";
-				}
-				currentPart = "index";
-				break;
-			case "]":
-				if (currentPart === "index") {
-					if (currentSegment === "") {
-						currentSegment = (parts.pop() || "") + "[]";
-						currentPart = "property";
-					} else {
-						const parsedNumber = Number.parseInt(currentSegment, 10);
-						if (!Number.isNaN(parsedNumber) && Number.isFinite(parsedNumber) && parsedNumber >= 0 && parsedNumber <= Number.MAX_SAFE_INTEGER && parsedNumber <= MAX_ARRAY_INDEX && currentSegment === String(parsedNumber)) parts.push(parsedNumber);
-						else parts.push(currentSegment);
-						currentSegment = "";
-						currentPart = "indexEnd";
-					}
-					break;
-				}
-				if (currentPart === "indexEnd") throw new Error(`Invalid character '${character}' after an index at position ${position}`);
-				currentSegment += character;
-				break;
-			default:
-				if (currentPart === "index" && !isDigit(character)) throw new Error(`Invalid character '${character}' in an index at position ${position}`);
-				if (currentPart === "indexEnd") throw new Error(`Invalid character '${character}' after an index at position ${position}`);
-				if (currentPart === "start") currentPart = "property";
-				currentSegment += character;
-		}
-	}
-	if (isEscaping) currentSegment += "\\";
-	switch (currentPart) {
-		case "property":
-			if (!processSegment(currentSegment, parts)) return [];
-			break;
-		case "index": throw new Error("Index was not closed");
-		case "start":
-			parts.push("");
-			break;
-	}
-	return parts;
-}
-function normalizePath(path) {
-	if (typeof path === "string") return parsePath(path);
-	if (Array.isArray(path)) {
-		const normalized = [];
-		for (const [index, segment] of path.entries()) {
-			if (typeof segment !== "string" && typeof segment !== "number") throw new TypeError(`Expected a string or number for path segment at index ${index}, got ${typeof segment}`);
-			if (typeof segment === "number" && !Number.isFinite(segment)) throw new TypeError(`Path segment at index ${index} must be a finite number, got ${segment}`);
-			if (disallowedKeys.has(segment)) return [];
-			if (typeof segment === "string" && shouldCoerceToNumber(segment)) normalized.push(Number.parseInt(segment, 10));
-			else normalized.push(segment);
-		}
-		return normalized;
-	}
-	return [];
-}
-function getProperty(object, path, value) {
-	if (!isObject(object) || typeof path !== "string" && !Array.isArray(path)) return value === void 0 ? object : value;
-	const pathArray = normalizePath(path);
-	if (pathArray.length === 0) return value;
-	for (let index = 0; index < pathArray.length; index++) {
-		const key = pathArray[index];
-		object = object[key];
-		if (object === void 0 || object === null) {
-			if (index !== pathArray.length - 1) return value;
-			break;
-		}
-	}
-	return object === void 0 ? value : object;
-}
-
-//#endregion
-export { getProperty as t };

package/dist/_libs/dotenv.mjs

@@ -1,345 +0,0 @@
-import { r as __require, t as __commonJSMin } from "../_rolldown.mjs";
-
-//#region node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/package.json
-var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = {
-		"name": "dotenv",
-		"version": "17.2.3",
-		"description": "Loads environment variables from .env file",
-		"main": "lib/main.js",
-		"types": "lib/main.d.ts",
-		"exports": {
-			".": {
-				"types": "./lib/main.d.ts",
-				"require": "./lib/main.js",
-				"default": "./lib/main.js"
-			},
-			"./config": "./config.js",
-			"./config.js": "./config.js",
-			"./lib/env-options": "./lib/env-options.js",
-			"./lib/env-options.js": "./lib/env-options.js",
-			"./lib/cli-options": "./lib/cli-options.js",
-			"./lib/cli-options.js": "./lib/cli-options.js",
-			"./package.json": "./package.json"
-		},
-		"scripts": {
-			"dts-check": "tsc --project tests/types/tsconfig.json",
-			"lint": "standard",
-			"pretest": "npm run lint && npm run dts-check",
-			"test": "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
-			"test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
-			"prerelease": "npm test",
-			"release": "standard-version"
-		},
-		"repository": {
-			"type": "git",
-			"url": "git://github.com/motdotla/dotenv.git"
-		},
-		"homepage": "https://github.com/motdotla/dotenv#readme",
-		"funding": "https://dotenvx.com",
-		"keywords": [
-			"dotenv",
-			"env",
-			".env",
-			"environment",
-			"variables",
-			"config",
-			"settings"
-		],
-		"readmeFilename": "README.md",
-		"license": "BSD-2-Clause",
-		"devDependencies": {
-			"@types/node": "^18.11.3",
-			"decache": "^4.6.2",
-			"sinon": "^14.0.1",
-			"standard": "^17.0.0",
-			"standard-version": "^9.5.0",
-			"tap": "^19.2.0",
-			"typescript": "^4.8.4"
-		},
-		"engines": { "node": ">=12" },
-		"browser": { "fs": false }
-	};
-}));
-
-//#endregion
-//#region node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/lib/main.js
-var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const fs = __require("fs");
-	const path = __require("path");
-	const os = __require("os");
-	const crypto = __require("crypto");
-	const version = require_package().version;
-	const TIPS = [
-		"🔐 encrypt with Dotenvx: https://dotenvx.com",
-		"🔐 prevent committing .env to code: https://dotenvx.com/precommit",
-		"🔐 prevent building .env in docker: https://dotenvx.com/prebuild",
-		"📡 add observability to secrets: https://dotenvx.com/ops",
-		"👥 sync secrets across teammates & machines: https://dotenvx.com/ops",
-		"🗂️ backup and recover secrets: https://dotenvx.com/ops",
-		"✅ audit secrets and track compliance: https://dotenvx.com/ops",
-		"🔄 add secrets lifecycle management: https://dotenvx.com/ops",
-		"🔑 add access controls to secrets: https://dotenvx.com/ops",
-		"🛠️  run anywhere with `dotenvx run -- yourcommand`",
-		"⚙️  specify custom .env file path with { path: '/custom/path/.env' }",
-		"⚙️  enable debug logging with { debug: true }",
-		"⚙️  override existing env vars with { override: true }",
-		"⚙️  suppress all logs with { quiet: true }",
-		"⚙️  write to custom object with { processEnv: myObject }",
-		"⚙️  load multiple .env files with { path: ['.env.local', '.env'] }"
-	];
-	function _getRandomTip() {
-		return TIPS[Math.floor(Math.random() * TIPS.length)];
-	}
-	function parseBoolean(value) {
-		if (typeof value === "string") return ![
-			"false",
-			"0",
-			"no",
-			"off",
-			""
-		].includes(value.toLowerCase());
-		return Boolean(value);
-	}
-	function supportsAnsi() {
-		return process.stdout.isTTY;
-	}
-	function dim(text) {
-		return supportsAnsi() ? `\x1b[2m${text}\x1b[0m` : text;
-	}
-	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) {
-		options = options || {};
-		const vaultPath = _vaultPath(options);
-		options.path = vaultPath;
-		const result = DotenvModule.configDotenv(options);
-		if (!result.parsed) {
-			const err = /* @__PURE__ */ 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 attrs = _instructions(result, keys[i].trim());
-			decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
-			break;
-		} catch (error) {
-			if (i + 1 >= length) throw error;
-		}
-		return DotenvModule.parse(decrypted);
-	}
-	function _warn(message) {
-		console.error(`[dotenv@${version}][WARN] ${message}`);
-	}
-	function _debug(message) {
-		console.log(`[dotenv@${version}][DEBUG] ${message}`);
-	}
-	function _log(message) {
-		console.log(`[dotenv@${version}] ${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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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) {
-		const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
-		const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
-		if (debug || !quiet) _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";
-		let processEnv = process.env;
-		if (options && options.processEnv != null) processEnv = options.processEnv;
-		let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
-		let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
-		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$1 of optionPaths) try {
-			const parsed = DotenvModule.parse(fs.readFileSync(path$1, { encoding }));
-			DotenvModule.populate(parsedAll, parsed, options);
-		} catch (e) {
-			if (debug) _debug(`Failed to load ${path$1} ${e.message}`);
-			lastError = e;
-		}
-		const populated = DotenvModule.populate(processEnv, parsedAll, options);
-		debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
-		quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
-		if (debug || !quiet) {
-			const keysCount = Object.keys(populated).length;
-			const shortPaths = [];
-			for (const filePath of optionPaths) try {
-				const relative = path.relative(process.cwd(), filePath);
-				shortPaths.push(relative);
-			} catch (e) {
-				if (debug) _debug(`Failed to load ${filePath} ${e.message}`);
-				lastError = e;
-			}
-			_log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
-		}
-		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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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);
-		const populated = {};
-		if (typeof parsed !== "object") {
-			const err = /* @__PURE__ */ 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];
-				populated[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];
-			populated[key] = parsed[key];
-		}
-		return populated;
-	}
-	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;
-}));
-
-//#endregion
-export { require_main as t };

package/dist/_libs/duplexer.mjs

@@ -1,71 +0,0 @@
-import { r as __require, t as __commonJSMin } from "../_rolldown.mjs";
-
-//#region node_modules/.pnpm/duplexer@0.1.2/node_modules/duplexer/index.js
-var require_duplexer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var Stream = __require("stream");
-	var writeMethods = [
-		"write",
-		"end",
-		"destroy"
-	];
-	var readMethods = ["resume", "pause"];
-	var readEvents = ["data", "close"];
-	var slice = Array.prototype.slice;
-	module.exports = duplex;
-	function forEach(arr, fn) {
-		if (arr.forEach) return arr.forEach(fn);
-		for (var i = 0; i < arr.length; i++) fn(arr[i], i);
-	}
-	function duplex(writer, reader) {
-		var stream = new Stream();
-		var ended = false;
-		forEach(writeMethods, proxyWriter);
-		forEach(readMethods, proxyReader);
-		forEach(readEvents, proxyStream);
-		reader.on("end", handleEnd);
-		writer.on("drain", function() {
-			stream.emit("drain");
-		});
-		writer.on("error", reemit);
-		reader.on("error", reemit);
-		stream.writable = writer.writable;
-		stream.readable = reader.readable;
-		return stream;
-		function proxyWriter(methodName) {
-			stream[methodName] = method;
-			function method() {
-				return writer[methodName].apply(writer, arguments);
-			}
-		}
-		function proxyReader(methodName) {
-			stream[methodName] = method;
-			function method() {
-				stream.emit(methodName);
-				var func = reader[methodName];
-				if (func) return func.apply(reader, arguments);
-				reader.emit(methodName);
-			}
-		}
-		function proxyStream(methodName) {
-			reader.on(methodName, reemit$1);
-			function reemit$1() {
-				var args = slice.call(arguments);
-				args.unshift(methodName);
-				stream.emit.apply(stream, args);
-			}
-		}
-		function handleEnd() {
-			if (ended) return;
-			ended = true;
-			var args = slice.call(arguments);
-			args.unshift("end");
-			stream.emit.apply(stream, args);
-		}
-		function reemit(err) {
-			stream.emit("error", err);
-		}
-	}
-}));
-
-//#endregion
-export { require_duplexer as t };