windmill-cli 1.423.0 → 1.423.2

package/esm/deps/jsr.io/@std/io/0.225.0/read_all.js

@@ -1,6 +1,6 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
-import { concat } from "../../bytes/1.0.3/concat.js";
+import { concat } from "../../bytes/1.0.4/concat.js";
 import { DEFAULT_CHUNK_SIZE } from "./_constants.js";
 /**
  * Read {@linkcode Reader} `r` until EOF (`null`) and resolve to the content as

package/esm/deps/jsr.io/@std/log/0.224.10/file_handler.js

@@ -0,0 +1,318 @@
+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;
+// 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.0/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 requires `--allow-write` permission on the log file.
+ *
+ * @example Usage
+ * ```ts no-assert ignore
+ * import { FileHandler } from "@std/log/file-handler";
+ *
+ * const handler = new FileHandler("INFO", { filename: "./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 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.
+         * @example Usage
+         * ```ts no-assert ignore
+         * import { FileHandler } from "@std/log/file-handler";
+         *
+         * const handler = new FileHandler("INFO", { filename: "./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
+         * ```
+         * **/
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Buffer used to write to file.
+         * @example Usage
+         * ```ts no-assert ignore
+         * import { FileHandler } from "@std/log/file-handler";
+         *
+         * const handler = new FileHandler("INFO", { filename: "./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
+         * ```
+         * **/
+        Object.defineProperty(this, _b, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Current position for pointer.
+         * @example Usage
+         * ```ts no-assert ignore
+         * import { FileHandler } from "@std/log/file-handler";
+         *
+         * const handler = new FileHandler("INFO", { filename: "./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
+         * ```
+         * **/
+        Object.defineProperty(this, _c, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /** Filename associated with the file being logged.
+         * @example Usage
+         * ```ts no-assert ignore
+         * import { FileHandler } from "@std/log/file-handler";
+         *
+         * const handler = new FileHandler("INFO", { filename: "./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
+         * ```
+         * **/
+        Object.defineProperty(this, _d, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Current log mode.
+         * @example Usage
+         * ```ts no-assert ignore
+         * import { FileHandler } from "@std/log/file-handler";
+         *
+         * const handler = new FileHandler("INFO", { filename: "./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
+         * ```
+         * **/
+        Object.defineProperty(this, _e, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** File open options.
+         * @example Usage
+         * ```ts no-assert ignore
+         * import { FileHandler } from "@std/log/file-handler";
+         *
+         * const handler = new FileHandler("INFO", { filename: "./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
+         * ```
+         * **/
+        Object.defineProperty(this, _f, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Text encoder.
+         * @example Usage
+         * ```ts no-assert ignore
+         * import { FileHandler } from "@std/log/file-handler";
+         *
+         * const handler = new FileHandler("INFO", { filename: "./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
+         * ```
+         * **/
+        Object.defineProperty(this, _g, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new TextEncoder()
+        });
+        _FileHandler_unloadCallback.set(this, (() => {
+            this.destroy();
+        }).bind(this));
+        this[filenameSymbol] = options.filename;
+        // default to append mode, write only
+        this[modeSymbol] = options.mode ?? "a";
+        this[openOptionsSymbol] = {
+            createNew: this[modeSymbol] === "x",
+            create: this[modeSymbol] !== "x",
+            append: this[modeSymbol] === "a",
+            truncate: this[modeSymbol] !== "a",
+            write: true,
+        };
+        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 ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./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 ignore
+     * 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: "./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 > 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 ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./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]) {
+            this.flush();
+        }
+        if (bytes.byteLength > this[bufSymbol].byteLength) {
+            writeAllSync(this[fileSymbol], bytes);
+        }
+        else {
+            this[bufSymbol].set(bytes, this[pointerSymbol]);
+            this[pointerSymbol] += bytes.byteLength;
+        }
+    }
+    /**
+     * Immediately writes the contents of the buffer to the previously opened file.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./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;
+            while (written < this[pointerSymbol]) {
+                written += this[fileSymbol].writeSync(this[bufSymbol].subarray(written, this[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 ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+     * handler.setup();
+     * handler.destroy();
+     *
+     * assertInstanceOf(handler, FileHandler);
+     * ```
+     */
+    destroy() {
+        this.flush();
+        this[fileSymbol]?.close();
+        this[fileSymbol] = undefined;
+        removeEventListener("unload", __classPrivateFieldGet(this, _FileHandler_unloadCallback, "f"));
+    }
+}
+_FileHandler_unloadCallback = new WeakMap(), _FileHandler_instances = new WeakSet(), _a = fileSymbol, _b = bufSymbol, _c = pointerSymbol, _d = filenameSymbol, _e = modeSymbol, _f = openOptionsSymbol, _g = encoderSymbol, _FileHandler_resetBuffer = function _FileHandler_resetBuffer() {
+    this[pointerSymbol] = 0;
+};

package/esm/deps/jsr.io/@std/log/{0.224.9 → 0.224.10}/logger.js

@@ -13,14 +13,92 @@ var _LogRecord_args, _LogRecord_datetime, _Logger_instances, _Logger_level, _Log
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { getLevelByName, getLevelName, LogLevels } from "./levels.js";
+/**
+ * Configuration options for a logger instance.
+ *
+ * @example Usage
+ *
+ * ```ts
+ * import { ConsoleHandler, getLogger, setup, type LogConfig} from "@std/log";
+ * import { assert } from "@std/assert";
+ *
+ * const handler = new ConsoleHandler("INFO");
+ * const logConfig: LogConfig = {
+ *     handlers: {
+ *         default: handler,
+ *     },
+ *     loggers: {
+ *         default: {
+ *             level: "INFO",
+ *             handlers: ["default"],
+ *         },
+ *     },
+ * }
+ * setup(logConfig);
+ * const logger = getLogger();
+ *
+ * assert(logger.handlers.at(0) instanceof ConsoleHandler);
+ * ```
+ */
 export class LoggerConfig {
     constructor() {
+        /** The minimum log level for the logger.
+         *
+         * @example Usage
+         *
+         * ```ts
+         * import { ConsoleHandler, getLogger, setup, type LogConfig} from "@std/log";
+         * import { assert } from "@std/assert";
+         *
+         * const handler = new ConsoleHandler("INFO");
+         * const logConfig: LogConfig = {
+         *     handlers: {
+         *         default: handler,
+         *     },
+         *     loggers: {
+         *         default: {
+         *             level: "INFO",
+         *             handlers: ["default"],
+         *         },
+         *     },
+         * }
+         * setup(logConfig);
+         * const logger = getLogger();
+         *
+         * assert(logger.handlers.at(0) instanceof ConsoleHandler);
+         * ```
+         */
         Object.defineProperty(this, "level", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /** A list of handler names attached to this logger.
+         *
+         * @example Usage
+         *
+         * ```ts
+         * import { ConsoleHandler, getLogger, setup, type LogConfig} from "@std/log";
+         * import { assert } from "@std/assert";
+         *
+         * const handler = new ConsoleHandler("INFO");
+         * const logConfig: LogConfig = {
+         *     handlers: {
+         *         default: handler,
+         *     },
+         *     loggers: {
+         *         default: {
+         *             level: "INFO",
+         *             handlers: ["default"],
+         *         },
+         *     },
+         * }
+         * setup(logConfig);
+         * const logger = getLogger();
+         *
+         * assert(logger.handlers.at(0) instanceof ConsoleHandler);
+         * ``` */
         Object.defineProperty(this, "handlers", {
             enumerable: true,
             configurable: true,

package/esm/deps.js

@@ -19,7 +19,7 @@ export { encodeHex } from "./deps/jsr.io/@std/encoding/1.0.5/mod.js";
 export { writeAllSync } from "./deps/jsr.io/@std/io/0.225.0/write_all.js";
 export { copy } from "./deps/jsr.io/@std/io/0.225.0/copy.js";
 export { readAll } from "./deps/jsr.io/@std/io/0.225.0/read_all.js";
-export * as log from "./deps/jsr.io/@std/log/0.224.9/mod.js";
+export * as log from "./deps/jsr.io/@std/log/0.224.10/mod.js";
 export { stringify as yamlStringify } from "./deps/jsr.io/@std/yaml/1.0.5/mod.js";
 import { parse as yamlParse } from "./deps/jsr.io/@std/yaml/1.0.5/mod.js";
 export async function yamlParseFile(path, options = {}) {

package/esm/gen/core/OpenAPI.js

@@ -32,7 +32,7 @@ export const OpenAPI = {
     PASSWORD: undefined,
     TOKEN: getEnv("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: '1.423.0',
+    VERSION: '1.423.2',
     WITH_CREDENTIALS: true,
     interceptors: {
         request: new Interceptors(),

package/esm/gen/services.gen.js

@@ -139,7 +139,7 @@ export const logout = () => {
 export const getUser = (data) => {
     return __request(OpenAPI, {
         method: 'GET',
-        url: '/w/{workspace}/users/{username}',
+        url: '/w/{workspace}/users/get/{username}',
         path: {
             workspace: data.workspace,
             username: data.username

package/esm/main.js

@@ -33,7 +33,7 @@ export { flow, app, script, workspace, resource, user, variable, hub, folder, sc
 //     console.error(JSON.stringify(event.error, null, 4));
 //   }
 // });
-export const VERSION = "1.423.0";
+export const VERSION = "1.423.2";
 const command = new Command()
     .name("wmill")
     .action(() => log.info(`Welcome to Windmill CLI ${VERSION}. Use -h for help.`))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windmill-cli",
-  "version": "1.423.0",
+  "version": "1.423.2",
   "description": "CLI for Windmill",
   "repository": {
     "type": "git",

package/types/deps/jsr.io/@std/bytes/{1.0.3 → 1.0.4}/concat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.3/concat.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,UAAU,CAaxD"}
+{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.4/concat.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,UAAU,CAaxD"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"_config.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/_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.10/_file_handler_symbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_file_handler_symbols.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/_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.10/_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_state.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/_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.10/base_handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/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.10/console_handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/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.10/critical.d.ts.map

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/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.10/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/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"}