windmill-cli 1.407.1 → 1.407.2

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

@@ -0,0 +1,447 @@
+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.
+ *
+ * @example Usage
+ * ```ts
+ * import { LogRecord } from "@std/log/logger";
+ * 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",
+ * });
+ *
+ * assertEquals(record.msg, "Hello, world!");
+ * assertEquals(record.args, ["foo", "bar"]);
+ * assertEquals(record.level, LogLevels.INFO);
+ * assertEquals(record.loggerName, "example");
+ * ```
+ */
+export class LogRecord {
+    /**
+     * Constructs a new instance.
+     *
+     * @param options The options to create a new log record.
+     *
+     * @example Usage
+     * ```ts
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     *
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     * ```
+     */
+    constructor(options) {
+        /** The message to log.
+         *
+         * @example Usage
+         * ```ts
+         * import { LogRecord } from "@std/log/logger";
+         * 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",
+         * });
+         *
+         * assertEquals(record.msg, "Hello, world!");
+         * ```
+         */
+        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);
+        /**
+         * The numeric log level of the log record.
+         *
+         * @example Usage
+         * ```ts
+         * import { LogRecord } from "@std/log/logger";
+         * 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",
+         * });
+         *
+         * assertEquals(record.level, LogLevels.INFO);
+         * ```
+         */
+        Object.defineProperty(this, "level", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * The name of the log level of the log record.
+         *
+         * @example Usage
+         * ```ts
+         * import { LogRecord } from "@std/log/logger";
+         * 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",
+         * });
+         *
+         * assertEquals(record.loggerName, "example");
+         * ```
+         */
+        Object.defineProperty(this, "levelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * The name of the logger that created the log record.
+         *
+         * @example Usage
+         * ```ts
+         * import { LogRecord } from "@std/log/logger";
+         * 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",
+         * });
+         *
+         * assertEquals(record.loggerName, "example");
+         * ```
+         */
+        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);
+    }
+    /**
+     * Getter for the arguments to log.
+     *
+     * @example Usage
+     * ```ts
+     * import { LogRecord } from "@std/log/logger";
+     * 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",
+     * });
+     *
+     * assertEquals(record.args, ["foo", "bar"]);
+     * ```
+     *
+     * @returns A copy of the arguments to log.
+     */
+    get args() {
+        return [...__classPrivateFieldGet(this, _LogRecord_args, "f")];
+    }
+    /**
+     * Getter for the date and time the log record was created.
+     *
+     * @example Usage
+     * ```ts
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertAlmostEquals } from "@std/assert/almost-equals";
+     *
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     *
+     * assertAlmostEquals(record.datetime.getTime(), Date.now(), 1);
+     * ```
+     *
+     * @returns The date and time the log record was created.
+     */
+    get datetime() {
+        return new Date(__classPrivateFieldGet(this, _LogRecord_datetime, "f").getTime());
+    }
+}
+_LogRecord_args = new WeakMap(), _LogRecord_datetime = new WeakMap();
+function 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}":${asString(v, true)}`)
+            .join(",")}}`;
+    }
+    return "undefined";
+}
+/**
+ * A logger that can log messages at different levels.
+ *
+ * @example Usage
+ * ```ts
+ * import { Logger } from "@std/log/logger";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * const logger = new Logger("example", "INFO");
+ * const result = logger.info("Hello, world!");
+ *
+ * assertEquals(result, "Hello, world!");
+ * ```
+ */
+export class Logger {
+    /**
+     * Constructs a new instance.
+     *
+     * @param loggerName The name of the logger.
+     * @param levelName The name of the log level.
+     * @param options The options to create a new logger.
+     */
+    constructor(loggerName, levelName, options = {}) {
+        _Logger_instances.add(this);
+        _Logger_level.set(this, void 0);
+        /**
+         * The handlers to use for the logger.
+         *
+         * @example Usage
+         * ```ts
+         * import { Logger } from "@std/log/logger";
+         * import { ConsoleHandler } from "@std/log/console-handler";
+         * import { assertEquals } from "@std/assert/equals";
+         *
+         * const handler = new ConsoleHandler("INFO");
+         * const logger = new Logger("example", "INFO", {
+         *  handlers: [handler],
+         * });
+         *
+         * assertEquals(logger.handlers, [handler]);
+         * ```
+         */
+        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 ?? [];
+    }
+    /**
+     * Getter for the log level.
+     *
+     * @returns The log level.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     * assertEquals(logger.level, LogLevels.INFO);
+     * ```
+     */
+    get level() {
+        return __classPrivateFieldGet(this, _Logger_level, "f");
+    }
+    /**
+     * Setter for the log level.
+     *
+     * @param level The log level to set.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     * logger.level = LogLevels.DEBUG;
+     *
+     * assertEquals(logger.level, LogLevels.DEBUG);
+     * ```
+     */
+    set level(level) {
+        try {
+            __classPrivateFieldSet(this, _Logger_level, getLevelByName(getLevelName(level)), "f");
+        }
+        catch (_) {
+            throw new TypeError(`Invalid log level: ${level}`);
+        }
+    }
+    /**
+     * Getter for the name of the log level.
+     *
+     * @returns The name of the log level.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     * assertEquals(logger.levelName, "INFO");
+     * ```
+     */
+    get levelName() {
+        return getLevelName(__classPrivateFieldGet(this, _Logger_level, "f"));
+    }
+    /**
+     * Setter for the name of the log level.
+     *
+     * @param levelName The name of the log level to set.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     * logger.levelName = "DEBUG";
+     *
+     * assertEquals(logger.level, LogLevels.DEBUG);
+     * ```
+     */
+    set levelName(levelName) {
+        __classPrivateFieldSet(this, _Logger_level, getLevelByName(levelName), "f");
+    }
+    /**
+     * Getter for the name of the logger.
+     *
+     * @returns The name of the logger.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     *
+     * assertEquals(logger.loggerName, "example");
+     * ```
+     */
+    get loggerName() {
+        return __classPrivateFieldGet(this, _Logger_loggerName, "f");
+    }
+    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 = asString(fnResult);
+    }
+    else {
+        logMessage = 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.8 → 0.224.9}/warn.js

@@ -1,6 +1,7 @@
 // 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) {

package/esm/deps.js

@@ -16,10 +16,10 @@ export { ensureDir } from "./deps/jsr.io/@std/fs/1.0.4/mod.js";
 export { SEPARATOR as SEP } from "./deps/jsr.io/@std/path/1.0.6/mod.js";
 export * as path from "./deps/jsr.io/@std/path/1.0.6/mod.js";
 export { encodeHex } from "./deps/jsr.io/@std/encoding/1.0.5/mod.js";
-export { writeAllSync } from "./deps/jsr.io/@std/io/0.224.9/write_all.js";
-export { copy } from "./deps/jsr.io/@std/io/0.224.9/copy.js";
-export { readAll } from "./deps/jsr.io/@std/io/0.224.9/read_all.js";
-export * as log from "./deps/jsr.io/@std/log/0.224.8/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 { stringify as yamlStringify, parse as yamlParse } from "./deps/jsr.io/@std/yaml/1.0.5/mod.js";
 // other
 export * as Diff from "diff";

package/esm/gen/core/OpenAPI.js

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

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.407.1";
+export const VERSION = "1.407.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.407.1",
+  "version": "1.407.2",
   "description": "CLI for Windmill",
   "repository": {
     "type": "git",

package/types/deps/jsr.io/@std/io/{0.224.9 → 0.225.0}/_constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.224.9/_constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,QAAS,CAAC;AACzC,eAAO,MAAM,mBAAmB,QAAY,CAAC"}
+{"version":3,"file":"_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.0/_constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,QAAS,CAAC;AACzC,eAAO,MAAM,mBAAmB,QAAY,CAAC"}

package/types/deps/jsr.io/@std/io/{0.224.9 → 0.225.0}/copy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"copy.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.224.9/copy.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,IAAI,CACxB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE;IACR,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GACA,OAAO,CAAC,MAAM,CAAC,CAUjB"}
+{"version":3,"file":"copy.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.0/copy.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,IAAI,CACxB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE;IACR,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GACA,OAAO,CAAC,MAAM,CAAC,CAUjB"}

package/types/deps/jsr.io/@std/io/{0.224.9 → 0.225.0}/read_all.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read_all.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.224.9/read_all.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAErD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAcjE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAe1D"}
+{"version":3,"file":"read_all.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.0/read_all.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAErD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAcjE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAe1D"}

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

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

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

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

package/types/deps/jsr.io/@std/io/{0.224.9 → 0.225.0}/write_all.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"write_all.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.224.9/write_all.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,iBAK9D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,QAKhE"}
+{"version":3,"file":"write_all.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.0/write_all.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,iBAK9D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,QAKhE"}

package/types/deps/jsr.io/@std/log/{0.224.8 → 0.224.9}/_config.d.ts.map

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