@skmtc/core 0.0.983 → 0.16.1

package/esm/deps/jsr.io/@std/fs/1.0.23/exists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.23/exists.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,OAAO,CAAC,CAsClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAqCT"}

package/esm/deps/jsr.io/@std/fs/1.0.23/exists.js

@@ -0,0 +1,271 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+/** Options for {@linkcode exists} and {@linkcode existsSync.} */
+import * as dntShim from "../../../../../_dnt.shims.js";
+/**
+ * Asynchronously test whether or not the given path exists by checking with
+ * the file system.
+ *
+ * Note: Do not use this function if performing a check before another operation
+ * on that file. Doing so creates a race condition. Instead, perform the actual
+ * file operation directly. This function is not recommended for this use case.
+ * See the recommended method below.
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use} for
+ * more information on the time-of-check to time-of-use bug.
+ *
+ * Requires `--allow-read` permissions, and in some cases, `--allow-sys`
+ * permissions if `options.isReadable` is `true`.
+ *
+ * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
+ * for more information on Deno's permissions system.
+ *
+ * @param path The path to the file or directory, as a string or URL.
+ * @param options Additional options for the check.
+ *
+ * @returns A promise that resolves with `true` if the path exists, `false`
+ * otherwise.
+ *
+ * @example Recommended method
+ * ```ts ignore
+ * // Notice no use of exists
+ * try {
+ *   await Deno.remove("./foo", { recursive: true });
+ * } catch (error) {
+ *   if (!(error instanceof Deno.errors.NotFound)) {
+ *     throw error;
+ *   }
+ *   // Do nothing...
+ * }
+ * ```
+ *
+ * Notice that `exists()` is not used in the above example. Doing so avoids a
+ * possible race condition. See the above note for details.
+ *
+ * @example Basic usage
+ * ```ts ignore
+ * import { exists } from "@std/fs/exists";
+ *
+ * await exists("./exists"); // true
+ * await exists("./does_not_exist"); // false
+ * ```
+ *
+ * @example Check if a path is readable
+ *
+ * Requires `--allow-sys` permissions in some cases.
+ *
+ * ```ts ignore
+ * import { exists } from "@std/fs/exists";
+ *
+ * await exists("./readable", { isReadable: true }); // true
+ * await exists("./not_readable", { isReadable: true }); // false
+ * ```
+ *
+ * @example Check if a path is a directory
+ * ```ts ignore
+ * import { exists } from "@std/fs/exists";
+ *
+ * await exists("./directory", { isDirectory: true }); // true
+ * await exists("./file", { isDirectory: true }); // false
+ * ```
+ *
+ * @example Check if a path is a file
+ * ```ts ignore
+ * import { exists } from "@std/fs/exists";
+ *
+ * await exists("./file", { isFile: true }); // true
+ * await exists("./directory", { isFile: true }); // false
+ * ```
+ *
+ * @example Check if a path is a readable directory
+ *
+ * Requires `--allow-sys` permissions in some cases.
+ *
+ * ```ts ignore
+ * import { exists } from "@std/fs/exists";
+ *
+ * await exists("./readable_directory", { isReadable: true, isDirectory: true }); // true
+ * await exists("./not_readable_directory", { isReadable: true, isDirectory: true }); // false
+ * ```
+ *
+ * @example Check if a path is a readable file
+ *
+ * Requires `--allow-sys` permissions in some cases.
+ *
+ * ```ts ignore
+ * import { exists } from "@std/fs/exists";
+ *
+ * await exists("./readable_file", { isReadable: true, isFile: true }); // true
+ * await exists("./not_readable_file", { isReadable: true, isFile: true }); // false
+ * ```
+ */
+export async function exists(path, options) {
+    try {
+        const stat = await dntShim.Deno.stat(path);
+        if (options &&
+            (options.isReadable || options.isDirectory || options.isFile)) {
+            if (options.isDirectory && options.isFile) {
+                throw new TypeError("ExistsOptions.options.isDirectory and ExistsOptions.options.isFile must not be true together");
+            }
+            if ((options.isDirectory && !stat.isDirectory) ||
+                (options.isFile && !stat.isFile)) {
+                return false;
+            }
+            if (options.isReadable) {
+                return fileIsReadable(stat);
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        if (error instanceof dntShim.Deno.errors.NotFound) {
+            return false;
+        }
+        if (error instanceof dntShim.Deno.errors.PermissionDenied) {
+            if ((await dntShim.Deno.permissions.query({ name: "read", path })).state ===
+                "granted") {
+                // --allow-read not missing
+                return !options?.isReadable; // PermissionDenied was raised by file system, so the item exists, but can't be read
+            }
+        }
+        throw error;
+    }
+}
+/**
+ * Synchronously test whether or not the given path exists by checking with
+ * the file system.
+ *
+ * Note: Do not use this function if performing a check before another operation
+ * on that file. Doing so creates a race condition. Instead, perform the actual
+ * file operation directly. This function is not recommended for this use case.
+ * See the recommended method below.
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use} for
+ * more information on the time-of-check to time-of-use bug.
+ *
+ * Requires `--allow-read` permissions, and in some cases, `--allow-sys`
+ * permissions if `options.isReadable` is `true`.
+ *
+ * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
+ * for more information on Deno's permissions system.
+ *
+ * @param path The path to the file or directory, as a string or URL.
+ * @param options Additional options for the check.
+ *
+ * @returns `true` if the path exists, `false` otherwise.
+ *
+ * @example Recommended method
+ * ```ts ignore
+ * // Notice no use of exists
+ * try {
+ *   Deno.removeSync("./foo", { recursive: true });
+ * } catch (error) {
+ *   if (!(error instanceof Deno.errors.NotFound)) {
+ *     throw error;
+ *   }
+ *   // Do nothing...
+ * }
+ * ```
+ *
+ * Notice that `existsSync()` is not used in the above example. Doing so avoids
+ * a possible race condition. See the above note for details.
+ *
+ * @example Basic usage
+ * ```ts ignore
+ * import { existsSync } from "@std/fs/exists";
+ *
+ * existsSync("./exists"); // true
+ * existsSync("./does_not_exist"); // false
+ * ```
+ *
+ * @example Check if a path is readable
+ *
+ * Requires `--allow-sys` permissions in some cases.
+ *
+ * ```ts ignore
+ * import { existsSync } from "@std/fs/exists";
+ *
+ * existsSync("./readable", { isReadable: true }); // true
+ * existsSync("./not_readable", { isReadable: true }); // false
+ * ```
+ *
+ * @example Check if a path is a directory
+ * ```ts ignore
+ * import { existsSync } from "@std/fs/exists";
+ *
+ * existsSync("./directory", { isDirectory: true }); // true
+ * existsSync("./file", { isDirectory: true }); // false
+ * ```
+ *
+ * @example Check if a path is a file
+ * ```ts ignore
+ * import { existsSync } from "@std/fs/exists";
+ *
+ * existsSync("./file", { isFile: true }); // true
+ * existsSync("./directory", { isFile: true }); // false
+ * ```
+ *
+ * @example Check if a path is a readable directory
+ *
+ * Requires `--allow-sys` permissions in some cases.
+ *
+ * ```ts ignore
+ * import { existsSync } from "@std/fs/exists";
+ *
+ * existsSync("./readable_directory", { isReadable: true, isDirectory: true }); // true
+ * existsSync("./not_readable_directory", { isReadable: true, isDirectory: true }); // false
+ * ```
+ *
+ * @example Check if a path is a readable file
+ *
+ * Requires `--allow-sys` permissions in some cases.
+ *
+ * ```ts ignore
+ * import { existsSync } from "@std/fs/exists";
+ *
+ * existsSync("./readable_file", { isReadable: true, isFile: true }); // true
+ * existsSync("./not_readable_file", { isReadable: true, isFile: true }); // false
+ * ```
+ */
+export function existsSync(path, options) {
+    try {
+        const stat = dntShim.Deno.statSync(path);
+        if (options &&
+            (options.isReadable || options.isDirectory || options.isFile)) {
+            if (options.isDirectory && options.isFile) {
+                throw new TypeError("ExistsOptions.options.isDirectory and ExistsOptions.options.isFile must not be true together");
+            }
+            if ((options.isDirectory && !stat.isDirectory) ||
+                (options.isFile && !stat.isFile)) {
+                return false;
+            }
+            if (options.isReadable) {
+                return fileIsReadable(stat);
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        if (error instanceof dntShim.Deno.errors.NotFound) {
+            return false;
+        }
+        if (error instanceof dntShim.Deno.errors.PermissionDenied) {
+            if (dntShim.Deno.permissions.querySync({ name: "read", path }).state === "granted") {
+                // --allow-read not missing
+                return !options?.isReadable; // PermissionDenied was raised by file system, so the item exists, but can't be read
+            }
+        }
+        throw error;
+    }
+}
+function fileIsReadable(stat) {
+    if (stat.mode === null) {
+        return true; // Exclusive on Non-POSIX systems
+    }
+    else if (dntShim.Deno.uid() === stat.uid) {
+        return (stat.mode & 0o400) === 0o400; // User is owner and can read?
+    }
+    else if (dntShim.Deno.gid() === stat.gid) {
+        return (stat.mode & 0o040) === 0o040; // User group is owner and can read?
+    }
+    return (stat.mode & 0o004) === 0o004; // Others can read?
+}

package/esm/deps/jsr.io/@std/internal/1.0.13/_os.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_os.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.13/_os.ts"],"names":[],"mappings":"AAIA,wBAAgB,YAAY,IAAI,OAAO,CAUtC"}

package/esm/deps/jsr.io/@std/internal/1.0.13/_os.js

@@ -0,0 +1,12 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+import * as dntShim from "../../../../../_dnt.shims.js";
+export function checkWindows() {
+    // deno-lint-ignore no-explicit-any
+    const global = dntShim.dntGlobalThis;
+    const os = global.Deno?.build?.os;
+    // Check Deno, then the remaining runtimes (e.g. Node, Bun and the browser)
+    return typeof os === "string"
+        ? os === "windows"
+        : global.navigator?.platform?.startsWith("Win") ??
+            global.process?.platform?.startsWith("win") ?? false;
+}

package/esm/deps/jsr.io/@std/internal/1.0.13/os.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"os.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.13/os.ts"],"names":[],"mappings":"AAKA,8CAA8C;AAC9C,eAAO,MAAM,SAAS,EAAE,OAAwB,CAAC"}

package/esm/deps/jsr.io/@std/internal/1.0.13/os.js

@@ -0,0 +1,5 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { checkWindows } from "./_os.js";
+/** Whether the current platform is Windows */
+export const isWindows = checkWindows();

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

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

@@ -0,0 +1,15 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * A enum which defines the seek mode for IO related APIs that support
+ * seeking.
+ */
+export var SeekMode;
+(function (SeekMode) {
+    /* Seek from the start of the file/resource. */
+    SeekMode[SeekMode["Start"] = 0] = "Start";
+    /* Seek from the current position within the file/resource. */
+    SeekMode[SeekMode["Current"] = 1] = "Current";
+    /* Seek from the end of the current file/resource. */
+    SeekMode[SeekMode["End"] = 2] = "End";
+})(SeekMode || (SeekMode = {}));

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

@@ -0,0 +1,52 @@
+import type { Writer, WriterSync } from "./types.js";
+export 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.3/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.3/write_all.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAErD,YAAY,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.3/write_all.js

@@ -0,0 +1,61 @@
+// Copyright 2018-2026 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/console_handler.js

@@ -13,7 +13,7 @@ var _ConsoleHandler_useColors;
 // Copyright 2018-2025 the Deno authors. MIT license.
 // This module is browser compatible.
 import { LogLevels } from "./levels.js";
-import { blue, bold, red, yellow } from "../../fmt/1.0.8/colors.js";
+import { blue, bold, red, yellow } from "../../fmt/1.0.10/colors.js";
 import { BaseHandler } from "./base_handler.js";
 function applyColors(msg, level) {
     switch (level) {

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

@@ -8,7 +8,7 @@ var _FileHandler_instances, _FileHandler_unloadCallback, _FileHandler_resetBuffe
 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.225.3/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.

package/esm/deps/jsr.io/@std/log/0.224.14/rotating_file_handler.js

@@ -12,7 +12,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _RotatingFileHandler_maxBytes, _RotatingFileHandler_maxBackupCount, _RotatingFileHandler_currentFileSize;
 // Copyright 2018-2025 the Deno authors. MIT license.
 import * as dntShim from "../../../../../_dnt.shims.js";
-import { existsSync } from "../../fs/1.0.20/exists.js";
+import { existsSync } from "../../fs/1.0.23/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/path/1.1.4/_common/assert_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert_path.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/_common/assert_path.ts"],"names":[],"mappings":"AAGA,wBAAgB,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,QAMvC"}

package/esm/deps/jsr.io/@std/path/1.1.4/_common/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/_common/constants.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAGpC,eAAO,MAAM,QAAQ,KAAK,CAAC;AAC3B,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,mBAAmB,KAAK,CAAC;AACtC,eAAO,MAAM,kBAAkB,MAAM,CAAC;AACtC,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,QAAQ,IAAI,CAAC;AAC1B,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,eAAO,MAAM,qBAAqB,KAAK,CAAC;AACxC,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,eAAO,MAAM,6BAA6B,QAAQ,CAAC;AACnD,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAC5C,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AACzC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,OAAO,KAAK,CAAC;AAC1B,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,eAAO,MAAM,UAAU,KAAK,CAAC;AAG7B,eAAO,MAAM,MAAM,KAAK,CAAC;AACzB,eAAO,MAAM,MAAM,KAAK,CAAC"}

package/esm/deps/jsr.io/@std/path/1.1.4/_common/from_file_url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from_file_url.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/_common/from_file_url.ts"],"names":[],"mappings":"AAGA,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,OAQ1C"}

package/esm/deps/jsr.io/@std/path/1.1.4/_common/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/_common/normalize.ts"],"names":[],"mappings":"AAKA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,mBAGrC"}

package/esm/deps/jsr.io/@std/path/1.1.4/_common/normalize_string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize_string.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/_common/normalize_string.ts"],"names":[],"mappings":"AAQA,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,OAAO,EACvB,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GACzC,MAAM,CA4DR"}

package/esm/deps/jsr.io/@std/path/1.1.4/join.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/path/1.1.4/join.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAEnE"}

package/esm/deps/jsr.io/@std/path/1.1.4/join.js

@@ -0,0 +1,29 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { isWindows } from "../../internal/1.0.13/os.js";
+import { join as posixJoin } from "./posix/join.js";
+import { join as windowsJoin } from "./windows/join.js";
+/**
+ * Joins a sequence of paths, then normalizes the resulting path.
+ *
+ * @example Usage
+ * ```ts
+ * import { join } from "@std/path/join";
+ * import { assertEquals } from "@std/assert";
+ *
+ * if (Deno.build.os === "windows") {
+ *   assertEquals(join("C:\\foo", "bar", "baz\\quux", "garply", ".."), "C:\\foo\\bar\\baz\\quux");
+ *   assertEquals(join(new URL("file:///C:/foo"), "bar", "baz/asdf", "quux", ".."), "C:\\foo\\bar\\baz\\asdf");
+ * } else {
+ *   assertEquals(join("/foo", "bar", "baz/quux", "garply", ".."), "/foo/bar/baz/quux");
+ *   assertEquals(join(new URL("file:///foo"), "bar", "baz/asdf", "quux", ".."), "/foo/bar/baz/asdf");
+ * }
+ * ```
+ *
+ * @param path The path to join. This can be string or file URL.
+ * @param paths Paths to be joined and normalized.
+ * @returns The joined and normalized path.
+ */
+export function join(path, ...paths) {
+    return isWindows ? windowsJoin(path, ...paths) : posixJoin(path, ...paths);
+}

package/esm/deps/jsr.io/@std/path/1.1.4/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/path/1.1.4/normalize.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CAEpD"}

package/esm/deps/jsr.io/@std/path/1.1.4/normalize.js

@@ -0,0 +1,32 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { isWindows } from "../../internal/1.0.13/os.js";
+import { normalize as posixNormalize } from "./posix/normalize.js";
+import { normalize as windowsNormalize } from "./windows/normalize.js";
+/**
+ * Normalize the path, resolving `'..'` and `'.'` segments.
+ *
+ * Note: Resolving these segments does not necessarily mean that all will be
+ * eliminated. A `'..'` at the top-level will be preserved, and an empty path is
+ * canonically `'.'`.
+ *
+ * @example Usage
+ * ```ts
+ * import { normalize } from "@std/path/normalize";
+ * import { assertEquals } from "@std/assert";
+ *
+ * if (Deno.build.os === "windows") {
+ *   assertEquals(normalize("C:\\foo\\bar\\..\\baz\\quux"), "C:\\foo\\baz\\quux");
+ *   assertEquals(normalize(new URL("file:///C:/foo/bar/../baz/quux")), "C:\\foo\\baz\\quux");
+ * } else {
+ *   assertEquals(normalize("/foo/bar/../baz/quux"), "/foo/baz/quux");
+ *   assertEquals(normalize(new URL("file:///foo/bar/../baz/quux")), "/foo/baz/quux");
+ * }
+ * ```
+ *
+ * @param path Path to be normalized
+ * @returns The normalized path.
+ */
+export function normalize(path) {
+    return isWindows ? windowsNormalize(path) : posixNormalize(path);
+}

package/esm/deps/jsr.io/@std/path/1.1.4/posix/_util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_util.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/posix/_util.ts"],"names":[],"mappings":"AAOA,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D"}

package/esm/deps/jsr.io/@std/path/1.1.4/posix/from_file_url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from_file_url.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/posix/from_file_url.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,GAAG,MAAM,CAKrD"}

package/esm/deps/jsr.io/@std/path/1.1.4/posix/join.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/posix/join.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CASpE"}

package/esm/deps/jsr.io/@std/path/1.1.4/posix/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/posix/normalize.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CAmBpD"}

package/esm/deps/jsr.io/@std/path/1.1.4/windows/_util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_util.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/windows/_util.ts"],"names":[],"mappings":"AAcA,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKzD"}

package/esm/deps/jsr.io/@std/path/1.1.4/windows/from_file_url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from_file_url.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/windows/from_file_url.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,GAAG,MAAM,CAYrD"}

package/esm/deps/jsr.io/@std/path/1.1.4/windows/join.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/windows/join.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAqDpE"}

package/esm/deps/jsr.io/@std/path/1.1.4/windows/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/windows/normalize.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CA6GpD"}

package/esm/dsl/CodeFileBase.d.ts

@@ -0,0 +1,38 @@
+import { FileBase } from './FileBase.js';
+import type { ImportBase } from './ImportBase.js';
+import type { ReExportBase } from './ReExportBase.js';
+/**
+ * The base every language's *code* file extends — a {@link FileBase} that
+ * also carries imports. (`JsonFile`, which has no imports, extends
+ * {@link FileBase} directly.)
+ *
+ * The import collection and its merge are **language-neutral**: imports are
+ * held keyed by {@link ImportBase.mergeKey} and collapsed via
+ * {@link ImportBase.merge}, with no language-specific logic. The spike
+ * proved this same `Map` + merge serves TypeScript (per-module grouping,
+ * type-tags) and Go (whole-package imports, discarded symbol lists)
+ * identically — only the *arrangement* of the rendered import section
+ * differs, which is why `toString()` stays abstract and lives on the
+ * language subclass (`TsFile`, `GoFile`).
+ */
+export declare abstract class CodeFileBase extends FileBase {
+    /** Registered imports, keyed by {@link ImportBase.mergeKey}. */
+    imports: Map<string, ImportBase>;
+    /** Registered re-exports, keyed by {@link ReExportBase.mergeKey}. */
+    reExports: Map<string, ReExportBase>;
+    /**
+     * Merge imports in, collapsing any that share a `mergeKey()` with an
+     * existing entry via {@link ImportBase.merge}. Neutral — the engine's
+     * `register` calls this on the abstract base for every language's file.
+     */
+    addImports(incoming: ImportBase[]): void;
+    /**
+     * Merge re-exports in, collapsing any that share a `mergeKey()` with an
+     * existing entry via {@link ReExportBase.merge}. Neutral — the engine's
+     * `register` calls this on the abstract base; a language without
+     * re-exports never receives any (its concise register vocabulary has no
+     * `reExports` field).
+     */
+    addReExports(incoming: ReExportBase[]): void;
+}
+//# sourceMappingURL=CodeFileBase.d.ts.map

package/esm/dsl/CodeFileBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeFileBase.d.ts","sourceRoot":"","sources":["../../src/dsl/CodeFileBase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;;;;;;;;;GAaG;AACH,8BAAsB,YAAa,SAAQ,QAAQ;IACjD,gEAAgE;IAChE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAY;IAE5C,qEAAqE;IACrE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAY;IAEhD;;;;OAIG;IACH,UAAU,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,IAAI;IASxC;;;;;;OAMG;IACH,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;CAQ7C"}