windmill-cli 1.475.0 → 1.476.0

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

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

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

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

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

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

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

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

@@ -1,34 +0,0 @@
-import type { LogRecord } from "./logger.js";
-/**
- * JSON log formatter.
- *
- * @example Usage
- * ```ts
- * import { LogRecord } from "@std/log/logger";
- * import { jsonFormatter } from "@std/log/formatters";
- * import { LogLevels } from "@std/log/levels";
- * import { assertEquals } from "@std/assert/equals";
- *
- * const record = new LogRecord({
- *   msg: "Hello, world!",
- *   args: ["foo", "bar"],
- *   level: LogLevels.INFO,
- *   loggerName: "example",
- * });
- * const formatted = jsonFormatter(record);
- *
- * assertEquals(
- *   formatted,
- *   `{"level":"INFO","datetime":${record.datetime.getTime()},"message":"Hello, world!","args":["foo","bar"]}`,
- * );
- * ```
- *
- * @param logRecord Log record to format.
- * @returns JSON string representation of the log record.
- */
-export declare function jsonFormatter(logRecord: LogRecord): string;
-/** Formatters for log records. */
-export declare const formatters: {
-    readonly jsonFormatter: typeof jsonFormatter;
-};
-//# sourceMappingURL=formatters.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/formatters.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAO1D;AAUD,kCAAkC;AAClC,eAAO,MAAM,UAAU;;CAA6B,CAAC"}

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

@@ -1,59 +0,0 @@
-import { Logger } from "./logger.js";
-export type { Logger };
-/**
- * Get a logger instance. If not specified `name`, get the default logger.
- *
- * @param name The name of the logger.
- * @returns The logger instance.
- *
- * @example Usage (without defined name and minimal setup)
- * ```ts
- * import { getLogger } from "@std/log/get-logger";
- * import "@std/log/setup";
- * import { assertEquals } from "@std/assert/equals";
- *
- * const logger = getLogger();
- * const result = logger.info("Hello world!"); // Prints "INFO Hello world!" in blue
- *
- * assertEquals(result, "Hello world!");
- * ```
- *
- * @example Usage (without defined name and custom setup)
- * ```ts
- * import { getLogger } from "@std/log/get-logger";
- * import { ConsoleHandler } from "@std/log/console-handler";
- * import { setup } from "@std/log/setup";
- * import { assertEquals } from "@std/assert/equals";
- *
- * setup({
- *   handlers: {
- *     console: new ConsoleHandler("DEBUG"),
- *   },
- *   loggers: {
- *     default: {
- *       level: "DEBUG",
- *       handlers: ["console"],
- *     },
- *   },
- * });
- *
- * const logger = getLogger();
- *
- * const result = logger.info("Hello world!"); // Prints "INFO Hello world!" in blue
- *
- * assertEquals(result, "Hello world!");
- * ```
- *
- * @example Usage (with defined name)
- * ```ts
- * import { getLogger } from "@std/log/get-logger";
- * import { assertEquals } from "@std/assert/equals";
- *
- * const logger = getLogger("my-logger");
- * const result = logger.info("Hello world!");
- *
- * assertEquals(result, "Hello world!");
- * ```
- */
-export declare function getLogger(name?: string): Logger;
-//# sourceMappingURL=get_logger.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"get_logger.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/get_logger.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAGrC,YAAY,EAAE,MAAM,EAAE,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,SAAS,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAiB/C"}

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"levels.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/levels.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,eAAO,MAAM,SAAS;;;;;;;CAOZ,CAAC;AAEX,gCAAgC;AAChC,MAAM,MAAM,QAAQ,GAAG,OAAO,SAAS,CAAC,SAAS,CAAC,CAAC;AAEnD,qCAAqC;AACrC,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,OAAO,SAAS,EAAE,MAAM,CAAC,CAAC;AAEhE,gCAAgC;AAChC,eAAO,MAAM,aAAa,EAAE,SAAS,EAErB,CAAC;AAWjB;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,CAMxD;AAED,yEAAyE;AACzE,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,CAMvD"}