@decaf-ts/logging 0.3.12 → 0.3.14

package/lib/esm/types.d.ts

@@ -1,8 +1,8 @@
 import { styles } from "styled-string-builder";
 import { LoggingMode, LogLevel } from "./constants";
 /**
- * @description A type representing string-like values
- * @summary Represents either a string or an object with a toString method that returns a string
+ * @description String-compatible value accepted by the logging APIs.
+ * @summary Represents either a literal string or an object exposing a `toString()` method, allowing lazy stringification of complex payloads.
  * @typedef {(string|Object)} StringLike
  * @memberOf module:Logging
  */
@@ -10,37 +10,51 @@ export type StringLike = string | {
     toString: () => string;
 };
 /**
- * @description A generic function type with any arguments and return
- * @summary Represents any callable signature, useful for annotating higher-order utilities
- * and dynamic method references where argument and return types are not constrained.
- * @typedef {Function} AnyFunction
+ * @description Generic function signature for loosely typed callbacks.
+ * @summary Covers variadic functions whose arguments and return types are not constrained, enabling the logging layer to accept any callable.
+ * @typedef {function(any[]): any} AnyFunction
  * @memberOf module:Logging
  */
 export type AnyFunction = (...args: any[]) => any;
 /**
- * @description A constructable class type
- * @summary Describes a class constructor that produces instances of type T. Useful when
- * passing class references around (e.g., for context or dependency injection).
+ * @description Constructable class type.
+ * @summary Describes a constructor that produces instances of type `T`, allowing APIs to accept class references for context-aware logging.
  * @template T
- * @typedef {function(any[]): T} Class
+ * @typedef {any} Class
  * @memberOf module:Logging
  */
 export type Class<T> = {
     new (...args: any[]): T;
 };
 /**
- * @description A type representing logging context
- * @summary Represents a context for logging, which can be a string, a class constructor, or a function
+ * @description Context descriptor accepted when requesting a logger instance.
+ * @summary Allows the logging system to resolve context names from strings, constructors, or functions.
  * @typedef {(string|Function|Object)} LoggingContext
  * @memberOf module:Logging
  */
 export type LoggingContext = string | Class<any> | AnyFunction;
+/**
+ * @description Interface for factories that create contextual clones of the receiver.
+ * @summary Declares a `for` method that returns another instance of `THIS` using the provided arguments, enabling chained logger customization.
+ * @template THIS
+ * @template ARGS
+ * @interface Impersonatable
+ * @memberOf module:Logging
+ */
 export interface Impersonatable<THIS, ARGS extends any[] = any[]> {
+    /**
+     * @description Produce a copy of the current instance with altered context.
+     * @summary Called by logging utilities to derive child objects with supplemental configuration and context metadata.
+     * @template THIS
+     * @template ARGS
+     * @param {ARGS} args - Arguments forwarded to the impersonation strategy.
+     * @return {THIS} Derived instance using the provided arguments.
+     */
     for(...args: ARGS): THIS;
 }
 /**
- * @description Interface for a logger with verbosity levels.
- * @summary Defines methods for logging at different verbosity levels.
+ * @description Interface for loggers that support multiple verbosity levels.
+ * @summary Declares severity-specific log methods, configuration overrides, and factory helpers used throughout the logging toolkit.
  * @interface Logger
  * @memberOf module:Logging
  */
@@ -51,52 +65,84 @@ export interface Logger extends Impersonatable<Logger, [
     Partial<LoggingConfig>,
     ...any[]
 ]> {
+    /**
+     * @description Logs a benchmark message.
+     * @summary Emits high-frequency performance metrics at the `benchmark` log level.
+     * @param {StringLike} msg - Message or payload to emit.
+     * @return {void}
+     */
+    benchmark(msg: StringLike): void;
     /**
      * @description Logs a `way too verbose` or a silly message.
-     * @param {StringLike} msg - The message to log.
+     * @summary Emits playful or extremely verbose details at the `silly` log level.
+     * @param {StringLike} msg - Message or payload to emit.
+     * @return {void}
      */
     silly(msg: StringLike): void;
     /**
      * @description Logs a verbose message.
-     * @param {StringLike} msg - The message to log.
-     * @param {number} verbosity - The verbosity level of the message.
+     * @summary Writes diagnostic output governed by the configured verbosity threshold.
+     * @param {StringLike} msg - Message or payload to emit.
+     * @param {number} [verbosity] - Verbosity level required for the message to pass through.
+     * @return {void}
      */
     verbose(msg: StringLike, verbosity?: number): void;
     /**
      * @description Logs an info message.
-     * @param {StringLike} msg - The message to log.
+     * @summary Emits general informational events that describe application progress.
+     * @param {StringLike} msg - Message or payload to emit.
+     * @return {void}
      */
     info(msg: StringLike): void;
     /**
      * @description Logs an error message.
-     * @param {StringLike | Error} msg - The message to log.
-     * @param e
+     * @summary Records errors and exceptions, including optional stack traces.
+     * @param {StringLike|Error} msg - Message or {@link Error} instance to log.
+     * @param {Error} [e] - Optional secondary error or cause.
+     * @return {void}
      */
     error(msg: StringLike | Error, e?: Error): void;
     /**
      * @description Logs a debug message.
-     * @param {string} msg - The message to log.
+     * @summary Emits fine-grained diagnostic details useful during development and troubleshooting.
+     * @param {StringLike} msg - Message or payload to emit.
+     * @return {void}
      */
     debug(msg: StringLike): void;
     /**
-     * @description Creates a new logger for a specific method or context
-     * @summary Returns a new logger instance that includes the specified method or context in its logs
-     * @param {string|Function} [method] - The method name or function to create a logger for
-     * @param {Partial<LoggingConfig>} [config] - Optional configuration for the new logger
-     * @param args
-     * @return {Logger} A new logger instance
+     * @description Creates a new logger for a specific method or context.
+     * @summary Produces a scoped logger that formats entries using the derived context and overrides supplied configuration.
+     * @param {any} method - Method name, callback, constructor, or partial configuration used to seed the child logger.
+     * @param {Partial<LoggingConfig>} [config] - Optional configuration overrides for the child logger.
+     * @param {...any[]} args - Extra arguments forwarded to factory implementations.
+     * @return {Logger} Logger instance tailored to the supplied context.
      */
     for(method: string | {
         new (...args: any[]): any;
     } | AnyFunction | Partial<LoggingConfig>, config?: Partial<LoggingConfig>, ...args: any[]): Logger;
     /**
-     * @description Updates the logger configuration
-     * @summary Sets or updates the configuration options for this logger instance
-     * @param {Partial<LoggingConfig>} config - The configuration options to apply
+     * @description Updates the logger configuration.
+     * @summary Merges the given options into the logger's existing configuration.
+     * @param {Partial<LoggingConfig>} config - Configuration overrides to apply.
+     * @return {void}
      */
     setConfig(config: Partial<LoggingConfig>): void;
 }
+/**
+ * @description Interface for filters that mutate or reject log messages.
+ * @summary Allows custom pre-processing of log entries before they are formatted or emitted.
+ * @interface LoggingFilter
+ * @memberOf module:Logging
+ */
 export interface LoggingFilter {
+    /**
+     * @description Apply filtering logic to an incoming message.
+     * @summary Receives the active configuration, original message, and context stack to produce the final message string.
+     * @param {LoggingConfig} config - Active logging configuration.
+     * @param {string} message - Message submitted for logging.
+     * @param {string[]} context - Context identifiers associated with the message.
+     * @return {string} Filtered message string.
+     */
     filter(config: LoggingConfig, message: string, context: string[]): string;
 }
 /**
@@ -136,21 +182,16 @@ export type LoggingConfig = {
     filters?: string[] | LoggingFilter[];
 };
 /**
- * @description A factory function type for creating loggers
- * @summary Defines a function type that creates and returns a logger instance for a given object
+ * @description Factory signature for creating logger instances.
+ * @summary Allows consumers to override logger construction with custom implementations.
  * @template L - The logger type, extending the base Logger interface
- * @typedef {Function} LoggerFactory
- * @param {string} object - The object or context name for the logger
- * @param {Partial<LoggingConfig>} [config] - Optional configuration for the logger
- * @return {L} A logger instance
+ * @typedef {function(string, Partial<LoggingConfig>, any[]): L} LoggerFactory
  * @memberOf module:Logging
  */
 export type LoggerFactory<L extends Logger = Logger> = (object: string, config?: Partial<LoggingConfig>, ...args: any[]) => L;
 /**
- * @description Represents a theme option for console output styling.
- * @summary Defines the structure for styling a specific element in the console output.
- * It allows for customization of foreground color, background color, and additional styles.
- * Colors can be specified as a single number, an RGB array, or left undefined for default.
+ * @description Theme option applied to a specific log element.
+ * @summary Configures foreground and background colors as well as additional style directives for styled console output.
  * @interface ThemeOption
  * @memberOf module:Logging
  */
@@ -160,28 +201,25 @@ export interface ThemeOption {
     style?: number[] | [keyof typeof styles];
 }
 /**
- * @description A type for theme options organized by log level
- * @summary Defines a partial record mapping log levels to theme options, allowing different styling for different log levels
+ * @description Mapping between log levels and theme overrides.
+ * @summary Enables level-specific styling by associating each {@link LogLevel} with a {@link ThemeOption} configuration.
  * @typedef {Object} ThemeOptionByLogLevel
  * @memberOf module:Logging
  */
 export type ThemeOptionByLogLevel = Partial<Record<LogLevel, ThemeOption>>;
 /**
- * @description Defines the color theme for console output.
- * @summary This interface specifies the color scheme for various elements of console output,
- * including styling for different log levels and components. It uses ThemeOption to
- * define the styling for each element, allowing for customization of colors and styles
- * for different parts of the log output.
+ * @description Theme definition applied to console output.
+ * @summary Specifies styling for each console log element and supports overrides based on {@link LogLevel} values.
  * @interface Theme
  * @memberOf module:Logging
  */
 export interface Theme {
     /**
-     * @description Styling for class names in the output.
+     * @description Styling for application identifiers in the output.
      */
     app: ThemeOption | ThemeOptionByLogLevel;
     /**
-     * @description Styling for class names in the output.
+     * @description Styling for separators inserted between log sections.
      */
     separator: ThemeOption | ThemeOptionByLogLevel;
     /**
@@ -205,11 +243,11 @@ export interface Theme {
      */
     id: ThemeOption | ThemeOptionByLogLevel;
     /**
-     * @description Styling for identifier elements in the output.
+     * @description Styling for stack trace blocks in the output.
      */
     stack: ThemeOption;
     /**
-     * @description Styling for different log levels in the output.
+     * @description Styling overrides keyed by {@link LogLevel}.
      */
     logLevel: ThemeOptionByLogLevel;
 }

package/lib/esm/types.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"","sourcesContent":["import { styles } from \"styled-string-builder\";\nimport { LoggingMode, LogLevel } from \"./constants\";\n/**\n * @description A type representing string-like values\n * @summary Represents either a string or an object with a toString method that returns a string\n * @typedef {(string|Object)} StringLike\n * @memberOf module:Logging\n */\nexport type StringLike = string | { toString: () => string };\n\n/**\n * @description A generic function type with any arguments and return\n * @summary Represents any callable signature, useful for annotating higher-order utilities\n * and dynamic method references where argument and return types are not constrained.\n * @typedef {Function} AnyFunction\n * @memberOf module:Logging\n */\nexport type AnyFunction = (...args: any[]) => any;\n\n/**\n * @description A constructable class type\n * @summary Describes a class constructor that produces instances of type T. Useful when\n * passing class references around (e.g., for context or dependency injection).\n * @template T\n * @typedef {function(any[]): T} Class\n * @memberOf module:Logging\n */\nexport type Class<T> = {\n  new (...args: any[]): T;\n};\n\n/**\n * @description A type representing logging context\n * @summary Represents a context for logging, which can be a string, a class constructor, or a function\n * @typedef {(string|Function|Object)} LoggingContext\n * @memberOf module:Logging\n */\nexport type LoggingContext = string | Class<any> | AnyFunction;\n\nexport interface Impersonatable<THIS, ARGS extends any[] = any[]> {\n  for(...args: ARGS): THIS;\n}\n\n/**\n * @description Interface for a logger with verbosity levels.\n * @summary Defines methods for logging at different verbosity levels.\n * @interface Logger\n * @memberOf module:Logging\n */\nexport interface Logger\n  extends Impersonatable<\n    Logger,\n    [\n      (\n        | string\n        | { new (...args: any[]): any }\n        | AnyFunction\n        | Partial<LoggingConfig>\n      ),\n      Partial<LoggingConfig>,\n      ...any[],\n    ]\n  > {\n  /**\n   * @description Logs a `way too verbose` or a silly message.\n   * @param {StringLike} msg - The message to log.\n   */\n  silly(msg: StringLike): void;\n  /**\n   * @description Logs a verbose message.\n   * @param {StringLike} msg - The message to log.\n   * @param {number} verbosity - The verbosity level of the message.\n   */\n  verbose(msg: StringLike, verbosity?: number): void;\n\n  /**\n   * @description Logs an info message.\n   * @param {StringLike} msg - The message to log.\n   */\n  info(msg: StringLike): void;\n\n  /**\n   * @description Logs an error message.\n   * @param {StringLike | Error} msg - The message to log.\n   * @param e\n   */\n  error(msg: StringLike | Error, e?: Error): void;\n\n  /**\n   * @description Logs a debug message.\n   * @param {string} msg - The message to log.\n   */\n  debug(msg: StringLike): void;\n\n  /**\n   * @description Creates a new logger for a specific method or context\n   * @summary Returns a new logger instance that includes the specified method or context in its logs\n   * @param {string|Function} [method] - The method name or function to create a logger for\n   * @param {Partial<LoggingConfig>} [config] - Optional configuration for the new logger\n   * @param args\n   * @return {Logger} A new logger instance\n   */\n  for(\n    method:\n      | string\n      | { new (...args: any[]): any }\n      | AnyFunction\n      | Partial<LoggingConfig>,\n    config?: Partial<LoggingConfig>,\n    ...args: any[]\n  ): Logger;\n\n  /**\n   * @description Updates the logger configuration\n   * @summary Sets or updates the configuration options for this logger instance\n   * @param {Partial<LoggingConfig>} config - The configuration options to apply\n   */\n  setConfig(config: Partial<LoggingConfig>): void;\n}\n\nexport interface LoggingFilter {\n  filter(config: LoggingConfig, message: string, context: string[]): string;\n}\n\n/**\n * @description Configuration for logging.\n * @summary Defines the log level and verbosity for logging.\n * @typedef {Object} LoggingConfig\n * @property {LogLevel} level - The logging level.\n * @property {boolean} [logLevel] - Whether to display log level in output.\n * @property {number} verbose - The verbosity level.\n * @property {LoggingMode} [mode] - Output format mode.\n * @property {string} contextSeparator - Separator between context entries.\n * @property {string} separator - Separator between log components.\n * @property {boolean} [style] - Whether to apply styling to log output.\n * @property {boolean} [timestamp] - Whether to include timestamps in log messages.\n * @property {string} [timestampFormat] - Format for timestamps.\n * @property {boolean} [context] - Whether to include context information in log messages.\n * @property {Theme} [theme] - The theme to use for styling log messages.\n * @property {string|number} [correlationId] - Correlation ID for tracking related log messages.\n * @memberOf module:Logging\n */\nexport type LoggingConfig = {\n  app?: string;\n  env: \"development\" | \"production\" | \"test\" | \"staging\" | string;\n  level: LogLevel;\n  logLevel?: boolean;\n  verbose: number;\n  contextSeparator: string;\n  separator: string;\n  style?: boolean;\n  timestamp?: boolean;\n  timestampFormat?: string;\n  context?: boolean;\n  theme?: Theme;\n  format: LoggingMode;\n  pattern: string;\n  correlationId?: string | number;\n  filters?: string[] | LoggingFilter[];\n};\n\n/**\n * @description A factory function type for creating loggers\n * @summary Defines a function type that creates and returns a logger instance for a given object\n * @template L - The logger type, extending the base Logger interface\n * @typedef {Function} LoggerFactory\n * @param {string} object - The object or context name for the logger\n * @param {Partial<LoggingConfig>} [config] - Optional configuration for the logger\n * @return {L} A logger instance\n * @memberOf module:Logging\n */\nexport type LoggerFactory<L extends Logger = Logger> = (\n  object: string,\n  config?: Partial<LoggingConfig>,\n  ...args: any[]\n) => L;\n\n/**\n * @description Represents a theme option for console output styling.\n * @summary Defines the structure for styling a specific element in the console output.\n * It allows for customization of foreground color, background color, and additional styles.\n * Colors can be specified as a single number, an RGB array, or left undefined for default.\n * @interface ThemeOption\n * @memberOf module:Logging\n */\nexport interface ThemeOption {\n  fg?: number | [number] | [number, number, number];\n\n  bg?: number | [number] | [number, number, number];\n\n  style?: number[] | [keyof typeof styles];\n}\n\n/**\n * @description A type for theme options organized by log level\n * @summary Defines a partial record mapping log levels to theme options, allowing different styling for different log levels\n * @typedef {Object} ThemeOptionByLogLevel\n * @memberOf module:Logging\n */\nexport type ThemeOptionByLogLevel = Partial<Record<LogLevel, ThemeOption>>;\n\n/**\n * @description Defines the color theme for console output.\n * @summary This interface specifies the color scheme for various elements of console output,\n * including styling for different log levels and components. It uses ThemeOption to\n * define the styling for each element, allowing for customization of colors and styles\n * for different parts of the log output.\n * @interface Theme\n * @memberOf module:Logging\n */\nexport interface Theme {\n  /**\n   * @description Styling for class names in the output.\n   */\n  app: ThemeOption | ThemeOptionByLogLevel;\n  /**\n   * @description Styling for class names in the output.\n   */\n  separator: ThemeOption | ThemeOptionByLogLevel;\n  /**\n   * @description Styling for class names in the output.\n   */\n  class: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for timestamps in the output.\n   */\n  timestamp: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for the main message text in the output.\n   */\n  message: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for method names in the output.\n   */\n  method: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for identifier elements in the output.\n   */\n  id: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for identifier elements in the output.\n   */\n  stack: ThemeOption;\n\n  /**\n   * @description Styling for different log levels in the output.\n   */\n  logLevel: ThemeOptionByLogLevel;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"","sourcesContent":["import { styles } from \"styled-string-builder\";\nimport { LoggingMode, LogLevel } from \"./constants\";\n/**\n * @description String-compatible value accepted by the logging APIs.\n * @summary Represents either a literal string or an object exposing a `toString()` method, allowing lazy stringification of complex payloads.\n * @typedef {(string|Object)} StringLike\n * @memberOf module:Logging\n */\nexport type StringLike = string | { toString: () => string };\n\n/**\n * @description Generic function signature for loosely typed callbacks.\n * @summary Covers variadic functions whose arguments and return types are not constrained, enabling the logging layer to accept any callable.\n * @typedef {function(any[]): any} AnyFunction\n * @memberOf module:Logging\n */\nexport type AnyFunction = (...args: any[]) => any;\n\n/**\n * @description Constructable class type.\n * @summary Describes a constructor that produces instances of type `T`, allowing APIs to accept class references for context-aware logging.\n * @template T\n * @typedef {any} Class\n * @memberOf module:Logging\n */\nexport type Class<T> = {\n  new (...args: any[]): T;\n};\n\n/**\n * @description Context descriptor accepted when requesting a logger instance.\n * @summary Allows the logging system to resolve context names from strings, constructors, or functions.\n * @typedef {(string|Function|Object)} LoggingContext\n * @memberOf module:Logging\n */\nexport type LoggingContext = string | Class<any> | AnyFunction;\n\n/**\n * @description Interface for factories that create contextual clones of the receiver.\n * @summary Declares a `for` method that returns another instance of `THIS` using the provided arguments, enabling chained logger customization.\n * @template THIS\n * @template ARGS\n * @interface Impersonatable\n * @memberOf module:Logging\n */\nexport interface Impersonatable<THIS, ARGS extends any[] = any[]> {\n  /**\n   * @description Produce a copy of the current instance with altered context.\n   * @summary Called by logging utilities to derive child objects with supplemental configuration and context metadata.\n   * @template THIS\n   * @template ARGS\n   * @param {ARGS} args - Arguments forwarded to the impersonation strategy.\n   * @return {THIS} Derived instance using the provided arguments.\n   */\n  for(...args: ARGS): THIS;\n}\n\n/**\n * @description Interface for loggers that support multiple verbosity levels.\n * @summary Declares severity-specific log methods, configuration overrides, and factory helpers used throughout the logging toolkit.\n * @interface Logger\n * @memberOf module:Logging\n */\nexport interface Logger\n  extends Impersonatable<\n    Logger,\n    [\n      (\n        | string\n        | { new (...args: any[]): any }\n        | AnyFunction\n        | Partial<LoggingConfig>\n      ),\n      Partial<LoggingConfig>,\n      ...any[],\n    ]\n  > {\n  /**\n   * @description Logs a benchmark message.\n   * @summary Emits high-frequency performance metrics at the `benchmark` log level.\n   * @param {StringLike} msg - Message or payload to emit.\n   * @return {void}\n   */\n  benchmark(msg: StringLike): void;\n\n  /**\n   * @description Logs a `way too verbose` or a silly message.\n   * @summary Emits playful or extremely verbose details at the `silly` log level.\n   * @param {StringLike} msg - Message or payload to emit.\n   * @return {void}\n   */\n  silly(msg: StringLike): void;\n  /**\n   * @description Logs a verbose message.\n   * @summary Writes diagnostic output governed by the configured verbosity threshold.\n   * @param {StringLike} msg - Message or payload to emit.\n   * @param {number} [verbosity] - Verbosity level required for the message to pass through.\n   * @return {void}\n   */\n  verbose(msg: StringLike, verbosity?: number): void;\n\n  /**\n   * @description Logs an info message.\n   * @summary Emits general informational events that describe application progress.\n   * @param {StringLike} msg - Message or payload to emit.\n   * @return {void}\n   */\n  info(msg: StringLike): void;\n\n  /**\n   * @description Logs an error message.\n   * @summary Records errors and exceptions, including optional stack traces.\n   * @param {StringLike|Error} msg - Message or {@link Error} instance to log.\n   * @param {Error} [e] - Optional secondary error or cause.\n   * @return {void}\n   */\n  error(msg: StringLike | Error, e?: Error): void;\n\n  /**\n   * @description Logs a debug message.\n   * @summary Emits fine-grained diagnostic details useful during development and troubleshooting.\n   * @param {StringLike} msg - Message or payload to emit.\n   * @return {void}\n   */\n  debug(msg: StringLike): void;\n\n  /**\n   * @description Creates a new logger for a specific method or context.\n   * @summary Produces a scoped logger that formats entries using the derived context and overrides supplied configuration.\n   * @param {any} method - Method name, callback, constructor, or partial configuration used to seed the child logger.\n   * @param {Partial<LoggingConfig>} [config] - Optional configuration overrides for the child logger.\n   * @param {...any[]} args - Extra arguments forwarded to factory implementations.\n   * @return {Logger} Logger instance tailored to the supplied context.\n   */\n  for(\n    method:\n      | string\n      | { new (...args: any[]): any }\n      | AnyFunction\n      | Partial<LoggingConfig>,\n    config?: Partial<LoggingConfig>,\n    ...args: any[]\n  ): Logger;\n\n  /**\n   * @description Updates the logger configuration.\n   * @summary Merges the given options into the logger's existing configuration.\n   * @param {Partial<LoggingConfig>} config - Configuration overrides to apply.\n   * @return {void}\n   */\n  setConfig(config: Partial<LoggingConfig>): void;\n}\n\n/**\n * @description Interface for filters that mutate or reject log messages.\n * @summary Allows custom pre-processing of log entries before they are formatted or emitted.\n * @interface LoggingFilter\n * @memberOf module:Logging\n */\nexport interface LoggingFilter {\n  /**\n   * @description Apply filtering logic to an incoming message.\n   * @summary Receives the active configuration, original message, and context stack to produce the final message string.\n   * @param {LoggingConfig} config - Active logging configuration.\n   * @param {string} message - Message submitted for logging.\n   * @param {string[]} context - Context identifiers associated with the message.\n   * @return {string} Filtered message string.\n   */\n  filter(config: LoggingConfig, message: string, context: string[]): string;\n}\n\n/**\n * @description Configuration for logging.\n * @summary Defines the log level and verbosity for logging.\n * @typedef {Object} LoggingConfig\n * @property {LogLevel} level - The logging level.\n * @property {boolean} [logLevel] - Whether to display log level in output.\n * @property {number} verbose - The verbosity level.\n * @property {LoggingMode} [mode] - Output format mode.\n * @property {string} contextSeparator - Separator between context entries.\n * @property {string} separator - Separator between log components.\n * @property {boolean} [style] - Whether to apply styling to log output.\n * @property {boolean} [timestamp] - Whether to include timestamps in log messages.\n * @property {string} [timestampFormat] - Format for timestamps.\n * @property {boolean} [context] - Whether to include context information in log messages.\n * @property {Theme} [theme] - The theme to use for styling log messages.\n * @property {string|number} [correlationId] - Correlation ID for tracking related log messages.\n * @memberOf module:Logging\n */\nexport type LoggingConfig = {\n  app?: string;\n  env: \"development\" | \"production\" | \"test\" | \"staging\" | string;\n  level: LogLevel;\n  logLevel?: boolean;\n  verbose: number;\n  contextSeparator: string;\n  separator: string;\n  style?: boolean;\n  timestamp?: boolean;\n  timestampFormat?: string;\n  context?: boolean;\n  theme?: Theme;\n  format: LoggingMode;\n  pattern: string;\n  correlationId?: string | number;\n  filters?: string[] | LoggingFilter[];\n};\n\n/**\n * @description Factory signature for creating logger instances.\n * @summary Allows consumers to override logger construction with custom implementations.\n * @template L - The logger type, extending the base Logger interface\n * @typedef {function(string, Partial<LoggingConfig>, any[]): L} LoggerFactory\n * @memberOf module:Logging\n */\nexport type LoggerFactory<L extends Logger = Logger> = (\n  object: string,\n  config?: Partial<LoggingConfig>,\n  ...args: any[]\n) => L;\n\n/**\n * @description Theme option applied to a specific log element.\n * @summary Configures foreground and background colors as well as additional style directives for styled console output.\n * @interface ThemeOption\n * @memberOf module:Logging\n */\nexport interface ThemeOption {\n  fg?: number | [number] | [number, number, number];\n  bg?: number | [number] | [number, number, number];\n  style?: number[] | [keyof typeof styles];\n}\n\n/**\n * @description Mapping between log levels and theme overrides.\n * @summary Enables level-specific styling by associating each {@link LogLevel} with a {@link ThemeOption} configuration.\n * @typedef {Object} ThemeOptionByLogLevel\n * @memberOf module:Logging\n */\nexport type ThemeOptionByLogLevel = Partial<Record<LogLevel, ThemeOption>>;\n\n/**\n * @description Theme definition applied to console output.\n * @summary Specifies styling for each console log element and supports overrides based on {@link LogLevel} values.\n * @interface Theme\n * @memberOf module:Logging\n */\nexport interface Theme {\n  /**\n   * @description Styling for application identifiers in the output.\n   */\n  app: ThemeOption | ThemeOptionByLogLevel;\n  /**\n   * @description Styling for separators inserted between log sections.\n   */\n  separator: ThemeOption | ThemeOptionByLogLevel;\n  /**\n   * @description Styling for class names in the output.\n   */\n  class: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for timestamps in the output.\n   */\n  timestamp: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for the main message text in the output.\n   */\n  message: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for method names in the output.\n   */\n  method: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for identifier elements in the output.\n   */\n  id: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for stack trace blocks in the output.\n   */\n  stack: ThemeOption;\n\n  /**\n   * @description Styling overrides keyed by {@link LogLevel}.\n   */\n  logLevel: ThemeOptionByLogLevel;\n}\n"]}

package/lib/filters/LogFilter.cjs

@@ -2,10 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogFilter = void 0;
 const LoggedClass_1 = require("./../LoggedClass.cjs");
+/**
+ * @description Base class for message filters that plug into the logging pipeline.
+ * @summary Extends {@link LoggedClass} to supply a scoped logger and defines the contract required by {@link LoggingFilter} implementers that transform or drop log messages before emission.
+ * @class LogFilter
+ * @example
+ * class RedactSecretsFilter extends LogFilter {
+ *   filter(config: LoggingConfig, message: string): string {
+ *     return message.replace(/secret/gi, "***");
+ *   }
+ * }
+ *
+ * const filter = new RedactSecretsFilter();
+ * filter.filter({ ...DefaultLoggingConfig, verbose: 0 }, "secret token");
+ * @mermaid
+ * sequenceDiagram
+ *   participant Logger
+ *   participant Filter as LogFilter
+ *   participant Impl as ConcreteFilter
+ *   participant Output
+ *   Logger->>Filter: filter(config, message, context)
+ *   Filter->>Impl: delegate to subclass implementation
+ *   Impl-->>Filter: transformed message
+ *   Filter-->>Output: return filtered message
+ */
 class LogFilter extends LoggedClass_1.LoggedClass {
+    /**
+     * @description Scoped logger that excludes other filters from the chain.
+     * @summary Returns a child logger dedicated to the filter, preventing recursive filter invocation when emitting diagnostic messages.
+     * @return {Logger} Context-aware logger for the filter instance.
+     */
     get log() {
         return super.log.for(this, { filters: [] });
     }
 }
 exports.LogFilter = LogFilter;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9nRmlsdGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ZpbHRlcnMvTG9nRmlsdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLHNEQUE2QztBQUU3QyxNQUFzQixTQUFVLFNBQVEseUJBQVc7SUFDakQsSUFBYSxHQUFHO1FBQ2QsT0FBTyxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxJQUFXLEVBQUUsRUFBRSxPQUFPLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUNyRCxDQUFDO0NBT0Y7QUFWRCw4QkFVQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IExvZ2dlciwgTG9nZ2luZ0NvbmZpZywgTG9nZ2luZ0ZpbHRlciB9IGZyb20gXCIuLi90eXBlc1wiO1xuaW1wb3J0IHsgTG9nZ2VkQ2xhc3MgfSBmcm9tIFwiLi4vTG9nZ2VkQ2xhc3NcIjtcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIExvZ0ZpbHRlciBleHRlbmRzIExvZ2dlZENsYXNzIGltcGxlbWVudHMgTG9nZ2luZ0ZpbHRlciB7XG4gIG92ZXJyaWRlIGdldCBsb2coKTogTG9nZ2VyIHtcbiAgICByZXR1cm4gc3VwZXIubG9nLmZvcih0aGlzIGFzIGFueSwgeyBmaWx0ZXJzOiBbXSB9KTtcbiAgfVxuXG4gIGFic3RyYWN0IGZpbHRlcihcbiAgICBjb25maWc6IExvZ2dpbmdDb25maWcsXG4gICAgbWVzc2FnZTogc3RyaW5nLFxuICAgIGNvbnRleHQ6IHN0cmluZ1tdXG4gICk6IHN0cmluZztcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/filters/LogFilter.d.ts

@@ -1,6 +1,43 @@
 import { Logger, LoggingConfig, LoggingFilter } from "../types";
 import { LoggedClass } from "../LoggedClass";
+/**
+ * @description Base class for message filters that plug into the logging pipeline.
+ * @summary Extends {@link LoggedClass} to supply a scoped logger and defines the contract required by {@link LoggingFilter} implementers that transform or drop log messages before emission.
+ * @class LogFilter
+ * @example
+ * class RedactSecretsFilter extends LogFilter {
+ *   filter(config: LoggingConfig, message: string): string {
+ *     return message.replace(/secret/gi, "***");
+ *   }
+ * }
+ *
+ * const filter = new RedactSecretsFilter();
+ * filter.filter({ ...DefaultLoggingConfig, verbose: 0 }, "secret token");
+ * @mermaid
+ * sequenceDiagram
+ *   participant Logger
+ *   participant Filter as LogFilter
+ *   participant Impl as ConcreteFilter
+ *   participant Output
+ *   Logger->>Filter: filter(config, message, context)
+ *   Filter->>Impl: delegate to subclass implementation
+ *   Impl-->>Filter: transformed message
+ *   Filter-->>Output: return filtered message
+ */
 export declare abstract class LogFilter extends LoggedClass implements LoggingFilter {
+    /**
+     * @description Scoped logger that excludes other filters from the chain.
+     * @summary Returns a child logger dedicated to the filter, preventing recursive filter invocation when emitting diagnostic messages.
+     * @return {Logger} Context-aware logger for the filter instance.
+     */
     get log(): Logger;
+    /**
+     * @description Transform or suppress a log message.
+     * @summary Inspect the provided message and context to produce the value that will be forwarded to subsequent filters or emitters.
+     * @param {LoggingConfig} config - Active logging configuration.
+     * @param {string} message - Original log message payload.
+     * @param {string[]} context - Context values attached to the message.
+     * @return {string} Filtered message to pass to downstream processing.
+     */
     abstract filter(config: LoggingConfig, message: string, context: string[]): string;
 }

package/lib/filters/PatternFilter.cjs

@@ -12,17 +12,57 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PatternFilter = void 0;
 const LogFilter_1 = require("./LogFilter.cjs");
 const decorators_1 = require("./../decorators.cjs");
+/**
+ * @description Filter that patches log messages using regular expressions.
+ * @summary Applies a configured {@link RegExp} and replacement strategy to redact, mask, or restructure log payloads before they are emitted.
+ * @param {RegExp} regexp - Expression used to detect sensitive or formatted text.
+ * @param {string|ReplacementFunction} replacement - Replacement string or callback invoked for each match.
+ * @class PatternFilter
+ * @example
+ * const filter = new PatternFilter(/token=[^&]+/g, "token=***");
+ * const sanitized = filter.filter(config, "token=123&user=tom", []);
+ * // sanitized === "token=***&user=tom"
+ * @mermaid
+ * sequenceDiagram
+ *   participant Logger
+ *   participant Filter as PatternFilter
+ *   participant RegExp
+ *   Logger->>Filter: filter(config, message, context)
+ *   Filter->>RegExp: execute match()
+ *   alt match found
+ *     RegExp-->>Filter: captures
+ *     Filter->>RegExp: replace(message, replacement)
+ *     RegExp-->>Filter: transformed message
+ *   else no match
+ *     RegExp-->>Filter: null
+ *   end
+ *   Filter-->>Logger: sanitized message
+ */
 class PatternFilter extends LogFilter_1.LogFilter {
     constructor(regexp, replacement) {
         super();
         this.regexp = regexp;
         this.replacement = replacement;
     }
+    /**
+     * @description Ensures deterministic RegExp matching.
+     * @summary Runs the configured expression, then resets its state so repeated invocations behave consistently.
+     * @param {string} message - Message to test for matches.
+     * @return {RegExpExecArray|null} Match result or null when no match is found.
+     */
     match(message) {
         const match = this.regexp.exec(message);
         this.regexp.lastIndex = 0;
         return match;
     }
+    /**
+     * @description Applies the replacement strategy to the incoming message.
+     * @summary Executes {@link PatternFilter.match} and, when a match is found, replaces every occurrence using the configured replacement handler.
+     * @param {LoggingConfig} config - Active logging configuration (unused but part of the filter contract).
+     * @param {string} message - Message to be sanitized.
+     * @param {string[]} context - Context entries associated with the log event.
+     * @return {string} Sanitized log message.
+     */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     filter(config, message, context) {
         const log = this.log.for(this.filter);
@@ -45,4 +85,4 @@ __decorate([
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", void 0)
 ], PatternFilter.prototype, "match", null);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUGF0dGVybkZpbHRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maWx0ZXJzL1BhdHRlcm5GaWx0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEsK0NBQXdDO0FBRXhDLG9EQUFzQztBQUl0QyxNQUFhLGFBQWMsU0FBUSxxQkFBUztJQUMxQyxZQUNxQixNQUFjLEVBQ2QsV0FBeUM7UUFFNUQsS0FBSyxFQUFFLENBQUM7UUFIVyxXQUFNLEdBQU4sTUFBTSxDQUFRO1FBQ2QsZ0JBQVcsR0FBWCxXQUFXLENBQThCO0lBRzlELENBQUM7SUFHUyxLQUFLLENBQUMsT0FBZTtRQUM3QixNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUN4QyxJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsR0FBRyxDQUFDLENBQUM7UUFDMUIsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBRUQsNkRBQTZEO0lBQzdELE1BQU0sQ0FBQyxNQUFxQixFQUFFLE9BQWUsRUFBRSxPQUFpQjtRQUM5RCxNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDdEMsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNsQyxJQUFJLENBQUMsS0FBSztZQUFFLE9BQU8sT0FBTyxDQUFDO1FBQzNCLElBQUksQ0FBQztZQUNILE9BQU8sT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxXQUFrQixDQUFDLENBQUM7UUFDL0QsQ0FBQztRQUFDLE9BQU8sQ0FBVSxFQUFFLENBQUM7WUFDcEIsR0FBRyxDQUFDLEtBQUssQ0FBQyxvQ0FBb0MsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUNyRCxDQUFDO1FBQ0QsT0FBTyxFQUFFLENBQUM7SUFDWixDQUFDO0NBQ0Y7QUEzQkQsc0NBMkJDO0FBbEJXO0lBRFQsSUFBQSxrQkFBSyxHQUFFOzs7OzBDQUtQIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTG9nRmlsdGVyIH0gZnJvbSBcIi4vTG9nRmlsdGVyXCI7XG5pbXBvcnQgeyBMb2dnaW5nQ29uZmlnIH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5pbXBvcnQgeyBmaW5hbCB9IGZyb20gXCIuLi9kZWNvcmF0b3JzXCI7XG5cbmV4cG9ydCB0eXBlIFJlcGxhY2VtZW50RnVuY3Rpb24gPSAoc3Vic3RyaW5nOiBzdHJpbmcsIC4uLmFyZ3M6IGFueVtdKSA9PiBzdHJpbmc7XG5cbmV4cG9ydCBjbGFzcyBQYXR0ZXJuRmlsdGVyIGV4dGVuZHMgTG9nRmlsdGVyIHtcbiAgY29uc3RydWN0b3IoXG4gICAgcHJvdGVjdGVkIHJlYWRvbmx5IHJlZ2V4cDogUmVnRXhwLFxuICAgIHByb3RlY3RlZCByZWFkb25seSByZXBsYWNlbWVudDogc3RyaW5nIHwgUmVwbGFjZW1lbnRGdW5jdGlvblxuICApIHtcbiAgICBzdXBlcigpO1xuICB9XG5cbiAgQGZpbmFsKClcbiAgcHJvdGVjdGVkIG1hdGNoKG1lc3NhZ2U6IHN0cmluZykge1xuICAgIGNvbnN0IG1hdGNoID0gdGhpcy5yZWdleHAuZXhlYyhtZXNzYWdlKTtcbiAgICB0aGlzLnJlZ2V4cC5sYXN0SW5kZXggPSAwO1xuICAgIHJldHVybiBtYXRjaDtcbiAgfVxuXG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tdW51c2VkLXZhcnNcbiAgZmlsdGVyKGNvbmZpZzogTG9nZ2luZ0NvbmZpZywgbWVzc2FnZTogc3RyaW5nLCBjb250ZXh0OiBzdHJpbmdbXSk6IHN0cmluZyB7XG4gICAgY29uc3QgbG9nID0gdGhpcy5sb2cuZm9yKHRoaXMuZmlsdGVyKTtcbiAgICBjb25zdCBtYXRjaCA9IHRoaXMubWF0Y2gobWVzc2FnZSk7XG4gICAgaWYgKCFtYXRjaCkgcmV0dXJuIG1lc3NhZ2U7XG4gICAgdHJ5IHtcbiAgICAgIHJldHVybiBtZXNzYWdlLnJlcGxhY2UodGhpcy5yZWdleHAsIHRoaXMucmVwbGFjZW1lbnQgYXMgYW55KTtcbiAgICB9IGNhdGNoIChlOiB1bmtub3duKSB7XG4gICAgICBsb2cuZXJyb3IoYFBhdHRlcm5GaWx0ZXIgcmVwbGFjZW1lbnQgZXJyb3I6ICR7ZX1gKTtcbiAgICB9XG4gICAgcmV0dXJuIFwiXCI7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/filters/PatternFilter.d.ts

@@ -1,10 +1,56 @@
 import { LogFilter } from "./LogFilter";
 import { LoggingConfig } from "../types";
+/**
+ * @description Replacement callback used to transform RegExp matches.
+ * @summary Receives the matched substring and additional capture arguments, returning the replacement text that will be injected into the log message.
+ * @typedef {function(string, any[]): string} ReplacementFunction
+ * @memberOf module:Logging
+ */
 export type ReplacementFunction = (substring: string, ...args: any[]) => string;
+/**
+ * @description Filter that patches log messages using regular expressions.
+ * @summary Applies a configured {@link RegExp} and replacement strategy to redact, mask, or restructure log payloads before they are emitted.
+ * @param {RegExp} regexp - Expression used to detect sensitive or formatted text.
+ * @param {string|ReplacementFunction} replacement - Replacement string or callback invoked for each match.
+ * @class PatternFilter
+ * @example
+ * const filter = new PatternFilter(/token=[^&]+/g, "token=***");
+ * const sanitized = filter.filter(config, "token=123&user=tom", []);
+ * // sanitized === "token=***&user=tom"
+ * @mermaid
+ * sequenceDiagram
+ *   participant Logger
+ *   participant Filter as PatternFilter
+ *   participant RegExp
+ *   Logger->>Filter: filter(config, message, context)
+ *   Filter->>RegExp: execute match()
+ *   alt match found
+ *     RegExp-->>Filter: captures
+ *     Filter->>RegExp: replace(message, replacement)
+ *     RegExp-->>Filter: transformed message
+ *   else no match
+ *     RegExp-->>Filter: null
+ *   end
+ *   Filter-->>Logger: sanitized message
+ */
 export declare class PatternFilter extends LogFilter {
     protected readonly regexp: RegExp;
     protected readonly replacement: string | ReplacementFunction;
     constructor(regexp: RegExp, replacement: string | ReplacementFunction);
+    /**
+     * @description Ensures deterministic RegExp matching.
+     * @summary Runs the configured expression, then resets its state so repeated invocations behave consistently.
+     * @param {string} message - Message to test for matches.
+     * @return {RegExpExecArray|null} Match result or null when no match is found.
+     */
     protected match(message: string): RegExpExecArray | null;
+    /**
+     * @description Applies the replacement strategy to the incoming message.
+     * @summary Executes {@link PatternFilter.match} and, when a match is found, replaces every occurrence using the configured replacement handler.
+     * @param {LoggingConfig} config - Active logging configuration (unused but part of the filter contract).
+     * @param {string} message - Message to be sanitized.
+     * @param {string[]} context - Context entries associated with the log event.
+     * @return {string} Sanitized log message.
+     */
     filter(config: LoggingConfig, message: string, context: string[]): string;
 }

package/lib/index.cjs

@@ -22,23 +22,20 @@ __exportStar(require("./environment.cjs"), exports);
 __exportStar(require("./LoggedClass.cjs"), exports);
 __exportStar(require("./logging.cjs"), exports);
 __exportStar(require("./text.cjs"), exports);
+__exportStar(require("./time.cjs"), exports);
 __exportStar(require("./types.cjs"), exports);
 __exportStar(require("./web.cjs"), exports);
 /**
- * @description A logging module for TypeScript applications
- * @summary Provides a comprehensive, flexible logging solution. This module exposes:
- * - Core classes like {@link Logging} and {@link MiniLogger}
- * - Decorators such as {@link log} for instrumenting methods
- * - Configuration and constants like {@link LogLevel} and {@link DefaultLoggingConfig}
- * - Type definitions including {@link Logger} and {@link LoggingConfig}
- * These exports enable consistent, context-aware, and optionally themed logging across projects.
+ * @description Comprehensive logging toolkit for browser and Node environments.
+ * @summary Exposes {@link Logging} and {@link MiniLogger} for runtime logging, decorators such as {@link log} for method instrumentation, and utilities like {@link PatternFilter}, {@link StopWatch}, and {@link LoggedEnvironment} to build configurable, theme-aware log pipelines.
  * @module Logging
  */
 /**
- * @description Current package version string
- * @summary Stores the current package version, used for version tracking and compatibility checks
+ * @description Current package version string.
+ * @summary Stores the package version for diagnostics and compatibility checks.
  * @const VERSION
+ * @type {string}
  * @memberOf module:Logging
  */
-exports.VERSION = "0.3.11";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxzREFBMEI7QUFDMUIsa0RBQTRCO0FBQzVCLG1EQUE2QjtBQUM3QixvREFBOEI7QUFDOUIsb0RBQThCO0FBQzlCLGdEQUEwQjtBQUMxQiw2Q0FBdUI7QUFDdkIsOENBQXdCO0FBQ3hCLDRDQUFzQjtBQUV0Qjs7Ozs7Ozs7O0dBU0c7QUFFSDs7Ozs7R0FLRztBQUNVLFFBQUEsT0FBTyxHQUFHLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2ZpbHRlcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdG9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZW52aXJvbm1lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0xvZ2dlZENsYXNzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9sb2dnaW5nXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90ZXh0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vd2ViXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEEgbG9nZ2luZyBtb2R1bGUgZm9yIFR5cGVTY3JpcHQgYXBwbGljYXRpb25zXG4gKiBAc3VtbWFyeSBQcm92aWRlcyBhIGNvbXByZWhlbnNpdmUsIGZsZXhpYmxlIGxvZ2dpbmcgc29sdXRpb24uIFRoaXMgbW9kdWxlIGV4cG9zZXM6XG4gKiAtIENvcmUgY2xhc3NlcyBsaWtlIHtAbGluayBMb2dnaW5nfSBhbmQge0BsaW5rIE1pbmlMb2dnZXJ9XG4gKiAtIERlY29yYXRvcnMgc3VjaCBhcyB7QGxpbmsgbG9nfSBmb3IgaW5zdHJ1bWVudGluZyBtZXRob2RzXG4gKiAtIENvbmZpZ3VyYXRpb24gYW5kIGNvbnN0YW50cyBsaWtlIHtAbGluayBMb2dMZXZlbH0gYW5kIHtAbGluayBEZWZhdWx0TG9nZ2luZ0NvbmZpZ31cbiAqIC0gVHlwZSBkZWZpbml0aW9ucyBpbmNsdWRpbmcge0BsaW5rIExvZ2dlcn0gYW5kIHtAbGluayBMb2dnaW5nQ29uZmlnfVxuICogVGhlc2UgZXhwb3J0cyBlbmFibGUgY29uc2lzdGVudCwgY29udGV4dC1hd2FyZSwgYW5kIG9wdGlvbmFsbHkgdGhlbWVkIGxvZ2dpbmcgYWNyb3NzIHByb2plY3RzLlxuICogQG1vZHVsZSBMb2dnaW5nXG4gKi9cblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gQ3VycmVudCBwYWNrYWdlIHZlcnNpb24gc3RyaW5nXG4gKiBAc3VtbWFyeSBTdG9yZXMgdGhlIGN1cnJlbnQgcGFja2FnZSB2ZXJzaW9uLCB1c2VkIGZvciB2ZXJzaW9uIHRyYWNraW5nIGFuZCBjb21wYXRpYmlsaXR5IGNoZWNrc1xuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6TG9nZ2luZ1xuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcbiJdfQ==
+exports.VERSION = "0.3.13";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxzREFBMEI7QUFDMUIsa0RBQTRCO0FBQzVCLG1EQUE2QjtBQUM3QixvREFBOEI7QUFDOUIsb0RBQThCO0FBQzlCLGdEQUEwQjtBQUMxQiw2Q0FBdUI7QUFDdkIsNkNBQXVCO0FBQ3ZCLDhDQUF3QjtBQUN4Qiw0Q0FBc0I7QUFFdEI7Ozs7R0FJRztBQUVIOzs7Ozs7R0FNRztBQUNVLFFBQUEsT0FBTyxHQUFHLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2ZpbHRlcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdG9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZW52aXJvbm1lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0xvZ2dlZENsYXNzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9sb2dnaW5nXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90ZXh0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi90aW1lXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vd2ViXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIENvbXByZWhlbnNpdmUgbG9nZ2luZyB0b29sa2l0IGZvciBicm93c2VyIGFuZCBOb2RlIGVudmlyb25tZW50cy5cbiAqIEBzdW1tYXJ5IEV4cG9zZXMge0BsaW5rIExvZ2dpbmd9IGFuZCB7QGxpbmsgTWluaUxvZ2dlcn0gZm9yIHJ1bnRpbWUgbG9nZ2luZywgZGVjb3JhdG9ycyBzdWNoIGFzIHtAbGluayBsb2d9IGZvciBtZXRob2QgaW5zdHJ1bWVudGF0aW9uLCBhbmQgdXRpbGl0aWVzIGxpa2Uge0BsaW5rIFBhdHRlcm5GaWx0ZXJ9LCB7QGxpbmsgU3RvcFdhdGNofSwgYW5kIHtAbGluayBMb2dnZWRFbnZpcm9ubWVudH0gdG8gYnVpbGQgY29uZmlndXJhYmxlLCB0aGVtZS1hd2FyZSBsb2cgcGlwZWxpbmVzLlxuICogQG1vZHVsZSBMb2dnaW5nXG4gKi9cblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gQ3VycmVudCBwYWNrYWdlIHZlcnNpb24gc3RyaW5nLlxuICogQHN1bW1hcnkgU3RvcmVzIHRoZSBwYWNrYWdlIHZlcnNpb24gZm9yIGRpYWdub3N0aWNzIGFuZCBjb21wYXRpYmlsaXR5IGNoZWNrcy5cbiAqIEBjb25zdCBWRVJTSU9OXG4gKiBAdHlwZSB7c3RyaW5nfVxuICogQG1lbWJlck9mIG1vZHVsZTpMb2dnaW5nXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIjI1ZFUlNJT04jI1wiO1xuIl19

package/lib/index.d.ts

@@ -5,22 +5,19 @@ export * from "./environment";
 export * from "./LoggedClass";
 export * from "./logging";
 export * from "./text";
+export * from "./time";
 export * from "./types";
 export * from "./web";
 /**
- * @description A logging module for TypeScript applications
- * @summary Provides a comprehensive, flexible logging solution. This module exposes:
- * - Core classes like {@link Logging} and {@link MiniLogger}
- * - Decorators such as {@link log} for instrumenting methods
- * - Configuration and constants like {@link LogLevel} and {@link DefaultLoggingConfig}
- * - Type definitions including {@link Logger} and {@link LoggingConfig}
- * These exports enable consistent, context-aware, and optionally themed logging across projects.
+ * @description Comprehensive logging toolkit for browser and Node environments.
+ * @summary Exposes {@link Logging} and {@link MiniLogger} for runtime logging, decorators such as {@link log} for method instrumentation, and utilities like {@link PatternFilter}, {@link StopWatch}, and {@link LoggedEnvironment} to build configurable, theme-aware log pipelines.
  * @module Logging
  */
 /**
- * @description Current package version string
- * @summary Stores the current package version, used for version tracking and compatibility checks
+ * @description Current package version string.
+ * @summary Stores the package version for diagnostics and compatibility checks.
  * @const VERSION
+ * @type {string}
  * @memberOf module:Logging
  */
-export declare const VERSION = "0.3.11";
+export declare const VERSION = "0.3.13";