windmill-cli 1.475.0 → 1.476.0

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

@@ -0,0 +1,58 @@
+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-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { LogLevels } from "./levels.js";
+import { blue, bold, red, yellow } from "../../fmt/1.0.2/colors.js";
+import { BaseHandler } from "./base_handler.js";
+/**
+ * This is the default logger. It will output color coded log messages to the
+ * console via `console.log()`.
+ */
+export class ConsoleHandler extends BaseHandler {
+    constructor(levelName, options = {}) {
+        super(levelName, options);
+        _ConsoleHandler_useColors.set(this, void 0);
+        __classPrivateFieldSet(this, _ConsoleHandler_useColors, options.useColors ?? true, "f");
+    }
+    format(logRecord) {
+        let msg = super.format(logRecord);
+        if (__classPrivateFieldGet(this, _ConsoleHandler_useColors, "f")) {
+            msg = this.applyColors(msg, logRecord.level);
+        }
+        return msg;
+    }
+    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;
+    }
+    log(msg) {
+        console.log(msg);
+    }
+}
+_ConsoleHandler_useColors = new WeakMap();

package/esm/deps/jsr.io/@std/log/{0.224.14 → 0.224.7}/critical.js

@@ -1,7 +1,6 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. 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) {

package/esm/deps/jsr.io/@std/log/{0.224.14 → 0.224.7}/debug.js

@@ -1,7 +1,6 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. 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) {

package/esm/deps/jsr.io/@std/log/{0.224.14 → 0.224.7}/error.js

@@ -1,7 +1,6 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. 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) {

package/esm/deps/jsr.io/@std/log/{0.224.14 → 0.224.7}/file_handler.js

@@ -4,110 +4,70 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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;
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 import * as dntShim from "../../../../../_dnt.shims.js";
 import { LogLevels } from "./levels.js";
 import { BaseHandler } from "./base_handler.js";
-import { writeAllSync } from "../../io/0.225.2/write_all.js";
+import { writeAllSync } from "../../io/0.224.8/write_all.js";
 import { bufSymbol, encoderSymbol, filenameSymbol, fileSymbol, modeSymbol, openOptionsSymbol, pointerSymbol, } from "./_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 will output to a file using an optional mode (default is `a`,
+ * e.g. append). The file will grow indefinitely. It uses a buffer for writing
+ * to file. Logs can be manually flushed with `fileHandler.flush()`. Log
+ * messages with a log level greater than error are immediately flushed. Logs
+ * are also flushed on process completion.
  *
- * This handler requires `--allow-write` permission on the log file.
+ * Behavior of the log modes is as follows:
  *
- * @example Usage
- * ```ts no-assert
- * import { FileHandler } from "@std/log/file-handler";
+ * - `'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.
  *
- * 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
- * ```
+ * This handler requires `--allow-write` permission on the log file.
  */
 export class FileHandler extends 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,
@@ -129,52 +89,11 @@ export class FileHandler extends BaseHandler {
         };
         this[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[fileSymbol] = dntShim.Deno.openSync(this[filenameSymbol], this[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
@@ -182,25 +101,6 @@ export class FileHandler extends BaseHandler {
             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[encoderSymbol].encode(msg + "\n");
         if (bytes.byteLength > this[bufSymbol].byteLength - this[pointerSymbol]) {
@@ -214,23 +114,6 @@ export class FileHandler extends BaseHandler {
             this[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[pointerSymbol] > 0 && this[fileSymbol]) {
             let written = 0;
@@ -240,21 +123,6 @@ export class FileHandler extends BaseHandler {
             __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[fileSymbol]?.close();

package/esm/deps/jsr.io/@std/log/0.224.7/formatters.js

@@ -0,0 +1,19 @@
+export 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;
+    }
+}
+export const formatters = {
+    jsonFormatter,
+};

package/esm/deps/jsr.io/@std/log/0.224.7/get_logger.js

@@ -0,0 +1,21 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { Logger } from "./logger.js";
+import { state } from "./_state.js";
+/** Get a logger instance. If not specified `name`, get the default logger. */
+export function getLogger(name) {
+    if (!name) {
+        const d = 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.loggers.get(name);
+    if (!result) {
+        const logger = new Logger(name, "NOTSET", { handlers: [] });
+        state.loggers.set(name, logger);
+        return logger;
+    }
+    return result;
+}

package/esm/deps/jsr.io/@std/log/{0.224.14 → 0.224.7}/info.js

@@ -1,7 +1,6 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { getLogger } from "./get_logger.js";
-import "./setup.js";
 export function info(msg, ...args) {
     // Assist TS compiler with pass-through generic type
     if (msg instanceof Function) {

package/esm/deps/jsr.io/@std/log/{0.224.14 → 0.224.7}/levels.js

@@ -1,10 +1,8 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 /**
  * Use this to retrieve the numeric log level by it's associated name.
  * Defaults to INFO.
- *
- * @internal
  */
 export const LogLevels = {
     NOTSET: 0,

package/esm/deps/jsr.io/@std/log/0.224.7/logger.js

@@ -0,0 +1,179 @@
+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 _LogRecord_args, _LogRecord_datetime, _Logger_instances, _Logger_level, _Logger_loggerName, _Logger_log;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { getLevelByName, getLevelName, LogLevels } from "./levels.js";
+export class LoggerConfig {
+    constructor() {
+        Object.defineProperty(this, "level", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "handlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+}
+/**
+ * An object that encapsulates provided message and arguments as well some
+ * metadata that can be later used when formatting a message.
+ */
+export class LogRecord {
+    constructor(options) {
+        Object.defineProperty(this, "msg", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _LogRecord_args.set(this, void 0);
+        _LogRecord_datetime.set(this, void 0);
+        Object.defineProperty(this, "level", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "levelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "loggerName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.msg = options.msg;
+        __classPrivateFieldSet(this, _LogRecord_args, [...options.args], "f");
+        this.level = options.level;
+        this.loggerName = options.loggerName;
+        __classPrivateFieldSet(this, _LogRecord_datetime, new Date(), "f");
+        this.levelName = getLevelName(options.level);
+    }
+    get args() {
+        return [...__classPrivateFieldGet(this, _LogRecord_args, "f")];
+    }
+    get datetime() {
+        return new Date(__classPrivateFieldGet(this, _LogRecord_datetime, "f").getTime());
+    }
+}
+_LogRecord_args = new WeakMap(), _LogRecord_datetime = new WeakMap();
+export class Logger {
+    constructor(loggerName, levelName, options = {}) {
+        _Logger_instances.add(this);
+        _Logger_level.set(this, void 0);
+        Object.defineProperty(this, "handlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _Logger_loggerName.set(this, void 0);
+        __classPrivateFieldSet(this, _Logger_loggerName, loggerName, "f");
+        __classPrivateFieldSet(this, _Logger_level, getLevelByName(levelName), "f");
+        this.handlers = options.handlers ?? [];
+    }
+    /** Use this to retrieve the current numeric log level. */
+    get level() {
+        return __classPrivateFieldGet(this, _Logger_level, "f");
+    }
+    /** Use this to set the numeric log level. */
+    set level(level) {
+        try {
+            __classPrivateFieldSet(this, _Logger_level, getLevelByName(getLevelName(level)), "f");
+        }
+        catch (_) {
+            throw new TypeError(`Invalid log level: ${level}`);
+        }
+    }
+    get levelName() {
+        return getLevelName(__classPrivateFieldGet(this, _Logger_level, "f"));
+    }
+    set levelName(levelName) {
+        __classPrivateFieldSet(this, _Logger_level, getLevelByName(levelName), "f");
+    }
+    get loggerName() {
+        return __classPrivateFieldGet(this, _Logger_loggerName, "f");
+    }
+    asString(data, isProperty = false) {
+        if (typeof data === "string") {
+            if (isProperty)
+                return `"${data}"`;
+            return data;
+        }
+        else if (data === null ||
+            typeof data === "number" ||
+            typeof data === "bigint" ||
+            typeof data === "boolean" ||
+            typeof data === "undefined" ||
+            typeof data === "symbol") {
+            return String(data);
+        }
+        else if (data instanceof Error) {
+            return data.stack;
+        }
+        else if (typeof data === "object") {
+            return `{${Object.entries(data)
+                .map(([k, v]) => `"${k}":${this.asString(v, true)}`)
+                .join(",")}}`;
+        }
+        return "undefined";
+    }
+    debug(msg, ...args) {
+        return __classPrivateFieldGet(this, _Logger_instances, "m", _Logger_log).call(this, LogLevels.DEBUG, msg, ...args);
+    }
+    info(msg, ...args) {
+        return __classPrivateFieldGet(this, _Logger_instances, "m", _Logger_log).call(this, LogLevels.INFO, msg, ...args);
+    }
+    warn(msg, ...args) {
+        return __classPrivateFieldGet(this, _Logger_instances, "m", _Logger_log).call(this, LogLevels.WARN, msg, ...args);
+    }
+    error(msg, ...args) {
+        return __classPrivateFieldGet(this, _Logger_instances, "m", _Logger_log).call(this, LogLevels.ERROR, msg, ...args);
+    }
+    critical(msg, ...args) {
+        return __classPrivateFieldGet(this, _Logger_instances, "m", _Logger_log).call(this, LogLevels.CRITICAL, msg, ...args);
+    }
+}
+_Logger_level = new WeakMap(), _Logger_loggerName = new WeakMap(), _Logger_instances = new WeakSet(), _Logger_log = function _Logger_log(level, msg, ...args) {
+    if (this.level > level) {
+        return msg instanceof Function ? undefined : msg;
+    }
+    let fnResult;
+    let logMessage;
+    if (msg instanceof Function) {
+        fnResult = msg();
+        logMessage = this.asString(fnResult);
+    }
+    else {
+        logMessage = this.asString(msg);
+    }
+    const record = new LogRecord({
+        msg: logMessage,
+        args: args,
+        level: level,
+        loggerName: this.loggerName,
+    });
+    this.handlers.forEach((handler) => {
+        handler.handle(record);
+    });
+    return msg instanceof Function ? fnResult : msg;
+};

package/esm/deps/jsr.io/@std/log/{0.224.14 → 0.224.7}/mod.js

@@ -1,12 +1,8 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 /**
- * Logging library with support for terminal and file outputs. Also provides
+ * Logging library with the support for terminal and file outputs. Also provides
  * interfaces for building custom loggers.
  *
- * > [!IMPORTANT]
- * > @std/log is [likely to be removed in the future](https://github.com/denoland/std/issues/6124).
- * > Consider using [Open Telemetry](https://docs.deno.com/runtime/fundamentals/open_telemetry/).
- *
  * ## Loggers
  *
  * Loggers are objects that you interact with. When you use a logger method it
@@ -28,7 +24,7 @@
  * `log.formatters.jsonFormatter` or write your own function that takes a
  * {@linkcode LogRecord} and returns a JSON.stringify'd object.
  * If you want the log to go to stdout then use {@linkcode ConsoleHandler} with
- * the configuration `useColors: false` to turn off the ANSI terminal colors.
+ * the configuration `useColors: false` to turn off the ANSI terminal colours.
  *
  * ```ts
  * import * as log from "@std/log";
@@ -85,12 +81,12 @@
  *   return getLogger("my-awesome-module");
  * }
  *
- * function sum(a: number, b: number) {
+ * export function sum(a: number, b: number) {
  *   logger().debug(`running ${a} + ${b}`);
  *   return a + b;
  * }
  *
- * function mult(a: number, b: number) {
+ * export function mult(a: number, b: number) {
  *   logger().debug(`running ${a} * ${b}`);
  *   return a * b;
  * }
@@ -126,14 +122,14 @@
  *
  * const logger = getLogger("my-awesome-module");
  *
- * function sum(a: number, b: number) {
+ * export function sum(a: number, b: number) {
  *   logger.debug(`running ${a} + ${b}`); // no message will be logged, because getLogger() was called before log.setup()
  *   return a + b;
  * }
  * ```
  *
  * @example
- * ```ts ignore
+ * ```ts
  * import * as log from "@std/log";
  *
  * // Simple default logger out of the box. You can customize it

package/esm/deps/jsr.io/@std/log/{0.224.14 → 0.224.7}/rotating_file_handler.js

@@ -10,9 +10,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _RotatingFileHandler_maxBytes, _RotatingFileHandler_maxBackupCount, _RotatingFileHandler_currentFileSize;
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 import * as dntShim from "../../../../../_dnt.shims.js";
-import { existsSync } from "../../fs/1.0.14/exists.js";
+import { existsSync } from "../../fs/1.0.3/exists.js";
 import { FileHandler } from "./file_handler.js";
 import { encoderSymbol, filenameSymbol, fileSymbol, modeSymbol, openOptionsSymbol, } from "./_file_handler_symbols.js";
 /**

package/esm/deps/jsr.io/@std/log/{0.224.14 → 0.224.7}/setup.js

@@ -1,4 +1,4 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { DEFAULT_CONFIG, DEFAULT_LEVEL } from "./_config.js";
 import { Logger } from "./logger.js";

package/esm/deps/jsr.io/@std/log/{0.224.14 → 0.224.7}/warn.js

@@ -1,7 +1,6 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { getLogger } from "./get_logger.js";
-import "./setup.js";
 export function warn(msg, ...args) {
     // Assist TS compiler with pass-through generic type
     if (msg instanceof Function) {