@decaf-ts/logging 0.3.7 → 0.3.9

package/dist/logging.cjs

@@ -1,9 +1,16 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('styled-string-builder')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'styled-string-builder'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.logging = {}, global.styledStringBuilder));
-})(this, (function (exports, styledStringBuilder) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('styled-string-builder'), require('typed-object-accumulator'), require('tslib')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'styled-string-builder', 'typed-object-accumulator', 'tslib'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.logging = {}, global.styledStringBuilder, global.typedObjectAccumulator, global.tslib));
+})(this, (function (exports, styledStringBuilder, typedObjectAccumulator, tslib) { 'use strict';
 
+    const BrowserEnvKey = "ENV";
+    /**
+     * @description Delimiter used for composing nested environment variable names.
+     * @summary Joins parent and child keys when mapping object paths to ENV strings.
+     */
+    const ENV_PATH_DELIMITER = "__";
+    const DefaultPlaceholderWrappers = ["${", "}"];
     /**
      * @description Enum for log levels.
      * @summary Defines different levels of logging for the application.
@@ -81,6 +88,8 @@
      * @memberOf module:Logging
      */
     const DefaultTheme = {
+        app: {},
+        separator: {},
         class: {
             fg: 34,
         },
@@ -100,10 +109,17 @@
                 fg: 31,
                 style: ["bold"],
             },
-            info: {},
-            verbose: {},
+            info: {
+                fg: 34,
+                style: ["bold"],
+            },
+            verbose: {
+                fg: 34,
+                style: ["bold"],
+            },
             debug: {
                 fg: 33,
+                style: ["bold"],
             },
         },
     };
@@ -125,19 +141,442 @@
      * @memberOf module:Logging
      */
     const DefaultLoggingConfig = {
+        env: "development",
         verbose: 0,
         level: exports.LogLevel.info,
         logLevel: true,
-        mode: exports.LoggingMode.RAW,
         style: false,
         contextSeparator: ".",
-        separator: " - ",
+        separator: "-",
         timestamp: true,
         timestampFormat: "HH:mm:ss.SSS",
         context: true,
+        format: exports.LoggingMode.RAW,
+        pattern: "{level} [{timestamp}] {app} {context} {separator} {message} {stack}",
         theme: DefaultTheme,
     };
 
+    /**
+     * @description Pads the end of a string with a specified character.
+     * @summary Extends the input string to a specified length by adding a padding character to the end.
+     * If the input string is already longer than the specified length, it is returned unchanged.
+     *
+     * @param {string} str - The input string to be padded.
+     * @param {number} length - The desired total length of the resulting string.
+     * @param {string} [char=" "] - The character to use for padding. Defaults to a space.
+     * @return {string} The padded string.
+     * @throws {Error} If the padding character is not exactly one character long.
+     *
+     * @function padEnd
+     *
+     * @memberOf module:Logging
+     */
+    function padEnd(str, length, char = " ") {
+        if (char.length !== 1)
+            throw new Error("Invalid character length for padding. must be one!");
+        return str.padEnd(length, char);
+    }
+    /**
+     * @description Replaces placeholders in a string with provided values.
+     * @summary Interpolates a string by replacing placeholders of the form ${variableName}
+     * with corresponding values from the provided object. If a placeholder doesn't have
+     * a corresponding value, it is left unchanged in the string.
+     *
+     * @param {string} input - The input string containing placeholders to be replaced.
+     * @param {Record<string, number | string>} values - An object containing key-value pairs for replacement.
+     * @param prefix
+     * @param suffix
+     * @param flags
+     * @return {string} The interpolated string with placeholders replaced by their corresponding values.
+     *
+     * @function patchPlaceholders
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant patchString
+     *   participant String.replace
+     *   Caller->>patchString: Call with input and values
+     *   patchString->>String.replace: Call with regex and replacement function
+     *   String.replace->>patchString: Return replaced string
+     *   patchString-->>Caller: Return patched string
+     *
+     * @memberOf module:Logging
+     */
+    function patchPlaceholders(input, values, prefix = DefaultPlaceholderWrappers[0], suffix = DefaultPlaceholderWrappers[1], flags = "g") {
+        const placeholders = Object.entries(values).reduce((acc, [key, val]) => {
+            acc[`${prefix}${key}${suffix}`] = val;
+            return acc;
+        }, {});
+        return patchString(input, placeholders, flags);
+    }
+    /**
+     * @description Replaces occurrences of keys with their corresponding values in a string.
+     * @summary Iterates through a set of key-value pairs and replaces all occurrences of each key
+     * in the input string with its corresponding value. Supports regular expression flags for customized replacement.
+     *
+     * @param {string} input - The input string in which replacements will be made.
+     * @param {Record<string, number | string>} values - An object containing key-value pairs for replacement.
+     * @param {string} [flags="g"] - Regular expression flags to control the replacement behavior.
+     * @return {string} The string with all specified replacements applied.
+     *
+     * @function patchString
+     *
+     * @memberOf module:Logging
+     */
+    function patchString(input, values, flags = "g") {
+        Object.entries(values).forEach(([key, val]) => {
+            const regexp = new RegExp(escapeRegExp(key), flags);
+            input = input.replace(regexp, val);
+        });
+        return input;
+    }
+    /**
+     * @description Converts a string to camelCase.
+     * @summary Transforms the input string into camelCase format, where words are joined without spaces
+     * and each word after the first starts with a capital letter.
+     *
+     * @param {string} text - The input string to be converted.
+     * @return {string} The input string converted to camelCase.
+     *
+     * @function toCamelCase
+     *
+     * @memberOf module:Logging
+     */
+    function toCamelCase(text) {
+        return text
+            .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => index === 0 ? word.toLowerCase() : word.toUpperCase())
+            .replace(/\s+/g, "");
+    }
+    /**
+     * @description Converts a string to ENVIRONMENT_VARIABLE format.
+     * @summary Transforms the input string into uppercase with words separated by underscores,
+     * typically used for environment variable names.
+     *
+     * @param {string} text - The input string to be converted.
+     * @return {string} The input string converted to ENVIRONMENT_VARIABLE format.
+     *
+     * @function toENVFormat
+     *
+     * @memberOf module:Logging
+     */
+    function toENVFormat(text) {
+        return toSnakeCase(text).toUpperCase();
+    }
+    /**
+     * @description Converts a string to snake_case.
+     * @summary Transforms the input string into lowercase with words separated by underscores.
+     *
+     * @param {string} text - The input string to be converted.
+     * @return {string} The input string converted to snake_case.
+     *
+     * @function toSnakeCase
+     *
+     * @memberOf module:Logging
+     */
+    function toSnakeCase(text) {
+        return text
+            .replace(/([a-z])([A-Z])/g, "$1_$2")
+            .replace(/[\s-]+/g, "_")
+            .toLowerCase();
+    }
+    /**
+     * @description Converts a string to kebab-case.
+     * @summary Transforms the input string into lowercase with words separated by hyphens.
+     *
+     * @param {string} text - The input string to be converted.
+     * @return {string} The input string converted to kebab-case.
+     *
+     * @function toKebabCase
+     *
+     * @memberOf module:Logging
+     */
+    function toKebabCase(text) {
+        return text
+            .replace(/([a-z])([A-Z])/g, "$1-$2")
+            .replace(/[\s_]+/g, "-")
+            .toLowerCase();
+    }
+    /**
+     * @description Converts a string to PascalCase.
+     * @summary Transforms the input string into PascalCase format, where words are joined without spaces
+     * and each word starts with a capital letter.
+     *
+     * @param {string} text - The input string to be converted.
+     * @return {string} The input string converted to PascalCase.
+     *
+     * @function toPascalCase
+     *
+     * @memberOf module:Logging
+     */
+    function toPascalCase(text) {
+        return text
+            .replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => word.toUpperCase())
+            .replace(/\s+/g, "");
+    }
+    /**
+     * @description Escapes special characters in a string for use in a regular expression.
+     * @summary Adds backslashes before characters that have special meaning in regular expressions,
+     * allowing the string to be used as a literal match in a RegExp.
+     *
+     * @param {string} string - The string to escape for regular expression use.
+     * @return {string} The escaped string safe for use in regular expressions.
+     *
+     * @function escapeRegExp
+     *
+     * @memberOf module:Logging
+     */
+    function escapeRegExp(string) {
+        return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+    }
+    /**
+     * @summary Util function to provide string format functionality similar to C#'s string.format
+     *
+     * @param {string} string
+     * @param {Array<string | number> | Record<string, any>} [args] replacements made by order of appearance (replacement0 wil replace {0} and so on)
+     * @return {string} formatted string
+     *
+     * @function sf
+     * @memberOf module:Logging
+     */
+    function sf(string, ...args) {
+        if (args.length > 1) {
+            if (!args.every((arg) => typeof arg === "string" || typeof arg === "number"))
+                throw new Error(`Only string and number arguments are supported for multiple replacements.`);
+        }
+        if (args.length === 1 && typeof args[0] === "object") {
+            const obj = args[0];
+            return Object.entries(obj).reduce((acc, [key, val]) => {
+                return acc.replace(new RegExp(`\\{${key}\\}`, "g"), function () {
+                    return val;
+                });
+            }, string);
+        }
+        return string.replace(/{(\d+)}/g, function (match, number) {
+            return typeof args[number] !== "undefined"
+                ? args[number].toString()
+                : "undefined";
+        });
+    }
+    /**
+     * @summary Util function to provide string format functionality similar to C#'s string.format
+     *
+     * @see sf
+     *
+     * @deprecated
+     * @function stringFormat
+     * @memberOf module:Logging
+     */
+    const stringFormat = sf;
+
+    /**
+     * @description Determines if the current environment is a browser by checking the prototype chain of the global object.
+     * @summary Checks if the code is running in a browser environment.
+     * @return {boolean} True if the environment is a browser, false otherwise.
+     * @function isBrowser
+     * @memberOf module:Logging
+     */
+    function isBrowser() {
+        return (Object.getPrototypeOf(Object.getPrototypeOf(globalThis)) !==
+            Object.prototype);
+    }
+
+    /**
+     * @class Environment
+     * @extends {ObjectAccumulator<T>}
+     * @template T
+     * @description A class representing an environment with accumulation capabilities.
+     * @summary Manages environment-related data and provides methods for accumulation and key retrieval.
+     * @param {T} [initialData] - The initial data to populate the environment with.
+     */
+    class Environment extends typedObjectAccumulator.ObjectAccumulator {
+        /**
+         * @static
+         * @protected
+         * @description A factory function for creating Environment instances.
+         * @summary Defines how new instances of the Environment class should be created.
+         * @return {Environment<any>} A new instance of the Environment class.
+         */
+        static { this.factory = () => new Environment(); }
+        constructor() {
+            super();
+        }
+        /**
+         * @description Retrieves a value from the environment
+         * @summary Gets a value from the environment variables, handling browser and Node.js environments differently
+         * @param {string} k - The key to retrieve from the environment
+         * @return {unknown} The value from the environment, or undefined if not found
+         */
+        fromEnv(k) {
+            let env;
+            if (isBrowser()) {
+                env = globalThis[BrowserEnvKey];
+            }
+            else {
+                env = globalThis.process.env;
+                k = toENVFormat(k);
+            }
+            return env[k];
+        }
+        /**
+         * @description Expands an object into the environment
+         * @summary Defines properties on the environment object that can be accessed as getters and setters
+         * @template V - Type of the object being expanded
+         * @param {V} value - The object to expand into the environment
+         * @return {void}
+         */
+        expand(value) {
+            Object.entries(value).forEach(([k, v]) => {
+                Object.defineProperty(this, k, {
+                    get: () => {
+                        const fromEnv = this.fromEnv(k);
+                        if (typeof fromEnv !== "undefined")
+                            return fromEnv;
+                        if (v && typeof v === "object") {
+                            return Environment.buildEnvProxy(v, [k]);
+                        }
+                        // If the model provides an empty string, expose a proxy that composes ENV keys
+                        if (v === "") {
+                            return Environment.buildEnvProxy(undefined, [k]);
+                        }
+                        return v;
+                    },
+                    set: (val) => {
+                        v = val;
+                    },
+                    configurable: true,
+                    enumerable: true,
+                });
+            });
+        }
+        /**
+         * @protected
+         * @static
+         * @description Retrieves or creates the singleton instance of the Environment class.
+         * @summary Ensures only one instance of the Environment class exists.
+         * @template E
+         * @param {...unknown[]} args - Arguments to pass to the factory function if a new instance is created.
+         * @return {E} The singleton instance of the Environment class.
+         */
+        static instance(...args) {
+            if (!Environment._instance) {
+                const base = Environment.factory(...args);
+                const proxied = new Proxy(base, {
+                    get(target, prop, receiver) {
+                        const value = Reflect.get(target, prop, receiver);
+                        if (typeof value !== "undefined")
+                            return value;
+                        if (typeof prop === "string") {
+                            // Avoid interfering with logging config lookups for optional fields like 'app'
+                            if (prop === "app")
+                                return undefined;
+                            return Environment.buildEnvProxy(undefined, [prop]);
+                        }
+                        return value;
+                    },
+                });
+                Environment._instance = proxied;
+            }
+            return Environment._instance;
+        }
+        /**
+         * @static
+         * @description Accumulates the given value into the environment.
+         * @summary Adds new properties to the environment from the provided object.
+         * @template V
+         * @param {V} value - The object to accumulate into the environment.
+         * @return {V} The updated environment instance.
+         */
+        static accumulate(value) {
+            const instance = Environment.instance();
+            Object.keys(instance).forEach((key) => {
+                const desc = Object.getOwnPropertyDescriptor(instance, key);
+                if (desc && desc.configurable && desc.enumerable) {
+                    Object.defineProperty(instance, key, {
+                        ...desc,
+                        enumerable: false,
+                    });
+                }
+            });
+            return instance.accumulate(value);
+        }
+        static get(key) {
+            return Environment._instance.get(key);
+        }
+        static buildEnvProxy(current, path) {
+            const buildKey = (p) => p.map((seg) => toENVFormat(seg)).join(ENV_PATH_DELIMITER);
+            // Helper to read from the active environment given a composed key
+            const readEnv = (key) => {
+                if (isBrowser()) {
+                    const env = globalThis[BrowserEnvKey];
+                    return env ? env[key] : undefined;
+                }
+                return globalThis?.process?.env?.[key];
+            };
+            const handler = {
+                get(_target, prop) {
+                    if (prop === Symbol.toPrimitive) {
+                        return () => buildKey(path);
+                    }
+                    if (prop === "toString") {
+                        return () => buildKey(path);
+                    }
+                    if (prop === "valueOf") {
+                        return () => buildKey(path);
+                    }
+                    if (typeof prop === "symbol")
+                        return undefined;
+                    const nextModel = current && Object.prototype.hasOwnProperty.call(current, prop)
+                        ? current[prop]
+                        : undefined;
+                    const nextPath = [...path, prop];
+                    const composedKey = buildKey(nextPath);
+                    // If an ENV value exists for this path, return it directly
+                    const envValue = readEnv(composedKey);
+                    if (typeof envValue !== "undefined")
+                        return envValue;
+                    // Otherwise, if the model has an object at this path, keep drilling with a proxy
+                    const isNextObject = nextModel && typeof nextModel === "object";
+                    if (isNextObject)
+                        return Environment.buildEnvProxy(nextModel, nextPath);
+                    // Always return a proxy for further path composition when no ENV value;
+                    // do not surface primitive model defaults here (this API is for key composition).
+                    return Environment.buildEnvProxy(undefined, nextPath);
+                },
+                ownKeys() {
+                    return current ? Reflect.ownKeys(current) : [];
+                },
+                getOwnPropertyDescriptor(_t, p) {
+                    if (!current)
+                        return undefined;
+                    if (Object.prototype.hasOwnProperty.call(current, p)) {
+                        return { enumerable: true, configurable: true };
+                    }
+                    return undefined;
+                },
+            };
+            const target = {};
+            return new Proxy(target, handler);
+        }
+        /**
+         * @static
+         * @description Retrieves the keys of the environment, optionally converting them to ENV format.
+         * @summary Gets all keys in the environment, with an option to format them for environment variables.
+         * @param {boolean} [toEnv=true] - Whether to convert the keys to ENV format.
+         * @return {string[]} An array of keys from the environment.
+         */
+        static keys(toEnv = true) {
+            return Environment.instance()
+                .keys()
+                .map((k) => (toEnv ? toENVFormat(k) : k));
+        }
+    }
+    const LoggedEnvironment = Environment.accumulate(Object.assign({}, DefaultLoggingConfig, {
+        env: (isBrowser() && globalThis[BrowserEnvKey]
+            ? globalThis[BrowserEnvKey]["NODE_ENV"]
+            : globalThis.process.env["NODE_ENV"]) || "development",
+    }));
+
     /**
      * @description A minimal logger implementation.
      * @summary MiniLogger is a lightweight logging class that implements the Logger interface.
@@ -218,35 +657,45 @@
          * @summary Generates a log string with timestamp, colored log level, context, and message
          * @param {LogLevel} level - The log level for this message
          * @param {StringLike | Error} message - The message to log or an Error object
-         * @param {string} [stack] - Optional stack trace to include in the log
+         * @param {string} [error] - Optional error to extract stack trace to include in the log
          * @return {string} A formatted log string with all components
          */
-        createLog(level, message, stack) {
-            const log = [];
+        createLog(level, message, error) {
+            const log = {};
             const style = this.config("style");
+            const separator = this.config("separator");
+            const app = this.config("app");
+            if (app)
+                log.app = style
+                    ? Logging.theme(app, "app", level)
+                    : app;
+            if (separator)
+                log.separator = style
+                    ? Logging.theme(separator, "separator", level)
+                    : separator;
             if (this.config("timestamp")) {
                 const date = new Date().toISOString();
                 const timestamp = style ? Logging.theme(date, "timestamp", level) : date;
-                log.push(timestamp);
+                log.timestamp = timestamp;
             }
             if (this.config("logLevel")) {
                 const lvl = style
                     ? Logging.theme(level, "logLevel", level)
                     : level;
-                log.push(lvl);
+                log.level = lvl.toUpperCase();
             }
             if (this.config("context")) {
                 const context = style
                     ? Logging.theme(this.context, "class", level)
                     : this.context;
-                log.push(context);
+                log.context = context;
             }
             if (this.config("correlationId")) {
                 {
                     const id = style
                         ? Logging.theme(this.config("correlationId").toString(), "id", level)
                         : this.config("correlationId").toString();
-                    log.push(id);
+                    log.correlationId = id;
                 }
             }
             const msg = style
@@ -254,14 +703,32 @@
                 : typeof message === "string"
                     ? message
                     : message.message;
-            log.push(msg);
-            if (stack || message instanceof Error) {
-                stack = style
-                    ? Logging.theme((stack || message.stack), "stack", level)
-                    : stack;
-                log.push(`\nStack trace:\n${stack}`);
+            log.message = msg;
+            if (error || message instanceof Error) {
+                const stack = style
+                    ? Logging.theme((error?.stack || message.stack), "stack", level)
+                    : error?.stack || "";
+                log.stack = ` | ${(error || message).message} - Stack trace:\n${stack}`;
+            }
+            switch (this.config("format")) {
+                case "json":
+                    return JSON.stringify(log);
+                case "raw":
+                    return this.config("pattern")
+                        .split(" ")
+                        .map((s) => {
+                        if (!s.match(/\{.*?}/g))
+                            return s;
+                        const formattedS = sf(s, log);
+                        if (formattedS !== s)
+                            return formattedS;
+                        return undefined;
+                    })
+                        .filter((s) => s)
+                        .join(" ");
+                default:
+                    throw new Error(`Unsupported logging format: ${this.config("format")}`);
             }
-            return log.join(this.config("separator"));
         }
         /**
          * @description Logs a message with the specified log level
@@ -269,12 +736,12 @@
          * then uses the appropriate console method to output the formatted log
          * @param {LogLevel} level - The log level of the message
          * @param {StringLike | Error} msg - The message to be logged or an Error object
-         * @param {string} [stack] - Optional stack trace to include in the log
+         * @param {string} [error] - Optional stack trace to include in the log
          * @return {void}
          */
-        log(level, msg, stack) {
-            if (NumericLogLevels[this.config("level")] <
-                NumericLogLevels[level])
+        log(level, msg, error) {
+            const confLvl = this.config("level");
+            if (NumericLogLevels[confLvl] < NumericLogLevels[level])
                 return;
             let method;
             switch (level) {
@@ -291,7 +758,7 @@
                 default:
                     throw new Error("Invalid log level");
             }
-            method(this.createLog(level, msg, stack));
+            method(this.createLog(level, msg, error));
         }
         /**
          * @description Logs a message at the silly level
@@ -337,10 +804,11 @@
          * @description Logs a message at the error level
          * @summary Logs a message at the error level for errors and exceptions
          * @param {StringLike | Error} msg - The message to be logged or an Error object
+         * @param e
          * @return {void}
          */
-        error(msg) {
-            this.log(exports.LogLevel.error, msg);
+        error(msg, e) {
+            this.log(exports.LogLevel.error, msg, e);
         }
         /**
          * @description Updates the logger configuration
@@ -425,11 +893,7 @@
         static { this._factory = (object, config) => {
             return new MiniLogger(object, config);
         }; }
-        /**
-         * @description Configuration for the logging system
-         * @summary Stores the global logging configuration including verbosity, log level, styling, and formatting settings
-         */
-        static { this._config = DefaultLoggingConfig; }
+        static { this._config = LoggedEnvironment; }
         constructor() { }
         /**
          * @description Sets the factory function for creating logger instances
@@ -447,7 +911,9 @@
          * @return {void}
          */
         static setConfig(config) {
-            Object.assign(this._config, config);
+            Object.entries(config).forEach(([k, v]) => {
+                this._config[k] = v;
+            });
         }
         /**
          * @description Gets a copy of the current global logging configuration
@@ -455,7 +921,7 @@
          * @return {LoggingConfig} A copy of the current configuration
          */
         static getConfig() {
-            return Object.assign({}, this._config);
+            return this._config;
         }
         /**
          * @description Retrieves or creates the global logger instance.
@@ -509,9 +975,10 @@
          * @summary Delegates the error logging to the global logger instance.
          *
          * @param msg - The message to be logged.
+         * @param e
          */
-        static error(msg) {
-            return this.get().error(msg);
+        static error(msg, e) {
+            return this.get().error(msg, e);
         }
         /**
          * @description Creates a logger for a specific object or context
@@ -648,6 +1115,57 @@
         }
     }
 
+    /**
+     * @description Base class that provides a ready-to-use logger instance
+     * @summary LoggedClass is a convenience abstract class that injects a type-safe logger
+     * into derived classes through a protected getter. Subclasses can directly access
+     * this.log to emit messages without manually creating a logger. This promotes
+     * consistent, context-aware logging across the codebase.
+     * @param {void} [constructor] - No constructor arguments; subclasses may define their own
+     * @class LoggedClass
+     * @example
+     * class UserService extends LoggedClass {
+     *   create(user: User) {
+     *     this.log.info(`Creating user ${user.id}`);
+     *   }
+     * }
+     *
+     * const svc = new UserService();
+     * svc.create({ id: "42" });
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant Instance as Subclass Instance
+     *   participant Getter as LoggedClass.log
+     *   participant Logging as Logging
+     *   participant Logger as Logger
+     *
+     *   Client->>Instance: call someMethod()
+     *   Instance->>Getter: access this.log
+     *   Getter->>Logging: Logging.for(this)
+     *   Logging-->>Getter: return Logger
+     *   Getter-->>Instance: return Logger
+     *   Instance->>Logger: info/debug/error(...)
+     */
+    class LoggedClass {
+        /**
+         * @description Lazily provides a context-aware logger for the current instance
+         * @summary Uses Logging.for(this) to create a logger whose context is the
+         * subclass name, allowing uniform and structured logs from any inheriting class.
+         * @return {Logger} A logger bound to the subclass context
+         */
+        get log() {
+            return Logging.for(this);
+        }
+        constructor() { }
+    }
+
+    class LogFilter extends LoggedClass {
+        get log() {
+            return super.log.for(this, { filters: [] });
+        }
+    }
+
     /**
      * @description Method decorator for logging function calls
      * @summary Creates a decorator that logs method calls with specified level, benchmarking, and verbosity
@@ -681,31 +1199,35 @@
      */
     function log(level = exports.LogLevel.info, benchmark = false, verbosity = 0) {
         return function (target, propertyKey, descriptor) {
-            const log = Logging.for(target).for(target[propertyKey]);
-            const method = log[level].bind(log);
+            if (!descriptor)
+                throw new Error(`Logging decoration only applies to methods`);
+            const logger = Logging.for(target).for(target[propertyKey]);
+            const method = logger[level].bind(logger);
             const originalMethod = descriptor.value;
-            descriptor.value = function (...args) {
-                method(`called with ${args}`, verbosity);
-                const start = Date.now();
-                let end;
-                const result = originalMethod.apply(this, args);
-                if (result instanceof Promise) {
-                    return result.then((r) => {
-                        if (benchmark) {
-                            end = Date.now();
-                            if (benchmark)
-                                method(`completed in ${end - start}ms`, verbosity);
+            descriptor.value = new Proxy(originalMethod, {
+                apply(fn, thisArg, args) {
+                    method(`called with ${args}`, verbosity);
+                    const start = Date.now();
+                    try {
+                        const result = Reflect.apply(fn, thisArg, args);
+                        if (result instanceof Promise) {
+                            return result.then((r) => {
+                                if (benchmark)
+                                    method(`completed in ${Date.now() - start}ms`, verbosity);
+                                return r;
+                            });
                         }
-                        return r;
-                    });
-                }
-                if (benchmark) {
-                    end = Date.now();
-                    if (benchmark)
-                        method(`completed in ${end - start}ms`, verbosity);
-                }
-                return result;
-            };
+                        if (benchmark)
+                            method(`completed in ${Date.now() - start}ms`, verbosity);
+                        return result;
+                    }
+                    catch (err) {
+                        if (benchmark)
+                            method(`failed in ${Date.now() - start}ms`, verbosity);
+                        throw err;
+                    }
+                },
+            });
         };
     }
     /**
@@ -757,51 +1279,56 @@
         }
         return log(exports.LogLevel.verbose, benchmark, verbosity);
     }
-
     /**
-     * @description Base class that provides a ready-to-use logger instance
-     * @summary LoggedClass is a convenience abstract class that injects a type-safe logger
-     * into derived classes through a protected getter. Subclasses can directly access
-     * this.log to emit messages without manually creating a logger. This promotes
-     * consistent, context-aware logging across the codebase.
-     * @param {void} [constructor] - No constructor arguments; subclasses may define their own
-     * @class LoggedClass
-     * @example
-     * class UserService extends LoggedClass {
-     *   create(user: User) {
-     *     this.log.info(`Creating user ${user.id}`);
-     *   }
-     * }
-     *
-     * const svc = new UserService();
-     * svc.create({ id: "42" });
-     * @mermaid
-     * sequenceDiagram
-     *   participant Client
-     *   participant Instance as Subclass Instance
-     *   participant Getter as LoggedClass.log
-     *   participant Logging as Logging
-     *   participant Logger as Logger
-     *
-     *   Client->>Instance: call someMethod()
-     *   Instance->>Getter: access this.log
-     *   Getter->>Logging: Logging.for(this)
-     *   Logging-->>Getter: return Logger
-     *   Getter-->>Instance: return Logger
-     *   Instance->>Logger: info/debug/error(...)
+     * @description Creates a decorator that makes a method non-configurable
+     * @summary This decorator prevents a method from being overridden by making it non-configurable.
+     * It throws an error if used on anything other than a method.
+     * @return {Function} A decorator function that can be applied to methods
+     * @function final
+     * @category Method Decorators
      */
-    class LoggedClass {
-        /**
-         * @description Lazily provides a context-aware logger for the current instance
-         * @summary Uses Logging.for(this) to create a logger whose context is the
-         * subclass name, allowing uniform and structured logs from any inheriting class.
-         * @return {Logger} A logger bound to the subclass context
-         */
-        get log() {
-            return Logging.for(this);
+    function final() {
+        return (target, propertyKey, descriptor) => {
+            if (!descriptor)
+                throw new Error("final decorator can only be used on methods");
+            if (descriptor?.configurable) {
+                descriptor.configurable = false;
+            }
+            return descriptor;
+        };
+    }
+
+    class PatternFilter extends LogFilter {
+        constructor(regexp, replacement) {
+            super();
+            this.regexp = regexp;
+            this.replacement = replacement;
+        }
+        match(message) {
+            const match = this.regexp.exec(message);
+            this.regexp.lastIndex = 0;
+            return match;
+        }
+        filter(config, message, context) {
+            const log = this.log.for(this.filter);
+            const match = this.match(message);
+            if (!match)
+                return message;
+            try {
+                return message.replace(this.regexp, this.replacement);
+            }
+            catch (e) {
+                log.error(`PatternFilter replacement error: ${e}`);
+            }
+            return "";
         }
-        constructor() { }
     }
+    tslib.__decorate([
+        final(),
+        tslib.__metadata("design:type", Function),
+        tslib.__metadata("design:paramtypes", [String]),
+        tslib.__metadata("design:returntype", void 0)
+    ], PatternFilter.prototype, "match", null);
 
     /**
      * @description A logging module for TypeScript applications
@@ -819,20 +1346,40 @@
      * @const VERSION
      * @memberOf module:Logging
      */
-    const VERSION = "0.3.7";
+    const VERSION = "0.3.9";
 
+    exports.BrowserEnvKey = BrowserEnvKey;
     exports.DefaultLoggingConfig = DefaultLoggingConfig;
+    exports.DefaultPlaceholderWrappers = DefaultPlaceholderWrappers;
     exports.DefaultTheme = DefaultTheme;
+    exports.ENV_PATH_DELIMITER = ENV_PATH_DELIMITER;
+    exports.Environment = Environment;
+    exports.LogFilter = LogFilter;
     exports.LoggedClass = LoggedClass;
+    exports.LoggedEnvironment = LoggedEnvironment;
     exports.Logging = Logging;
     exports.MiniLogger = MiniLogger;
     exports.NumericLogLevels = NumericLogLevels;
+    exports.PatternFilter = PatternFilter;
     exports.VERSION = VERSION;
     exports.debug = debug;
+    exports.escapeRegExp = escapeRegExp;
+    exports.final = final;
     exports.info = info;
+    exports.isBrowser = isBrowser;
     exports.log = log;
+    exports.padEnd = padEnd;
+    exports.patchPlaceholders = patchPlaceholders;
+    exports.patchString = patchString;
+    exports.sf = sf;
     exports.silly = silly;
+    exports.stringFormat = stringFormat;
+    exports.toCamelCase = toCamelCase;
+    exports.toENVFormat = toENVFormat;
+    exports.toKebabCase = toKebabCase;
+    exports.toPascalCase = toPascalCase;
+    exports.toSnakeCase = toSnakeCase;
     exports.verbose = verbose;
 
 }));
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"logging.cjs","sources":["../src/constants.ts","../src/logging.ts","../src/decorators.ts","../src/LoggedClass.ts","../src/index.ts"],"sourcesContent":["import { LoggingConfig, Theme } from \"./types\";\n\n/**\n * @description Enum for log levels.\n * @summary Defines different levels of logging for the application.\n * @enum {string}\n * @readonly\n * @memberOf module:Logging\n */\nexport enum LogLevel {\n  /** Error events that are likely to cause problems. */\n  error = \"error\",\n  /** Routine information, such as ongoing status or performance. */\n  info = \"info\",\n  /** Additional relevant information. */\n  verbose = \"verbose\",\n  /** Debug or trace information. */\n  debug = \"debug\",\n  /** way too verbose or silly information. */\n  silly = \"silly\",\n}\n\n/**\n * @description Numeric values associated with log levels.\n * @summary Provides a numeric representation of log levels for comparison and filtering.\n * @const NumericLogLevels\n * @property {number} error - Numeric value for error level (2).\n * @property {number} info - Numeric value for info level (4).\n * @property {number} verbose - Numeric value for verbose level (6).\n * @property {number} debug - Numeric value for debug level (7).\n * @property {number} silly - Numeric value for silly level (9).\n * @memberOf module:Logging\n */\nexport const NumericLogLevels = {\n  error: 2,\n  info: 4,\n  verbose: 6,\n  debug: 7,\n  silly: 9,\n};\n\n/**\n * @description Enum for logging output modes.\n * @summary Defines different output formats for log messages.\n * @enum {string}\n * @memberOf module:Logging\n */\nexport enum LoggingMode {\n  /** Raw text format for human readability */\n  RAW = \"raw\",\n  /** JSON format for machine parsing */\n  JSON = \"json\",\n}\n\n/**\n * @description Default theme for styling log output.\n * @summary Defines the default color and style settings for various components of log messages.\n * @const DefaultTheme\n * @typedef {Theme} DefaultTheme\n * @property {Object} class - Styling for class names.\n * @property {number} class.fg - Foreground color code for class names (34).\n * @property {Object} id - Styling for identifiers.\n * @property {number} id.fg - Foreground color code for identifiers (36).\n * @property {Object} stack - Styling for stack traces (empty object).\n * @property {Object} timestamp - Styling for timestamps (empty object).\n * @property {Object} message - Styling for different types of messages.\n * @property {Object} message.error - Styling for error messages.\n * @property {number} message.error.fg - Foreground color code for error messages (31).\n * @property {Object} method - Styling for method names (empty object).\n * @property {Object} logLevel - Styling for different log levels.\n * @property {Object} logLevel.error - Styling for error level logs.\n * @property {number} logLevel.error.fg - Foreground color code for error level logs (31).\n * @property {string[]} logLevel.error.style - Style attributes for error level logs ([\"bold\"]).\n * @property {Object} logLevel.info - Styling for info level logs (empty object).\n * @property {Object} logLevel.verbose - Styling for verbose level logs (empty object).\n * @property {Object} logLevel.debug - Styling for debug level logs.\n * @property {number} logLevel.debug.fg - Foreground color code for debug level logs (33).\n * @memberOf module:Logging\n */\nexport const DefaultTheme: Theme = {\n  class: {\n    fg: 34,\n  },\n  id: {\n    fg: 36,\n  },\n  stack: {},\n  timestamp: {},\n  message: {\n    error: {\n      fg: 31,\n    },\n  },\n  method: {},\n  logLevel: {\n    error: {\n      fg: 31,\n      style: [\"bold\"],\n    },\n    info: {},\n    verbose: {},\n    debug: {\n      fg: 33,\n    },\n  },\n};\n\n/**\n * @description Default configuration for logging.\n * @summary Defines the default settings for the logging system, including verbosity, log level, styling, and timestamp format.\n * @const DefaultLoggingConfig\n * @typedef {LoggingConfig} DefaultLoggingConfig\n * @property {number} verbose - Verbosity level (0).\n * @property {LogLevel} level - Default log level (LogLevel.info).\n * @property {boolean} logLevel - Whether to display log level in output (true).\n * @property {LoggingMode} mode - Output format mode (LoggingMode.RAW).\n * @property {boolean} style - Whether to apply styling to log output (false).\n * @property {string} separator - Separator between log components (\" - \").\n * @property {boolean} timestamp - Whether to include timestamps in log messages (true).\n * @property {string} timestampFormat - Format for timestamps (\"HH:mm:ss.SSS\").\n * @property {boolean} context - Whether to include context information in log messages (true).\n * @property {Theme} theme - The theme to use for styling log messages (DefaultTheme).\n * @memberOf module:Logging\n */\nexport const DefaultLoggingConfig: LoggingConfig = {\n  verbose: 0,\n  level: LogLevel.info,\n  logLevel: true,\n  mode: LoggingMode.RAW,\n  style: false,\n  contextSeparator: \".\",\n  separator: \" - \",\n  timestamp: true,\n  timestampFormat: \"HH:mm:ss.SSS\",\n  context: true,\n  theme: DefaultTheme,\n};\n","import {\n  LoggerFactory,\n  LoggingConfig,\n  LoggingContext,\n  StringLike,\n  Theme,\n  ThemeOption,\n  ThemeOptionByLogLevel,\n  Logger,\n} from \"./types\";\nimport { ColorizeOptions, style, StyledString } from \"styled-string-builder\";\nimport {\n  DefaultLoggingConfig,\n  DefaultTheme,\n  LogLevel,\n  NumericLogLevels,\n} from \"./constants\";\n\n/**\n * @description A minimal logger implementation.\n * @summary MiniLogger is a lightweight logging class that implements the Logger interface.\n * It provides basic logging functionality with support for different log levels, verbosity,\n * context-aware logging, and customizable formatting.\n * @param {string} context - The context (typically class name) this logger is associated with\n * @param {Partial<LoggingConfig>} conf - Optional configuration to override global settings\n * @class MiniLogger\n * @example\n * // Create a new logger for a class\n * const logger = new MiniLogger('MyClass');\n *\n * // Log messages at different levels\n * logger.info('This is an info message');\n * logger.debug('This is a debug message');\n * logger.error('Something went wrong');\n *\n * // Create a child logger for a specific method\n * const methodLogger = logger.for('myMethod');\n * methodLogger.verbose('Detailed information', 2);\n *\n * // Log with custom configuration\n * logger.for('specialMethod', { style: true }).info('Styled message');\n */\nexport class MiniLogger implements Logger {\n  constructor(\n    protected context: string,\n    protected conf?: Partial<LoggingConfig>\n  ) {}\n\n  protected config(\n    key: keyof LoggingConfig\n  ): LoggingConfig[keyof LoggingConfig] {\n    if (this.conf && key in this.conf) return this.conf[key];\n    return Logging.getConfig()[key];\n  }\n\n  for(method: string | ((...args: any[]) => any)): Logger;\n  for(config: Partial<LoggingConfig>): Logger;\n  /**\n   * @description Creates a child logger for a specific method or context\n   * @summary Returns a new logger instance with the current context extended by the specified method name\n   * @param {string | Function} method - The method name or function to create a logger for\n   * @param {Partial<LoggingConfig>} config - Optional configuration to override settings\n   * @param {...any[]} args - Additional arguments to pass to the logger factory\n   * @return {Logger} A new logger instance for the specified method\n   */\n  for(\n    method?: string | ((...args: any[]) => any) | Partial<LoggingConfig>,\n    config?: Partial<LoggingConfig>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Logger {\n    if (!config && typeof method === \"object\") {\n      config = method;\n      method = undefined;\n    } else {\n      method = method\n        ? typeof method === \"string\"\n          ? method\n          : (method as any).name\n        : undefined;\n    }\n\n    return new Proxy(this, {\n      get: (target: typeof this, p: string | symbol, receiver: any) => {\n        const result = Reflect.get(target, p, receiver);\n        if (p === \"config\") {\n          return new Proxy(this.config, {\n            get: (target: typeof this.config, p: string | symbol) => {\n              if (config && p in config)\n                return config[p as keyof LoggingConfig];\n              return Reflect.get(target, p, receiver);\n            },\n          });\n        }\n        if (p === \"context\" && method) {\n          return [result, method].join(\".\");\n        }\n        return result;\n      },\n    });\n  }\n\n  /**\n   * @description Creates a formatted log string\n   * @summary Generates a log string with timestamp, colored log level, context, and message\n   * @param {LogLevel} level - The log level for this message\n   * @param {StringLike | Error} message - The message to log or an Error object\n   * @param {string} [stack] - Optional stack trace to include in the log\n   * @return {string} A formatted log string with all components\n   */\n  protected createLog(\n    level: LogLevel,\n    message: StringLike | Error,\n    stack?: string\n  ): string {\n    const log: string[] = [];\n    const style = this.config(\"style\");\n    if (this.config(\"timestamp\")) {\n      const date = new Date().toISOString();\n      const timestamp = style ? Logging.theme(date, \"timestamp\", level) : date;\n      log.push(timestamp);\n    }\n\n    if (this.config(\"logLevel\")) {\n      const lvl: string = style\n        ? Logging.theme(level, \"logLevel\", level)\n        : level;\n      log.push(lvl);\n    }\n\n    if (this.config(\"context\")) {\n      const context: string = style\n        ? Logging.theme(this.context, \"class\", level)\n        : this.context;\n      log.push(context);\n    }\n\n    if (this.config(\"correlationId\")) {\n      {\n        const id: string = style\n          ? Logging.theme(this.config(\"correlationId\")!.toString(), \"id\", level)\n          : this.config(\"correlationId\")!.toString();\n        log.push(id);\n      }\n    }\n\n    const msg: string = style\n      ? Logging.theme(\n          typeof message === \"string\" ? message : (message as Error).message,\n          \"message\",\n          level\n        )\n      : typeof message === \"string\"\n        ? message\n        : (message as Error).message;\n    log.push(msg);\n    if (stack || message instanceof Error) {\n      stack = style\n        ? Logging.theme(\n            (stack || (message as Error).stack) as string,\n            \"stack\",\n            level\n          )\n        : stack;\n      log.push(`\\nStack trace:\\n${stack}`);\n    }\n\n    return log.join(this.config(\"separator\") as string);\n  }\n\n  /**\n   * @description Logs a message with the specified log level\n   * @summary Checks if the message should be logged based on the current log level,\n   * then uses the appropriate console method to output the formatted log\n   * @param {LogLevel} level - The log level of the message\n   * @param {StringLike | Error} msg - The message to be logged or an Error object\n   * @param {string} [stack] - Optional stack trace to include in the log\n   * @return {void}\n   */\n  protected log(\n    level: LogLevel,\n    msg: StringLike | Error,\n    stack?: string\n  ): void {\n    if (\n      NumericLogLevels[this.config(\"level\") as LogLevel] <\n      NumericLogLevels[level]\n    )\n      return;\n    let method;\n    switch (level) {\n      case LogLevel.info:\n        method = console.log;\n        break;\n      case LogLevel.verbose:\n      case LogLevel.debug:\n        method = console.debug;\n        break;\n      case LogLevel.error:\n        method = console.error;\n        break;\n      default:\n        throw new Error(\"Invalid log level\");\n    }\n    method(this.createLog(level, msg, stack));\n  }\n\n  /**\n   * @description Logs a message at the silly level\n   * @summary Logs a message at the silly level if the current verbosity setting allows it\n   * @param {StringLike} msg - The message to be logged\n   * @param {number} [verbosity=0] - The verbosity level of the message\n   * @return {void}\n   */\n  silly(msg: StringLike, verbosity: number = 0): void {\n    if ((this.config(\"verbose\") as number) >= verbosity)\n      this.log(LogLevel.verbose, msg);\n  }\n\n  /**\n   * @description Logs a message at the verbose level\n   * @summary Logs a message at the verbose level if the current verbosity setting allows it\n   * @param {StringLike} msg - The message to be logged\n   * @param {number} [verbosity=0] - The verbosity level of the message\n   * @return {void}\n   */\n  verbose(msg: StringLike, verbosity: number = 0): void {\n    if ((this.config(\"verbose\") as number) >= verbosity)\n      this.log(LogLevel.verbose, msg);\n  }\n\n  /**\n   * @description Logs a message at the info level\n   * @summary Logs a message at the info level for general application information\n   * @param {StringLike} msg - The message to be logged\n   * @return {void}\n   */\n  info(msg: StringLike): void {\n    this.log(LogLevel.info, msg);\n  }\n\n  /**\n   * @description Logs a message at the debug level\n   * @summary Logs a message at the debug level for detailed troubleshooting information\n   * @param {StringLike} msg - The message to be logged\n   * @return {void}\n   */\n  debug(msg: StringLike): void {\n    this.log(LogLevel.debug, msg);\n  }\n\n  /**\n   * @description Logs a message at the error level\n   * @summary Logs a message at the error level for errors and exceptions\n   * @param {StringLike | Error} msg - The message to be logged or an Error object\n   * @return {void}\n   */\n  error(msg: StringLike | Error): void {\n    this.log(LogLevel.error, msg);\n  }\n\n  /**\n   * @description Updates the logger configuration\n   * @summary Merges the provided configuration with the existing configuration\n   * @param {Partial<LoggingConfig>} config - The configuration options to apply\n   * @return {void}\n   */\n  setConfig(config: Partial<LoggingConfig>): void {\n    this.conf = { ...(this.conf || {}), ...config };\n  }\n}\n\n/**\n * @description A static class for managing logging operations\n * @summary The Logging class provides a centralized logging mechanism with support for\n * different log levels, verbosity, and styling. It uses a singleton pattern to maintain a global\n * logger instance and allows creating specific loggers for different classes and methods.\n * @class Logging\n * @example\n * // Set global configuration\n * Logging.setConfig({ level: LogLevel.debug, style: true });\n *\n * // Get a logger for a specific class\n * const logger = Logging.for('MyClass');\n *\n * // Log messages at different levels\n * logger.info('Application started');\n * logger.debug('Processing data...');\n *\n * // Log with context\n * const methodLogger = Logging.for('MyClass.myMethod');\n * methodLogger.verbose('Detailed operation information', 1);\n *\n * // Log errors\n * try {\n *   // some operation\n * } catch (error) {\n *   logger.error(error);\n * }\n * @mermaid\n * classDiagram\n *   class Logger {\n *     <<interface>>\n *     +for(method, config, ...args)\n *     +silly(msg, verbosity)\n *     +verbose(msg, verbosity)\n *     +info(msg)\n *     +debug(msg)\n *     +error(msg)\n *     +setConfig(config)\n *   }\n *\n *   class Logging {\n *     -global: Logger\n *     -_factory: LoggerFactory\n *     -_config: LoggingConfig\n *     +setFactory(factory)\n *     +setConfig(config)\n *     +getConfig()\n *     +get()\n *     +verbose(msg, verbosity)\n *     +info(msg)\n *     +debug(msg)\n *     +silly(msg)\n *     +error(msg)\n *     +for(object, config, ...args)\n *     +because(reason, id)\n *     +theme(text, type, loggerLevel, template)\n *   }\n *\n *   class MiniLogger {\n *     +constructor(context, conf?)\n *   }\n *\n *   Logging ..> Logger : creates\n *   Logging ..> MiniLogger : creates by default\n */\nexport class Logging {\n  /**\n   * @description The global logger instance\n   * @summary A singleton instance of Logger used for global logging\n   */\n  private static global?: Logger;\n\n  /**\n   * @description Factory function for creating logger instances\n   * @summary A function that creates new Logger instances. By default, it creates a MiniLogger.\n   */\n  private static _factory: LoggerFactory = (\n    object: string,\n    config?: Partial<LoggingConfig>\n  ) => {\n    return new MiniLogger(object, config);\n  };\n  /**\n   * @description Configuration for the logging system\n   * @summary Stores the global logging configuration including verbosity, log level, styling, and formatting settings\n   */\n  private static _config: LoggingConfig = DefaultLoggingConfig;\n\n  private constructor() {}\n\n  /**\n   * @description Sets the factory function for creating logger instances\n   * @summary Allows customizing how logger instances are created\n   * @param {LoggerFactory} factory - The factory function to use for creating loggers\n   * @return {void}\n   */\n  static setFactory(factory: LoggerFactory) {\n    Logging._factory = factory;\n  }\n\n  /**\n   * @description Updates the global logging configuration\n   * @summary Allows updating the global logging configuration with new settings\n   * @param {Partial<LoggingConfig>} config - The configuration options to apply\n   * @return {void}\n   */\n  static setConfig(config: Partial<LoggingConfig>) {\n    Object.assign(this._config, config);\n  }\n\n  /**\n   * @description Gets a copy of the current global logging configuration\n   * @summary Returns a copy of the current global logging configuration\n   * @return {LoggingConfig} A copy of the current configuration\n   */\n  static getConfig(): LoggingConfig {\n    return Object.assign({}, this._config);\n  }\n\n  /**\n   * @description Retrieves or creates the global logger instance.\n   * @summary Returns the existing global logger or creates a new one if it doesn't exist.\n   *\n   * @return The global VerbosityLogger instance.\n   */\n  static get(): Logger {\n    this.global = this.global ? this.global : this._factory(\"Logging\");\n    return this.global;\n  }\n\n  /**\n   * @description Logs a verbose message.\n   * @summary Delegates the verbose logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   * @param verbosity - The verbosity level of the message (default: 0).\n   */\n  static verbose(msg: StringLike, verbosity: number = 0): void {\n    return this.get().verbose(msg, verbosity);\n  }\n\n  /**\n   * @description Logs an info message.\n   * @summary Delegates the info logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static info(msg: StringLike): void {\n    return this.get().info(msg);\n  }\n\n  /**\n   * @description Logs a debug message.\n   * @summary Delegates the debug logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static debug(msg: StringLike): void {\n    return this.get().debug(msg);\n  }\n\n  /**\n   * @description Logs a silly message.\n   * @summary Delegates the debug logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static silly(msg: StringLike): void {\n    return this.get().silly(msg);\n  }\n\n  /**\n   * @description Logs an error message.\n   * @summary Delegates the error logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static error(msg: StringLike): void {\n    return this.get().error(msg);\n  }\n\n  /**\n   * @description Creates a logger for a specific object or context\n   * @summary Creates a new logger instance for the given object or context using the factory function\n   * @param {LoggingContext} object - The object, class, or context to create a logger for\n   * @param {Partial<LoggingConfig>} [config] - Optional configuration to override global settings\n   * @param {...any} args - Additional arguments to pass to the logger factory\n   * @return {Logger} A new logger instance for the specified object or context\n   */\n  static for(\n    object: LoggingContext,\n    config?: Partial<LoggingConfig>,\n    ...args: any[]\n  ): Logger {\n    object =\n      typeof object === \"string\"\n        ? object\n        : object.constructor\n          ? object.constructor.name\n          : object.name;\n    return this._factory(object, config, ...args);\n  }\n\n  /**\n   * @description Creates a logger for a specific reason or correlation context\n   * @summary Utility to quickly create a logger labeled with a free-form reason and optional identifier\n   * so that ad-hoc operations can be traced without tying the logger to a class or method name.\n   * @param {string} reason - A textual reason or context label for this logger instance\n   * @param {string} [id] - Optional identifier to help correlate related log entries\n   * @return {Logger} A new logger instance labeled with the provided reason and id\n   */\n  static because(reason: string, id?: string): Logger {\n    return this._factory(reason, this._config, id);\n  }\n\n  /**\n   * @description Applies theme styling to text\n   * @summary Applies styling (colors, formatting) to text based on the theme configuration\n   * @param {string} text - The text to style\n   * @param {string} type - The type of element to style (e.g., \"class\", \"message\", \"logLevel\")\n   * @param {LogLevel} loggerLevel - The log level to use for styling\n   * @param {Theme} [template=DefaultTheme] - The theme to use for styling\n   * @return {string} The styled text\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant Theme as Logging.theme\n   *   participant Apply as apply function\n   *   participant Style as styled-string-builder\n   *\n   *   Caller->>Theme: theme(text, type, loggerLevel)\n   *   Theme->>Theme: Check if styling is enabled\n   *   alt styling disabled\n   *     Theme-->>Caller: return original text\n   *   else styling enabled\n   *     Theme->>Theme: Get theme for type\n   *     alt theme not found\n   *       Theme-->>Caller: return original text\n   *     else theme found\n   *       Theme->>Theme: Determine actual theme based on log level\n   *       Theme->>Apply: Apply each style property\n   *       Apply->>Style: Apply colors and formatting\n   *       Style-->>Apply: Return styled text\n   *       Apply-->>Theme: Return styled text\n   *       Theme-->>Caller: Return final styled text\n   *     end\n   *   end\n   */\n  static theme(\n    text: string,\n    type: keyof Theme | keyof LogLevel,\n    loggerLevel: LogLevel,\n    template: Theme = DefaultTheme\n  ) {\n    if (!this._config.style) return text;\n    const logger = Logging.get().for(this.theme);\n\n    function apply(\n      txt: string,\n      option: keyof ThemeOption,\n      value: number | [number] | [number, number, number] | number[] | string[]\n    ): string {\n      try {\n        const t: string | StyledString = txt;\n        let c = style(t);\n\n        function applyColor(\n          val: number | [number] | [number, number, number],\n          isBg = false\n        ): StyledString {\n          let f:\n            | typeof c.background\n            | typeof c.foreground\n            | typeof c.rgb\n            | typeof c.color256 = isBg ? c.background : c.foreground;\n          if (!Array.isArray(val)) {\n            return (f as typeof c.background | typeof c.foreground).call(\n              c,\n              value as number\n            );\n          }\n          switch (val.length) {\n            case 1:\n              f = isBg ? c.bgColor256 : c.color256;\n              return (f as typeof c.bgColor256 | typeof c.color256)(val[0]);\n            case 3:\n              f = isBg ? c.bgRgb : c.rgb;\n              return c.rgb(val[0], val[1], val[2]);\n            default:\n              logger.error(`Not a valid color option: ${option}`);\n              return style(t as string);\n          }\n        }\n\n        function applyStyle(v: number | string): void {\n          if (typeof v === \"number\") {\n            c = c.style(v);\n          } else {\n            c = c[v as keyof ColorizeOptions] as StyledString;\n          }\n        }\n\n        switch (option) {\n          case \"bg\":\n          case \"fg\":\n            return applyColor(value as number).text;\n          case \"style\":\n            if (Array.isArray(value)) {\n              value.forEach(applyStyle);\n            } else {\n              applyStyle(value as number | string);\n            }\n            return c.text;\n          default:\n            logger.error(`Not a valid theme option: ${option}`);\n            return t;\n        }\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      } catch (e: unknown) {\n        logger.error(`Error applying style: ${option} with value ${value}`);\n        return txt;\n      }\n    }\n\n    const individualTheme = template[type as keyof Theme];\n    if (!individualTheme || !Object.keys(individualTheme).length) {\n      return text;\n    }\n\n    let actualTheme: ThemeOption = individualTheme as ThemeOption;\n\n    const logLevels = Object.assign({}, LogLevel);\n    if (Object.keys(individualTheme)[0] in logLevels)\n      actualTheme =\n        (individualTheme as ThemeOptionByLogLevel)[loggerLevel] || {};\n\n    return Object.keys(actualTheme).reduce((acc: string, key: string) => {\n      const val = (actualTheme as ThemeOption)[key as keyof ThemeOption];\n      if (val)\n        return apply(\n          acc,\n          key as keyof ThemeOption,\n          val as\n            | number\n            | [number]\n            | [number, number, number]\n            | number[]\n            | string[]\n        );\n      return acc;\n    }, text);\n  }\n}\n","import { LogLevel } from \"./constants\";\nimport { Logging } from \"./logging\";\n\n/**\n * @description Method decorator for logging function calls\n * @summary Creates a decorator that logs method calls with specified level, benchmarking, and verbosity\n * @param {LogLevel} level - The log level to use (default: LogLevel.info)\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @param {number} [verbosity=0] - The verbosity level for the log messages (default: 0)\n * @return {Function} A method decorator that wraps the original method with logging\n * @function log\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Decorator as log decorator\n *   participant Method as Original Method\n *   participant Logger as Logging instance\n *\n *   Client->>Decorator: call decorated method\n *   Decorator->>Logger: log method call\n *   Decorator->>Method: call original method\n *   alt result is Promise\n *     Method-->>Decorator: return Promise\n *     Decorator->>Decorator: attach then handler\n *     Note over Decorator: Promise resolves\n *     Decorator->>Logger: log benchmark (if enabled)\n *     Decorator-->>Client: return result\n *   else result is not Promise\n *     Method-->>Decorator: return result\n *     Decorator->>Logger: log benchmark (if enabled)\n *     Decorator-->>Client: return result\n *   end\n * @category Method Decorators\n */\nexport function log(\n  level: LogLevel = LogLevel.info,\n  benchmark: boolean = false,\n  verbosity = 0\n) {\n  return function (\n    target: any,\n    propertyKey: string,\n    descriptor: PropertyDescriptor\n  ) {\n    const log = Logging.for(target).for(target[propertyKey]);\n    const method = log[level].bind(log);\n    const originalMethod = descriptor.value;\n    descriptor.value = function (...args: any[]) {\n      method(`called with ${args}`, verbosity);\n      const start = Date.now();\n      let end: number;\n      const result: any = originalMethod.apply(this, args);\n      if (result instanceof Promise) {\n        return result.then((r) => {\n          if (benchmark) {\n            end = Date.now();\n            if (benchmark) method(`completed in ${end - start}ms`, verbosity);\n          }\n          return r;\n        });\n      }\n      if (benchmark) {\n        end = Date.now();\n        if (benchmark) method(`completed in ${end - start}ms`, verbosity);\n      }\n\n      return result;\n    };\n  };\n}\n\n/**\n * @description Method decorator for logging function calls with debug level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.debug\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with debug logging\n * @function debug\n * @category Method Decorators\n */\nexport function debug(benchmark: boolean = false) {\n  return log(LogLevel.debug, benchmark);\n}\n\n/**\n * @description Method decorator for logging function calls with info level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.info\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with info logging\n * @function info\n * @category Method Decorators\n */\nexport function info(benchmark: boolean = false) {\n  return log(LogLevel.info, benchmark);\n}\n\n/**\n * @description Method decorator for logging function calls with silly level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.silly\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with silly logging\n * @function silly\n * @category Method Decorators\n */\nexport function silly(benchmark: boolean = false) {\n  return log(LogLevel.silly, benchmark);\n}\n\n/**\n * @description Method decorator for logging function calls with verbose level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity\n * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n */\nexport function verbose(): void;\n\n/**\n * @description Method decorator for logging function calls with verbose level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity\n * @param {boolean} benchmark - Whether to log execution time\n * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n */\nexport function verbose(benchmark: boolean): void;\n\n/**\n * @description Method decorator for logging function calls with verbose level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity\n * @param {number} verbosity - The verbosity level for the log messages (default: 0)\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n * @category Method Decorators\n */\nexport function verbose(verbosity: number | boolean = 0, benchmark?: boolean) {\n  if (typeof verbosity === \"boolean\") {\n    benchmark = verbosity;\n    verbosity = 0;\n  }\n  return log(LogLevel.verbose, benchmark, verbosity);\n}\n","import { Logging } from \"./logging\";\nimport { Logger } from \"./types\";\n\n/**\n * @description Base class that provides a ready-to-use logger instance\n * @summary LoggedClass is a convenience abstract class that injects a type-safe logger\n * into derived classes through a protected getter. Subclasses can directly access\n * this.log to emit messages without manually creating a logger. This promotes\n * consistent, context-aware logging across the codebase.\n * @param {void} [constructor] - No constructor arguments; subclasses may define their own\n * @class LoggedClass\n * @example\n * class UserService extends LoggedClass {\n *   create(user: User) {\n *     this.log.info(`Creating user ${user.id}`);\n *   }\n * }\n *\n * const svc = new UserService();\n * svc.create({ id: \"42\" });\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Instance as Subclass Instance\n *   participant Getter as LoggedClass.log\n *   participant Logging as Logging\n *   participant Logger as Logger\n *\n *   Client->>Instance: call someMethod()\n *   Instance->>Getter: access this.log\n *   Getter->>Logging: Logging.for(this)\n *   Logging-->>Getter: return Logger\n *   Getter-->>Instance: return Logger\n *   Instance->>Logger: info/debug/error(...)\n */\nexport abstract class LoggedClass {\n  /**\n   * @description Lazily provides a context-aware logger for the current instance\n   * @summary Uses Logging.for(this) to create a logger whose context is the\n   * subclass name, allowing uniform and structured logs from any inheriting class.\n   * @return {Logger} A logger bound to the subclass context\n   */\n  protected get log(): Logger {\n    return Logging.for(this as any);\n  }\n\n  protected constructor() {}\n}\n","export * from \"./constants\";\nexport * from \"./decorators\";\nexport * from \"./LoggedClass\";\nexport * from \"./logging\";\nexport * from \"./types\";\n\n/**\n * @description A logging module for TypeScript applications\n * @summary Provides a comprehensive, flexible logging solution. This module exposes:\n * - Core classes like {@link Logging} and {@link MiniLogger}\n * - Decorators such as {@link log} for instrumenting methods\n * - Configuration and constants like {@link LogLevel} and {@link DefaultLoggingConfig}\n * - Type definitions including {@link Logger} and {@link LoggingConfig}\n * These exports enable consistent, context-aware, and optionally themed logging across projects.\n * @module Logging\n */\n\n/**\n * @description Current package version string\n * @summary Stores the current package version, used for version tracking and compatibility checks\n * @const VERSION\n * @memberOf module:Logging\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["LogLevel","LoggingMode","style"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"logging.cjs","sources":["../src/constants.ts","../src/text.ts","../src/web.ts","../src/environment.ts","../src/logging.ts","../src/LoggedClass.ts","../src/filters/LogFilter.ts","../src/decorators.ts","../src/filters/PatternFilter.ts","../src/index.ts"],"sourcesContent":["import { LoggingConfig, Theme } from \"./types\";\n\nexport const BrowserEnvKey = \"ENV\";\n\n/**\n * @description Delimiter used for composing nested environment variable names.\n * @summary Joins parent and child keys when mapping object paths to ENV strings.\n */\nexport const ENV_PATH_DELIMITER = \"__\";\n\nexport const DefaultPlaceholderWrappers = [\"${\", \"}\"];\n\n/**\n * @description Enum for log levels.\n * @summary Defines different levels of logging for the application.\n * @enum {string}\n * @readonly\n * @memberOf module:Logging\n */\nexport enum LogLevel {\n  /** Error events that are likely to cause problems. */\n  error = \"error\",\n  /** Routine information, such as ongoing status or performance. */\n  info = \"info\",\n  /** Additional relevant information. */\n  verbose = \"verbose\",\n  /** Debug or trace information. */\n  debug = \"debug\",\n  /** way too verbose or silly information. */\n  silly = \"silly\",\n}\n\n/**\n * @description Numeric values associated with log levels.\n * @summary Provides a numeric representation of log levels for comparison and filtering.\n * @const NumericLogLevels\n * @property {number} error - Numeric value for error level (2).\n * @property {number} info - Numeric value for info level (4).\n * @property {number} verbose - Numeric value for verbose level (6).\n * @property {number} debug - Numeric value for debug level (7).\n * @property {number} silly - Numeric value for silly level (9).\n * @memberOf module:Logging\n */\nexport const NumericLogLevels = {\n  error: 2,\n  info: 4,\n  verbose: 6,\n  debug: 7,\n  silly: 9,\n};\n\n/**\n * @description Enum for logging output modes.\n * @summary Defines different output formats for log messages.\n * @enum {string}\n * @memberOf module:Logging\n */\nexport enum LoggingMode {\n  /** Raw text format for human readability */\n  RAW = \"raw\",\n  /** JSON format for machine parsing */\n  JSON = \"json\",\n}\n\n/**\n * @description Default theme for styling log output.\n * @summary Defines the default color and style settings for various components of log messages.\n * @const DefaultTheme\n * @typedef {Theme} DefaultTheme\n * @property {Object} class - Styling for class names.\n * @property {number} class.fg - Foreground color code for class names (34).\n * @property {Object} id - Styling for identifiers.\n * @property {number} id.fg - Foreground color code for identifiers (36).\n * @property {Object} stack - Styling for stack traces (empty object).\n * @property {Object} timestamp - Styling for timestamps (empty object).\n * @property {Object} message - Styling for different types of messages.\n * @property {Object} message.error - Styling for error messages.\n * @property {number} message.error.fg - Foreground color code for error messages (31).\n * @property {Object} method - Styling for method names (empty object).\n * @property {Object} logLevel - Styling for different log levels.\n * @property {Object} logLevel.error - Styling for error level logs.\n * @property {number} logLevel.error.fg - Foreground color code for error level logs (31).\n * @property {string[]} logLevel.error.style - Style attributes for error level logs ([\"bold\"]).\n * @property {Object} logLevel.info - Styling for info level logs (empty object).\n * @property {Object} logLevel.verbose - Styling for verbose level logs (empty object).\n * @property {Object} logLevel.debug - Styling for debug level logs.\n * @property {number} logLevel.debug.fg - Foreground color code for debug level logs (33).\n * @memberOf module:Logging\n */\nexport const DefaultTheme: Theme = {\n  app: {},\n  separator: {},\n  class: {\n    fg: 34,\n  },\n  id: {\n    fg: 36,\n  },\n  stack: {},\n  timestamp: {},\n  message: {\n    error: {\n      fg: 31,\n    },\n  },\n  method: {},\n  logLevel: {\n    error: {\n      fg: 31,\n      style: [\"bold\"],\n    },\n    info: {\n      fg: 34,\n      style: [\"bold\"],\n    },\n    verbose: {\n      fg: 34,\n      style: [\"bold\"],\n    },\n    debug: {\n      fg: 33,\n      style: [\"bold\"],\n    },\n  },\n};\n\n/**\n * @description Default configuration for logging.\n * @summary Defines the default settings for the logging system, including verbosity, log level, styling, and timestamp format.\n * @const DefaultLoggingConfig\n * @typedef {LoggingConfig} DefaultLoggingConfig\n * @property {number} verbose - Verbosity level (0).\n * @property {LogLevel} level - Default log level (LogLevel.info).\n * @property {boolean} logLevel - Whether to display log level in output (true).\n * @property {LoggingMode} mode - Output format mode (LoggingMode.RAW).\n * @property {boolean} style - Whether to apply styling to log output (false).\n * @property {string} separator - Separator between log components (\" - \").\n * @property {boolean} timestamp - Whether to include timestamps in log messages (true).\n * @property {string} timestampFormat - Format for timestamps (\"HH:mm:ss.SSS\").\n * @property {boolean} context - Whether to include context information in log messages (true).\n * @property {Theme} theme - The theme to use for styling log messages (DefaultTheme).\n * @memberOf module:Logging\n */\nexport const DefaultLoggingConfig: LoggingConfig = {\n  env: \"development\",\n  verbose: 0,\n  level: LogLevel.info,\n  logLevel: true,\n  style: false,\n  contextSeparator: \".\",\n  separator: \"-\",\n  timestamp: true,\n  timestampFormat: \"HH:mm:ss.SSS\",\n  context: true,\n  format: LoggingMode.RAW,\n  pattern:\n    \"{level} [{timestamp}] {app} {context} {separator} {message} {stack}\",\n  theme: DefaultTheme,\n};\n","import { DefaultPlaceholderWrappers } from \"./constants\";\n\n/**\n * @description Pads the end of a string with a specified character.\n * @summary Extends the input string to a specified length by adding a padding character to the end.\n * If the input string is already longer than the specified length, it is returned unchanged.\n *\n * @param {string} str - The input string to be padded.\n * @param {number} length - The desired total length of the resulting string.\n * @param {string} [char=\" \"] - The character to use for padding. Defaults to a space.\n * @return {string} The padded string.\n * @throws {Error} If the padding character is not exactly one character long.\n *\n * @function padEnd\n *\n * @memberOf module:Logging\n */\nexport function padEnd(\n  str: string,\n  length: number,\n  char: string = \" \"\n): string {\n  if (char.length !== 1)\n    throw new Error(\"Invalid character length for padding. must be one!\");\n  return str.padEnd(length, char);\n}\n\n/**\n * @description Replaces placeholders in a string with provided values.\n * @summary Interpolates a string by replacing placeholders of the form ${variableName}\n * with corresponding values from the provided object. If a placeholder doesn't have\n * a corresponding value, it is left unchanged in the string.\n *\n * @param {string} input - The input string containing placeholders to be replaced.\n * @param {Record<string, number | string>} values - An object containing key-value pairs for replacement.\n * @param prefix\n * @param suffix\n * @param flags\n * @return {string} The interpolated string with placeholders replaced by their corresponding values.\n *\n * @function patchPlaceholders\n *\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant patchString\n *   participant String.replace\n *   Caller->>patchString: Call with input and values\n *   patchString->>String.replace: Call with regex and replacement function\n *   String.replace->>patchString: Return replaced string\n *   patchString-->>Caller: Return patched string\n *\n * @memberOf module:Logging\n */\nexport function patchPlaceholders(\n  input: string,\n  values: Record<string, number | string>,\n  prefix: string = DefaultPlaceholderWrappers[0],\n  suffix: string = DefaultPlaceholderWrappers[1],\n  flags: string = \"g\"\n): string {\n  const placeholders = Object.entries(values).reduce(\n    (acc: Record<string, any>, [key, val]) => {\n      acc[`${prefix}${key}${suffix}`] = val;\n      return acc;\n    },\n    {}\n  );\n  return patchString(input, placeholders, flags);\n}\n\n/**\n * @description Replaces occurrences of keys with their corresponding values in a string.\n * @summary Iterates through a set of key-value pairs and replaces all occurrences of each key\n * in the input string with its corresponding value. Supports regular expression flags for customized replacement.\n *\n * @param {string} input - The input string in which replacements will be made.\n * @param {Record<string, number | string>} values - An object containing key-value pairs for replacement.\n * @param {string} [flags=\"g\"] - Regular expression flags to control the replacement behavior.\n * @return {string} The string with all specified replacements applied.\n *\n * @function patchString\n *\n * @memberOf module:Logging\n */\nexport function patchString(\n  input: string,\n  values: Record<string, number | string>,\n  flags: string = \"g\"\n): string {\n  Object.entries(values).forEach(([key, val]) => {\n    const regexp = new RegExp(escapeRegExp(key), flags);\n    input = input.replace(regexp, val as string);\n  });\n  return input;\n}\n\n/**\n * @description Converts a string to camelCase.\n * @summary Transforms the input string into camelCase format, where words are joined without spaces\n * and each word after the first starts with a capital letter.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to camelCase.\n *\n * @function toCamelCase\n *\n * @memberOf module:Logging\n */\nexport function toCamelCase(text: string): string {\n  return text\n    .replace(/(?:^\\w|[A-Z]|\\b\\w)/g, (word, index) =>\n      index === 0 ? word.toLowerCase() : word.toUpperCase()\n    )\n    .replace(/\\s+/g, \"\");\n}\n\n/**\n * @description Converts a string to ENVIRONMENT_VARIABLE format.\n * @summary Transforms the input string into uppercase with words separated by underscores,\n * typically used for environment variable names.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to ENVIRONMENT_VARIABLE format.\n *\n * @function toENVFormat\n *\n * @memberOf module:Logging\n */\nexport function toENVFormat(text: string): string {\n  return toSnakeCase(text).toUpperCase();\n}\n\n/**\n * @description Converts a string to snake_case.\n * @summary Transforms the input string into lowercase with words separated by underscores.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to snake_case.\n *\n * @function toSnakeCase\n *\n * @memberOf module:Logging\n */\nexport function toSnakeCase(text: string): string {\n  return text\n    .replace(/([a-z])([A-Z])/g, \"$1_$2\")\n    .replace(/[\\s-]+/g, \"_\")\n    .toLowerCase();\n}\n\n/**\n * @description Converts a string to kebab-case.\n * @summary Transforms the input string into lowercase with words separated by hyphens.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to kebab-case.\n *\n * @function toKebabCase\n *\n * @memberOf module:Logging\n */\nexport function toKebabCase(text: string): string {\n  return text\n    .replace(/([a-z])([A-Z])/g, \"$1-$2\")\n    .replace(/[\\s_]+/g, \"-\")\n    .toLowerCase();\n}\n\n/**\n * @description Converts a string to PascalCase.\n * @summary Transforms the input string into PascalCase format, where words are joined without spaces\n * and each word starts with a capital letter.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to PascalCase.\n *\n * @function toPascalCase\n *\n * @memberOf module:Logging\n */\nexport function toPascalCase(text: string): string {\n  return text\n    .replace(/(?:^\\w|[A-Z]|\\b\\w)/g, (word) => word.toUpperCase())\n    .replace(/\\s+/g, \"\");\n}\n\n/**\n * @description Escapes special characters in a string for use in a regular expression.\n * @summary Adds backslashes before characters that have special meaning in regular expressions,\n * allowing the string to be used as a literal match in a RegExp.\n *\n * @param {string} string - The string to escape for regular expression use.\n * @return {string} The escaped string safe for use in regular expressions.\n *\n * @function escapeRegExp\n *\n * @memberOf module:Logging\n */\nexport function escapeRegExp(string: string) {\n  return string.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"); // $& means the whole matched string\n}\n\n/**\n * @summary Util function to provide string format functionality similar to C#'s string.format\n *\n * @param {string} string\n * @param {Array<string | number> | Record<string, any>} [args] replacements made by order of appearance (replacement0 wil replace {0} and so on)\n * @return {string} formatted string\n *\n * @function sf\n * @memberOf module:Logging\n */\nexport function sf(\n  string: string,\n  ...args: (string | number | Record<string, any>)[]\n) {\n  if (args.length > 1) {\n    if (\n      !args.every((arg) => typeof arg === \"string\" || typeof arg === \"number\")\n    )\n      throw new Error(\n        `Only string and number arguments are supported for multiple replacements.`\n      );\n  }\n\n  if (args.length === 1 && typeof args[0] === \"object\") {\n    const obj = args[0] as Record<string, any>;\n    return Object.entries(obj).reduce((acc, [key, val]) => {\n      return acc.replace(new RegExp(`\\\\{${key}\\\\}`, \"g\"), function () {\n        return val;\n      });\n    }, string);\n  }\n\n  return string.replace(/{(\\d+)}/g, function (match, number) {\n    return typeof args[number] !== \"undefined\"\n      ? args[number].toString()\n      : \"undefined\";\n  });\n}\n\n/**\n * @summary Util function to provide string format functionality similar to C#'s string.format\n *\n * @see sf\n *\n * @deprecated\n * @function stringFormat\n * @memberOf module:Logging\n */\nexport const stringFormat = sf;\n","/**\n * @description Determines if the current environment is a browser by checking the prototype chain of the global object.\n * @summary Checks if the code is running in a browser environment.\n * @return {boolean} True if the environment is a browser, false otherwise.\n * @function isBrowser\n * @memberOf module:Logging\n */\nexport function isBrowser(): boolean {\n  return (\n    Object.getPrototypeOf(Object.getPrototypeOf(globalThis)) !==\n    Object.prototype\n  );\n}\n","import { ObjectAccumulator } from \"typed-object-accumulator\";\nimport { toENVFormat } from \"./text\";\nimport { isBrowser } from \"./web\";\nimport {\n  BrowserEnvKey,\n  DefaultLoggingConfig,\n  ENV_PATH_DELIMITER,\n} from \"./constants\";\n\n/**\n * @description Factory type for creating Environment instances.\n * @summary Defines a function type that creates and returns Environment instances.\n *\n * @template T - The type of object the Environment will accumulate.\n * @template E - The specific Environment type to be created, extending Environment<T>.\n * @typedef {function(...unknown[]): E} EnvironmentFactory\n * @memberOf module:Logging\n */\nexport type EnvironmentFactory<T extends object, E extends Environment<T>> = (\n  ...args: unknown[]\n) => E;\n\n/**\n * @class Environment\n * @extends {ObjectAccumulator<T>}\n * @template T\n * @description A class representing an environment with accumulation capabilities.\n * @summary Manages environment-related data and provides methods for accumulation and key retrieval.\n * @param {T} [initialData] - The initial data to populate the environment with.\n */\nexport class Environment<T extends object> extends ObjectAccumulator<T> {\n  /**\n   * @static\n   * @protected\n   * @description A factory function for creating Environment instances.\n   * @summary Defines how new instances of the Environment class should be created.\n   * @return {Environment<any>} A new instance of the Environment class.\n   */\n  protected static factory: EnvironmentFactory<any, any> =\n    (): Environment<any> => new Environment();\n\n  /**\n   * @static\n   * @private\n   * @description The singleton instance of the Environment class.\n   * @type {Environment<any>}\n   */\n  private static _instance: Environment<any>;\n\n  protected constructor() {\n    super();\n  }\n\n  /**\n   * @description Retrieves a value from the environment\n   * @summary Gets a value from the environment variables, handling browser and Node.js environments differently\n   * @param {string} k - The key to retrieve from the environment\n   * @return {unknown} The value from the environment, or undefined if not found\n   */\n  protected fromEnv(k: string) {\n    let env: Record<string, unknown>;\n    if (isBrowser()) {\n      env = (\n        globalThis as typeof globalThis & {\n          [BrowserEnvKey]: Record<string, any>;\n        }\n      )[BrowserEnvKey];\n    } else {\n      env = globalThis.process.env;\n      k = toENVFormat(k);\n    }\n    return env[k];\n  }\n\n  /**\n   * @description Expands an object into the environment\n   * @summary Defines properties on the environment object that can be accessed as getters and setters\n   * @template V - Type of the object being expanded\n   * @param {V} value - The object to expand into the environment\n   * @return {void}\n   */\n  protected override expand<V extends object>(value: V): void {\n    Object.entries(value).forEach(([k, v]) => {\n      Object.defineProperty(this, k, {\n        get: () => {\n          const fromEnv = this.fromEnv(k);\n          if (typeof fromEnv !== \"undefined\") return fromEnv;\n          if (v && typeof v === \"object\") {\n            return Environment.buildEnvProxy(v as any, [k]);\n          }\n          // If the model provides an empty string, expose a proxy that composes ENV keys\n          if (v === \"\") {\n            return Environment.buildEnvProxy(undefined, [k]);\n          }\n          return v;\n        },\n        set: (val: V[keyof V]) => {\n          v = val;\n        },\n        configurable: true,\n        enumerable: true,\n      });\n    });\n  }\n\n  /**\n   * @protected\n   * @static\n   * @description Retrieves or creates the singleton instance of the Environment class.\n   * @summary Ensures only one instance of the Environment class exists.\n   * @template E\n   * @param {...unknown[]} args - Arguments to pass to the factory function if a new instance is created.\n   * @return {E} The singleton instance of the Environment class.\n   */\n  protected static instance<E extends Environment<any>>(...args: unknown[]): E {\n    if (!Environment._instance) {\n      const base = Environment.factory(...args) as E;\n      const proxied = new Proxy(base as any, {\n        get(target, prop, receiver) {\n          const value = Reflect.get(target, prop, receiver);\n          if (typeof value !== \"undefined\") return value;\n          if (typeof prop === \"string\") {\n            // Avoid interfering with logging config lookups for optional fields like 'app'\n            if (prop === \"app\") return undefined;\n            return Environment.buildEnvProxy(undefined, [prop]);\n          }\n          return value;\n        },\n      });\n      Environment._instance = proxied as any;\n    }\n    return Environment._instance as E;\n  }\n\n  /**\n   * @static\n   * @description Accumulates the given value into the environment.\n   * @summary Adds new properties to the environment from the provided object.\n   * @template V\n   * @param {V} value - The object to accumulate into the environment.\n   * @return {V} The updated environment instance.\n   */\n  static accumulate<V extends object>(\n    value: V\n  ): typeof Environment._instance &\n    V &\n    ObjectAccumulator<typeof Environment._instance & V> {\n    const instance = Environment.instance();\n    Object.keys(instance as any).forEach((key) => {\n      const desc = Object.getOwnPropertyDescriptor(instance as any, key);\n      if (desc && desc.configurable && desc.enumerable) {\n        Object.defineProperty(instance as any, key, {\n          ...desc,\n          enumerable: false,\n        });\n      }\n    });\n    return instance.accumulate(value);\n  }\n\n  static get(key: string) {\n    return Environment._instance.get(key);\n  }\n\n  private static buildEnvProxy(current: any, path: string[]): any {\n    const buildKey = (p: string[]) =>\n      p.map((seg) => toENVFormat(seg)).join(ENV_PATH_DELIMITER);\n\n    // Helper to read from the active environment given a composed key\n    const readEnv = (key: string): unknown => {\n      if (isBrowser()) {\n        const env = (\n          globalThis as typeof globalThis & {\n            [BrowserEnvKey]?: Record<string, unknown>;\n          }\n        )[BrowserEnvKey];\n        return env ? env[key] : undefined;\n      }\n      return (globalThis as any)?.process?.env?.[key];\n    };\n\n    const handler: ProxyHandler<any> = {\n      get(_target, prop: string | symbol) {\n        if (prop === Symbol.toPrimitive) {\n          return () => buildKey(path);\n        }\n        if (prop === \"toString\") {\n          return () => buildKey(path);\n        }\n        if (prop === \"valueOf\") {\n          return () => buildKey(path);\n        }\n        if (typeof prop === \"symbol\") return undefined;\n\n        const nextModel =\n          current && Object.prototype.hasOwnProperty.call(current, prop)\n            ? (current as any)[prop]\n            : undefined;\n        const nextPath = [...path, prop];\n        const composedKey = buildKey(nextPath);\n\n        // If an ENV value exists for this path, return it directly\n        const envValue = readEnv(composedKey);\n        if (typeof envValue !== \"undefined\") return envValue;\n\n        // Otherwise, if the model has an object at this path, keep drilling with a proxy\n        const isNextObject = nextModel && typeof nextModel === \"object\";\n        if (isNextObject) return Environment.buildEnvProxy(nextModel, nextPath);\n\n        // Always return a proxy for further path composition when no ENV value;\n        // do not surface primitive model defaults here (this API is for key composition).\n        return Environment.buildEnvProxy(undefined, nextPath);\n      },\n      ownKeys() {\n        return current ? Reflect.ownKeys(current) : [];\n      },\n      getOwnPropertyDescriptor(_t, p) {\n        if (!current) return undefined as any;\n        if (Object.prototype.hasOwnProperty.call(current, p)) {\n          return { enumerable: true, configurable: true } as PropertyDescriptor;\n        }\n        return undefined as any;\n      },\n    };\n\n    const target = {} as any;\n    return new Proxy(target, handler);\n  }\n\n  /**\n   * @static\n   * @description Retrieves the keys of the environment, optionally converting them to ENV format.\n   * @summary Gets all keys in the environment, with an option to format them for environment variables.\n   * @param {boolean} [toEnv=true] - Whether to convert the keys to ENV format.\n   * @return {string[]} An array of keys from the environment.\n   */\n  static keys(toEnv: boolean = true): string[] {\n    return Environment.instance()\n      .keys()\n      .map((k) => (toEnv ? toENVFormat(k) : k));\n  }\n}\n\nexport const LoggedEnvironment = Environment.accumulate(\n  Object.assign({}, DefaultLoggingConfig, {\n    env:\n      (isBrowser() && (globalThis as any)[BrowserEnvKey]\n        ? (globalThis as any)[BrowserEnvKey][\"NODE_ENV\"]\n        : (globalThis as any).process.env[\"NODE_ENV\"]) || \"development\",\n  })\n);\n","import {\n  LoggerFactory,\n  LoggingConfig,\n  LoggingContext,\n  StringLike,\n  Theme,\n  ThemeOption,\n  ThemeOptionByLogLevel,\n  Logger,\n} from \"./types\";\nimport { ColorizeOptions, style, StyledString } from \"styled-string-builder\";\nimport { DefaultTheme, LogLevel, NumericLogLevels } from \"./constants\";\nimport { sf } from \"./text\";\nimport { LoggedEnvironment } from \"./environment\";\n\n/**\n * @description A minimal logger implementation.\n * @summary MiniLogger is a lightweight logging class that implements the Logger interface.\n * It provides basic logging functionality with support for different log levels, verbosity,\n * context-aware logging, and customizable formatting.\n * @param {string} context - The context (typically class name) this logger is associated with\n * @param {Partial<LoggingConfig>} conf - Optional configuration to override global settings\n * @class MiniLogger\n * @example\n * // Create a new logger for a class\n * const logger = new MiniLogger('MyClass');\n *\n * // Log messages at different levels\n * logger.info('This is an info message');\n * logger.debug('This is a debug message');\n * logger.error('Something went wrong');\n *\n * // Create a child logger for a specific method\n * const methodLogger = logger.for('myMethod');\n * methodLogger.verbose('Detailed information', 2);\n *\n * // Log with custom configuration\n * logger.for('specialMethod', { style: true }).info('Styled message');\n */\nexport class MiniLogger implements Logger {\n  constructor(\n    protected context: string,\n    protected conf?: Partial<LoggingConfig>\n  ) {}\n\n  protected config(\n    key: keyof LoggingConfig\n  ): LoggingConfig[keyof LoggingConfig] {\n    if (this.conf && key in this.conf) return this.conf[key];\n    return Logging.getConfig()[key];\n  }\n\n  for(method: string | ((...args: any[]) => any)): Logger;\n  for(config: Partial<LoggingConfig>): Logger;\n  for(\n    method: string | ((...args: any[]) => any) | Partial<LoggingConfig>,\n    config: Partial<LoggingConfig>,\n    ...args: any[]\n  ): Logger;\n  /**\n   * @description Creates a child logger for a specific method or context\n   * @summary Returns a new logger instance with the current context extended by the specified method name\n   * @param {string | Function} method - The method name or function to create a logger for\n   * @param {Partial<LoggingConfig>} config - Optional configuration to override settings\n   * @param {...any[]} args - Additional arguments to pass to the logger factory\n   * @return {Logger} A new logger instance for the specified method\n   */\n  for(\n    method?: string | ((...args: any[]) => any) | Partial<LoggingConfig>,\n    config?: Partial<LoggingConfig>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Logger {\n    if (!config && typeof method === \"object\") {\n      config = method;\n      method = undefined;\n    } else {\n      method = method\n        ? typeof method === \"string\"\n          ? method\n          : (method as any).name\n        : undefined;\n    }\n\n    return new Proxy(this, {\n      get: (target: typeof this, p: string | symbol, receiver: any) => {\n        const result = Reflect.get(target, p, receiver);\n        if (p === \"config\") {\n          return new Proxy(this.config, {\n            get: (target: typeof this.config, p: string | symbol) => {\n              if (config && p in config)\n                return config[p as keyof LoggingConfig];\n              return Reflect.get(target, p, receiver);\n            },\n          });\n        }\n        if (p === \"context\" && method) {\n          return [result, method].join(\".\");\n        }\n        return result;\n      },\n    });\n  }\n\n  /**\n   * @description Creates a formatted log string\n   * @summary Generates a log string with timestamp, colored log level, context, and message\n   * @param {LogLevel} level - The log level for this message\n   * @param {StringLike | Error} message - The message to log or an Error object\n   * @param {string} [error] - Optional error to extract stack trace to include in the log\n   * @return {string} A formatted log string with all components\n   */\n  protected createLog(\n    level: LogLevel,\n    message: StringLike | Error,\n    error?: Error\n  ): string {\n    const log: Record<\n      | \"timestamp\"\n      | \"level\"\n      | \"context\"\n      | \"correlationId\"\n      | \"message\"\n      | \"separator\"\n      | \"stack\"\n      | \"app\",\n      string\n    > = {} as any;\n    const style = this.config(\"style\");\n    const separator = this.config(\"separator\");\n    const app = this.config(\"app\");\n    if (app)\n      log.app = style\n        ? Logging.theme(app as string, \"app\", level)\n        : (app as string);\n\n    if (separator)\n      log.separator = style\n        ? Logging.theme(separator as string, \"separator\", level)\n        : (separator as string);\n\n    if (this.config(\"timestamp\")) {\n      const date = new Date().toISOString();\n      const timestamp = style ? Logging.theme(date, \"timestamp\", level) : date;\n      log.timestamp = timestamp;\n    }\n\n    if (this.config(\"logLevel\")) {\n      const lvl: string = style\n        ? Logging.theme(level, \"logLevel\", level)\n        : level;\n      log.level = lvl.toUpperCase();\n    }\n\n    if (this.config(\"context\")) {\n      const context: string = style\n        ? Logging.theme(this.context, \"class\", level)\n        : this.context;\n      log.context = context;\n    }\n\n    if (this.config(\"correlationId\")) {\n      {\n        const id: string = style\n          ? Logging.theme(this.config(\"correlationId\")!.toString(), \"id\", level)\n          : this.config(\"correlationId\")!.toString();\n        log.correlationId = id;\n      }\n    }\n\n    const msg: string = style\n      ? Logging.theme(\n          typeof message === \"string\" ? message : (message as Error).message,\n          \"message\",\n          level\n        )\n      : typeof message === \"string\"\n        ? message\n        : (message as Error).message;\n    log.message = msg;\n    if (error || message instanceof Error) {\n      const stack = style\n        ? Logging.theme(\n            (error?.stack || (message as Error).stack) as string,\n            \"stack\",\n            level\n          )\n        : error?.stack || \"\";\n      log.stack = ` | ${(error || (message as Error)).message} - Stack trace:\\n${stack}`;\n    }\n\n    switch (this.config(\"format\")) {\n      case \"json\":\n        return JSON.stringify(log);\n      case \"raw\":\n        return (this.config(\"pattern\") as string)\n          .split(\" \")\n          .map((s) => {\n            if (!s.match(/\\{.*?}/g)) return s;\n            const formattedS = sf(s, log);\n            if (formattedS !== s) return formattedS;\n            return undefined;\n          })\n          .filter((s) => s)\n          .join(\" \");\n      default:\n        throw new Error(`Unsupported logging format: ${this.config(\"format\")}`);\n    }\n  }\n\n  /**\n   * @description Logs a message with the specified log level\n   * @summary Checks if the message should be logged based on the current log level,\n   * then uses the appropriate console method to output the formatted log\n   * @param {LogLevel} level - The log level of the message\n   * @param {StringLike | Error} msg - The message to be logged or an Error object\n   * @param {string} [error] - Optional stack trace to include in the log\n   * @return {void}\n   */\n  protected log(level: LogLevel, msg: StringLike | Error, error?: Error): void {\n    const confLvl = this.config(\"level\") as LogLevel;\n    if (NumericLogLevels[confLvl] < NumericLogLevels[level]) return;\n    let method;\n    switch (level) {\n      case LogLevel.info:\n        method = console.log;\n        break;\n      case LogLevel.verbose:\n      case LogLevel.debug:\n        method = console.debug;\n        break;\n      case LogLevel.error:\n        method = console.error;\n        break;\n      default:\n        throw new Error(\"Invalid log level\");\n    }\n    method(this.createLog(level, msg, error));\n  }\n\n  /**\n   * @description Logs a message at the silly level\n   * @summary Logs a message at the silly level if the current verbosity setting allows it\n   * @param {StringLike} msg - The message to be logged\n   * @param {number} [verbosity=0] - The verbosity level of the message\n   * @return {void}\n   */\n  silly(msg: StringLike, verbosity: number = 0): void {\n    if ((this.config(\"verbose\") as number) >= verbosity)\n      this.log(LogLevel.verbose, msg);\n  }\n\n  /**\n   * @description Logs a message at the verbose level\n   * @summary Logs a message at the verbose level if the current verbosity setting allows it\n   * @param {StringLike} msg - The message to be logged\n   * @param {number} [verbosity=0] - The verbosity level of the message\n   * @return {void}\n   */\n  verbose(msg: StringLike, verbosity: number = 0): void {\n    if ((this.config(\"verbose\") as number) >= verbosity)\n      this.log(LogLevel.verbose, msg);\n  }\n\n  /**\n   * @description Logs a message at the info level\n   * @summary Logs a message at the info level for general application information\n   * @param {StringLike} msg - The message to be logged\n   * @return {void}\n   */\n  info(msg: StringLike): void {\n    this.log(LogLevel.info, msg);\n  }\n\n  /**\n   * @description Logs a message at the debug level\n   * @summary Logs a message at the debug level for detailed troubleshooting information\n   * @param {StringLike} msg - The message to be logged\n   * @return {void}\n   */\n  debug(msg: StringLike): void {\n    this.log(LogLevel.debug, msg);\n  }\n\n  /**\n   * @description Logs a message at the error level\n   * @summary Logs a message at the error level for errors and exceptions\n   * @param {StringLike | Error} msg - The message to be logged or an Error object\n   * @param e\n   * @return {void}\n   */\n  error(msg: StringLike | Error, e?: Error): void {\n    this.log(LogLevel.error, msg, e);\n  }\n\n  /**\n   * @description Updates the logger configuration\n   * @summary Merges the provided configuration with the existing configuration\n   * @param {Partial<LoggingConfig>} config - The configuration options to apply\n   * @return {void}\n   */\n  setConfig(config: Partial<LoggingConfig>): void {\n    this.conf = { ...(this.conf || {}), ...config };\n  }\n}\n\n/**\n * @description A static class for managing logging operations\n * @summary The Logging class provides a centralized logging mechanism with support for\n * different log levels, verbosity, and styling. It uses a singleton pattern to maintain a global\n * logger instance and allows creating specific loggers for different classes and methods.\n * @class Logging\n * @example\n * // Set global configuration\n * Logging.setConfig({ level: LogLevel.debug, style: true });\n *\n * // Get a logger for a specific class\n * const logger = Logging.for('MyClass');\n *\n * // Log messages at different levels\n * logger.info('Application started');\n * logger.debug('Processing data...');\n *\n * // Log with context\n * const methodLogger = Logging.for('MyClass.myMethod');\n * methodLogger.verbose('Detailed operation information', 1);\n *\n * // Log errors\n * try {\n *   // some operation\n * } catch (error) {\n *   logger.error(error);\n * }\n * @mermaid\n * classDiagram\n *   class Logger {\n *     <<interface>>\n *     +for(method, config, ...args)\n *     +silly(msg, verbosity)\n *     +verbose(msg, verbosity)\n *     +info(msg)\n *     +debug(msg)\n *     +error(msg)\n *     +setConfig(config)\n *   }\n *\n *   class Logging {\n *     -global: Logger\n *     -_factory: LoggerFactory\n *     -_config: LoggingConfig\n *     +setFactory(factory)\n *     +setConfig(config)\n *     +getConfig()\n *     +get()\n *     +verbose(msg, verbosity)\n *     +info(msg)\n *     +debug(msg)\n *     +silly(msg)\n *     +error(msg)\n *     +for(object, config, ...args)\n *     +because(reason, id)\n *     +theme(text, type, loggerLevel, template)\n *   }\n *\n *   class MiniLogger {\n *     +constructor(context, conf?)\n *   }\n *\n *   Logging ..> Logger : creates\n *   Logging ..> MiniLogger : creates by default\n */\nexport class Logging {\n  /**\n   * @description The global logger instance\n   * @summary A singleton instance of Logger used for global logging\n   */\n  private static global?: Logger;\n\n  /**\n   * @description Factory function for creating logger instances\n   * @summary A function that creates new Logger instances. By default, it creates a MiniLogger.\n   */\n  private static _factory: LoggerFactory = (\n    object: string,\n    config?: Partial<LoggingConfig>\n  ) => {\n    return new MiniLogger(object, config);\n  };\n\n  private static _config: typeof LoggedEnvironment = LoggedEnvironment;\n\n  private constructor() {}\n\n  /**\n   * @description Sets the factory function for creating logger instances\n   * @summary Allows customizing how logger instances are created\n   * @param {LoggerFactory} factory - The factory function to use for creating loggers\n   * @return {void}\n   */\n  static setFactory(factory: LoggerFactory) {\n    Logging._factory = factory;\n  }\n\n  /**\n   * @description Updates the global logging configuration\n   * @summary Allows updating the global logging configuration with new settings\n   * @param {Partial<LoggingConfig>} config - The configuration options to apply\n   * @return {void}\n   */\n  static setConfig(config: Partial<LoggingConfig>): void {\n    Object.entries(config).forEach(([k, v]) => {\n      (this._config as any)[k] = v as any;\n    });\n  }\n\n  /**\n   * @description Gets a copy of the current global logging configuration\n   * @summary Returns a copy of the current global logging configuration\n   * @return {LoggingConfig} A copy of the current configuration\n   */\n  static getConfig(): typeof LoggedEnvironment {\n    return this._config;\n  }\n\n  /**\n   * @description Retrieves or creates the global logger instance.\n   * @summary Returns the existing global logger or creates a new one if it doesn't exist.\n   *\n   * @return The global VerbosityLogger instance.\n   */\n  static get(): Logger {\n    this.global = this.global ? this.global : this._factory(\"Logging\");\n    return this.global;\n  }\n\n  /**\n   * @description Logs a verbose message.\n   * @summary Delegates the verbose logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   * @param verbosity - The verbosity level of the message (default: 0).\n   */\n  static verbose(msg: StringLike, verbosity: number = 0): void {\n    return this.get().verbose(msg, verbosity);\n  }\n\n  /**\n   * @description Logs an info message.\n   * @summary Delegates the info logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static info(msg: StringLike): void {\n    return this.get().info(msg);\n  }\n\n  /**\n   * @description Logs a debug message.\n   * @summary Delegates the debug logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static debug(msg: StringLike): void {\n    return this.get().debug(msg);\n  }\n\n  /**\n   * @description Logs a silly message.\n   * @summary Delegates the debug logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static silly(msg: StringLike): void {\n    return this.get().silly(msg);\n  }\n\n  /**\n   * @description Logs an error message.\n   * @summary Delegates the error logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   * @param e\n   */\n  static error(msg: StringLike, e?: Error): void {\n    return this.get().error(msg, e);\n  }\n\n  /**\n   * @description Creates a logger for a specific object or context\n   * @summary Creates a new logger instance for the given object or context using the factory function\n   * @param {LoggingContext} object - The object, class, or context to create a logger for\n   * @param {Partial<LoggingConfig>} [config] - Optional configuration to override global settings\n   * @param {...any} args - Additional arguments to pass to the logger factory\n   * @return {Logger} A new logger instance for the specified object or context\n   */\n  static for(\n    object: LoggingContext,\n    config?: Partial<LoggingConfig>,\n    ...args: any[]\n  ): Logger {\n    object =\n      typeof object === \"string\"\n        ? object\n        : object.constructor\n          ? object.constructor.name\n          : object.name;\n    return this._factory(object, config, ...args);\n  }\n\n  /**\n   * @description Creates a logger for a specific reason or correlation context\n   * @summary Utility to quickly create a logger labeled with a free-form reason and optional identifier\n   * so that ad-hoc operations can be traced without tying the logger to a class or method name.\n   * @param {string} reason - A textual reason or context label for this logger instance\n   * @param {string} [id] - Optional identifier to help correlate related log entries\n   * @return {Logger} A new logger instance labeled with the provided reason and id\n   */\n  static because(reason: string, id?: string): Logger {\n    return this._factory(reason, this._config, id);\n  }\n\n  /**\n   * @description Applies theme styling to text\n   * @summary Applies styling (colors, formatting) to text based on the theme configuration\n   * @param {string} text - The text to style\n   * @param {string} type - The type of element to style (e.g., \"class\", \"message\", \"logLevel\")\n   * @param {LogLevel} loggerLevel - The log level to use for styling\n   * @param {Theme} [template=DefaultTheme] - The theme to use for styling\n   * @return {string} The styled text\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant Theme as Logging.theme\n   *   participant Apply as apply function\n   *   participant Style as styled-string-builder\n   *\n   *   Caller->>Theme: theme(text, type, loggerLevel)\n   *   Theme->>Theme: Check if styling is enabled\n   *   alt styling disabled\n   *     Theme-->>Caller: return original text\n   *   else styling enabled\n   *     Theme->>Theme: Get theme for type\n   *     alt theme not found\n   *       Theme-->>Caller: return original text\n   *     else theme found\n   *       Theme->>Theme: Determine actual theme based on log level\n   *       Theme->>Apply: Apply each style property\n   *       Apply->>Style: Apply colors and formatting\n   *       Style-->>Apply: Return styled text\n   *       Apply-->>Theme: Return styled text\n   *       Theme-->>Caller: Return final styled text\n   *     end\n   *   end\n   */\n  static theme(\n    text: string,\n    type: keyof Theme | keyof LogLevel,\n    loggerLevel: LogLevel,\n    template: Theme = DefaultTheme\n  ) {\n    if (!this._config.style) return text;\n    const logger = Logging.get().for(this.theme);\n\n    function apply(\n      txt: string,\n      option: keyof ThemeOption,\n      value: number | [number] | [number, number, number] | number[] | string[]\n    ): string {\n      try {\n        const t: string | StyledString = txt;\n        let c = style(t);\n\n        function applyColor(\n          val: number | [number] | [number, number, number],\n          isBg = false\n        ): StyledString {\n          let f:\n            | typeof c.background\n            | typeof c.foreground\n            | typeof c.rgb\n            | typeof c.color256 = isBg ? c.background : c.foreground;\n          if (!Array.isArray(val)) {\n            return (f as typeof c.background | typeof c.foreground).call(\n              c,\n              value as number\n            );\n          }\n          switch (val.length) {\n            case 1:\n              f = isBg ? c.bgColor256 : c.color256;\n              return (f as typeof c.bgColor256 | typeof c.color256)(val[0]);\n            case 3:\n              f = isBg ? c.bgRgb : c.rgb;\n              return c.rgb(val[0], val[1], val[2]);\n            default:\n              logger.error(`Not a valid color option: ${option}`);\n              return style(t as string);\n          }\n        }\n\n        function applyStyle(v: number | string): void {\n          if (typeof v === \"number\") {\n            c = c.style(v);\n          } else {\n            c = c[v as keyof ColorizeOptions] as StyledString;\n          }\n        }\n\n        switch (option) {\n          case \"bg\":\n          case \"fg\":\n            return applyColor(value as number).text;\n          case \"style\":\n            if (Array.isArray(value)) {\n              value.forEach(applyStyle);\n            } else {\n              applyStyle(value as number | string);\n            }\n            return c.text;\n          default:\n            logger.error(`Not a valid theme option: ${option}`);\n            return t;\n        }\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      } catch (e: unknown) {\n        logger.error(`Error applying style: ${option} with value ${value}`);\n        return txt;\n      }\n    }\n\n    const individualTheme = template[type as keyof Theme];\n    if (!individualTheme || !Object.keys(individualTheme).length) {\n      return text;\n    }\n\n    let actualTheme: ThemeOption = individualTheme as ThemeOption;\n\n    const logLevels = Object.assign({}, LogLevel);\n    if (Object.keys(individualTheme)[0] in logLevels)\n      actualTheme =\n        (individualTheme as ThemeOptionByLogLevel)[loggerLevel] || {};\n\n    return Object.keys(actualTheme).reduce((acc: string, key: string) => {\n      const val = (actualTheme as ThemeOption)[key as keyof ThemeOption];\n      if (val)\n        return apply(\n          acc,\n          key as keyof ThemeOption,\n          val as\n            | number\n            | [number]\n            | [number, number, number]\n            | number[]\n            | string[]\n        );\n      return acc;\n    }, text);\n  }\n}\n","import { Logging } from \"./logging\";\nimport { Logger } from \"./types\";\n\n/**\n * @description Base class that provides a ready-to-use logger instance\n * @summary LoggedClass is a convenience abstract class that injects a type-safe logger\n * into derived classes through a protected getter. Subclasses can directly access\n * this.log to emit messages without manually creating a logger. This promotes\n * consistent, context-aware logging across the codebase.\n * @param {void} [constructor] - No constructor arguments; subclasses may define their own\n * @class LoggedClass\n * @example\n * class UserService extends LoggedClass {\n *   create(user: User) {\n *     this.log.info(`Creating user ${user.id}`);\n *   }\n * }\n *\n * const svc = new UserService();\n * svc.create({ id: \"42\" });\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Instance as Subclass Instance\n *   participant Getter as LoggedClass.log\n *   participant Logging as Logging\n *   participant Logger as Logger\n *\n *   Client->>Instance: call someMethod()\n *   Instance->>Getter: access this.log\n *   Getter->>Logging: Logging.for(this)\n *   Logging-->>Getter: return Logger\n *   Getter-->>Instance: return Logger\n *   Instance->>Logger: info/debug/error(...)\n */\nexport abstract class LoggedClass {\n  /**\n   * @description Lazily provides a context-aware logger for the current instance\n   * @summary Uses Logging.for(this) to create a logger whose context is the\n   * subclass name, allowing uniform and structured logs from any inheriting class.\n   * @return {Logger} A logger bound to the subclass context\n   */\n  protected get log(): Logger {\n    return Logging.for(this as any);\n  }\n\n  protected constructor() {}\n}\n","import { Logger, LoggingConfig, LoggingFilter } from \"../types\";\nimport { LoggedClass } from \"../LoggedClass\";\n\nexport abstract class LogFilter extends LoggedClass implements LoggingFilter {\n  override get log(): Logger {\n    return super.log.for(this as any, { filters: [] });\n  }\n\n  abstract filter(\n    config: LoggingConfig,\n    message: string,\n    context: string[]\n  ): string;\n}\n","import { LogLevel } from \"./constants\";\nimport { Logging } from \"./logging\";\n\n/**\n * @description Method decorator for logging function calls\n * @summary Creates a decorator that logs method calls with specified level, benchmarking, and verbosity\n * @param {LogLevel} level - The log level to use (default: LogLevel.info)\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @param {number} [verbosity=0] - The verbosity level for the log messages (default: 0)\n * @return {Function} A method decorator that wraps the original method with logging\n * @function log\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Decorator as log decorator\n *   participant Method as Original Method\n *   participant Logger as Logging instance\n *\n *   Client->>Decorator: call decorated method\n *   Decorator->>Logger: log method call\n *   Decorator->>Method: call original method\n *   alt result is Promise\n *     Method-->>Decorator: return Promise\n *     Decorator->>Decorator: attach then handler\n *     Note over Decorator: Promise resolves\n *     Decorator->>Logger: log benchmark (if enabled)\n *     Decorator-->>Client: return result\n *   else result is not Promise\n *     Method-->>Decorator: return result\n *     Decorator->>Logger: log benchmark (if enabled)\n *     Decorator-->>Client: return result\n *   end\n * @category Method Decorators\n */\nexport function log(\n  level: LogLevel = LogLevel.info,\n  benchmark: boolean = false,\n  verbosity = 0\n) {\n  return function (\n    target: any,\n    propertyKey?: any,\n    descriptor?: PropertyDescriptor\n  ) {\n    if (!descriptor)\n      throw new Error(`Logging decoration only applies to methods`);\n    const logger = Logging.for(target).for(target[propertyKey]);\n    const method = logger[level].bind(logger) as any;\n    const originalMethod = descriptor.value;\n\n    descriptor.value = new Proxy(originalMethod, {\n      apply(fn, thisArg, args: any[]) {\n        method(`called with ${args}`, verbosity);\n        const start = Date.now();\n        try {\n          const result = Reflect.apply(fn, thisArg, args);\n          if (result instanceof Promise) {\n            return result.then((r: any) => {\n              if (benchmark)\n                method(`completed in ${Date.now() - start}ms`, verbosity);\n              return r;\n            });\n          }\n          if (benchmark)\n            method(`completed in ${Date.now() - start}ms`, verbosity);\n          return result;\n        } catch (err) {\n          if (benchmark) method(`failed in ${Date.now() - start}ms`, verbosity);\n          throw err;\n        }\n      },\n    });\n  };\n}\n\n/**\n * @description Method decorator for logging function calls with debug level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.debug\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with debug logging\n * @function debug\n * @category Method Decorators\n */\nexport function debug(benchmark: boolean = false) {\n  return log(LogLevel.debug, benchmark);\n}\n\n/**\n * @description Method decorator for logging function calls with info level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.info\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with info logging\n * @function info\n * @category Method Decorators\n */\nexport function info(benchmark: boolean = false) {\n  return log(LogLevel.info, benchmark);\n}\n\n/**\n * @description Method decorator for logging function calls with silly level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.silly\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with silly logging\n * @function silly\n * @category Method Decorators\n */\nexport function silly(benchmark: boolean = false) {\n  return log(LogLevel.silly, benchmark);\n}\n\n/**\n * @description Method decorator for logging function calls with verbose level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity\n * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n */\nexport function verbose(): (\n  target: any,\n  propertyKey?: any,\n  descriptor?: any\n) => void;\n\n/**\n * @description Method decorator for logging function calls with verbose level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity\n * @param {boolean} benchmark - Whether to log execution time\n * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n */\nexport function verbose(\n  benchmark: boolean\n): (target: any, propertyKey?: any, descriptor?: any) => void;\n\n/**\n * @description Method decorator for logging function calls with verbose level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity\n * @param {number} verbosity - The verbosity level for the log messages (default: 0)\n * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n * @category Method Decorators\n */\nexport function verbose(\n  verbosity: number | boolean\n): (target: any, propertyKey?: any, descriptor?: any) => void;\n/**\n * @description Method decorator for logging function calls with verbose level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity\n * @param {number} verbosity - The verbosity level for the log messages (default: 0)\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n * @category Method Decorators\n */\nexport function verbose(verbosity: number | boolean = 0, benchmark?: boolean) {\n  if (typeof verbosity === \"boolean\") {\n    benchmark = verbosity;\n    verbosity = 0;\n  }\n  return log(LogLevel.verbose, benchmark, verbosity);\n}\n\n/**\n * @description Creates a decorator that makes a method non-configurable\n * @summary This decorator prevents a method from being overridden by making it non-configurable.\n * It throws an error if used on anything other than a method.\n * @return {Function} A decorator function that can be applied to methods\n * @function final\n * @category Method Decorators\n */\nexport function final() {\n  return (\n    target: object,\n    propertyKey?: any,\n    descriptor?: PropertyDescriptor\n  ) => {\n    if (!descriptor)\n      throw new Error(\"final decorator can only be used on methods\");\n    if (descriptor?.configurable) {\n      descriptor.configurable = false;\n    }\n    return descriptor;\n  };\n}\n","import { LogFilter } from \"./LogFilter\";\nimport { LoggingConfig } from \"../types\";\nimport { final } from \"../decorators\";\n\nexport type ReplacementFunction = (substring: string, ...args: any[]) => string;\n\nexport class PatternFilter extends LogFilter {\n  constructor(\n    protected readonly regexp: RegExp,\n    protected readonly replacement: string | ReplacementFunction\n  ) {\n    super();\n  }\n\n  @final()\n  protected match(message: string) {\n    const match = this.regexp.exec(message);\n    this.regexp.lastIndex = 0;\n    return match;\n  }\n\n  filter(config: LoggingConfig, message: string, context: string[]): string {\n    const log = this.log.for(this.filter);\n    const match = this.match(message);\n    if (!match) return message;\n    try {\n      return message.replace(this.regexp, this.replacement as any);\n    } catch (e: unknown) {\n      log.error(`PatternFilter replacement error: ${e}`);\n    }\n    return \"\";\n  }\n}\n","export * from \"./filters\";\nexport * from \"./constants\";\nexport * from \"./decorators\";\nexport * from \"./environment\";\nexport * from \"./LoggedClass\";\nexport * from \"./logging\";\nexport * from \"./text\";\nexport * from \"./types\";\nexport * from \"./web\";\n\n/**\n * @description A logging module for TypeScript applications\n * @summary Provides a comprehensive, flexible logging solution. This module exposes:\n * - Core classes like {@link Logging} and {@link MiniLogger}\n * - Decorators such as {@link log} for instrumenting methods\n * - Configuration and constants like {@link LogLevel} and {@link DefaultLoggingConfig}\n * - Type definitions including {@link Logger} and {@link LoggingConfig}\n * These exports enable consistent, context-aware, and optionally themed logging across projects.\n * @module Logging\n */\n\n/**\n * @description Current package version string\n * @summary Stores the current package version, used for version tracking and compatibility checks\n * @const VERSION\n * @memberOf module:Logging\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["LogLevel","LoggingMode","ObjectAccumulator","style","__decorate"],"mappings":"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"}