@catbee/utils 0.0.8-rc.1 → 0.0.8-rc.2

package/build/esm/utils/env.utils.js

@@ -21,42 +21,6 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 /* eslint-disable n/no-process-env */
 import { existsSync, readFileSync } from 'fs';
 import { isAbsolute, resolve } from 'path';
@@ -74,76 +38,65 @@ export var Environment;
  * Utility class for accessing and managing environment variables.
  * Provides typed getters with fallback defaults and validation.
  */
-var Env = /** @class */ (function () {
-    function Env() {
-    }
+export class Env {
+    // Cache for parsed values to avoid repeated parsing of complex values
+    static cache = new Map();
     /**
      * Checks if the current NODE_ENV is 'development'.
      *
      * @returns {boolean} `true` if NODE_ENV is 'development', else `false`.
      */
-    Env.isDev = function () {
+    static isDev() {
         return Env.get('NODE_ENV', Environment.DEVELOPMENT) === Environment.DEVELOPMENT;
-    };
+    }
     /**
      * Checks if the current NODE_ENV is 'production'.
      *
      * @returns {boolean} `true` if NODE_ENV is 'production', else `false`.
      */
-    Env.isProd = function () {
+    static isProd() {
         return Env.get('NODE_ENV', Environment.DEVELOPMENT) === Environment.PRODUCTION;
-    };
+    }
     /**
      * Checks if the current NODE_ENV is 'testing'.
      *
      * @returns {boolean} `true` if NODE_ENV is 'testing', else `false`.
      */
-    Env.isTest = function () {
+    static isTest() {
         return Env.get('NODE_ENV', Environment.DEVELOPMENT) === Environment.TESTING;
-    };
+    }
     /**
      * Checks if the current NODE_ENV is 'staging'.
      *
      * @returns {boolean} `true` if NODE_ENV is 'staging', else `false`.
      */
-    Env.isStaging = function () {
+    static isStaging() {
         return Env.get('NODE_ENV', Environment.DEVELOPMENT) === Environment.STAGING;
-    };
+    }
     /**
      * Sets an environment variable (only affects runtime memory).
      *
      * @param {string} key - The environment variable key.
      * @param {string} value - The value to set.
      */
-    Env.set = function (key, value) {
-        var e_1, _a;
+    static set(key, value) {
         process.env[key] = value;
         // Clear all cached values for this key with any prefix
         this.cache.delete(key);
-        try {
-            for (var _b = __values(__spreadArray([], __read(this.cache.keys()), false)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var cacheKey = _c.value;
-                if (cacheKey.includes(":".concat(key))) {
-                    this.cache.delete(cacheKey);
-                }
+        for (const cacheKey of [...this.cache.keys()]) {
+            if (cacheKey.includes(`:${key}`)) {
+                this.cache.delete(cacheKey);
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    };
+    }
     /**
      * Returns all environment variables as an object.
      *
      * @returns {object} The current `process.env` object.
      */
-    Env.getAll = function () {
+    static getAll() {
         return process.env;
-    };
+    }
     /**
      * Retrieves a string environment variable with a fallback default.
      * Supports variable expansion with ${VAR_NAME} syntax.
@@ -157,18 +110,16 @@ var Env = /** @class */ (function () {
      * // and DB_NAME is "myapp"
      * const url = Env.get('DATABASE_URL', ''); // "postgres://localhost:5432/myapp"
      */
-    Env.get = function (key, defaultValue) {
-        var _a;
-        var value = (_a = process.env[key]) !== null && _a !== void 0 ? _a : defaultValue;
+    static get(key, defaultValue) {
+        let value = process.env[key] ?? defaultValue;
         // Expand ${VAR} references
         if (value && value.includes('${')) {
-            value = value.replace(/\${([A-Za-z0-9_]+)}/g, function (_, varName) {
-                var _a;
-                return (_a = process.env[varName]) !== null && _a !== void 0 ? _a : '';
+            value = value.replace(/\${([A-Za-z0-9_]+)}/g, (_, varName) => {
+                return process.env[varName] ?? '';
             });
         }
         return value;
-    };
+    }
     /**
      * Retrieves a string environment variable and throws if it's missing.
      *
@@ -176,13 +127,13 @@ var Env = /** @class */ (function () {
      * @returns {string} The environment variable's value.
      * @throws {Error} If the variable is not defined.
      */
-    Env.getRequired = function (key) {
-        var value = process.env[key];
+    static getRequired(key) {
+        const value = process.env[key];
         if (value === undefined) {
-            throw new Error("Required environment variable '".concat(key, "' is missing"));
+            throw new Error(`Required environment variable '${key}' is missing`);
         }
         return Env.get(key, ''); // Use get to handle variable expansion
-    };
+    }
     /**
      * Retrieves a value using a default generating function if the key doesn't exist.
      * Useful for expensive default calculations.
@@ -197,12 +148,12 @@ var Env = /** @class */ (function () {
      *   return require('os').hostname();
      * });
      */
-    Env.getWithDefault = function (key, defaultFn) {
+    static getWithDefault(key, defaultFn) {
         if (Env.has(key)) {
             return Env.get(key, '');
         }
         return defaultFn();
-    };
+    }
     /**
      * Retrieves an environment variable as a number, or returns a default.
      *
@@ -211,21 +162,21 @@ var Env = /** @class */ (function () {
      * @returns {number} Parsed numeric value or default.
      * @throws {Error} If the value is not a valid number.
      */
-    Env.getNumber = function (key, defaultValue) {
-        if (this.cache.has("number:".concat(key))) {
-            return this.cache.get("number:".concat(key));
+    static getNumber(key, defaultValue) {
+        if (this.cache.has(`number:${key}`)) {
+            return this.cache.get(`number:${key}`);
         }
-        var value = process.env[key];
+        const value = process.env[key];
         if (value === undefined) {
             return defaultValue;
         }
-        var numberValue = Number(value);
+        const numberValue = Number(value);
         if (isNaN(numberValue)) {
-            throw new Error("Environment variable '".concat(key, "' is not a valid number, got: \"").concat(value, "\""));
+            throw new Error(`Environment variable '${key}' is not a valid number, got: "${value}"`);
         }
-        this.cache.set("number:".concat(key), numberValue);
+        this.cache.set(`number:${key}`, numberValue);
         return numberValue;
-    };
+    }
     /**
      * Retrieves a required environment variable as a number.
      *
@@ -233,13 +184,13 @@ var Env = /** @class */ (function () {
      * @returns {number} Parsed number.
      * @throws {Error} If the value is missing or not a number.
      */
-    Env.getNumberRequired = function (key) {
-        var value = process.env[key];
+    static getNumberRequired(key) {
+        const value = process.env[key];
         if (value === undefined) {
-            throw new Error("Required environment variable '".concat(key, "' is missing"));
+            throw new Error(`Required environment variable '${key}' is missing`);
         }
         return Env.getNumber(key, 0); // The default is ignored since we know the key exists
-    };
+    }
     /**
      * Retrieves an integer environment variable and validates it.
      *
@@ -254,21 +205,20 @@ var Env = /** @class */ (function () {
      * // Require PORT to be between 1000 and 9999
      * const port = Env.getInteger('PORT', 3000, { min: 1000, max: 9999 });
      */
-    Env.getInteger = function (key, defaultValue, options) {
-        if (options === void 0) { options = {}; }
-        var num = Env.getNumber(key, defaultValue);
-        var intValue = Math.floor(num);
+    static getInteger(key, defaultValue, options = {}) {
+        const num = Env.getNumber(key, defaultValue);
+        const intValue = Math.floor(num);
         if (intValue !== num) {
-            throw new Error("Environment variable '".concat(key, "' must be an integer, got: ").concat(num));
+            throw new Error(`Environment variable '${key}' must be an integer, got: ${num}`);
         }
         if (options.min !== undefined && intValue < options.min) {
-            throw new Error("Environment variable '".concat(key, "' must be at least ").concat(options.min, ", got: ").concat(intValue));
+            throw new Error(`Environment variable '${key}' must be at least ${options.min}, got: ${intValue}`);
         }
         if (options.max !== undefined && intValue > options.max) {
-            throw new Error("Environment variable '".concat(key, "' must be at most ").concat(options.max, ", got: ").concat(intValue));
+            throw new Error(`Environment variable '${key}' must be at most ${options.max}, got: ${intValue}`);
         }
         return intValue;
-    };
+    }
     /**
      * Retrieves an environment variable as a boolean.
      * Accepts `true`, `1`, `yes`, `on` as true; `false`, `0`, `no`, `off` as false.
@@ -282,26 +232,25 @@ var Env = /** @class */ (function () {
      * // If DEBUG=yes
      * const isDebug = Env.getBoolean('DEBUG', false); // true
      */
-    Env.getBoolean = function (key, defaultValue) {
-        if (defaultValue === void 0) { defaultValue = false; }
-        if (this.cache.has("bool:".concat(key))) {
-            return this.cache.get("bool:".concat(key));
+    static getBoolean(key, defaultValue = false) {
+        if (this.cache.has(`bool:${key}`)) {
+            return this.cache.get(`bool:${key}`);
         }
-        var value = process.env[key];
+        const value = process.env[key];
         if (value === undefined) {
             return defaultValue;
         }
-        var lowerValue = value.toLowerCase();
+        const lowerValue = value.toLowerCase();
         if (['true', '1', 'yes', 'on'].includes(lowerValue)) {
-            this.cache.set("bool:".concat(key), true);
+            this.cache.set(`bool:${key}`, true);
             return true;
         }
         if (['false', '0', 'no', 'off'].includes(lowerValue)) {
-            this.cache.set("bool:".concat(key), false);
+            this.cache.set(`bool:${key}`, false);
             return false;
         }
-        throw new Error("Environment variable '".concat(key, "' is not a valid boolean, got: \"").concat(value, "\". Use true/false, yes/no, 1/0, or on/off."));
-    };
+        throw new Error(`Environment variable '${key}' is not a valid boolean, got: "${value}". Use true/false, yes/no, 1/0, or on/off.`);
+    }
     /**
      * Retrieves a required environment variable as a boolean.
      *
@@ -309,13 +258,13 @@ var Env = /** @class */ (function () {
      * @returns {boolean} Parsed boolean value.
      * @throws {Error} If missing or invalid.
      */
-    Env.getBooleanRequired = function (key) {
-        var value = process.env[key];
+    static getBooleanRequired(key) {
+        const value = process.env[key];
         if (value === undefined) {
-            throw new Error("Required environment variable '".concat(key, "' is missing"));
+            throw new Error(`Required environment variable '${key}' is missing`);
         }
         return Env.getBoolean(key);
-    };
+    }
     /**
      * Parses a stringified JSON object from an environment variable.
      *
@@ -330,23 +279,23 @@ var Env = /** @class */ (function () {
      * const config = Env.getJSON('CONFIG', { debug: false });
      * // { debug: true, api: { url: "https://api.example.com" }}
      */
-    Env.getJSON = function (key, defaultValue) {
-        if (this.cache.has("json:".concat(key))) {
-            return this.cache.get("json:".concat(key));
+    static getJSON(key, defaultValue) {
+        if (this.cache.has(`json:${key}`)) {
+            return this.cache.get(`json:${key}`);
         }
-        var v = process.env[key];
+        const v = process.env[key];
         if (v === undefined) {
             return defaultValue;
         }
         try {
-            var parsed = JSON.parse(v);
-            this.cache.set("json:".concat(key), parsed);
+            const parsed = JSON.parse(v);
+            this.cache.set(`json:${key}`, parsed);
             return parsed;
         }
         catch (error) {
-            throw new Error("Environment variable '".concat(key, "' is not valid JSON: ").concat(error.message));
+            throw new Error(`Environment variable '${key}' is not valid JSON: ${error.message}`);
         }
-    };
+    }
     /**
      * Parses a comma-separated string as an array.
      *
@@ -365,35 +314,33 @@ var Env = /** @class */ (function () {
      * // With transformation function
      * const ports = Env.getArray('PORTS', [], ',', (p) => parseInt(p, 10));
      */
-    Env.getArray = function (key, defaultValue, splitter, transform) {
-        if (defaultValue === void 0) { defaultValue = []; }
-        if (splitter === void 0) { splitter = ','; }
-        var cacheKey = "array:".concat(key, ":").concat(splitter, ":").concat(transform ? 'transformed' : 'raw');
+    static getArray(key, defaultValue = [], splitter = ',', transform) {
+        const cacheKey = `array:${key}:${splitter}:${transform ? 'transformed' : 'raw'}`;
         if (this.cache.has(cacheKey)) {
             return this.cache.get(cacheKey);
         }
-        var value = process.env[key];
+        const value = process.env[key];
         if (!value || value.trim() === '') {
             return defaultValue;
         }
-        var items = value
+        const items = value
             .split(splitter)
-            .map(function (item) { return item.trim(); })
-            .filter(function (item) { return item.length > 0; });
+            .map(item => item.trim())
+            .filter(item => item.length > 0);
         if (transform) {
             try {
-                var result_1 = items.map(transform);
-                this.cache.set(cacheKey, result_1);
-                return result_1;
+                const result = items.map(transform);
+                this.cache.set(cacheKey, result);
+                return result;
             }
             catch (error) {
-                throw new Error("Failed to transform items in '".concat(key, "': ").concat(error.message));
+                throw new Error(`Failed to transform items in '${key}': ${error.message}`);
             }
         }
-        var result = items;
+        const result = items;
         this.cache.set(cacheKey, result);
         return result;
-    };
+    }
     /**
      * Parses a comma-separated list of numbers.
      *
@@ -407,17 +354,15 @@ var Env = /** @class */ (function () {
      * const ports = Env.getNumberArray('ALLOWED_PORTS');
      * // [80, 443, 3000, 8080]
      */
-    Env.getNumberArray = function (key, defaultValue, splitter) {
-        if (defaultValue === void 0) { defaultValue = []; }
-        if (splitter === void 0) { splitter = ','; }
-        return Env.getArray(key, defaultValue, splitter, function (item) {
-            var num = Number(item);
+    static getNumberArray(key, defaultValue = [], splitter = ',') {
+        return Env.getArray(key, defaultValue, splitter, item => {
+            const num = Number(item);
             if (isNaN(num)) {
-                throw new Error("Value \"".concat(item, "\" in array '").concat(key, "' is not a valid number"));
+                throw new Error(`Value "${item}" in array '${key}' is not a valid number`);
             }
             return num;
         });
-    };
+    }
     /**
      * Retrieves an enum-like environment variable value, validating against allowed values.
      *
@@ -433,16 +378,16 @@ var Env = /** @class */ (function () {
      * const level = Env.getEnum('LOG_LEVEL', ['debug', 'info', 'warn', 'error'] as const, 'info');
      * // 'debug' (typed as 'debug' | 'info' | 'warn' | 'error')
      */
-    Env.getEnum = function (key, allowedValues, defaultValue) {
-        var value = process.env[key];
+    static getEnum(key, allowedValues, defaultValue) {
+        const value = process.env[key];
         if (!value) {
             return defaultValue;
         }
         if (!allowedValues.includes(value)) {
-            throw new Error("Environment variable '".concat(key, "' must be one of: ").concat(allowedValues.join(', '), ". Received: \"").concat(value, "\""));
+            throw new Error(`Environment variable '${key}' must be one of: ${allowedValues.join(', ')}. Received: "${value}"`);
         }
         return value;
-    };
+    }
     /**
      * Retrieves an enum-like numeric environment variable.
      *
@@ -455,13 +400,13 @@ var Env = /** @class */ (function () {
      * // If NODE_VERSION=16
      * const version = Env.getNumberEnum('NODE_VERSION', [14, 16, 18], 16);
      */
-    Env.getNumberEnum = function (key, allowedValues, defaultValue) {
-        var value = Env.getNumber(key, defaultValue);
+    static getNumberEnum(key, allowedValues, defaultValue) {
+        const value = Env.getNumber(key, defaultValue);
         if (!allowedValues.includes(value)) {
-            throw new Error("Environment variable '".concat(key, "' must be one of: ").concat(allowedValues.join(', '), ". Received: ").concat(value));
+            throw new Error(`Environment variable '${key}' must be one of: ${allowedValues.join(', ')}. Received: ${value}`);
         }
         return value;
-    };
+    }
     /**
      * Retrieves a URL environment variable and validates it.
      *
@@ -479,41 +424,40 @@ var Env = /** @class */ (function () {
      *   allowIp: false
      * });
      */
-    Env.getUrl = function (key, defaultValue, options) {
-        if (options === void 0) { options = {}; }
-        var cacheKey = "url:".concat(key, ":").concat(JSON.stringify(options));
+    static getUrl(key, defaultValue, options = {}) {
+        const cacheKey = `url:${key}:${JSON.stringify(options)}`;
         if (this.cache.has(cacheKey)) {
             return this.cache.get(cacheKey);
         }
-        var value = Env.get(key, defaultValue);
+        const value = Env.get(key, defaultValue);
         if (!value) {
-            throw new Error("URL environment variable '".concat(key, "' is missing or empty"));
+            throw new Error(`URL environment variable '${key}' is missing or empty`);
         }
-        var url;
+        let url;
         try {
             url = new URL(value);
         }
-        catch (_a) {
-            throw new Error("Environment variable '".concat(key, "' is not a valid URL: \"").concat(value, "\""));
+        catch {
+            throw new Error(`Environment variable '${key}' is not a valid URL: "${value}"`);
         }
         // Validate protocol
         if (options.protocols && options.protocols.length > 0) {
-            var protocol = url.protocol.replace(':', '');
+            const protocol = url.protocol.replace(':', '');
             if (!options.protocols.includes(protocol)) {
-                throw new Error("Environment variable '".concat(key, "' must use one of the protocols: ").concat(options.protocols.join(', '), ". Got: ").concat(protocol));
+                throw new Error(`Environment variable '${key}' must use one of the protocols: ${options.protocols.join(', ')}. Got: ${protocol}`);
             }
         }
         // Validate hostname
-        var hostname = url.hostname;
-        var isIp = /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/.test(hostname);
-        var isLocalhost = hostname === 'localhost';
+        const { hostname } = url;
+        const isIp = /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/.test(hostname);
+        const isLocalhost = hostname === 'localhost';
         // Check if hostname is an IP address when not allowed
         if (isIp && options.allowIp === false) {
-            throw new Error("Environment variable '".concat(key, "' cannot be an IP address: \"").concat(hostname, "\""));
+            throw new Error(`Environment variable '${key}' cannot be an IP address: "${hostname}"`);
         }
         // Check if hostname is localhost when not allowed
         if (isLocalhost && options.allowLocalhost === false) {
-            throw new Error("Environment variable '".concat(key, "' cannot be localhost"));
+            throw new Error(`Environment variable '${key}' cannot be localhost`);
         }
         // Check for TLD requirement - include localhost in check if requireTld is true and allowLocalhost is false
         if (options.requireTld === true) {
@@ -524,12 +468,12 @@ var Env = /** @class */ (function () {
                 // IP is allowed, so no TLD check needed for it
             }
             else if (!hostname.includes('.') || hostname.endsWith('.')) {
-                throw new Error("Environment variable '".concat(key, "' must have a valid host with TLD: \"").concat(hostname, "\""));
+                throw new Error(`Environment variable '${key}' must have a valid host with TLD: "${hostname}"`);
             }
         }
         this.cache.set(cacheKey, value);
         return value;
-    };
+    }
     /**
      * Retrieves an email environment variable and validates it.
      *
@@ -541,25 +485,25 @@ var Env = /** @class */ (function () {
      * @example
      * const supportEmail = Env.getEmail('SUPPORT_EMAIL', 'support@example.com');
      */
-    Env.getEmail = function (key, defaultValue) {
-        if (this.cache.has("email:".concat(key))) {
-            return this.cache.get("email:".concat(key));
+    static getEmail(key, defaultValue) {
+        if (this.cache.has(`email:${key}`)) {
+            return this.cache.get(`email:${key}`);
         }
-        var value = Env.get(key, defaultValue);
+        const value = Env.get(key, defaultValue);
         if (!value) {
             if (defaultValue === undefined) {
-                throw new Error("Email environment variable '".concat(key, "' is missing"));
+                throw new Error(`Email environment variable '${key}' is missing`);
             }
             return defaultValue;
         }
         // More comprehensive email validation regex
-        var emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+        const emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
         if (!emailRegex.test(value)) {
-            throw new Error("Environment variable '".concat(key, "' is not a valid email address: \"").concat(value, "\""));
+            throw new Error(`Environment variable '${key}' is not a valid email address: "${value}"`);
         }
-        this.cache.set("email:".concat(key), value);
+        this.cache.set(`email:${key}`, value);
         return value;
-    };
+    }
     /**
      * Retrieves a path environment variable and validates it exists.
      *
@@ -576,34 +520,33 @@ var Env = /** @class */ (function () {
      *   allowedExtensions: ['.json', '.yaml']
      * });
      */
-    Env.getPath = function (key, defaultValue, options) {
-        if (options === void 0) { options = {}; }
-        var cacheKey = "path:".concat(key, ":").concat(JSON.stringify(options));
+    static getPath(key, defaultValue, options = {}) {
+        const cacheKey = `path:${key}:${JSON.stringify(options)}`;
         if (this.cache.has(cacheKey)) {
             return this.cache.get(cacheKey);
         }
-        var value = Env.get(key, defaultValue);
+        const value = Env.get(key, defaultValue);
         if (!value) {
             if (defaultValue === undefined) {
-                throw new Error("Path environment variable '".concat(key, "' is missing"));
+                throw new Error(`Path environment variable '${key}' is missing`);
             }
             return defaultValue;
         }
-        var path = options.makeAbsolute !== false && !isAbsolute(value) ? resolve(process.cwd(), value) : value;
+        const path = options.makeAbsolute !== false && !isAbsolute(value) ? resolve(process.cwd(), value) : value;
         // Validate path exists if required
         if (options.mustExist && !existsSync(path)) {
-            throw new Error("Path in environment variable '".concat(key, "' does not exist: \"").concat(path, "\""));
+            throw new Error(`Path in environment variable '${key}' does not exist: "${path}"`);
         }
         // Validate file extension if specified
         if (options.allowedExtensions && options.allowedExtensions.length > 0) {
-            var hasValidExtension = options.allowedExtensions.some(function (ext) { return path.toLowerCase().endsWith(ext.toLowerCase()); });
+            const hasValidExtension = options.allowedExtensions.some(ext => path.toLowerCase().endsWith(ext.toLowerCase()));
             if (!hasValidExtension) {
-                throw new Error("Path in environment variable '".concat(key, "' must have one of these extensions: ").concat(options.allowedExtensions.join(', '), ". Got: \"").concat(path, "\""));
+                throw new Error(`Path in environment variable '${key}' must have one of these extensions: ${options.allowedExtensions.join(', ')}. Got: "${path}"`);
             }
         }
         this.cache.set(cacheKey, path);
         return path;
-    };
+    }
     /**
      * Retrieves a port environment variable and validates it.
      *
@@ -615,18 +558,18 @@ var Env = /** @class */ (function () {
      * @example
      * const serverPort = Env.getPort('PORT', 3000);
      */
-    Env.getPort = function (key, defaultValue) {
+    static getPort(key, defaultValue) {
         try {
             return Env.getInteger(key, defaultValue, { min: 0, max: 65535 });
         }
         catch (error) {
             // Rewrite the error message to match the expected pattern
             if (error.message.includes('must be at most 65535')) {
-                throw new Error("Environment variable '".concat(key, "' must be a valid port number (0-65535)"));
+                throw new Error(`Environment variable '${key}' must be a valid port number (0-65535)`);
             }
             throw error;
         }
-    };
+    }
     /**
      * Retrieves an ISO date string and converts it to a Date object.
      *
@@ -638,18 +581,17 @@ var Env = /** @class */ (function () {
      * // If EXPIRY_DATE=2023-12-31T23:59:59Z
      * const expiryDate = Env.getDate('EXPIRY_DATE', new Date());
      */
-    Env.getDate = function (key, defaultValue) {
-        if (defaultValue === void 0) { defaultValue = new Date(); }
-        var value = Env.get(key, defaultValue instanceof Date ? defaultValue.toISOString() : defaultValue);
+    static getDate(key, defaultValue = new Date()) {
+        const value = Env.get(key, defaultValue instanceof Date ? defaultValue.toISOString() : defaultValue);
         if (!value) {
             return defaultValue instanceof Date ? defaultValue : new Date();
         }
-        var date = new Date(value);
+        const date = new Date(value);
         if (isNaN(date.getTime())) {
-            throw new Error("Environment variable '".concat(key, "' is not a valid date: \"").concat(value, "\""));
+            throw new Error(`Environment variable '${key}' is not a valid date: "${value}"`);
         }
         return date;
-    };
+    }
     /**
      * Retrieves a duration string and converts it to milliseconds.
      * Supports formats like "1d", "2h", "30m", "45s", "100ms" or combinations like "1h30m".
@@ -664,29 +606,28 @@ var Env = /** @class */ (function () {
      * const cacheTtlMs = Env.getDuration('CACHE_TTL', '1h');
      * // 9000000 (2.5 hours in milliseconds)
      */
-    Env.getDuration = function (key, defaultValue) {
-        if (defaultValue === void 0) { defaultValue = '0'; }
-        var cacheKey = "duration:".concat(key);
+    static getDuration(key, defaultValue = '0') {
+        const cacheKey = `duration:${key}`;
         if (this.cache.has(cacheKey)) {
             return this.cache.get(cacheKey);
         }
-        var value = Env.get(key, String(defaultValue));
+        const value = Env.get(key, String(defaultValue));
         if (!value)
             return 0;
         // Handle plain number input (assume milliseconds)
         if (/^\d+$/.test(value)) {
-            var ms_1 = parseInt(value, 10);
-            this.cache.set(cacheKey, ms_1);
-            return ms_1;
+            const ms = parseInt(value, 10);
+            this.cache.set(cacheKey, ms);
+            return ms;
         }
         // Enhanced duration parsing with more precise regex
-        var durationRegex = /^(?:(\d+)y)?(?:(\d+)w)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?(?:(\d+)ms)?$/;
-        var matches = value.match(durationRegex);
+        const durationRegex = /^(?:(\d+)y)?(?:(\d+)w)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?(?:(\d+)ms)?$/;
+        const matches = value.match(durationRegex);
         if (!matches || matches[0] === '') {
-            throw new Error("Environment variable '".concat(key, "' has invalid duration format: \"").concat(value, "\". ") +
-                "Use formats like 1y, 2w, 3d, 4h, 5m, 6s, or 7ms.");
+            throw new Error(`Environment variable '${key}' has invalid duration format: "${value}". ` +
+                `Use formats like 1y, 2w, 3d, 4h, 5m, 6s, or 7ms.`);
         }
-        var ms = 0;
+        let ms = 0;
         if (matches[1])
             ms += parseInt(matches[1], 10) * 31536000000; // years (approximate)
         if (matches[2])
@@ -703,7 +644,7 @@ var Env = /** @class */ (function () {
             ms += parseInt(matches[7], 10); // milliseconds
         this.cache.set(cacheKey, ms);
         return ms;
-    };
+    }
     /**
      * Gets all environment variables with sensitive values masked for safe logging.
      *
@@ -714,31 +655,16 @@ var Env = /** @class */ (function () {
      * console.log(Env.getSafeEnv(['password', 'secret', 'key']));
      * // { DATABASE_URL: "postgres://...", API_KEY: "******", ... }
      */
-    Env.getSafeEnv = function (sensitiveKeys) {
-        var e_2, _a;
-        if (sensitiveKeys === void 0) { sensitiveKeys = ['password', 'secret', 'key', 'token', 'auth']; }
-        var safeEnv = {};
-        var _loop_1 = function (key, value) {
+    static getSafeEnv(sensitiveKeys = ['password', 'secret', 'key', 'token', 'auth']) {
+        const safeEnv = {};
+        for (const [key, value] of Object.entries(process.env)) {
             if (!value)
-                return "continue";
-            var isSensitive = sensitiveKeys.some(function (sensitiveKey) { return key.toLowerCase().includes(sensitiveKey.toLowerCase()); });
+                continue;
+            const isSensitive = sensitiveKeys.some(sensitiveKey => key.toLowerCase().includes(sensitiveKey.toLowerCase()));
             safeEnv[key] = isSensitive ? '******' : value;
-        };
-        try {
-            for (var _b = __values(Object.entries(process.env)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
-                _loop_1(key, value);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_2) throw e_2.error; }
         }
         return safeEnv;
-    };
+    }
     /**
      * Loads environment variables from a .env file.
      * Does not override existing variables.
@@ -750,45 +676,44 @@ var Env = /** @class */ (function () {
      * // Load variables from .env.development
      * Env.loadFromFile('.env.development');
      */
-    Env.loadFromFile = function (path) {
-        if (path === void 0) { path = '.env'; }
+    static loadFromFile(path = '.env') {
         if (!existsSync(path)) {
-            throw new Error("Environment file not found: \"".concat(path, "\""));
+            throw new Error(`Environment file not found: "${path}"`);
         }
-        var content = readFileSync(path, 'utf8');
-        var variables = {};
-        var lines = content.split(/\r?\n/);
-        var i = 0;
+        const content = readFileSync(path, 'utf8');
+        const variables = {};
+        const lines = content.split(/\r?\n/);
+        let i = 0;
         while (i < lines.length) {
-            var line = lines[i].trim();
+            let line = lines[i].trim();
             // Skip empty lines or comment-only lines
             if (!line || line.startsWith('#')) {
                 i++;
                 continue;
             }
-            var match = line.match(/^([^=]+)=(.*)$/);
+            const match = line.match(/^([^=]+)=(.*)$/);
             if (!match) {
                 i++;
                 continue;
             }
-            var key = match[1].trim();
-            var value = match[2].trim();
+            const key = match[1].trim();
+            let value = match[2].trim();
             // Remove inline comment for unquoted values
             if (!/^['"]/.test(value)) {
-                var hashIndex = value.indexOf(' #');
+                const hashIndex = value.indexOf(' #');
                 if (hashIndex !== -1) {
                     value = value.slice(0, hashIndex).trim();
                 }
             }
             // Handle quoted values
             if ((value.startsWith('"') || value.startsWith("'")) && value.length > 1) {
-                var quote = value[0];
+                const quote = value[0];
                 if (!value.endsWith(quote) || value.length === 1) {
                     // multiline quoted
-                    var multilineValue = value.slice(1);
+                    let multilineValue = value.slice(1);
                     i++;
                     while (i < lines.length) {
-                        var nextLine = lines[i];
+                        const nextLine = lines[i];
                         if (nextLine.endsWith(quote)) {
                             multilineValue += '\n' + nextLine.slice(0, -1);
                             break;
@@ -821,53 +746,37 @@ var Env = /** @class */ (function () {
             i++;
         }
         return variables;
-    };
+    }
     /**
      * Checks whether the specified environment variable exists.
      *
      * @param {string} key - The environment variable key.
      * @returns {boolean} `true` if the variable is defined, otherwise `false`.
      */
-    Env.has = function (key) {
+    static has(key) {
         return process.env[key] !== undefined;
-    };
+    }
     /**
      * Deletes the given environment variable (useful in tests).
      *
      * @param {string} key - The environment variable key to delete.
      * @returns {void}
      */
-    Env.delete = function (key) {
-        var e_3, _a;
+    static delete(key) {
         delete process.env[key];
         this.cache.delete(key);
-        try {
-            // Also clear all cached variations of this key
-            for (var _b = __values(this.cache.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var cacheKey = _c.value;
-                if (cacheKey.includes(":".concat(key))) {
-                    this.cache.delete(cacheKey);
-                }
+        // Also clear all cached variations of this key
+        for (const cacheKey of this.cache.keys()) {
+            if (cacheKey.includes(`:${key}`)) {
+                this.cache.delete(cacheKey);
             }
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_3) throw e_3.error; }
-        }
-    };
+    }
     /**
      * Clears the internal cache of parsed environment values.
      * Useful for testing or when environment variables might change.
      */
-    Env.clearCache = function () {
+    static clearCache() {
         this.cache.clear();
-    };
-    // Cache for parsed values to avoid repeated parsing of complex values
-    Env.cache = new Map();
-    return Env;
-}());
-export { Env };
-//# sourceMappingURL=env.utils.js.map
+    }
+}