@bolt-foundry/gambit 0.8.3 → 0.8.5-rc.5

package/script/deps/jsr.io/@std/collections/1.1.5/deep_merge.d.ts

@@ -0,0 +1,322 @@
+/**
+ * Merges the two given records, recursively merging any nested records with the
+ * second collection overriding the first in case of conflict.
+ *
+ * For arrays, maps and sets, a merging strategy can be specified to either
+ * `replace` values, or `merge` them instead.
+ *
+ * @typeParam T Type of the first record
+ *
+ * @param record First record to merge.
+ * @param other Second record to merge.
+ * @param options Merging options.
+ *
+ * @returns A new record with the merged values.
+ *
+ * @example Merge objects
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: true };
+ * const b = { foo: { bar: true } };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: { bar: true } };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge arrays
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: [1, 2] };
+ * const b = { foo: [3, 4] };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: [1, 2, 3, 4] };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge maps
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: new Map([["a", 1]]) };
+ * const b = { foo: new Map([["b", 2]]) };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: new Map([["a", 1], ["b", 2]]) };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge sets
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: new Set([1]) };
+ * const b = { foo: new Set([2]) };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: new Set([1, 2]) };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge with custom options
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: [1, 2] };
+ * const b = { foo: [3, 4] };
+ *
+ * const result = deepMerge(a, b, { arrays: "replace" });
+ *
+ * const expected = { foo: [3, 4] };
+ *
+ * assertEquals(result, expected);
+ * ```
+ */
+export declare function deepMerge<T extends Record<PropertyKey, unknown>>(record: Partial<Readonly<T>>, other: Partial<Readonly<T>>, options?: Readonly<DeepMergeOptions>): T;
+/**
+ * Merges the two given records, recursively merging any nested records with the
+ * second collection overriding the first in case of conflict.
+ *
+ * For arrays, maps and sets, a merging strategy can be specified to either
+ * `replace` values, or `merge` them instead.
+ *
+ * @typeParam T Type of the first record
+ * @typeParam U Type of the second record
+ * @typeParam Options Merging options
+ *
+ * @param record First record to merge.
+ * @param other Second record to merge.
+ * @param options Merging options.
+ *
+ * @returns A new record with the merged values.
+ *
+ * @example Merge objects
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: true };
+ * const b = { foo: { bar: true } };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: { bar: true } };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge arrays
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: [1, 2] };
+ * const b = { foo: [3, 4] };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: [1, 2, 3, 4] };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge maps
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: new Map([["a", 1]]) };
+ * const b = { foo: new Map([["b", 2]]) };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: new Map([["a", 1], ["b", 2]]) };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge sets
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: new Set([1]) };
+ * const b = { foo: new Set([2]) };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: new Set([1, 2]) };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge with custom options
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: [1, 2] };
+ * const b = { foo: [3, 4] };
+ *
+ * const result = deepMerge(a, b, { arrays: "replace" });
+ *
+ * const expected = { foo: [3, 4] };
+ *
+ * assertEquals(result, expected);
+ * ```
+ */
+export declare function deepMerge<T extends Record<PropertyKey, unknown>, U extends Record<PropertyKey, unknown>, Options extends DeepMergeOptions>(record: Readonly<T>, other: Readonly<U>, options?: Readonly<Options>): DeepMerge<T, U, Options>;
+/** Merging strategy */
+export type MergingStrategy = "replace" | "merge";
+/** Options for {@linkcode deepMerge}. */
+export type DeepMergeOptions = {
+    /**
+     * Merging strategy for arrays
+     *
+     * @default {"merge"}
+     */
+    arrays?: MergingStrategy;
+    /**
+     * Merging strategy for maps.
+     *
+     * @default {"merge"}
+     */
+    maps?: MergingStrategy;
+    /**
+     * Merging strategy for sets.
+     *
+     * @default {"merge"}
+     */
+    sets?: MergingStrategy;
+};
+/**
+ * How does recursive typing works ?
+ *
+ * Deep merging process is handled through `DeepMerge<T, U, Options>` type.
+ * If both T and U are Records, we recursively merge them,
+ * else we treat them as primitives.
+ *
+ * Merging process is handled through `Merge<T, U>` type, in which
+ * we remove all maps, sets, arrays and records so we can handle them
+ * separately depending on merging strategy:
+ *
+ *    Merge<
+ *      {foo: string},
+ *      {bar: string, baz: Set<unknown>},
+ *    > // "foo" and "bar" will be handled with `MergeRightOmitComplexes`
+ *      // "baz" will be handled with `MergeAll*` type
+ *
+ * `MergeRightOmitComplexes<T, U>` will do the above: all T's
+ * exclusive keys will be kept, though common ones with U will have their
+ * typing overridden instead:
+ *
+ *    MergeRightOmitComplexes<
+ *      {foo: string, baz: number},
+ *      {foo: boolean, bar: string}
+ *    > // {baz: number, foo: boolean, bar: string}
+ *      // "baz" was kept from T
+ *      // "foo" was overridden by U's typing
+ *      // "bar" was added from U
+ *
+ * For Maps, Arrays, Sets and Records, we use `MergeAll*<T, U>` utility
+ * types. They will extract relevant data structure from both T and U
+ * (providing that both have same data data structure, except for typing).
+ *
+ * From these, `*ValueType<T>` will extract values (and keys) types to be
+ * able to create a new data structure with an union typing from both
+ * data structure of T and U:
+ *
+ *    MergeAllSets<
+ *      {foo: Set<number>},
+ *      {foo: Set<string>}
+ *    > // `SetValueType` will extract "number" for T
+ *      // `SetValueType` will extract "string" for U
+ *      // `MergeAllSets` will infer type as Set<number|string>
+ *      // Process is similar for Maps, Arrays, and Sets
+ *
+ * `DeepMerge<T, U, Options>` is taking a third argument to be handle to
+ * infer final typing depending on merging strategy:
+ *
+ *    & (Options extends { sets: "replace" } ? PartialByType<U, Set<unknown>>
+ *      : MergeAllSets<T, U>)
+ *
+ * In the above line, if "Options" have its merging strategy for Sets set to
+ * "replace", instead of performing merging of Sets type, it will take the
+ * typing from right operand (U) instead, effectively replacing the typing.
+ *
+ * An additional note, we use `ExpandRecursively<T>` utility type to expand
+ * the resulting typing and hide all the typing logic of deep merging so it is
+ * more user friendly.
+ */
+/** Force intellisense to expand the typing to hide merging typings */
+export type ExpandRecursively<T> = T extends Record<PropertyKey, unknown> ? T extends infer O ? {
+    [K in keyof O]: ExpandRecursively<O[K]>;
+} : never : T;
+/** Filter of keys matching a given type */
+export type PartialByType<T, U> = {
+    [K in keyof T as T[K] extends U ? K : never]: T[K];
+};
+/** Get set values type */
+export type SetValueType<T> = T extends Set<infer V> ? V : never;
+/** Merge all sets types definitions from keys present in both objects */
+export type MergeAllSets<T, U, X = PartialByType<T, Set<unknown>>, Y = PartialByType<U, Set<unknown>>, Z = {
+    [K in keyof X & keyof Y]: Set<SetValueType<X[K]> | SetValueType<Y[K]>>;
+}> = Z;
+/** Get array values type */
+export type ArrayValueType<T> = T extends Array<infer V> ? V : never;
+/** Merge all arrays types definitions from keys present in both objects */
+export type MergeAllArrays<T, U, X = PartialByType<T, Array<unknown>>, Y = PartialByType<U, Array<unknown>>, Z = {
+    [K in keyof X & keyof Y]: Array<ArrayValueType<X[K]> | ArrayValueType<Y[K]>>;
+}> = Z;
+/** Get map values types */
+export type MapKeyType<T> = T extends Map<infer K, unknown> ? K : never;
+/** Get map values types */
+export type MapValueType<T> = T extends Map<unknown, infer V> ? V : never;
+/** Merge all maps types definitions from keys present in both objects */
+export type MergeAllMaps<T, U, X = PartialByType<T, Map<unknown, unknown>>, Y = PartialByType<U, Map<unknown, unknown>>, Z = {
+    [K in keyof X & keyof Y]: Map<MapKeyType<X[K]> | MapKeyType<Y[K]>, MapValueType<X[K]> | MapValueType<Y[K]>>;
+}> = Z;
+/** Merge all records types definitions from keys present in both objects */
+export type MergeAllRecords<T, U, Options, X = PartialByType<T, Record<PropertyKey, unknown>>, Y = PartialByType<U, Record<PropertyKey, unknown>>, Z = {
+    [K in keyof X & keyof Y]: DeepMerge<X[K], Y[K], Options>;
+}> = Z;
+/** Exclude map, sets and array from type */
+export type OmitComplexes<T> = Omit<T, keyof PartialByType<T, Map<unknown, unknown> | Set<unknown> | Array<unknown> | Record<PropertyKey, unknown>>>;
+/** Object with keys in either T or U but not in both */
+export type ObjectXorKeys<T, U, X = Omit<T, keyof U> & Omit<U, keyof T>, Y = {
+    [K in keyof X]: X[K];
+}> = Y;
+/** Merge two objects, with left precedence */
+export type MergeRightOmitComplexes<T, U, X = ObjectXorKeys<T, U> & OmitComplexes<{
+    [K in keyof U]: U[K];
+}>> = X;
+/** Merge two objects */
+export type Merge<T, U, Options, X = MergeRightOmitComplexes<T, U> & MergeAllRecords<T, U, Options> & (Options extends {
+    sets: "replace";
+} ? PartialByType<U, Set<unknown>> : MergeAllSets<T, U>) & (Options extends {
+    arrays: "replace";
+} ? PartialByType<U, Array<unknown>> : MergeAllArrays<T, U>) & (Options extends {
+    maps: "replace";
+} ? PartialByType<U, Map<unknown, unknown>> : MergeAllMaps<T, U>)> = ExpandRecursively<X>;
+/** Merge deeply two objects */
+export type DeepMerge<T, U, Options = Record<string, MergingStrategy>> = [
+    T,
+    U
+] extends [Record<PropertyKey, unknown>, Record<PropertyKey, unknown>] ? Merge<T, U, Options> : T | U;
+//# sourceMappingURL=deep_merge.d.ts.map

package/script/deps/jsr.io/@std/collections/1.1.5/deep_merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep_merge.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.1.5/deep_merge.ts"],"names":[],"mappings":"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"}

package/script/deps/jsr.io/@std/collections/1.1.5/deep_merge.js

@@ -0,0 +1,108 @@
+"use strict";
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMerge = deepMerge;
+/** Default merging options - cached to avoid object allocation on each call */
+const DEFAULT_OPTIONS = {
+    arrays: "merge",
+    sets: "merge",
+    maps: "merge",
+};
+function deepMerge(record, other, options) {
+    return deepMergeInternal(record, other, new Set(), options ?? DEFAULT_OPTIONS);
+}
+function deepMergeInternal(record, other, seen, options) {
+    const result = {};
+    const keys = new Set([
+        ...getKeys(record),
+        ...getKeys(other),
+    ]);
+    // Iterate through each key of other object and use correct merging strategy
+    for (const key of keys) {
+        // Skip to prevent Object.prototype.__proto__ accessor property calls on non-Deno platforms
+        if (key === "__proto__") {
+            continue;
+        }
+        const a = record[key];
+        if (!Object.hasOwn(other, key)) {
+            result[key] = a;
+            continue;
+        }
+        const b = other[key];
+        if (isNonNullObject(a) && isNonNullObject(b) && !seen.has(a) && !seen.has(b)) {
+            seen.add(a);
+            seen.add(b);
+            result[key] = mergeObjects(a, b, seen, options);
+            continue;
+        }
+        // Override value
+        result[key] = b;
+    }
+    return result;
+}
+function mergeObjects(left, right, seen, options) {
+    // Recursively merge mergeable objects
+    if (isMergeable(left) && isMergeable(right)) {
+        return deepMergeInternal(left, right, seen, options);
+    }
+    if (isIterable(left) && isIterable(right)) {
+        // Handle arrays
+        if ((Array.isArray(left)) && (Array.isArray(right))) {
+            if (options.arrays === "merge") {
+                return left.concat(right);
+            }
+            return right;
+        }
+        // Handle maps
+        if ((left instanceof Map) && (right instanceof Map)) {
+            if (options.maps === "merge") {
+                const result = new Map(left);
+                for (const [k, v] of right) {
+                    result.set(k, v);
+                }
+                return result;
+            }
+            return right;
+        }
+        // Handle sets
+        if ((left instanceof Set) && (right instanceof Set)) {
+            if (options.sets === "merge") {
+                const result = new Set(left);
+                for (const v of right) {
+                    result.add(v);
+                }
+                return result;
+            }
+            return right;
+        }
+    }
+    return right;
+}
+/**
+ * Test whether a value is mergeable or not
+ * Builtins that look like objects, null and user defined classes
+ * are not considered mergeable (it means that reference will be copied)
+ */
+function isMergeable(value) {
+    return Object.getPrototypeOf(value) === Object.prototype;
+}
+function isIterable(value) {
+    return typeof value[Symbol.iterator] === "function";
+}
+function isNonNullObject(value) {
+    return value !== null && typeof value === "object";
+}
+function getKeys(record) {
+    const keys = Object.keys(record);
+    const symbols = Object.getOwnPropertySymbols(record);
+    // Fast path: most objects have no symbol keys
+    if (symbols.length === 0)
+        return keys;
+    for (const sym of symbols) {
+        if (Object.prototype.propertyIsEnumerable.call(record, sym)) {
+            keys.push(sym);
+        }
+    }
+    return keys;
+}

package/script/deps/jsr.io/@std/fs/1.0.22/_create_walk_entry.d.ts

@@ -0,0 +1,14 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+/**
+ * Walk entry for {@linkcode walk}, {@linkcode walkSync},
+ * {@linkcode expandGlob} and {@linkcode expandGlobSync}.
+ */
+export interface WalkEntry extends dntShim.Deno.DirEntry {
+    /** Full path of the entry. */
+    path: string;
+}
+/** Create {@linkcode WalkEntry} for the `path` synchronously. */
+export declare function createWalkEntrySync(path: string | URL): WalkEntry;
+/** Create {@linkcode WalkEntry} for the `path` asynchronously. */
+export declare function createWalkEntry(path: string | URL): Promise<WalkEntry>;
+//# sourceMappingURL=_create_walk_entry.d.ts.map

package/script/deps/jsr.io/@std/fs/1.0.22/_create_walk_entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_create_walk_entry.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.22/_create_walk_entry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAC;AAOxD;;;GAGG;AACH,MAAM,WAAW,SAAU,SAAQ,OAAO,CAAC,IAAI,CAAC,QAAQ;IACtD,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,iEAAiE;AACjE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAYjE;AAED,kEAAkE;AAClE,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,CAAC,SAAS,CAAC,CAY5E"}

package/script/deps/jsr.io/@std/fs/1.0.22/_create_walk_entry.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWalkEntrySync = createWalkEntrySync;
+exports.createWalkEntry = createWalkEntry;
+// Copyright 2018-2026 the Deno authors. MIT license.
+// Copyright the Browserify authors. MIT License.
+const dntShim = __importStar(require("../../../../../_dnt.shims.js"));
+const basename_js_1 = require("../../path/1.1.4/basename.js");
+const normalize_js_1 = require("../../path/1.1.4/normalize.js");
+const _to_path_string_js_1 = require("./_to_path_string.js");
+/** Create {@linkcode WalkEntry} for the `path` synchronously. */
+function createWalkEntrySync(path) {
+    path = (0, _to_path_string_js_1.toPathString)(path);
+    path = (0, normalize_js_1.normalize)(path);
+    const name = (0, basename_js_1.basename)(path);
+    const info = dntShim.Deno.statSync(path);
+    return {
+        path,
+        name,
+        isFile: info.isFile,
+        isDirectory: info.isDirectory,
+        isSymlink: info.isSymlink,
+    };
+}
+/** Create {@linkcode WalkEntry} for the `path` asynchronously. */
+async function createWalkEntry(path) {
+    path = (0, _to_path_string_js_1.toPathString)(path);
+    path = (0, normalize_js_1.normalize)(path);
+    const name = (0, basename_js_1.basename)(path);
+    const info = await dntShim.Deno.stat(path);
+    return {
+        path,
+        name,
+        isFile: info.isFile,
+        isDirectory: info.isDirectory,
+        isSymlink: info.isSymlink,
+    };
+}

package/script/deps/jsr.io/@std/fs/1.0.22/_get_file_info_type.d.ts

@@ -0,0 +1,13 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+export type PathType = "file" | "dir" | "symlink";
+/**
+ * Get a human readable file type string.
+ *
+ * @param file File information, as returned by {@linkcode Deno.stat} or
+ * {@linkcode Deno.lstat}.
+ *
+ * @returns The file type as a string, or `undefined` if the file type is
+ * unknown.
+ */
+export declare function getFileInfoType(fileInfo: dntShim.Deno.FileInfo): PathType | undefined;
+//# sourceMappingURL=_get_file_info_type.d.ts.map

package/script/deps/jsr.io/@std/fs/1.0.22/_get_file_info_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_get_file_info_type.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.22/_get_file_info_type.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAC;AAGxD,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;AAElD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAQrF"}

package/script/deps/jsr.io/@std/fs/1.0.22/_get_file_info_type.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileInfoType = getFileInfoType;
+/**
+ * Get a human readable file type string.
+ *
+ * @param file File information, as returned by {@linkcode Deno.stat} or
+ * {@linkcode Deno.lstat}.
+ *
+ * @returns The file type as a string, or `undefined` if the file type is
+ * unknown.
+ */
+function getFileInfoType(fileInfo) {
+    return fileInfo.isFile
+        ? "file"
+        : fileInfo.isDirectory
+            ? "dir"
+            : fileInfo.isSymlink
+                ? "symlink"
+                : undefined;
+}

package/script/deps/jsr.io/@std/fs/1.0.22/_is_same_path.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Checks if two paths are the same.
+ *
+ * @param src Source file path as a string or URL.
+ * @param dest Destination file path as a string or URL.
+ *
+ * @returns `true` if the paths are the same, `false` otherwise.
+ */
+export declare function isSamePath(src: string | URL, dest: string | URL): boolean;
+//# sourceMappingURL=_is_same_path.d.ts.map

package/script/deps/jsr.io/@std/fs/1.0.22/_is_same_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_is_same_path.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.22/_is_same_path.ts"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,IAAI,EAAE,MAAM,GAAG,GAAG,GACjB,OAAO,CAKT"}

package/script/deps/jsr.io/@std/fs/1.0.22/_is_same_path.js

@@ -0,0 +1,20 @@
+"use strict";
+// Copyright 2018-2026 the Deno authors. MIT license.
+// Copyright the Browserify authors. MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSamePath = isSamePath;
+const resolve_js_1 = require("../../path/1.1.4/resolve.js");
+const _to_path_string_js_1 = require("./_to_path_string.js");
+/**
+ * Checks if two paths are the same.
+ *
+ * @param src Source file path as a string or URL.
+ * @param dest Destination file path as a string or URL.
+ *
+ * @returns `true` if the paths are the same, `false` otherwise.
+ */
+function isSamePath(src, dest) {
+    src = (0, _to_path_string_js_1.toPathString)(src);
+    dest = (0, _to_path_string_js_1.toPathString)(dest);
+    return (0, resolve_js_1.resolve)(src) === (0, resolve_js_1.resolve)(dest);
+}

package/script/deps/jsr.io/@std/fs/1.0.22/_is_subdir.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Checks whether `src` is a sub-directory of `dest`.
+ *
+ * @param src Source file path as a string or URL.
+ * @param dest Destination file path as a string or URL.
+ * @param sep Path separator. Defaults to `\\` for Windows and `/` for other
+ * platforms.
+ *
+ * @returns `true` if `src` is a sub-directory of `dest`, `false` otherwise.
+ */
+export declare function isSubdir(src: string | URL, dest: string | URL, sep?: "/" | "\\"): boolean;
+//# sourceMappingURL=_is_subdir.d.ts.map

package/script/deps/jsr.io/@std/fs/1.0.22/_is_subdir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_is_subdir.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.22/_is_subdir.ts"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,GAAG,aAAY,GACd,OAAO,CAYT"}

package/script/deps/jsr.io/@std/fs/1.0.22/_is_subdir.js

@@ -0,0 +1,28 @@
+"use strict";
+// Copyright 2018-2026 the Deno authors. MIT license.
+// Copyright the Browserify authors. MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSubdir = isSubdir;
+const resolve_js_1 = require("../../path/1.1.4/resolve.js");
+const constants_js_1 = require("../../path/1.1.4/constants.js");
+const _to_path_string_js_1 = require("./_to_path_string.js");
+/**
+ * Checks whether `src` is a sub-directory of `dest`.
+ *
+ * @param src Source file path as a string or URL.
+ * @param dest Destination file path as a string or URL.
+ * @param sep Path separator. Defaults to `\\` for Windows and `/` for other
+ * platforms.
+ *
+ * @returns `true` if `src` is a sub-directory of `dest`, `false` otherwise.
+ */
+function isSubdir(src, dest, sep = constants_js_1.SEPARATOR) {
+    src = (0, _to_path_string_js_1.toPathString)(src);
+    dest = (0, _to_path_string_js_1.toPathString)(dest);
+    if ((0, resolve_js_1.resolve)(src) === (0, resolve_js_1.resolve)(dest)) {
+        return false;
+    }
+    const srcArray = src.split(sep);
+    const destArray = dest.split(sep);
+    return srcArray.every((current, i) => destArray[i] === current);
+}

package/script/deps/jsr.io/@std/fs/1.0.22/_to_path_string.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Convert a URL or string to a path.
+ *
+ * @param pathUrl A URL or string to be converted.
+ *
+ * @returns The path as a string.
+ */
+export declare function toPathString(pathUrl: string | URL): string;
+//# sourceMappingURL=_to_path_string.d.ts.map

package/script/deps/jsr.io/@std/fs/1.0.22/_to_path_string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_to_path_string.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.22/_to_path_string.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,GAAG,GAAG,GACpB,MAAM,CAER"}