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

package/esm/deps/jsr.io/@std/io/0.225.2/write_all.d.ts

@@ -0,0 +1,51 @@
+import type { Writer, WriterSync } from "./types.js";
+/**
+ * Write all the content of the array buffer (`arr`) to the writer (`w`).
+ *
+ * @example Writing to stdout
+ * ```ts no-assert
+ * import { writeAll } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * await writeAll(Deno.stdout, contentBytes);
+ * ```
+ *
+ * @example Writing to file
+ * ```ts ignore no-assert
+ * import { writeAll } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * using file = await Deno.open('test.file', { write: true });
+ * await writeAll(file, contentBytes);
+ * ```
+ *
+ * @param writer The writer to write to
+ * @param data The data to write
+ */
+export declare function writeAll(writer: Writer, data: Uint8Array): Promise<void>;
+/**
+ * Synchronously write all the content of the array buffer (`arr`) to the
+ * writer (`w`).
+ *
+ * @example "riting to stdout
+ * ```ts no-assert
+ * import { writeAllSync } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * writeAllSync(Deno.stdout, contentBytes);
+ * ```
+ *
+ * @example Writing to file
+ * ```ts ignore no-assert
+ * import { writeAllSync } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * using file = Deno.openSync("test.file", { write: true });
+ * writeAllSync(file, contentBytes);
+ * ```
+ *
+ * @param writer The writer to write to
+ * @param data The data to write
+ */
+export declare function writeAllSync(writer: WriterSync, data: Uint8Array): void;
+//# sourceMappingURL=write_all.d.ts.map

package/esm/deps/jsr.io/@std/io/0.225.2/write_all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write_all.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.2/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/esm/deps/jsr.io/@std/io/0.225.2/write_all.js

@@ -0,0 +1,61 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Write all the content of the array buffer (`arr`) to the writer (`w`).
+ *
+ * @example Writing to stdout
+ * ```ts no-assert
+ * import { writeAll } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * await writeAll(Deno.stdout, contentBytes);
+ * ```
+ *
+ * @example Writing to file
+ * ```ts ignore no-assert
+ * import { writeAll } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * using file = await Deno.open('test.file', { write: true });
+ * await writeAll(file, contentBytes);
+ * ```
+ *
+ * @param writer The writer to write to
+ * @param data The data to write
+ */
+export async function writeAll(writer, data) {
+    let nwritten = 0;
+    while (nwritten < data.length) {
+        nwritten += await writer.write(data.subarray(nwritten));
+    }
+}
+/**
+ * Synchronously write all the content of the array buffer (`arr`) to the
+ * writer (`w`).
+ *
+ * @example "riting to stdout
+ * ```ts no-assert
+ * import { writeAllSync } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * writeAllSync(Deno.stdout, contentBytes);
+ * ```
+ *
+ * @example Writing to file
+ * ```ts ignore no-assert
+ * import { writeAllSync } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * using file = Deno.openSync("test.file", { write: true });
+ * writeAllSync(file, contentBytes);
+ * ```
+ *
+ * @param writer The writer to write to
+ * @param data The data to write
+ */
+export function writeAllSync(writer, data) {
+    let nwritten = 0;
+    while (nwritten < data.length) {
+        nwritten += writer.writeSync(data.subarray(nwritten));
+    }
+}

package/esm/deps/jsr.io/@std/log/0.224.14/_config.d.ts

@@ -0,0 +1,4 @@
+import type { LogConfig } from "./logger.js";
+export declare const DEFAULT_LEVEL = "INFO";
+export declare const DEFAULT_CONFIG: LogConfig;
+//# sourceMappingURL=_config.d.ts.map

package/esm/deps/jsr.io/@std/log/0.224.14/_config.d.ts.map

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

@@ -0,0 +1,14 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+import { ConsoleHandler } from "./console_handler.js";
+export const DEFAULT_LEVEL = "INFO";
+export const DEFAULT_CONFIG = {
+    handlers: {
+        default: new ConsoleHandler(DEFAULT_LEVEL),
+    },
+    loggers: {
+        default: {
+            level: DEFAULT_LEVEL,
+            handlers: ["default"],
+        },
+    },
+};

package/esm/deps/jsr.io/@std/log/0.224.14/_file_handler_symbols.d.ts

@@ -0,0 +1,8 @@
+export declare const fileSymbol: unique symbol;
+export declare const bufSymbol: unique symbol;
+export declare const pointerSymbol: unique symbol;
+export declare const filenameSymbol: unique symbol;
+export declare const modeSymbol: unique symbol;
+export declare const openOptionsSymbol: unique symbol;
+export declare const encoderSymbol: unique symbol;
+//# sourceMappingURL=_file_handler_symbols.d.ts.map

package/esm/deps/jsr.io/@std/log/0.224.14/_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.14/_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/esm/deps/jsr.io/@std/log/0.224.14/_file_handler_symbols.js

@@ -0,0 +1,8 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+export const fileSymbol = Symbol("file");
+export const bufSymbol = Symbol("buf");
+export const pointerSymbol = Symbol("pointer");
+export const filenameSymbol = Symbol("filename");
+export const modeSymbol = Symbol("mode");
+export const openOptionsSymbol = Symbol("openOptions");
+export const encoderSymbol = Symbol("encoder");

package/esm/deps/jsr.io/@std/log/0.224.14/_state.d.ts

@@ -0,0 +1,8 @@
+import type { BaseHandler } from "./base_handler.js";
+import type { Logger } from "./logger.js";
+export declare const state: {
+    handlers: Map<string, BaseHandler>;
+    loggers: Map<string, Logger>;
+    config: import("./logger.js").LogConfig;
+};
+//# sourceMappingURL=_state.d.ts.map

package/esm/deps/jsr.io/@std/log/0.224.14/_state.d.ts.map

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

@@ -0,0 +1,7 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+import { DEFAULT_CONFIG } from "./_config.js";
+export const state = {
+    handlers: new Map(),
+    loggers: new Map(),
+    config: DEFAULT_CONFIG,
+};

package/esm/deps/jsr.io/@std/log/0.224.14/base_handler.d.ts

@@ -0,0 +1,326 @@
+import { type LevelName, type LogLevel } from "./levels.js";
+import type { LogRecord } from "./logger.js";
+export type { LevelName, LogLevel, LogRecord };
+/**
+ * A function type that defines the structure of a formatter function.
+ *
+ * @param logRecord The log record that needs to be formatted.
+ * @returns A string representation of the log record.
+ */
+export type FormatterFunction = (logRecord: LogRecord) => string;
+/** Options for {@linkcode BaseHandler}. */
+export interface BaseHandlerOptions {
+    /** A function that formats log records. */
+    formatter?: FormatterFunction;
+}
+/**
+ * A base class for all log handlers.
+ *
+ * This class is abstract and should not be instantiated directly. Instead, it
+ * should be extended by other classes that implement the `log` method.
+ *
+ * @example Usage
+ * ```ts
+ * import { BaseHandler } from "@std/log/base-handler";
+ * import { assertInstanceOf } from "@std/assert/instance-of";
+ *
+ * class MyHandler extends BaseHandler {
+ *   log(msg: string) {
+ *     console.log(msg);
+ *   }
+ * }
+ *
+ * const handler = new MyHandler("INFO");
+ * assertInstanceOf(handler, BaseHandler);
+ * ```
+ */
+export declare abstract class BaseHandler {
+    #private;
+    /**
+     * The function that formats log records.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * class MyHandler extends BaseHandler {
+     *  log(msg: string) {
+     *   console.log(msg);
+     * }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     * const formatted = handler.formatter(record);
+     * assertEquals(formatted, "INFO Hello, world!");
+     * ```
+     */
+    formatter: FormatterFunction;
+    /**
+     * Constructs a new instance.
+     *
+     * @param levelName The name of the log level to handle.
+     * @param options Options for the handler.
+     */
+    constructor(levelName: LevelName, options?: BaseHandlerOptions);
+    /**
+     * Getter for the log level that this handler will handle.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * assertEquals(handler.level, LogLevels.INFO);
+     * ```
+     *
+     * @returns The log level to handle.
+     */
+    get level(): LogLevel;
+    /**
+     * Setter for the log level that this handler will handle.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * handler.level = LogLevels.DEBUG;
+     * assertEquals(handler.level, LogLevels.DEBUG);
+     * ```
+     *
+     * @param level The log level to handle.
+     */
+    set level(level: LogLevel);
+    /**
+     * Getter for the name of the log level that this handler will handle.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * assertEquals(handler.levelName, "INFO");
+     * ```
+     *
+     * @returns The name of the log level to handle.
+     */
+    get levelName(): LevelName;
+    /**
+     * Setter for the name of the log level that this handler will handle.
+     *
+     * @param levelName The name of the log level to handle.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * handler.levelName = "DEBUG";
+     * assertEquals(handler.levelName, "DEBUG");
+     * ```
+     */
+    set levelName(levelName: LevelName);
+    /**
+     * Handles a log record.
+     *
+     * @param logRecord The log record to handle.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     * handler.handle(record);
+     *
+     * assertInstanceOf(handler, BaseHandler);
+     * ```
+     */
+    handle(logRecord: LogRecord): void;
+    /**
+     * Formats a log record.
+     *
+     * @param logRecord The log record to format.
+     * @returns A string representation of the log record.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     * const formatted = handler.format(record);
+     * assertEquals(formatted, "INFO Hello, world!");
+     * ```
+     */
+    format(logRecord: LogRecord): string;
+    /**
+     * Logs a message.
+     *
+     * This method should be implemented by subclasses to handle the log record.
+     *
+     * @param msg The message to log.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * handler.log("Hello, world!"); // Prints "Hello, world!"
+     *
+     * assertInstanceOf(handler, BaseHandler);
+     * ```
+     */
+    abstract log(msg: string): void;
+    /**
+     * Initializes the handler.
+     *
+     * This method is called when the handler is added to a logger. It can be
+     * used to perform any setup that is required by the handler.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     *
+     *   override setup() {
+     *     console.log("Handler setup!");
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * handler.setup(); // Prints "Handler setup!"
+     *
+     * assertInstanceOf(handler, BaseHandler);
+     * ```
+     */
+    setup(): void;
+    /**
+     * Destroys the handler, performing any cleanup that is required.
+     *
+     * This method is called when the handler is removed from a logger. It can be
+     * used to perform any cleanup that is required by the handler.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     *
+     *   override destroy() {
+     *     console.log("Handler destroyed!");
+     *   }
+     * }
+     *
+     * const handler = new MyHandler("INFO");
+     * handler.destroy(); // Prints "Handler destroyed!"
+     * assertInstanceOf(handler, BaseHandler);
+     * ```
+     */
+    destroy(): void;
+    /**
+     * Automatically disposes of the handler when instantiated with the `using`
+     * keyword by calling the {@linkcode BaseHandler.destroy} method.
+     *
+     * @example Usage
+     * ```ts
+     * import { BaseHandler } from "@std/log/base-handler";
+     * import { LogRecord } from "@std/log/logger";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * class MyHandler extends BaseHandler {
+     *   log(msg: string) {
+     *     console.log(msg);
+     *   }
+     * }
+     *
+     * using handler = new MyHandler("INFO");
+     * assertInstanceOf(handler, BaseHandler);
+     * ```
+     */
+    [Symbol.dispose](): void;
+}
+//# sourceMappingURL=base_handler.d.ts.map

package/esm/deps/jsr.io/@std/log/0.224.14/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.14/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"}