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

package/script/deps/jsr.io/@std/log/0.224.14/file_handler.js

@@ -0,0 +1,294 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 _FileHandler_instances, _FileHandler_unloadCallback, _FileHandler_resetBuffer, _a, _b, _c, _d, _e, _f, _g;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileHandler = void 0;
+// Copyright 2018-2025 the Deno authors. MIT license.
+const dntShim = __importStar(require("../../../../../_dnt.shims.js"));
+const levels_js_1 = require("./levels.js");
+const base_handler_js_1 = require("./base_handler.js");
+const write_all_js_1 = require("../../io/0.225.2/write_all.js");
+const _file_handler_symbols_js_1 = require("./_file_handler_symbols.js");
+/**
+ * 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
+ * ```
+ */
+class FileHandler extends base_handler_js_1.BaseHandler {
+    /**
+     * Constructs a new FileHandler instance.
+     *
+     * @param levelName The level name to log messages at.
+     * @param options Options for the handler.
+     */
+    constructor(levelName, options) {
+        super(levelName, options);
+        _FileHandler_instances.add(this);
+        /** Opened file to append logs to.
+         *
+         * @private
+         */
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Buffer used to write to file.
+         *
+         * @private
+         */
+        Object.defineProperty(this, _b, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Current position for pointer.
+         *
+         * @private
+         */
+        Object.defineProperty(this, _c, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /**
+         * Filename associated with the file being logged.
+         *
+         * @private
+         */
+        Object.defineProperty(this, _d, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Current log mode.
+         *
+         * @private
+         */
+        Object.defineProperty(this, _e, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * File open options.
+         *
+         * @private
+         */
+        Object.defineProperty(this, _f, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Text encoder.
+         *
+         * @private
+         */
+        Object.defineProperty(this, _g, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new TextEncoder()
+        });
+        _FileHandler_unloadCallback.set(this, (() => {
+            this.destroy();
+        }).bind(this));
+        this[_file_handler_symbols_js_1.filenameSymbol] = options.filename;
+        // default to append mode, write only
+        this[_file_handler_symbols_js_1.modeSymbol] = options.mode ?? "a";
+        this[_file_handler_symbols_js_1.openOptionsSymbol] = {
+            createNew: this[_file_handler_symbols_js_1.modeSymbol] === "x",
+            create: this[_file_handler_symbols_js_1.modeSymbol] !== "x",
+            append: this[_file_handler_symbols_js_1.modeSymbol] === "a",
+            truncate: this[_file_handler_symbols_js_1.modeSymbol] !== "a",
+            write: true,
+        };
+        this[_file_handler_symbols_js_1.bufSymbol] = new Uint8Array(options.bufferSize ?? 4096);
+    }
+    /**
+     * 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() {
+        this[_file_handler_symbols_js_1.fileSymbol] = dntShim.Deno.openSync(this[_file_handler_symbols_js_1.filenameSymbol], this[_file_handler_symbols_js_1.openOptionsSymbol]);
+        __classPrivateFieldGet(this, _FileHandler_instances, "m", _FileHandler_resetBuffer).call(this);
+        addEventListener("unload", __classPrivateFieldGet(this, _FileHandler_unloadCallback, "f"));
+    }
+    /**
+     * 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) {
+        super.handle(logRecord);
+        // Immediately flush if log level is higher than ERROR
+        if (logRecord.level > levels_js_1.LogLevels.ERROR) {
+            this.flush();
+        }
+    }
+    /**
+     * 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) {
+        const bytes = this[_file_handler_symbols_js_1.encoderSymbol].encode(msg + "\n");
+        if (bytes.byteLength > this[_file_handler_symbols_js_1.bufSymbol].byteLength - this[_file_handler_symbols_js_1.pointerSymbol]) {
+            this.flush();
+        }
+        if (bytes.byteLength > this[_file_handler_symbols_js_1.bufSymbol].byteLength) {
+            (0, write_all_js_1.writeAllSync)(this[_file_handler_symbols_js_1.fileSymbol], bytes);
+        }
+        else {
+            this[_file_handler_symbols_js_1.bufSymbol].set(bytes, this[_file_handler_symbols_js_1.pointerSymbol]);
+            this[_file_handler_symbols_js_1.pointerSymbol] += bytes.byteLength;
+        }
+    }
+    /**
+     * 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() {
+        if (this[_file_handler_symbols_js_1.pointerSymbol] > 0 && this[_file_handler_symbols_js_1.fileSymbol]) {
+            let written = 0;
+            while (written < this[_file_handler_symbols_js_1.pointerSymbol]) {
+                written += this[_file_handler_symbols_js_1.fileSymbol].writeSync(this[_file_handler_symbols_js_1.bufSymbol].subarray(written, this[_file_handler_symbols_js_1.pointerSymbol]));
+            }
+            __classPrivateFieldGet(this, _FileHandler_instances, "m", _FileHandler_resetBuffer).call(this);
+        }
+    }
+    /**
+     * 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() {
+        this.flush();
+        this[_file_handler_symbols_js_1.fileSymbol]?.close();
+        this[_file_handler_symbols_js_1.fileSymbol] = undefined;
+        removeEventListener("unload", __classPrivateFieldGet(this, _FileHandler_unloadCallback, "f"));
+    }
+}
+exports.FileHandler = FileHandler;
+_FileHandler_unloadCallback = new WeakMap(), _FileHandler_instances = new WeakSet(), _a = _file_handler_symbols_js_1.fileSymbol, _b = _file_handler_symbols_js_1.bufSymbol, _c = _file_handler_symbols_js_1.pointerSymbol, _d = _file_handler_symbols_js_1.filenameSymbol, _e = _file_handler_symbols_js_1.modeSymbol, _f = _file_handler_symbols_js_1.openOptionsSymbol, _g = _file_handler_symbols_js_1.encoderSymbol, _FileHandler_resetBuffer = function _FileHandler_resetBuffer() {
+    this[_file_handler_symbols_js_1.pointerSymbol] = 0;
+};

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

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

@@ -0,0 +1 @@
+{"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/script/deps/jsr.io/@std/log/0.224.14/formatters.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatters = void 0;
+exports.jsonFormatter = jsonFormatter;
+/**
+ * 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.
+ */
+function jsonFormatter(logRecord) {
+    return JSON.stringify({
+        level: logRecord.levelName,
+        datetime: logRecord.datetime.getTime(),
+        message: logRecord.msg,
+        args: flattenArgs(logRecord.args),
+    });
+}
+function flattenArgs(args) {
+    if (args.length === 1) {
+        return args[0];
+    }
+    else if (args.length > 1) {
+        return args;
+    }
+}
+/** Formatters for log records. */
+exports.formatters = { jsonFormatter };

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

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

@@ -0,0 +1 @@
+{"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/script/deps/jsr.io/@std/log/0.224.14/get_logger.js

@@ -0,0 +1,78 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = getLogger;
+const logger_js_1 = require("./logger.js");
+const _state_js_1 = require("./_state.js");
+/**
+ * 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!");
+ * ```
+ */
+function getLogger(name) {
+    if (!name) {
+        const d = _state_js_1.state.loggers.get("default");
+        if (d === undefined) {
+            throw new Error(`"default" logger must be set for getting logger without name`);
+        }
+        return d;
+    }
+    const result = _state_js_1.state.loggers.get(name);
+    if (!result) {
+        const logger = new logger_js_1.Logger(name, "NOTSET", { handlers: [] });
+        _state_js_1.state.loggers.set(name, logger);
+        return logger;
+    }
+    return result;
+}

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

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

@@ -0,0 +1 @@
+{"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/script/deps/jsr.io/@std/log/0.224.14/info.js

@@ -0,0 +1,14 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.info = info;
+const get_logger_js_1 = require("./get_logger.js");
+require("./setup.js");
+function info(msg, ...args) {
+    // Assist TS compiler with pass-through generic type
+    if (msg instanceof Function) {
+        return (0, get_logger_js_1.getLogger)("default").info(msg, ...args);
+    }
+    return (0, get_logger_js_1.getLogger)("default").info(msg, ...args);
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Use this to retrieve the numeric log level by it's associated name.
+ * Defaults to INFO.
+ *
+ * @internal
+ */
+export declare const LogLevels: {
+    readonly NOTSET: 0;
+    readonly DEBUG: 10;
+    readonly INFO: 20;
+    readonly WARN: 30;
+    readonly ERROR: 40;
+    readonly CRITICAL: 50;
+};
+/** Union of valid log levels */
+export type LogLevel = typeof LogLevels[LevelName];
+/** Union of valid log level names */
+export type LevelName = Exclude<keyof typeof LogLevels, number>;
+/** Permitted log level names */
+export declare const LogLevelNames: LevelName[];
+/**
+ * Returns the numeric log level associated with the passed,
+ * stringy log level name.
+ */
+export declare function getLevelByName(name: LevelName): LogLevel;
+/** Returns the stringy log level name provided the numeric log level. */
+export declare function getLevelName(level: LogLevel): LevelName;
+//# sourceMappingURL=levels.d.ts.map

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

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

package/script/deps/jsr.io/@std/log/0.224.14/levels.js

@@ -0,0 +1,50 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevelNames = exports.LogLevels = void 0;
+exports.getLevelByName = getLevelByName;
+exports.getLevelName = getLevelName;
+/**
+ * Use this to retrieve the numeric log level by it's associated name.
+ * Defaults to INFO.
+ *
+ * @internal
+ */
+exports.LogLevels = {
+    NOTSET: 0,
+    DEBUG: 10,
+    INFO: 20,
+    WARN: 30,
+    ERROR: 40,
+    CRITICAL: 50,
+};
+/** Permitted log level names */
+exports.LogLevelNames = Object.keys(exports.LogLevels).filter((key) => isNaN(Number(key)));
+const byLevel = {
+    [exports.LogLevels.NOTSET]: "NOTSET",
+    [exports.LogLevels.DEBUG]: "DEBUG",
+    [exports.LogLevels.INFO]: "INFO",
+    [exports.LogLevels.WARN]: "WARN",
+    [exports.LogLevels.ERROR]: "ERROR",
+    [exports.LogLevels.CRITICAL]: "CRITICAL",
+};
+/**
+ * Returns the numeric log level associated with the passed,
+ * stringy log level name.
+ */
+function getLevelByName(name) {
+    const level = exports.LogLevels[name];
+    if (level !== undefined) {
+        return level;
+    }
+    throw new Error(`Cannot get log level: no level named ${name}`);
+}
+/** Returns the stringy log level name provided the numeric log level. */
+function getLevelName(level) {
+    const levelName = byLevel[level];
+    if (levelName) {
+        return levelName;
+    }
+    throw new Error(`Cannot get log level: no name for level: ${level}`);
+}