@versori/run 0.0.1-alpha.0 → 0.0.1-alpha.1

package/esm/deps/jsr.io/@std/log/0.224.14/base_handler.js

@@ -0,0 +1,331 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BaseHandler_levelName, _BaseHandler_level;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { getLevelByName, getLevelName, } from "./levels.js";
+const DEFAULT_FORMATTER = ({ levelName, msg }) => `${levelName} ${msg}`;
+/**
+ * A base class for all log handlers.
+ *
+ * This class is abstract and should not be instantiated directly. Instead, it
+ * should be extended by other classes that implement the `log` method.
+ *
+ * @example Usage
+ * ```ts
+ * import { BaseHandler } from "@std/log/base-handler";
+ * import { assertInstanceOf } from "@std/assert/instance-of";
+ *
+ * class MyHandler extends BaseHandler {
+ *   log(msg: string) {
+ *     console.log(msg);
+ *   }
+ * }
+ *
+ * const handler = new MyHandler("INFO");
+ * assertInstanceOf(handler, BaseHandler);
+ * ```
+ */
+export class BaseHandler {
+    /**
+     * Constructs a new instance.
+     *
+     * @param levelName The name of the log level to handle.
+     * @param options Options for the handler.
+     */
+    constructor(levelName, options) {
+        _BaseHandler_levelName.set(this, void 0);
+        _BaseHandler_level.set(this, void 0);
+        /**
+         * The function that formats log records.
+         *
+         * @example Usage
+         * ```ts
+         * import { BaseHandler } from "@std/log/base-handler";
+         * import { LogRecord } from "@std/log/logger";
+         * import { LogLevels } from "@std/log/levels";
+         * import { assertEquals } from "@std/assert/equals";
+         *
+         * class MyHandler extends BaseHandler {
+         *  log(msg: string) {
+         *   console.log(msg);
+         * }
+         * }
+         *
+         * const handler = new MyHandler("INFO");
+         * const record = new LogRecord({
+         *   msg: "Hello, world!",
+         *   args: ["foo", "bar"],
+         *   level: LogLevels.INFO,
+         *   loggerName: "example",
+         * });
+         * const formatted = handler.formatter(record);
+         * assertEquals(formatted, "INFO Hello, world!");
+         * ```
+         */
+        Object.defineProperty(this, "formatter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const { formatter = DEFAULT_FORMATTER } = options ?? {};
+        __classPrivateFieldSet(this, _BaseHandler_levelName, levelName, "f");
+        __classPrivateFieldSet(this, _BaseHandler_level, getLevelByName(levelName), "f");
+        this.formatter = formatter;
+    }
+    /**
+     * Getter for the log level that this handler will handle.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * assertEquals(handler.level, LogLevels.INFO);
+     * ```
+     *
+     * @returns The log level to handle.
+     */
+    get level() {
+        return __classPrivateFieldGet(this, _BaseHandler_level, "f");
+    }
+    /**
+     * Setter for the log level that this handler will handle.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * handler.level = LogLevels.DEBUG;
+     * assertEquals(handler.level, LogLevels.DEBUG);
+     * ```
+     *
+     * @param level The log level to handle.
+     */
+    set level(level) {
+        __classPrivateFieldSet(this, _BaseHandler_level, level, "f");
+        __classPrivateFieldSet(this, _BaseHandler_levelName, getLevelName(level), "f");
+    }
+    /**
+     * Getter for the name of the log level that this handler will handle.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * assertEquals(handler.levelName, "INFO");
+     * ```
+     *
+     * @returns The name of the log level to handle.
+     */
+    get levelName() {
+        return __classPrivateFieldGet(this, _BaseHandler_levelName, "f");
+    }
+    /**
+     * Setter for the name of the log level that this handler will handle.
+     *
+     * @param levelName The name of the log level to handle.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * handler.levelName = "DEBUG";
+     * assertEquals(handler.levelName, "DEBUG");
+     * ```
+     */
+    set levelName(levelName) {
+        __classPrivateFieldSet(this, _BaseHandler_levelName, levelName, "f");
+        __classPrivateFieldSet(this, _BaseHandler_level, getLevelByName(levelName), "f");
+    }
+    /**
+     * Handles a log record.
+     *
+     * @param logRecord The log record to handle.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     * handler.handle(record);
+     *
+     * assertInstanceOf(handler, BaseHandler);
+     * ```
+     */
+    handle(logRecord) {
+        if (this.level > logRecord.level)
+            return;
+        const msg = this.format(logRecord);
+        this.log(msg);
+    }
+    /**
+     * Formats a log record.
+     *
+     * @param logRecord The log record to format.
+     * @returns A string representation of the log record.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     * const formatted = handler.format(record);
+     * assertEquals(formatted, "INFO Hello, world!");
+     * ```
+     */
+    format(logRecord) {
+        return this.formatter(logRecord);
+    }
+    /**
+     * Initializes the handler.
+     *
+     * This method is called when the handler is added to a logger. It can be
+     * used to perform any setup that is required by the handler.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     *
+     *   override setup() {
+     *     console.log("Handler setup!");
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * handler.setup(); // Prints "Handler setup!"
+     *
+     * assertInstanceOf(handler, BaseHandler);
+     * ```
+     */
+    setup() { }
+    /**
+     * Destroys the handler, performing any cleanup that is required.
+     *
+     * This method is called when the handler is removed from a logger. It can be
+     * used to perform any cleanup that is required by the handler.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     *
+     *   override destroy() {
+     *     console.log("Handler destroyed!");
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * handler.destroy(); // Prints "Handler destroyed!"
+     * assertInstanceOf(handler, BaseHandler);
+     * ```
+     */
+    destroy() { }
+    /**
+     * Automatically disposes of the handler when instantiated with the `using`
+     * keyword by calling the {@linkcode BaseHandler.destroy} method.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { LogRecord } from "@std/log/logger";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * using handler = new MyHandler("INFO");
+     * assertInstanceOf(handler, BaseHandler);
+     * ```
+     */
+    [(_BaseHandler_levelName = new WeakMap(), _BaseHandler_level = new WeakMap(), Symbol.dispose)]() {
+        this.destroy();
+    }
+}

package/esm/deps/jsr.io/@std/log/0.224.14/console_handler.d.ts

@@ -0,0 +1,76 @@
+import { type LevelName } from "./levels.js";
+import type { LogRecord } from "./logger.js";
+import { BaseHandler, type BaseHandlerOptions } from "./base_handler.js";
+/** Options for {@linkcode ConsoleHandler}. */
+export interface ConsoleHandlerOptions extends BaseHandlerOptions {
+    /**
+     * Whether to use colors in the output.
+     *
+     * @default {true}
+     */
+    useColors?: boolean;
+}
+/**
+ * Default logger that outputs log messages to the console via
+ * {@linkcode console.log}.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { ConsoleHandler } from "@std/log/console-handler";
+ *
+ * const handler = new ConsoleHandler("INFO");
+ * handler.log("Hello, world!"); // Prints "Hello, world!"
+ * ```
+ */
+export declare class ConsoleHandler extends BaseHandler {
+    #private;
+    /**
+     * Constructs a new instance.
+     *
+     * @param levelName The level name to log messages at.
+     * @param options Options for the handler.
+     */
+    constructor(levelName: LevelName, options?: ConsoleHandlerOptions);
+    /**
+     * Formats a log record into a string.
+     *
+     * @example Usage
+     * ```ts
+     * import { ConsoleHandler } from "@std/log/console-handler";
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     * import { blue } from "@std/fmt/colors";
+     *
+     * const handler = new ConsoleHandler("INFO");
+     * const logRecord = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "my-logger",
+     * });
+     * const result = handler.format(logRecord);
+     *
+     * assertEquals(result, blue("INFO Hello, world!"));
+     * ```
+     *
+     * @param logRecord The log record to format.
+     * @returns The formatted log record.
+     */
+    format(logRecord: LogRecord): string;
+    /**
+     * Logs a message to the console.
+     *
+     * @example Usage
+     * ```ts no-assert
+     * import { ConsoleHandler } from "@std/log/console-handler";
+     *
+     * const handler = new ConsoleHandler("INFO");
+     * handler.log("Hello, world!"); // Prints "Hello, world!"
+     * ```
+     *
+     * @param msg The message to log.
+     */
+    log(msg: string): void;
+}
+//# sourceMappingURL=console_handler.d.ts.map

package/esm/deps/jsr.io/@std/log/0.224.14/console_handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/console_handler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEzE,8CAA8C;AAC9C,MAAM,WAAW,qBAAsB,SAAQ,kBAAkB;IAC/D;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAuBD;;;;;;;;;;;GAWG;AACH,qBAAa,cAAe,SAAQ,WAAW;;IAG7C;;;;;OAKG;gBACS,SAAS,EAAE,SAAS,EAAE,OAAO,GAAE,qBAA0B;IAKrE;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACM,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM;IAU7C;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM;CAIhB"}

package/esm/deps/jsr.io/@std/log/0.224.14/console_handler.js

@@ -0,0 +1,112 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ConsoleHandler_useColors;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { LogLevels } from "./levels.js";
+import { blue, bold, red, yellow } from "../../fmt/1.0.5/colors.js";
+import { BaseHandler } from "./base_handler.js";
+function applyColors(msg, level) {
+    switch (level) {
+        case LogLevels.INFO:
+            msg = blue(msg);
+            break;
+        case LogLevels.WARN:
+            msg = yellow(msg);
+            break;
+        case LogLevels.ERROR:
+            msg = red(msg);
+            break;
+        case LogLevels.CRITICAL:
+            msg = bold(red(msg));
+            break;
+        default:
+            break;
+    }
+    return msg;
+}
+/**
+ * Default logger that outputs log messages to the console via
+ * {@linkcode console.log}.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { ConsoleHandler } from "@std/log/console-handler";
+ *
+ * const handler = new ConsoleHandler("INFO");
+ * handler.log("Hello, world!"); // Prints "Hello, world!"
+ * ```
+ */
+export class ConsoleHandler extends BaseHandler {
+    /**
+     * Constructs a new instance.
+     *
+     * @param levelName The level name to log messages at.
+     * @param options Options for the handler.
+     */
+    constructor(levelName, options = {}) {
+        super(levelName, options);
+        _ConsoleHandler_useColors.set(this, void 0);
+        __classPrivateFieldSet(this, _ConsoleHandler_useColors, options.useColors ?? true, "f");
+    }
+    /**
+     * Formats a log record into a string.
+     *
+     * @example Usage
+     * ```ts
+     * import { ConsoleHandler } from "@std/log/console-handler";
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     * import { blue } from "@std/fmt/colors";
+     *
+     * const handler = new ConsoleHandler("INFO");
+     * const logRecord = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "my-logger",
+     * });
+     * const result = handler.format(logRecord);
+     *
+     * assertEquals(result, blue("INFO Hello, world!"));
+     * ```
+     *
+     * @param logRecord The log record to format.
+     * @returns The formatted log record.
+     */
+    format(logRecord) {
+        let msg = super.format(logRecord);
+        if (__classPrivateFieldGet(this, _ConsoleHandler_useColors, "f")) {
+            msg = applyColors(msg, logRecord.level);
+        }
+        return msg;
+    }
+    /**
+     * Logs a message to the console.
+     *
+     * @example Usage
+     * ```ts no-assert
+     * import { ConsoleHandler } from "@std/log/console-handler";
+     *
+     * const handler = new ConsoleHandler("INFO");
+     * handler.log("Hello, world!"); // Prints "Hello, world!"
+     * ```
+     *
+     * @param msg The message to log.
+     */
+    log(msg) {
+        // deno-lint-ignore no-console
+        console.log(msg);
+    }
+}
+_ConsoleHandler_useColors = new WeakMap();

package/esm/deps/jsr.io/@std/log/0.224.14/critical.d.ts

@@ -0,0 +1,53 @@
+import type { GenericFunction } from "./logger.js";
+import "./setup.js";
+/**
+ * Log at the critical level.
+ *
+ * This function is a pass-through to the default logger's `critical` method. By
+ * default, the default logger is configured to use {@linkcode console.log} and
+ * print in bold red text.
+ *
+ * @template T The type of the message to log.
+ * @param msg The message to log.
+ * @param args Arguments to be formatted into the message.
+ * @returns The message that was logged.
+ *
+ * @example Usage
+ * ```ts
+ * import { critical } from "@std/log/critical";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * assertEquals(critical("This is a critical message."), "This is a critical message.");
+ * // Prints: "CRITICAL This is a critical message."
+ *
+ * assertEquals(critical(() => "This is a critical message."), "This is a critical message.");
+ * // Prints: "CRITICAL This is a critical message."
+ * ```
+ */
+export declare function critical<T>(msg: () => T, ...args: unknown[]): T | undefined;
+/**
+ * Log at the critical level.
+ *
+ * This function is a pass-through to the default logger's `critical` method. By
+ * default, the default logger is configured to use {@linkcode console.log} and
+ * print in bold red text.
+ *
+ * @template T The type of the message to log.
+ * @param msg The message to log.
+ * @param args Arguments to be formatted into the message.
+ * @returns The message that was logged.
+ *
+ * @example Usage
+ * ```ts
+ * import { critical } from "@std/log/critical";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * assertEquals(critical("This is a critical message."), "This is a critical message.");
+ * // Prints: "CRITICAL This is a critical message."
+ *
+ * assertEquals(critical(() => "This is a critical message."), "This is a critical message.");
+ * // Prints: "CRITICAL This is a critical message."
+ * ```
+ */
+export declare function critical<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+//# sourceMappingURL=critical.d.ts.map

package/esm/deps/jsr.io/@std/log/0.224.14/critical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"critical.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/critical.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;AAC7E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,GAAG,EAAE,CAAC,SAAS,eAAe,GAAG,KAAK,GAAG,CAAC,EAC1C,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,CAAC,CAAC"}

package/esm/deps/jsr.io/@std/log/0.224.14/critical.js

@@ -0,0 +1,11 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { getLogger } from "./get_logger.js";
+import "./setup.js";
+export function critical(msg, ...args) {
+    // Assist TS compiler with pass-through generic type
+    if (msg instanceof Function) {
+        return getLogger("default").critical(msg, ...args);
+    }
+    return getLogger("default").critical(msg, ...args);
+}

package/esm/deps/jsr.io/@std/log/0.224.14/debug.d.ts

@@ -0,0 +1,105 @@
+import type { GenericFunction } from "./logger.js";
+import "./setup.js";
+/**
+ * Log at the debug level.
+ *
+ * This function is a pass-through to the default logger's `debug` method. By
+ * default, this function is a no-op. To enable debug logging, set call
+ * {@linkcode https://jsr.io/@std/log/doc/setup/~/setup | setup} and set the
+ * default level to `DEBUG`.
+ *
+ * @template T The type of the message to log.
+ * @param msg The message to log.
+ * @param args Arguments to be formatted into the message.
+ * @returns The message that was logged.
+ *
+ * @example Usage without setup
+ * ```ts
+ * import { debug } from "@std/log/debug";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * assertEquals(debug("This is a debug message."), "This is a debug message.");
+ * // Prints: ""
+ *
+ * assertEquals(debug(() => "This is a debug message."), undefined);
+ * // Prints: ""
+ * ```
+ *
+ * @example Usage with setup
+ * ```ts
+ * import { ConsoleHandler, debug, setup } from "@std/log";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * setup({
+ *   handlers: {
+ *     default: new ConsoleHandler("DEBUG"),
+ *   },
+ *   loggers: {
+ *     default: {
+ *       level: "DEBUG",
+ *       handlers: ["default"],
+ *     },
+ *   },
+ * });
+ *
+ * assertEquals(debug("This is a debug message."), "This is a debug message.");
+ *
+ * assertEquals(
+ *   debug(() => "This is a debug message."),
+ *   "This is a debug message.",
+ * );
+ * ```
+ */
+export declare function debug<T>(msg: () => T, ...args: unknown[]): T | undefined;
+/**
+ * Log at the debug level.
+ *
+ * This function is a pass-through to the default logger's `debug` method. By
+ * default, this function is a no-op. To enable debug logging, set call
+ * {@linkcode https://jsr.io/@std/log/doc/setup/~/setup | setup} and set the
+ * default level to `DEBUG`.
+ *
+ * @template T The type of the message to log.
+ * @param msg The message to log.
+ * @param args Arguments to be formatted into the message.
+ * @returns The message that was logged.
+ *
+ * @example Usage without setup
+ * ```ts
+ * import { debug } from "@std/log/debug";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * assertEquals(debug("This is a debug message."), "This is a debug message.");
+ * // Prints: ""
+ *
+ * assertEquals(debug(() => "This is a debug message."), undefined);
+ * // Prints: ""
+ * ```
+ *
+ * @example Usage with setup
+ * ```ts
+ * import { ConsoleHandler, debug, setup } from "@std/log";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * setup({
+ *   handlers: {
+ *     default: new ConsoleHandler("DEBUG"),
+ *   },
+ *   loggers: {
+ *     default: {
+ *       level: "DEBUG",
+ *       handlers: ["default"],
+ *     },
+ *   },
+ * });
+ *
+ * assertEquals(debug("This is a debug message."), "This is a debug message.");
+ *
+ * assertEquals(
+ *   debug(() => "This is a debug message."),
+ *   "This is a debug message.",
+ * );
+ * ```
+ */
+export declare function debug<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+//# sourceMappingURL=debug.d.ts.map