windmill-cli 1.475.0 → 1.476.0

package/types/deps/jsr.io/@std/io/0.225.2/types.d.ts

@@ -1,146 +0,0 @@
-/**
- * An abstract interface which when implemented provides an interface to read
- * bytes into an array buffer asynchronously.
- */
-export interface Reader {
-    /** Reads up to `p.byteLength` bytes into `p`. It resolves to the number of
-     * bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
-     * encountered. Even if `read()` resolves to `n` < `p.byteLength`, it may
-     * use all of `p` as scratch space during the call. If some data is
-     * available but not `p.byteLength` bytes, `read()` conventionally resolves
-     * to what is available instead of waiting for more.
-     *
-     * When `read()` encounters end-of-file condition, it resolves to EOF
-     * (`null`).
-     *
-     * When `read()` encounters an error, it rejects with an error.
-     *
-     * Callers should always process the `n` > `0` bytes returned before
-     * considering the EOF (`null`). Doing so correctly handles I/O errors that
-     * happen after reading some bytes and also both of the allowed EOF
-     * behaviors.
-     *
-     * Implementations should not retain a reference to `p`.
-     *
-     * Use
-     * {@linkcode @std/io/to-iterator.ts?s=toIterator}
-     * to turn a {@linkcode Reader} into an {@linkcode AsyncIterableIterator}.
-     */
-    read(p: Uint8Array): Promise<number | null>;
-}
-/**
- * An abstract interface which when implemented provides an interface to read
- * bytes into an array buffer synchronously.
- */
-export interface ReaderSync {
-    /** Reads up to `p.byteLength` bytes into `p`. It resolves to the number
-     * of bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
-     * encountered. Even if `read()` returns `n` < `p.byteLength`, it may use
-     * all of `p` as scratch space during the call. If some data is available
-     * but not `p.byteLength` bytes, `read()` conventionally returns what is
-     * available instead of waiting for more.
-     *
-     * When `readSync()` encounters end-of-file condition, it returns EOF
-     * (`null`).
-     *
-     * When `readSync()` encounters an error, it throws with an error.
-     *
-     * Callers should always process the `n` > `0` bytes returned before
-     * considering the EOF (`null`). Doing so correctly handles I/O errors that happen
-     * after reading some bytes and also both of the allowed EOF behaviors.
-     *
-     * Implementations should not retain a reference to `p`.
-     *
-     * Use
-     * {@linkcode @std/io/to-iterator.ts?s=toIteratorSync}
-     * to turn a {@linkcode ReaderSync} into an {@linkcode IterableIterator}.
-     */
-    readSync(p: Uint8Array): number | null;
-}
-/**
- * An abstract interface which when implemented provides an interface to write
- * bytes from an array buffer to a file/resource asynchronously.
- */
-export interface Writer {
-    /** Writes `p.byteLength` bytes from `p` to the underlying data stream. It
-     * resolves to the number of bytes written from `p` (`0` <= `n` <=
-     * `p.byteLength`) or reject with the error encountered that caused the
-     * write to stop early. `write()` must reject with a non-null error if
-     * would resolve to `n` < `p.byteLength`. `write()` must not modify the
-     * slice data, even temporarily.
-     *
-     * Implementations should not retain a reference to `p`.
-     */
-    write(p: Uint8Array): Promise<number>;
-}
-/**
- * An abstract interface which when implemented provides an interface to write
- * bytes from an array buffer to a file/resource synchronously.
- */
-export interface WriterSync {
-    /** Writes `p.byteLength` bytes from `p` to the underlying data
-     * stream. It returns the number of bytes written from `p` (`0` <= `n`
-     * <= `p.byteLength`) and any error encountered that caused the write to
-     * stop early. `writeSync()` must throw a non-null error if it returns `n` <
-     * `p.byteLength`. `writeSync()` must not modify the slice data, even
-     * temporarily.
-     *
-     * Implementations should not retain a reference to `p`.
-     */
-    writeSync(p: Uint8Array): number;
-}
-/**
- * An abstract interface which when implemented provides an interface to close
- * files/resources that were previously opened.
- */
-export interface Closer {
-    /** Closes the resource, "freeing" the backing file/resource. */
-    close(): void;
-}
-/**
- * A enum which defines the seek mode for IO related APIs that support
- * seeking.
- */
-export declare enum SeekMode {
-    Start = 0,
-    Current = 1,
-    End = 2
-}
-/**
- * An abstract interface which when implemented provides an interface to seek
- * within an open file/resource asynchronously.
- */
-export interface Seeker {
-    /** Seek sets the offset for the next `read()` or `write()` to offset,
-     * interpreted according to `whence`: `Start` means relative to the
-     * start of the file, `Current` means relative to the current offset,
-     * and `End` means relative to the end. Seek resolves to the new offset
-     * relative to the start of the file.
-     *
-     * Seeking to an offset before the start of the file is an error. Seeking to
-     * any positive offset is legal, but the behavior of subsequent I/O
-     * operations on the underlying object is implementation-dependent.
-     *
-     * It resolves with the updated offset.
-     */
-    seek(offset: number | bigint, whence: SeekMode): Promise<number>;
-}
-/**
- * An abstract interface which when implemented provides an interface to seek
- * within an open file/resource synchronously.
- */
-export interface SeekerSync {
-    /** Seek sets the offset for the next `readSync()` or `writeSync()` to
-     * offset, interpreted according to `whence`: `Start` means relative
-     * to the start of the file, `Current` means relative to the current
-     * offset, and `End` means relative to the end.
-     *
-     * Seeking to an offset before the start of the file is an error. Seeking to
-     * any positive offset is legal, but the behavior of subsequent I/O
-     * operations on the underlying object is implementation-dependent.
-     *
-     * It returns the updated offset.
-     */
-    seekSync(offset: number | bigint, whence: SeekMode): number;
-}
-//# sourceMappingURL=types.d.ts.map

package/types/deps/jsr.io/@std/io/0.225.2/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.2/types.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,IAAI,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC7C;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAAC;CACxC;AAED;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;;;;OAQG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACvC;AACD;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;OAQG;IACH,SAAS,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,gEAAgE;IAChE,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;GAGG;AACH,oBAAY,QAAQ;IAElB,KAAK,IAAI;IAET,OAAO,IAAI;IAEX,GAAG,IAAI;CACR;AAED;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAClE;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAC;CAC7D"}

package/types/deps/jsr.io/@std/log/0.224.14/_config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_config.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/_config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,eAAO,MAAM,aAAa,SAAS,CAAC;AAEpC,eAAO,MAAM,cAAc,EAAE,SAW5B,CAAC"}

package/types/deps/jsr.io/@std/log/0.224.14/_file_handler_symbols.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_file_handler_symbols.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/_file_handler_symbols.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,UAAU,eAAiB,CAAC;AACzC,eAAO,MAAM,SAAS,eAAgB,CAAC;AACvC,eAAO,MAAM,aAAa,eAAoB,CAAC;AAC/C,eAAO,MAAM,cAAc,eAAqB,CAAC;AACjD,eAAO,MAAM,UAAU,eAAiB,CAAC;AACzC,eAAO,MAAM,iBAAiB,eAAwB,CAAC;AACvD,eAAO,MAAM,aAAa,eAAoB,CAAC"}

package/types/deps/jsr.io/@std/log/0.224.14/_state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_state.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/_state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,eAAO,MAAM,KAAK;;;;CAIjB,CAAC"}

package/types/deps/jsr.io/@std/log/0.224.14/base_handler.d.ts

@@ -1,326 +0,0 @@
-import { type LevelName, type LogLevel } from "./levels.js";
-import type { LogRecord } from "./logger.js";
-export type { LevelName, LogLevel, LogRecord };
-/**
- * A function type that defines the structure of a formatter function.
- *
- * @param logRecord The log record that needs to be formatted.
- * @returns A string representation of the log record.
- */
-export type FormatterFunction = (logRecord: LogRecord) => string;
-/** Options for {@linkcode BaseHandler}. */
-export interface BaseHandlerOptions {
-    /** A function that formats log records. */
-    formatter?: FormatterFunction;
-}
-/**
- * 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 declare abstract class BaseHandler {
-    #private;
-    /**
-     * 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!");
-     * ```
-     */
-    formatter: FormatterFunction;
-    /**
-     * Constructs a new instance.
-     *
-     * @param levelName The name of the log level to handle.
-     * @param options Options for the handler.
-     */
-    constructor(levelName: LevelName, options?: BaseHandlerOptions);
-    /**
-     * 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(): LogLevel;
-    /**
-     * 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: LogLevel);
-    /**
-     * 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(): LevelName;
-    /**
-     * 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: LevelName);
-    /**
-     * 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: LogRecord): void;
-    /**
-     * 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: LogRecord): string;
-    /**
-     * Logs a message.
-     *
-     * This method should be implemented by subclasses to handle the log record.
-     *
-     * @param msg The message to log.
-     *
-     * @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");
-     * handler.log("Hello, world!"); // Prints "Hello, world!"
-     *
-     * assertInstanceOf(handler, BaseHandler);
-     * ```
-     */
-    abstract log(msg: string): void;
-    /**
-     * 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(): void;
-    /**
-     * 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(): void;
-    /**
-     * 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);
-     * ```
-     */
-    [Symbol.dispose](): void;
-}
-//# sourceMappingURL=base_handler.d.ts.map

package/types/deps/jsr.io/@std/log/0.224.14/base_handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/base_handler.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,QAAQ,EACd,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,SAAS,EAAE,SAAS,KAAK,MAAM,CAAC;AAIjE,2CAA2C;AAC3C,MAAM,WAAW,kBAAkB;IACjC,2CAA2C;IAC3C,SAAS,CAAC,EAAE,iBAAiB,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,8BAAsB,WAAW;;IAG/B;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,SAAS,EAAE,iBAAiB,CAAC;IAE7B;;;;;OAKG;gBAED,SAAS,EAAE,SAAS,EACpB,OAAO,CAAC,EAAE,kBAAkB;IAQ9B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,KAAK,IAAI,QAAQ,CAEpB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,IAAI,KAAK,CAAC,KAAK,EAAE,QAAQ,EAGxB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,IAAI,SAAS,IAAI,SAAS,CAEzB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,SAAS,CAAC,SAAS,EAAE,SAAS,EAGjC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,MAAM,CAAC,SAAS,EAAE,SAAS;IAO3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM;IAIpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,KAAK;IAEL;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO;IAEP;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC;CAGjB"}

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

@@ -1,76 +0,0 @@
-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/types/deps/jsr.io/@std/log/0.224.14/console_handler.d.ts.map

@@ -1 +0,0 @@
-{"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/types/deps/jsr.io/@std/log/0.224.14/critical.d.ts

@@ -1,53 +0,0 @@
-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/types/deps/jsr.io/@std/log/0.224.14/critical.d.ts.map

@@ -1 +0,0 @@
-{"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"}