@skmtc/core 0.0.684 → 0.0.686

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.8/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

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

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/debug.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;AAC1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,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/debug.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 debug(msg, ...args) {
+    // Assist TS compiler with pass-through generic type
+    if (msg instanceof Function) {
+        return getLogger("default").debug(msg, ...args);
+    }
+    return getLogger("default").debug(msg, ...args);
+}

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

@@ -0,0 +1,53 @@
+import type { GenericFunction } from "./logger.js";
+import "./setup.js";
+/**
+ * Log at the error level.
+ *
+ * This function is a pass-through to the default logger's `error` method. By
+ * default, the default logger is configured to use {@linkcode console.log} and
+ * print in 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 { error } from "@std/log/error";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * assertEquals(error("This is an error message."), "This is an error message.");
+ * // Prints: "ERROR This is an error message."
+ *
+ * assertEquals(error(() => "This is an error message."), "This is an error message.");
+ * // Prints: "ERROR This is an error message."
+ * ```
+ */
+export declare function error<T>(msg: () => T, ...args: unknown[]): T | undefined;
+/**
+ * Log at the error level.
+ *
+ * This function is a pass-through to the default logger's `error` method. By
+ * default, the default logger is configured to use {@linkcode console.log} and
+ * print in 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 { error } from "@std/log/error";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * assertEquals(error("This is an error message."), "This is an error message.");
+ * // Prints: "ERROR This is an error message."
+ *
+ * assertEquals(error(() => "This is an error message."), "This is an error message.");
+ * // Prints: "ERROR This is an error message."
+ * ```
+ */
+export declare function error<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+//# sourceMappingURL=error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/error.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;AAC1E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,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/error.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 error(msg, ...args) {
+    // Assist TS compiler with pass-through generic type
+    if (msg instanceof Function) {
+        return getLogger("default").error(msg, ...args);
+    }
+    return getLogger("default").error(msg, ...args);
+}

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

@@ -0,0 +1,200 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+import { type LevelName } from "./levels.js";
+import type { LogRecord } from "./logger.js";
+import { BaseHandler, type BaseHandlerOptions } from "./base_handler.js";
+import { bufSymbol, encoderSymbol, filenameSymbol, fileSymbol, modeSymbol, openOptionsSymbol, pointerSymbol } from "./_file_handler_symbols.js";
+/** Supported log modes for FileHandlerOptions {@linkcode FileHandlerOptions.mode}. */
+export type LogMode = "a" | "w" | "x";
+/** Options for {@linkcode FileHandler}. */
+export interface FileHandlerOptions extends BaseHandlerOptions {
+    /**
+     * The filename to output to.
+     */
+    filename: string;
+    /**
+     * Log mode for the handler. Behavior of the log modes is as follows:
+     *
+     * - `'a'` - Default mode. Appends new log messages to the end of an existing log
+     *   file, or create a new log file if none exists.
+     * - `'w'` - Upon creation of the handler, any existing log file will be removed
+     *   and a new one created.
+     * - `'x'` - This will create a new log file and throw an error if one already
+     *   exists.
+     *
+     * @default {"a"}
+     */
+    mode?: LogMode;
+    /**
+     * Buffer size for writing log messages to file, in bytes.
+     *
+     * @default {4096}
+     */
+    bufferSize?: number;
+}
+/**
+ * A file-based log handler that writes log messages to a specified file with buffering and optional modes.
+ * The logs are buffered for optimized performance, writing to the file only
+ * when the buffer is full, on manual .flush() call, during logging of a critical message or when process ends.
+ * It is important to note that the file can grow indefinitely.
+ *
+ * This handler requires `--allow-write` permission on the log file.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { FileHandler } from "@std/log/file-handler";
+ *
+ * const handler = new FileHandler("INFO", { filename: "./_tmp/logs.txt" });
+ * handler.setup();
+ * handler.log('Hello, world!'); // Buffers the message, or writes it to the file depending on buffer state
+ * handler.flush(); // Manually flushes the buffer
+ * handler.destroy(); // Closes the file and removes listeners
+ * ```
+ */
+export declare class FileHandler extends BaseHandler {
+    #private;
+    /** Opened file to append logs to.
+     *
+     * @private
+     */
+    [fileSymbol]: dntShim.Deno.FsFile | undefined;
+    /** Buffer used to write to file.
+     *
+     * @private
+     */
+    [bufSymbol]: Uint8Array;
+    /**
+     * Current position for pointer.
+     *
+     * @private
+     */
+    [pointerSymbol]: number;
+    /**
+     * Filename associated with the file being logged.
+     *
+     * @private
+     */
+    [filenameSymbol]: string;
+    /**
+     * Current log mode.
+     *
+     * @private
+     */
+    [modeSymbol]: LogMode;
+    /**
+     * File open options.
+     *
+     * @private
+     */
+    [openOptionsSymbol]: dntShim.Deno.OpenOptions;
+    /**
+     * Text encoder.
+     *
+     * @private
+     */
+    [encoderSymbol]: TextEncoder;
+    /**
+     * Constructs a new FileHandler instance.
+     *
+     * @param levelName The level name to log messages at.
+     * @param options Options for the handler.
+     */
+    constructor(levelName: LevelName, options: FileHandlerOptions);
+    /**
+     * Sets up the file handler by opening the specified file and initializing resources.
+     *
+     * @example Usage
+     * ```ts no-assert
+     * import { FileHandler } from "@std/log/file-handler";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./_tmp/logs.txt" });
+     * handler.setup(); // Opens the file and prepares the handler for logging.
+     * handler.destroy();
+     * ```
+     */
+    setup(): void;
+    /**
+     * Handles a log record and flushes the buffer if the log level is higher than error.
+     *
+     * @param logRecord Log record to handle.
+     *
+     * @example Usage
+     * ```ts
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     * import { LogLevels } from "./levels.ts";
+     * import { LogRecord } from "./logger.ts";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./_tmp/logs.txt" });
+     * handler.setup();
+     *
+     * // Flushes the buffer immediately and logs "CRITICAL This log is very critical indeed." into the file.
+     * handler.handle(
+     *   new LogRecord({
+     *     msg: "This log is very critical indeed.",
+     *     args: [],
+     *     level: LogLevels.CRITICAL,
+     *     loggerName: "INFO",
+     *   }),
+     * );
+     * handler.destroy();
+     *
+     * assertInstanceOf(handler, FileHandler);
+     * ```
+     */
+    handle(logRecord: LogRecord): void;
+    /**
+     * Logs a message by adding it to the buffer, with flushing as needed.
+     *
+     * @param msg The message to log.
+     *
+     * @example Usage
+     * ```ts
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./_tmp/logs.txt" });
+     * handler.setup();
+     * handler.log('Hello, world!');
+     * handler.flush();
+     * handler.destroy();
+     *
+     * assertInstanceOf(handler, FileHandler);
+     * ```
+     */
+    log(msg: string): void;
+    /**
+     * Immediately writes the contents of the buffer to the previously opened file.
+     *
+     * @example Usage
+     * ```ts
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./_tmp/logs.txt" });
+     * handler.setup();
+     * handler.log('Hello, world!');
+     * handler.flush(); // Writes buffered log messages to the file immediately.
+     * handler.destroy();
+     *
+     * assertInstanceOf(handler, FileHandler);
+     * ```
+     */
+    flush(): void;
+    /**
+     * Destroys the handler, performing any cleanup that is required and closes the file handler.
+     *
+     * @example Usage
+     * ```ts
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./_tmp/logs.txt" });
+     * handler.setup();
+     * handler.destroy();
+     *
+     * assertInstanceOf(handler, FileHandler);
+     * ```
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=file_handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/file_handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAC;AAExD,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEzE,OAAO,EACL,SAAS,EACT,aAAa,EACb,cAAc,EACd,UAAU,EACV,UAAU,EACV,iBAAiB,EACjB,aAAa,EACd,MAAM,4BAA4B,CAAC;AAEpC,sFAAsF;AACtF,MAAM,MAAM,OAAO,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAEtC,2CAA2C;AAC3C,MAAM,WAAW,kBAAmB,SAAQ,kBAAkB;IAC5D;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,WAAY,SAAQ,WAAW;;IAC1C;;;OAGG;IACH,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;IAC9C;;;OAGG;IACH,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC;IACxB;;;;OAIG;IACH,CAAC,aAAa,CAAC,SAAK;IACpB;;;;OAIG;IACH,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC;IAC9C;;;;OAIG;IACH,CAAC,aAAa,CAAC,EAAE,WAAW,CAAqB;IAKjD;;;;;OAKG;gBACS,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,kBAAkB;IAe7D;;;;;;;;;;;OAWG;IACM,KAAK;IAUd;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACM,MAAM,CAAC,SAAS,EAAE,SAAS;IASpC;;;;;;;;;;;;;;;;;;OAkBG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM;IAaf;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK;IAgBL;;;;;;;;;;;;;;OAcG;IACM,OAAO;CAMjB"}