@catbee/utils 2.0.0-next.0 → 2.0.0-next.1

package/config/index.mjs

@@ -24,57 +24,39 @@
 
 import { Env } from '@catbee/utils/env';
 import { uuid } from '@catbee/utils/id';
-import { deepObjMerge } from '@catbee/utils/obj';
+import { deepClone, deepObjMerge } from '@catbee/utils/obj';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var defaultCatbeeConfig = {
-  logger: {
-    level: Env.get("LOGGER_LEVEL", Env.isDev() ? "debug" : "info"),
-    name: Env.get("LOGGER_NAME", Env.get("npm_package_name", "@catbee/utils")),
-    pretty: Env.getBoolean("LOGGER_PRETTY", false),
-    colorize: Env.getBoolean("LOGGER_PRETTY_COLORIZE", true),
-    singleLine: Env.getBoolean("LOGGER_PRETTY_SINGLE_LINE", false),
-    dir: Env.getPath("LOGGER_DIR", "", {
-      mustExist: false
-    })
-  },
-  cache: {
-    defaultTtl: Env.getNumber("CACHE_DEFAULT_TTL_SECONDS", 3600) * 1e3
-  },
-  server: {
-    skipHealthz: Env.getBoolean("SERVER_SKIP_HEALTHZ", false)
-  }
-};
 var defaultServerConfig = {
-  port: 3e3,
-  host: "0.0.0.0",
-  cors: false,
-  helmet: false,
-  compression: false,
+  port: Env.getNumber("SERVER_PORT", 0) || Env.getNumber("PORT", 3e3),
+  host: Env.get("SERVER_HOST", "") || Env.get("HOST", "0.0.0.0"),
+  cors: Env.getBoolean("SERVER_CORS_ENABLE", false) ? {} : false,
+  helmet: Env.getBoolean("SERVER_HELMET_ENABLE", false) ? {} : false,
+  compression: Env.getBoolean("SERVER_COMPRESSION_ENABLE", false) ? {} : false,
   bodyParser: {
     json: {
-      limit: "1mb"
+      limit: Env.get("SERVER_BODY_PARSER_JSON_LIMIT", "1mb")
     },
     urlencoded: {
       extended: true,
-      limit: "1mb"
+      limit: Env.get("SERVER_BODY_PARSER_URLENCODED_LIMIT", "1mb")
     }
   },
-  cookieParser: false,
-  isMicroservice: false,
-  appName: "express_app",
-  globalHeaders: {},
+  cookieParser: Env.getBoolean("SERVER_COOKIE_PARSER_ENABLE", false) ? {} : false,
+  isMicroservice: Env.getBoolean("SERVER_IS_MICROSERVICE", false),
+  appName: Env.get("SERVER_APP_NAME", Env.get("npm_package_name", "catbee_server")),
+  globalHeaders: Env.getJSON("SERVER_GLOBAL_HEADERS", {}),
   rateLimit: {
-    enable: false,
-    windowMs: 15 * 60 * 1e3,
-    max: 100,
-    message: "Too many requests",
-    standardHeaders: true,
-    legacyHeaders: false
+    enable: Env.getBoolean("SERVER_RATE_LIMIT_ENABLE", false),
+    windowMs: Env.getDuration("SERVER_RATE_LIMIT_WINDOW_MS", 15 * 60 * 1e3),
+    max: Env.getNumber("SERVER_RATE_LIMIT_MAX", 100),
+    message: Env.get("SERVER_RATE_LIMIT_MESSAGE", "Too many requests, please try again later."),
+    standardHeaders: Env.getBoolean("SERVER_RATE_LIMIT_STANDARD_HEADERS", true),
+    legacyHeaders: Env.getBoolean("SERVER_RATE_LIMIT_LEGACY_HEADERS", false)
   },
   requestLogging: {
-    enable: Env.isDev(),
+    enable: Env.getBoolean("SERVER_REQUEST_LOGGING_ENABLE", Env.isDev()),
     ignorePaths: /* @__PURE__ */ __name((req, _res) => {
       const skipPaths = [
         "/healthz",
@@ -85,47 +67,77 @@ var defaultServerConfig = {
       ];
       return skipPaths.some((path) => req.path.startsWith(path));
     }, "ignorePaths"),
-    skipNotFoundRoutes: false
+    skipNotFoundRoutes: Env.getBoolean("SERVER_REQUEST_LOGGING_SKIP_NOT_FOUND_ROUTES", true)
   },
+  trustProxy: Env.getBoolean("SERVER_TRUST_PROXY_ENABLE", false),
   openApi: {
-    enable: false,
-    mountPath: "/docs",
-    verbose: false,
-    withGlobalPrefix: false
+    enable: Env.getBoolean("SERVER_OPENAPI_ENABLE", false),
+    mountPath: Env.get("SERVER_OPENAPI_MOUNT_PATH", "/docs"),
+    verbose: Env.getBoolean("SERVER_OPENAPI_VERBOSE", false),
+    withGlobalPrefix: Env.getBoolean("SERVER_OPENAPI_WITH_GLOBAL_PREFIX", false)
   },
   healthCheck: {
-    path: "/healthz",
-    detailed: true
+    path: Env.get("SERVER_HEALTH_CHECK_PATH", "/healthz"),
+    detailed: Env.getBoolean("SERVER_HEALTH_CHECK_DETAILED_OUTPUT", true),
+    withGlobalPrefix: Env.getBoolean("SERVER_HEALTH_CHECK_WITH_GLOBAL_PREFIX", false)
   },
-  requestTimeout: 3e4,
+  requestTimeout: Env.getDuration("SERVER_REQUEST_TIMEOUT_MS", 0),
   responseTime: {
-    enable: false,
-    addHeader: true,
-    logOnComplete: false
+    enable: Env.getBoolean("SERVER_RESPONSE_TIME_ENABLE", false),
+    addHeader: Env.getBoolean("SERVER_RESPONSE_TIME_ADD_HEADER", true),
+    logOnComplete: Env.getBoolean("SERVER_RESPONSE_TIME_LOG_ON_COMPLETE", false)
   },
   requestId: {
-    headerName: "x-request-id",
-    exposeHeader: true,
+    headerName: Env.get("SERVER_REQUEST_ID_HEADER_NAME", "x-request-id"),
+    exposeHeader: Env.getBoolean("SERVER_REQUEST_ID_EXPOSE_HEADER", true),
     generator: /* @__PURE__ */ __name(() => uuid(), "generator")
   },
   metrics: {
-    enable: false,
-    path: "/metrics",
-    withGlobalPrefix: false
+    enable: Env.getBoolean("SERVER_METRICS_ENABLE", false),
+    path: Env.get("SERVER_METRICS_PATH", "/metrics"),
+    withGlobalPrefix: Env.getBoolean("SERVER_METRICS_WITH_GLOBAL_PREFIX", false)
   },
   serviceVersion: {
-    enable: false,
-    headerName: "x-service-version",
-    version: "0.0.0"
-  }
+    enable: Env.getBoolean("SERVER_SERVICE_VERSION_ENABLE", false),
+    headerName: Env.get("SERVER_SERVICE_VERSION_HEADER_NAME", "x-service-version"),
+    version: Env.get("SERVER_SERVICE_VERSION", "0.0.0")
+  },
+  skipHealthz: Env.getBoolean("SERVER_SKIP_HEALTHZ", false)
 };
-function setConfig(value) {
-  deepObjMerge(defaultCatbeeConfig, value);
+var defaultCatbeeConfig = {
+  logger: {
+    level: Env.get("LOGGER_LEVEL", Env.isDev() || Env.isTest() ? "debug" : "info"),
+    name: Env.get("LOGGER_NAME", Env.get("npm_package_name", "@catbee/utils")),
+    pretty: Env.getBoolean("LOGGER_PRETTY", false),
+    colorize: Env.getBoolean("LOGGER_PRETTY_COLORIZE", true),
+    singleLine: Env.getBoolean("LOGGER_PRETTY_SINGLE_LINE", false),
+    dir: Env.getPath("LOGGER_DIR", "", {
+      mustExist: false
+    })
+  },
+  cache: {
+    defaultTtl: Env.getNumber("CACHE_DEFAULT_TTL_SECONDS", 3600) * 1e3
+  },
+  server: defaultServerConfig
+};
+var _config = deepClone(defaultCatbeeConfig);
+function getCatbeeGlobalConfig() {
+  return deepClone(_config);
+}
+__name(getCatbeeGlobalConfig, "getCatbeeGlobalConfig");
+var getConfig = getCatbeeGlobalConfig;
+function setCatbeeGlobalConfig(value) {
+  _config = deepObjMerge(_config, value);
+}
+__name(setCatbeeGlobalConfig, "setCatbeeGlobalConfig");
+var setConfig = setCatbeeGlobalConfig;
+function setCatbeeServerGlobalConfig(value) {
+  _config.server = deepObjMerge(_config.server, value);
 }
-__name(setConfig, "setConfig");
-function getConfig() {
-  return defaultCatbeeConfig;
+__name(setCatbeeServerGlobalConfig, "setCatbeeServerGlobalConfig");
+function getCatbeeServerGlobalConfig() {
+  return getCatbeeGlobalConfig().server;
 }
-__name(getConfig, "getConfig");
+__name(getCatbeeServerGlobalConfig, "getCatbeeServerGlobalConfig");
 
-export { defaultCatbeeConfig, defaultServerConfig, getConfig, setConfig };
+export { getCatbeeGlobalConfig, getCatbeeServerGlobalConfig, getConfig, setCatbeeGlobalConfig, setCatbeeServerGlobalConfig, setConfig };

package/context-store/index.d.ts

@@ -22,4 +22,195 @@
  * SOFTWARE.
  */
 
-export * from './context-store.utils';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+/**
+ * Type representing the store object used in AsyncLocalStorage.
+ * Keys must be unique symbols to ensure isolation and prevent collisions.
+ */
+interface Store {
+    [key: symbol]: unknown;
+}
+/**
+ * Predefined symbols used as keys in AsyncLocalStorage.
+ * Add new symbols here to avoid duplication.
+ */
+declare const StoreKeys: {
+    LOGGER: symbol;
+    REQUEST_ID: symbol;
+    USER: symbol;
+    SESSION: symbol;
+    TRANSACTION_ID: symbol;
+    USER_ID: symbol;
+    TENANT_ID: symbol;
+    TRACE_ID: symbol;
+    CORRELATION_ID: symbol;
+};
+/**
+ * Retrieves the current request ID from the async context, if available.
+ *
+ * @returns {string | undefined} The request ID string or undefined if not present in the current context.
+ */
+declare function getRequestId(): string | undefined;
+/**
+ * Type-safe getter for common context values.
+ *
+ * @param key The store key symbol
+ * @returns The typed value from the store
+ */
+declare function getFromContext<T>(key: symbol): T | undefined;
+/**
+ * ContextStore manages per-request scoped context using AsyncLocalStorage.
+ * It allows storing and retrieving data across async calls (e.g., request ID, logger).
+ *
+ * Example (Express middleware):
+ * ```
+ * // Middleware to initialize context and logger
+ * app.use((req, res, next) => {
+ *   const requestId = req.headers["x-request-id"]?.toString() || crypto.randomUUID();
+ *   ContextStore.run({ [StoreKeys.REQUEST_ID]: requestId }, () => {
+ *     ContextStore.set(StoreKeys.LOGGER, getLogger().child({ requestId }));
+ *     next();
+ *   });
+ * });
+ * ```
+ */
+declare class ContextStore {
+    /**
+     * The underlying AsyncLocalStorage instance for context.
+     * @private
+     */
+    private static readonly storage;
+    /**
+     * Returns the raw AsyncLocalStorage instance for advanced access.
+     *
+     * @returns {AsyncLocalStorage<Store>} The AsyncLocalStorage instance.
+     */
+    static getInstance(): AsyncLocalStorage<Store>;
+    /**
+     * Retrieves a value from the async context store by symbol key.
+     *
+     * @typeParam T - The expected return type of the value.
+     * @param {symbol} key - Unique symbol used as the store key.
+     * @returns {T | undefined} The value found (typed) or undefined if not present.
+     */
+    static get<T>(key: symbol): T | undefined;
+    /**
+     * Sets a value in the current context store by symbol key.
+     *
+     * @typeParam T - The value type to set.
+     * @param {symbol} key - Unique symbol key.
+     * @param {T} value - Value to set in context.
+     * @throws {Error} If called outside an active context (not within a .run call or in the wrong async boundaries).
+     */
+    static set<T>(key: symbol, value: T): void;
+    /**
+     * Retrieves the entire context store object for the current async context.
+     *
+     * @returns {Store | undefined} The current store object or undefined if called outside a context.
+     */
+    static getAll(): Store | undefined;
+    /**
+     * Initializes a new async context and executes a callback within it.
+     * This must be called at the beginning of a request or logical async flow.
+     *
+     * @typeParam T - The callback's return type.
+     * @param {Store} store - The initial key-value store object.
+     * @param {() => T} callback - The function to run within the new context.
+     * @returns {T} The result of the callback function.
+     */
+    static run<T>(store: Store, callback: () => T): T;
+    /**
+     * Checks if a key exists in the current context store.
+     *
+     * @param {symbol} key - The symbol key to check.
+     * @returns {boolean} True if the key exists, false otherwise.
+     */
+    static has(key: symbol): boolean;
+    /**
+     * Removes a value from the current context store by symbol key.
+     *
+     * @param {symbol} key - The symbol key to delete.
+     * @returns {boolean} True if the key was deleted, false if the key wasn't found or no active context.
+     * @throws {Error} If called outside an active context.
+     */
+    static delete(key: symbol): boolean;
+    /**
+     * Updates multiple values in the current context store at once.
+     *
+     * @param {Partial<Record<symbol, unknown>>} values - Object containing symbol keys and values to update.
+     * @throws {Error} If called outside an active context.
+     */
+    static patch(values: Partial<Record<symbol, unknown>>): void;
+    /**
+     * Executes a callback with a temporary store value that only exists during execution.
+     * Original store is restored after callback completes.
+     *
+     * @typeParam T - The callback's return type.
+     * @param {symbol} key - The symbol key to temporarily set.
+     * @param {unknown} value - The temporary value.
+     * @param {() => T} callback - The function to execute with the temporary value.
+     * @returns {T} The result of the callback function.
+     * @throws {Error} If called outside an active context.
+     */
+    static withValue<T>(key: symbol, value: unknown, callback: () => T): T;
+    /**
+     * Creates a new context that inherits values from the current context.
+     *
+     * @typeParam T - The callback's return type.
+     * @param {Partial<Record<symbol, unknown>>} newValues - New values to add to or override in the context.
+     * @param {() => T} callback - The function to execute in the new context.
+     * @returns {T} The result of the callback function.
+     */
+    static extend<T>(newValues: Partial<Record<symbol, unknown>>, callback: () => T): T;
+    /**
+     * Creates Express middleware that initializes a context for each request.
+     *
+     * @param {(req: any) => Partial<Record<symbol, unknown>>} initialValuesFactory - Function that returns initial context values.
+     * @returns Express middleware function.
+     */
+    static createExpressMiddleware(initialValuesFactory?: (req: any) => Partial<Record<symbol, unknown>>): (req: any, _res: any, next: any) => void;
+}
+/**
+ * Type-safe wrapper for accessing and modifying context values with specific types.
+ *
+ * @typeParam T - The value type.
+ */
+declare class TypedContextKey<T> {
+    private readonly symbol;
+    private readonly defaultValue?;
+    /**
+     * Creates a new typed context key.
+     *
+     * @param symbol - The unique symbol for this key
+     * @param defaultValue - Optional default value if key is not found
+     */
+    constructor(symbol: symbol, defaultValue?: T | undefined);
+    /**
+     * Gets the current value for this key.
+     *
+     * @returns The value or defaultValue if not found
+     */
+    get(): T | undefined;
+    /**
+     * Sets the value for this key.
+     *
+     * @param value The value to set
+     */
+    set(value: T): void;
+    /**
+     * Checks if this key exists in the context.
+     *
+     * @returns True if the key exists
+     */
+    exists(): boolean;
+    /**
+     * Deletes this key from the context.
+     *
+     * @returns True if the key was deleted
+     */
+    delete(): boolean;
+}
+
+export { ContextStore, StoreKeys, TypedContextKey, getFromContext, getRequestId };
+export type { Store };

package/crypto/index.d.ts

@@ -22,4 +22,166 @@
  * SOFTWARE.
  */
 
-export * from './crypto.utils';
+import { BinaryToTextEncoding, CipherGCMTypes } from 'node:crypto';
+
+type BufferEncoding = 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'utf-16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex';
+/**
+ * Generates an HMAC digest using the specified algorithm and secret key.
+ *
+ * @param {string} algorithm - The hashing algorithm (e.g., 'sha256', 'sha1').
+ * @param {string} input - The string to hash.
+ * @param {string} secret - The secret key for HMAC.
+ * @param {BinaryToTextEncoding} [encoding='hex'] - Output encoding ('hex', 'base64', etc).
+ * @returns {string} HMAC digest as a string.
+ */
+declare function hmac(algorithm: string, input: string, secret: string, encoding?: BinaryToTextEncoding): string;
+/**
+ * Generates a hash digest using the specified algorithm.
+ *
+ * @param {string} algorithm - The hashing algorithm (e.g., 'sha256', 'md5').
+ * @param {string} input - The string to hash.
+ * @param {BinaryToTextEncoding} [encoding='hex'] - Output encoding ('hex', 'base64', etc).
+ * @returns {string} Hash digest as a string.
+ */
+declare function hash(algorithm: string, input: string, encoding?: BinaryToTextEncoding): string;
+/**
+ * Generates an HMAC-SHA256 digest.
+ *
+ * @param {string} input - The string to hash.
+ * @param {string} secret - The secret key.
+ * @returns {string} SHA-256 HMAC digest as a string.
+ */
+declare function sha256Hmac(input: string, secret: string): string;
+/**
+ * Generates a SHA1 hash digest.
+ *
+ * @param {string} input - The string to hash.
+ * @param {BinaryToTextEncoding} [encoding='hex'] - Output encoding.
+ * @returns {string} SHA-1 hash as a string.
+ */
+declare function sha1(input: string, encoding?: BinaryToTextEncoding): string;
+/**
+ * Generates a SHA256 hash digest.
+ *
+ * @param {string} input - The string to hash.
+ * @param {BinaryToTextEncoding} [encoding='hex'] - Output encoding.
+ * @returns {string} SHA-256 hash as a string.
+ */
+declare function sha256(input: string, encoding?: BinaryToTextEncoding): string;
+/**
+ * Generates an MD5 hash digest.
+ *
+ * @param {string} input - The string to hash.
+ * @returns {string} MD5 hash as a string.
+ */
+declare function md5(input: string): string;
+/**
+ * Generates a cryptographically strong random string by hashing a random UUID with SHA-256.
+ *
+ * @returns {string} Random string hashed with SHA-256 (hex encoding).
+ */
+declare function randomString(): string;
+/**
+ * Generates a secure random buffer of specified byte length.
+ *
+ * @param {number} [byteLength=32] - Number of random bytes to generate.
+ * @returns {Buffer} Buffer containing random bytes.
+ */
+declare function generateRandomBytes(byteLength?: number): Buffer;
+/**
+ * Generates a secure random string of specified byte length with specified encoding.
+ *
+ * @param {number} [byteLength=32] - Number of random bytes to generate.
+ * @param {BinaryToTextEncoding} [encoding='hex'] - Output encoding.
+ * @returns {string} Random string in specified encoding.
+ */
+declare function generateRandomBytesAsString(byteLength?: number, encoding?: BinaryToTextEncoding): string;
+/**
+ * Generates a secure API key with a specified format.
+ *
+ * @param {string} [prefix=''] - Optional prefix for the key.
+ * @param {number} [byteLength=24] - Number of random bytes to generate.
+ * @returns {string} Formatted API key.
+ */
+declare function generateApiKey(prefix?: string, byteLength?: number): string;
+/**
+ * Compares two strings, arrays, or buffers in constant time to prevent timing attacks.
+ *
+ * @param {string | Buffer | Uint8Array} a - First value to compare
+ * @param {string | Buffer | Uint8Array} b - Second value to compare
+ * @returns {boolean} True if values are equal
+ */
+declare function safeCompare(a: string | Buffer | Uint8Array, b: string | Buffer | Uint8Array): boolean;
+/**
+ * Interface for encryption options
+ */
+interface EncryptionOptions {
+    /** Algorithm to use (default: aes-256-gcm) */
+    algorithm?: CipherGCMTypes;
+    /** Input encoding for plaintext if string (default: utf8) */
+    inputEncoding?: BufferEncoding;
+    /** Output encoding for ciphertext (default: hex) */
+    outputEncoding?: BinaryToTextEncoding;
+}
+/**
+ * Interface for decryption options
+ */
+interface DecryptionOptions {
+    /** Algorithm to use (default: aes-256-gcm) */
+    algorithm?: CipherGCMTypes;
+    /** Input encoding for ciphertext if string (default: hex) */
+    inputEncoding?: BinaryToTextEncoding;
+    /** Output encoding for plaintext (default: utf8) */
+    outputEncoding?: BufferEncoding;
+}
+/**
+ * Result of encryption operation including all data needed for decryption
+ */
+interface EncryptionResult {
+    /** Encrypted data (string or Buffer based on options) */
+    ciphertext: string | Buffer;
+    /** Initialization vector */
+    iv: Buffer;
+    /** Authentication tag (for GCM mode) */
+    authTag?: Buffer;
+    /** Algorithm used */
+    algorithm: string;
+}
+/**
+ * Encrypts data using a symmetric key with secure defaults (AES-256-GCM).
+ *
+ * @param {string | Buffer} data - Data to encrypt
+ * @param {string | Buffer} key - Encryption key or passphrase
+ * @param {EncryptionOptions} [options] - Encryption options
+ * @returns {Promise<EncryptionResult>} Encrypted data with metadata
+ */
+declare function encrypt(data: string | Buffer, key: string | Buffer, options?: EncryptionOptions): Promise<EncryptionResult>;
+/**
+ * Decrypts data that was encrypted with the encrypt function.
+ *
+ * @param {EncryptionResult} encryptedData - The encrypted data and metadata
+ * @param {string | Buffer} key - Decryption key or passphrase
+ * @param {DecryptionOptions} [options] - Decryption options
+ * @returns {Promise<string | Buffer>} Decrypted data
+ */
+declare function decrypt(encryptedData: EncryptionResult, key: string | Buffer, options?: DecryptionOptions): Promise<string | Buffer>;
+/**
+ * Creates a signed token with an expiration time and payload.
+ *
+ * @param {object} payload - Data to include in the token
+ * @param {string} secret - Secret key for signing
+ * @param {number} [expiresInSeconds=3600] - Token expiration in seconds
+ * @returns {string} Signed token string
+ */
+declare function createSignedToken(payload: Record<string, any>, secret: string, expiresInSeconds?: number): string;
+/**
+ * Verifies and decodes a signed token.
+ *
+ * @param {string} token - The token to verify
+ * @param {string} secret - Secret key for verification
+ * @returns {object | null} Decoded payload if valid, null if invalid
+ */
+declare function verifySignedToken(token: string, secret: string): Record<string, any> | null;
+
+export { createSignedToken, decrypt, encrypt, generateApiKey, generateRandomBytes, generateRandomBytesAsString, hash, hmac, md5, randomString, safeCompare, sha1, sha256, sha256Hmac, verifySignedToken };
+export type { BufferEncoding, DecryptionOptions, EncryptionOptions, EncryptionResult };

package/date/index.cjs

@@ -88,7 +88,7 @@ function parseDate(input, fallback) {
   }
   try {
     const date = new Date(input);
-    if (isNaN(date.getTime())) {
+    if (Number.isNaN(date.getTime())) {
       return fallback || null;
     }
     return date;
@@ -281,6 +281,49 @@ function formatDuration(ms) {
   return parts.join(" ");
 }
 __name(formatDuration, "formatDuration");
+function parseDuration(value) {
+  const MAX_SAFE = Number.MAX_SAFE_INTEGER;
+  if (typeof value === "number" && Number.isFinite(value)) return Math.min(value, MAX_SAFE);
+  if (typeof value !== "string" || !value.trim()) return 0;
+  if (/^\d+$/.test(value)) return Math.min(Number(value), MAX_SAFE);
+  const val = value.replace(/\s+/g, "").toLowerCase();
+  const unitMap = {
+    y: 31536e6,
+    w: 6048e5,
+    d: 864e5,
+    h: 36e5,
+    m: 6e4,
+    s: 1e3,
+    ms: 1
+  };
+  const unitKeys = Object.keys(unitMap).sort((a, b) => b.length - a.length);
+  let total = 0;
+  let i = 0;
+  while (i < val.length) {
+    const start = i;
+    while (i < val.length && /\d/.test(val[i])) i++;
+    if (start === i) {
+      throw new Error(`Invalid duration at offset ${i} in "${value}"`);
+    }
+    const num = Number(val.slice(start, i));
+    if (!Number.isSafeInteger(num)) throw new Error(`Invalid number at offset ${start} in "${value}"`);
+    const unit = unitKeys.find((u) => val.startsWith(u, i));
+    if (!unit) throw new Error(`Unknown unit at offset ${i} in "${value}"`);
+    const add = num * unitMap[unit];
+    total = Math.min(total + add, MAX_SAFE);
+    i += unit.length;
+  }
+  return total;
+}
+__name(parseDuration, "parseDuration");
+function getDateFromDuration(input) {
+  const ms = parseDuration(input);
+  if (ms <= 0) {
+    throw new Error(`Invalid duration: "${input}". Duration must be a positive value.`);
+  }
+  return new Date(Date.now() + ms);
+}
+__name(getDateFromDuration, "getDateFromDuration");
 
 exports.addToDate = addToDate;
 exports.dateDiff = dateDiff;
@@ -289,7 +332,9 @@ exports.endOf = endOf;
 exports.formatDate = formatDate;
 exports.formatDuration = formatDuration;
 exports.formatRelativeTime = formatRelativeTime;
+exports.getDateFromDuration = getDateFromDuration;
 exports.isBetween = isBetween;
 exports.isLeapYear = isLeapYear;
 exports.parseDate = parseDate;
+exports.parseDuration = parseDuration;
 exports.startOf = startOf;