@decaf-ts/logging 0.3.12 → 0.3.14

package/lib/esm/environment.js

@@ -3,13 +3,33 @@ import { toENVFormat } from "./text.js";
 import { isBrowser } from "./web.js";
 import { BrowserEnvKey, DefaultLoggingConfig, ENV_PATH_DELIMITER, } from "./constants.js";
 /**
- * @class Environment
- * @extends {ObjectAccumulator<T>}
+ * @description Environment accumulator that lazily reads from runtime sources.
+ * @summary Extends {@link ObjectAccumulator} to merge configuration objects while resolving values from Node or browser environment variables on demand.
  * @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
+ * @example
+ * const Config = Environment.accumulate({ logging: { level: "info" } });
+ * console.log(Config.logging.level);
+ * console.log(String(Config.logging.level)); // => LOGGING__LEVEL key when serialized
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Env as Environment
+ *   participant Process as process.env
+ *   participant Browser as globalThis.ENV
+ *   Client->>Env: accumulate(partialConfig)
+ *   Env->>Env: expand(values)
+ *   Client->>Env: Config.logging.level
+ *   alt Browser runtime
+ *     Env->>Browser: lookup ENV key
+ *     Browser-->>Env: resolved value
+ *   else Node runtime
+ *     Env->>Process: lookup ENV key
+ *     Process-->>Env: resolved value
+ *   end
+ *   Env-->>Client: merged value
  */
+const EmptyValue = Symbol("EnvironmentEmpty");
 export class Environment extends ObjectAccumulator {
     /**
      * @static
@@ -23,10 +43,10 @@ export class Environment extends ObjectAccumulator {
         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
+     * @description Retrieves a value from the runtime environment.
+     * @summary Handles browser and Node.js environments by normalizing keys and parsing values.
+     * @param {string} k - Key to resolve from the environment.
+     * @return {unknown} Value resolved from the environment or `undefined` when absent.
      */
     fromEnv(k) {
         let env;
@@ -40,6 +60,12 @@ export class Environment extends ObjectAccumulator {
         }
         return this.parseEnvValue(env[k]);
     }
+    /**
+     * @description Converts stringified environment values into native types.
+     * @summary Interprets booleans and numbers while leaving other types unchanged.
+     * @param {unknown} val - Raw value retrieved from the environment.
+     * @return {unknown} Parsed value converted to boolean, number, or left as-is.
+     */
     parseEnvValue(val) {
         if (typeof val !== "string")
             return val;
@@ -53,10 +79,10 @@ export class Environment extends ObjectAccumulator {
         return val;
     }
     /**
-     * @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
+     * @description Expands an object into the environment.
+     * @summary Defines lazy properties that first consult runtime variables before falling back to seeded values.
+     * @template V - Type of the object being expanded.
+     * @param {V} value - Object to expose through environment getters and setters.
      * @return {void}
      */
     expand(value) {
@@ -69,9 +95,9 @@ export class Environment extends ObjectAccumulator {
                     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 the model provides an empty string, mark with EmptyValue so instance proxy can return undefined without enabling key composition
                     if (v === "") {
-                        return Environment.buildEnvProxy(undefined, [k]);
+                        return EmptyValue;
                     }
                     return v;
                 },
@@ -87,10 +113,10 @@ export class Environment extends ObjectAccumulator {
      * @protected
      * @static
      * @description Retrieves or creates the singleton instance of the Environment class.
-     * @summary Ensures only one instance of the Environment class exists.
+     * @summary Ensures only one {@link Environment} instance is created, wrapping it in a proxy to compose ENV keys on demand.
      * @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.
+     * @param {...unknown[]} args - Arguments forwarded to the factory when instantiating the singleton.
+     * @return {E} Singleton environment instance.
      */
     static instance(...args) {
         if (!Environment._instance) {
@@ -98,6 +124,8 @@ export class Environment extends ObjectAccumulator {
             const proxied = new Proxy(base, {
                 get(target, prop, receiver) {
                     const value = Reflect.get(target, prop, receiver);
+                    if (value === EmptyValue)
+                        return undefined;
                     if (typeof value !== "undefined")
                         return value;
                     if (typeof prop === "string") {
@@ -116,10 +144,11 @@ export class Environment extends ObjectAccumulator {
     /**
      * @static
      * @description Accumulates the given value into the environment.
-     * @summary Adds new properties to the environment from the provided object.
+     * @summary Adds new properties, hiding raw descriptors to avoid leaking enumeration semantics.
+     * @template T
      * @template V
-     * @param {V} value - The object to accumulate into the environment.
-     * @return {V} The updated environment instance.
+     * @param {V} value - Object to merge into the environment.
+     * @return {Environment} Updated environment reference.
      */
     static accumulate(value) {
         const instance = Environment.instance();
@@ -134,9 +163,22 @@ export class Environment extends ObjectAccumulator {
         });
         return instance.accumulate(value);
     }
+    /**
+     * @description Retrieves a value using a dot-path key from the accumulated environment.
+     * @summary Delegates to the singleton instance to access stored configuration.
+     * @param {string} key - Key to resolve from the environment store.
+     * @return {unknown} Stored value corresponding to the provided key.
+     */
     static get(key) {
         return Environment._instance.get(key);
     }
+    /**
+     * @description Builds a proxy that composes environment keys for nested properties.
+     * @summary Allows chained property access to emit uppercase ENV identifiers while honoring existing runtime overrides.
+     * @param {any} current - Seed model segment used when projecting nested structures.
+     * @param {string[]} path - Accumulated path segments leading to the proxy.
+     * @return {any} Proxy that resolves environment values or composes additional proxies for deeper paths.
+     */
     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
@@ -173,6 +215,9 @@ export class Environment extends ObjectAccumulator {
                 const isNextObject = nextModel && typeof nextModel === "object";
                 if (isNextObject)
                     return Environment.buildEnvProxy(nextModel, nextPath);
+                // If the model marks this leaf as an empty string, treat as undefined (no proxy)
+                if (nextModel === "")
+                    return undefined;
                 // 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);
@@ -205,9 +250,15 @@ export class Environment extends ObjectAccumulator {
             .map((k) => (toEnv ? toENVFormat(k) : k));
     }
 }
+/**
+ * @description Singleton environment instance seeded with default logging configuration.
+ * @summary Combines {@link DefaultLoggingConfig} with runtime environment variables to provide consistent logging defaults across platforms.
+ * @const LoggedEnvironment
+ * @memberOf module:Logging
+ */
 export const LoggedEnvironment = Environment.accumulate(Object.assign({}, DefaultLoggingConfig, {
     env: (isBrowser() && globalThis[BrowserEnvKey]
         ? globalThis[BrowserEnvKey]["NODE_ENV"]
         : globalThis.process.env["NODE_ENV"]) || "development",
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["../../src/environment.ts"],"names":[],"mappings":"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","sourcesContent":["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        (\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 this.parseEnvValue(env[k]);\n  }\n\n  protected parseEnvValue(val: unknown) {\n    if (typeof val !== \"string\") return val;\n    if (val === \"true\") return true;\n    if (val === \"false\") return false;\n    const result = parseFloat(val);\n    if (!isNaN(result)) return result;\n    return val;\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["../../src/environment.ts"],"names":[],"mappings":"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","sourcesContent":["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 Describes factories that construct {@link Environment} derivatives with custom initialization.\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 * @description Environment accumulator that lazily reads from runtime sources.\n * @summary Extends {@link ObjectAccumulator} to merge configuration objects while resolving values from Node or browser environment variables on demand.\n * @template T\n * @class Environment\n * @example\n * const Config = Environment.accumulate({ logging: { level: \"info\" } });\n * console.log(Config.logging.level);\n * console.log(String(Config.logging.level)); // => LOGGING__LEVEL key when serialized\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Env as Environment\n *   participant Process as process.env\n *   participant Browser as globalThis.ENV\n *   Client->>Env: accumulate(partialConfig)\n *   Env->>Env: expand(values)\n *   Client->>Env: Config.logging.level\n *   alt Browser runtime\n *     Env->>Browser: lookup ENV key\n *     Browser-->>Env: resolved value\n *   else Node runtime\n *     Env->>Process: lookup ENV key\n *     Process-->>Env: resolved value\n *   end\n *   Env-->>Client: merged value\n */\nconst EmptyValue = Symbol(\"EnvironmentEmpty\");\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 runtime environment.\n   * @summary Handles browser and Node.js environments by normalizing keys and parsing values.\n   * @param {string} k - Key to resolve from the environment.\n   * @return {unknown} Value resolved from the environment or `undefined` when absent.\n   */\n  protected fromEnv(k: string) {\n    let env: Record<string, unknown>;\n    if (isBrowser()) {\n      env =\n        (\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 this.parseEnvValue(env[k]);\n  }\n\n  /**\n   * @description Converts stringified environment values into native types.\n   * @summary Interprets booleans and numbers while leaving other types unchanged.\n   * @param {unknown} val - Raw value retrieved from the environment.\n   * @return {unknown} Parsed value converted to boolean, number, or left as-is.\n   */\n  protected parseEnvValue(val: unknown) {\n    if (typeof val !== \"string\") return val;\n    if (val === \"true\") return true;\n    if (val === \"false\") return false;\n    const result = parseFloat(val);\n    if (!isNaN(result)) return result;\n    return val;\n  }\n\n  /**\n   * @description Expands an object into the environment.\n   * @summary Defines lazy properties that first consult runtime variables before falling back to seeded values.\n   * @template V - Type of the object being expanded.\n   * @param {V} value - Object to expose through environment getters and setters.\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, mark with EmptyValue so instance proxy can return undefined without enabling key composition\n          if (v === \"\") {\n            return EmptyValue as unknown as V[keyof V];\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 {@link Environment} instance is created, wrapping it in a proxy to compose ENV keys on demand.\n   * @template E\n   * @param {...unknown[]} args - Arguments forwarded to the factory when instantiating the singleton.\n   * @return {E} Singleton environment instance.\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 (value === EmptyValue) return undefined;\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, hiding raw descriptors to avoid leaking enumeration semantics.\n   * @template T\n   * @template V\n   * @param {V} value - Object to merge into the environment.\n   * @return {Environment} Updated environment reference.\n   */\n  static accumulate<V extends object, TBase extends object = object>(\n    value: V\n  ): Environment<TBase & V> & TBase & V {\n    const instance = Environment.instance<Environment<TBase & V>>();\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) as unknown as Environment<TBase & V> &\n      TBase &\n      V;\n  }\n\n  /**\n   * @description Retrieves a value using a dot-path key from the accumulated environment.\n   * @summary Delegates to the singleton instance to access stored configuration.\n   * @param {string} key - Key to resolve from the environment store.\n   * @return {unknown} Stored value corresponding to the provided key.\n   */\n  static get(key: string) {\n    return Environment._instance.get(key);\n  }\n\n  /**\n   * @description Builds a proxy that composes environment keys for nested properties.\n   * @summary Allows chained property access to emit uppercase ENV identifiers while honoring existing runtime overrides.\n   * @param {any} current - Seed model segment used when projecting nested structures.\n   * @param {string[]} path - Accumulated path segments leading to the proxy.\n   * @return {any} Proxy that resolves environment values or composes additional proxies for deeper paths.\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        // If the model marks this leaf as an empty string, treat as undefined (no proxy)\n        if (nextModel === \"\") return undefined;\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\n/**\n * @description Singleton environment instance seeded with default logging configuration.\n * @summary Combines {@link DefaultLoggingConfig} with runtime environment variables to provide consistent logging defaults across platforms.\n * @const LoggedEnvironment\n * @memberOf module:Logging\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"]}

package/lib/esm/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/esm/filters/LogFilter.js

@@ -1,7 +1,36 @@
 import { LoggedClass } from "./../LoggedClass.js";
+/**
+ * @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 class LogFilter extends 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: [] });
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9nRmlsdGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2ZpbHRlcnMvTG9nRmlsdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxXQUFXLEVBQUUsNEJBQXVCO0FBRTdDLE1BQU0sT0FBZ0IsU0FBVSxTQUFRLFdBQVc7SUFDakQsSUFBYSxHQUFHO1FBQ2QsT0FBTyxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxJQUFXLEVBQUUsRUFBRSxPQUFPLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUNyRCxDQUFDO0NBT0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMb2dnZXIsIExvZ2dpbmdDb25maWcsIExvZ2dpbmdGaWx0ZXIgfSBmcm9tIFwiLi4vdHlwZXNcIjtcbmltcG9ydCB7IExvZ2dlZENsYXNzIH0gZnJvbSBcIi4uL0xvZ2dlZENsYXNzXCI7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBMb2dGaWx0ZXIgZXh0ZW5kcyBMb2dnZWRDbGFzcyBpbXBsZW1lbnRzIExvZ2dpbmdGaWx0ZXIge1xuICBvdmVycmlkZSBnZXQgbG9nKCk6IExvZ2dlciB7XG4gICAgcmV0dXJuIHN1cGVyLmxvZy5mb3IodGhpcyBhcyBhbnksIHsgZmlsdGVyczogW10gfSk7XG4gIH1cblxuICBhYnN0cmFjdCBmaWx0ZXIoXG4gICAgY29uZmlnOiBMb2dnaW5nQ29uZmlnLFxuICAgIG1lc3NhZ2U6IHN0cmluZyxcbiAgICBjb250ZXh0OiBzdHJpbmdbXVxuICApOiBzdHJpbmc7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/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/esm/filters/PatternFilter.js

@@ -9,17 +9,57 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { LogFilter } from "./LogFilter.js";
 import { final } from "./../decorators.js";
+/**
+ * @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 class PatternFilter extends 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);
@@ -41,4 +81,4 @@ __decorate([
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", void 0)
 ], PatternFilter.prototype, "match", null);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/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";

package/lib/esm/index.js

@@ -5,23 +5,20 @@ export * from "./environment.js";
 export * from "./LoggedClass.js";
 export * from "./logging.js";
 export * from "./text.js";
+export * from "./time.js";
 export * from "./types.js";
 export * from "./web.js";
 /**
- * @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 const VERSION = "0.3.11";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsbUNBQTBCO0FBQzFCLCtCQUE0QjtBQUM1QixnQ0FBNkI7QUFDN0IsaUNBQThCO0FBQzlCLGlDQUE4QjtBQUM5Qiw2QkFBMEI7QUFDMUIsMEJBQXVCO0FBQ3ZCLDJCQUF3QjtBQUN4Qix5QkFBc0I7QUFFdEI7Ozs7Ozs7OztHQVNHO0FBRUg7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vZmlsdGVyc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lbnZpcm9ubWVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vTG9nZ2VkQ2xhc3NcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xvZ2dpbmdcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RleHRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi93ZWJcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gQSBsb2dnaW5nIG1vZHVsZSBmb3IgVHlwZVNjcmlwdCBhcHBsaWNhdGlvbnNcbiAqIEBzdW1tYXJ5IFByb3ZpZGVzIGEgY29tcHJlaGVuc2l2ZSwgZmxleGlibGUgbG9nZ2luZyBzb2x1dGlvbi4gVGhpcyBtb2R1bGUgZXhwb3NlczpcbiAqIC0gQ29yZSBjbGFzc2VzIGxpa2Uge0BsaW5rIExvZ2dpbmd9IGFuZCB7QGxpbmsgTWluaUxvZ2dlcn1cbiAqIC0gRGVjb3JhdG9ycyBzdWNoIGFzIHtAbGluayBsb2d9IGZvciBpbnN0cnVtZW50aW5nIG1ldGhvZHNcbiAqIC0gQ29uZmlndXJhdGlvbiBhbmQgY29uc3RhbnRzIGxpa2Uge0BsaW5rIExvZ0xldmVsfSBhbmQge0BsaW5rIERlZmF1bHRMb2dnaW5nQ29uZmlnfVxuICogLSBUeXBlIGRlZmluaXRpb25zIGluY2x1ZGluZyB7QGxpbmsgTG9nZ2VyfSBhbmQge0BsaW5rIExvZ2dpbmdDb25maWd9XG4gKiBUaGVzZSBleHBvcnRzIGVuYWJsZSBjb25zaXN0ZW50LCBjb250ZXh0LWF3YXJlLCBhbmQgb3B0aW9uYWxseSB0aGVtZWQgbG9nZ2luZyBhY3Jvc3MgcHJvamVjdHMuXG4gKiBAbW9kdWxlIExvZ2dpbmdcbiAqL1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBDdXJyZW50IHBhY2thZ2UgdmVyc2lvbiBzdHJpbmdcbiAqIEBzdW1tYXJ5IFN0b3JlcyB0aGUgY3VycmVudCBwYWNrYWdlIHZlcnNpb24sIHVzZWQgZm9yIHZlcnNpb24gdHJhY2tpbmcgYW5kIGNvbXBhdGliaWxpdHkgY2hlY2tzXG4gKiBAY29uc3QgVkVSU0lPTlxuICogQG1lbWJlck9mIG1vZHVsZTpMb2dnaW5nXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIjI1ZFUlNJT04jI1wiO1xuIl19
+export const VERSION = "0.3.13";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsbUNBQTBCO0FBQzFCLCtCQUE0QjtBQUM1QixnQ0FBNkI7QUFDN0IsaUNBQThCO0FBQzlCLGlDQUE4QjtBQUM5Qiw2QkFBMEI7QUFDMUIsMEJBQXVCO0FBQ3ZCLDBCQUF1QjtBQUN2QiwyQkFBd0I7QUFDeEIseUJBQXNCO0FBRXRCOzs7O0dBSUc7QUFFSDs7Ozs7O0dBTUc7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vZmlsdGVyc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lbnZpcm9ubWVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vTG9nZ2VkQ2xhc3NcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xvZ2dpbmdcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RleHRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RpbWVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi93ZWJcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gQ29tcHJlaGVuc2l2ZSBsb2dnaW5nIHRvb2xraXQgZm9yIGJyb3dzZXIgYW5kIE5vZGUgZW52aXJvbm1lbnRzLlxuICogQHN1bW1hcnkgRXhwb3NlcyB7QGxpbmsgTG9nZ2luZ30gYW5kIHtAbGluayBNaW5pTG9nZ2VyfSBmb3IgcnVudGltZSBsb2dnaW5nLCBkZWNvcmF0b3JzIHN1Y2ggYXMge0BsaW5rIGxvZ30gZm9yIG1ldGhvZCBpbnN0cnVtZW50YXRpb24sIGFuZCB1dGlsaXRpZXMgbGlrZSB7QGxpbmsgUGF0dGVybkZpbHRlcn0sIHtAbGluayBTdG9wV2F0Y2h9LCBhbmQge0BsaW5rIExvZ2dlZEVudmlyb25tZW50fSB0byBidWlsZCBjb25maWd1cmFibGUsIHRoZW1lLWF3YXJlIGxvZyBwaXBlbGluZXMuXG4gKiBAbW9kdWxlIExvZ2dpbmdcbiAqL1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBDdXJyZW50IHBhY2thZ2UgdmVyc2lvbiBzdHJpbmcuXG4gKiBAc3VtbWFyeSBTdG9yZXMgdGhlIHBhY2thZ2UgdmVyc2lvbiBmb3IgZGlhZ25vc3RpY3MgYW5kIGNvbXBhdGliaWxpdHkgY2hlY2tzLlxuICogQGNvbnN0IFZFUlNJT05cbiAqIEB0eXBlIHtzdHJpbmd9XG4gKiBAbWVtYmVyT2YgbW9kdWxlOkxvZ2dpbmdcbiAqL1xuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBcIiMjVkVSU0lPTiMjXCI7XG4iXX0=

package/lib/esm/logging.d.ts

@@ -52,6 +52,13 @@ export declare class MiniLogger implements Logger {
      * @return {void}
      */
     protected log(level: LogLevel, msg: StringLike | Error, error?: Error): void;
+    /**
+     * @description Logs a message at the benchmark level
+     * @summary Logs a message at the benchmark level if the current verbosity setting allows it
+     * @param {StringLike} msg - The message to be logged
+     * @return {void}
+     */
+    benchmark(msg: StringLike): void;
     /**
      * @description Logs a message at the silly level
      * @summary Logs a message at the silly level if the current verbosity setting allows it
@@ -225,6 +232,13 @@ export declare class Logging {
      * @param msg - The message to be logged.
      */
     static debug(msg: StringLike): void;
+    /**
+     * @description Logs a benchmark message.
+     * @summary Delegates the benchmark logging to the global logger instance.
+     *
+     * @param msg - The message to be logged.
+     */
+    static benchmark(msg: StringLike): void;
     /**
      * @description Logs a silly message.
      * @summary Delegates the debug logging to the global logger instance.