{
  "version": 3,
  "sources": ["../Source/index.ts", "../Source/Array/index.ts", "../Source/Array/Array.ts", "../Source/Async/index.ts", "../Source/Miscellaneous/Utility.Types.ts", "../Source/Async/Async.ts", "../Source/Math/Complex.ts", "../Source/Math/Complex.Internal.ts", "../Source/Effect/index.ts", "../Source/Effect/Effect.ts", "../Source/Effect/Platform/index.ts", "../Source/Effect/Platform/Platform.ts", "../Source/FileSystem/index.ts", "../Source/FileSystem/FileSystem.ts", "../Source/FileSystem/Effect/index.ts", "../Source/FileSystem/Effect/FileSystem.Effect.ts", "../Source/FileSystem/Module/index.ts", "../Source/FileSystem/Module/Extension.ts", "../Source/String/String.ts", "../Source/FileSystem/Module/Module.ts", "../Source/Functional/index.ts", "../Source/Functional/Functional.ts", "../Source/Math/index.ts", "../Source/Math/Index.Complex.ts", "../Source/Math/Vector.ts", "../Source/Math/Math.ts", "../Source/Miscellaneous/index.ts", "../Source/Npm/index.ts", "../Source/Npm/Npm.ts", "../Source/Npm/Npm.Error.ts", "../Source/Npm/Npm.Internal.ts", "../Source/Path/index.ts", "../Source/Path/Path.ts", "../Source/Record/index.ts", "../Source/Record/Record.ts", "../Source/String/index.ts", "../Source/TsConfig/index.ts", "../Source/Tuple/index.ts", "../Source/Type/index.ts", "../Source/Type/Test.ts"],
  "sourcesContent": ["/**\n * General-purpose utility types and functions.  You may import modules\n * directly from here, or you may use the corresponding scoped export path.\n * For example, to import the {@link \\@sorrell/utilities/dependency} module, you\n * may use either of,\n *\n * ```typescript\n * import { Dependency } from \"@sorrell/utilities\";\n * import * as Dependency from \"@sorrell/utilities/dependency\";\n * ```\n *\n * This module only exports the top-level modules of this package, however there\n * exists a scoped export path for *every* module in this package.  For example,\n * to import the {@link \\@sorrell/utilities/generic/option} module, you must use\n * either of the scoped paths containing the module,\n *\n * ```typescript\n * import { Option } from \"@sorrell/utilities/generic\";\n * import * as Option from \"@sorrell/utilities/generic/option\";\n * ```\n *\n * @module @sorrell/utilities\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * as Array from \"./Array/index.ts\";\nexport * as Async from \"./Async/index.ts\";\nexport * as Complex from \"./Math/Complex.ts\";\nexport * as Effect from \"./Effect/index.ts\";\nexport * as FileSystem from \"./FileSystem/index.ts\";\nexport * as Functional from \"./Functional/index.ts\";\nexport * as Math from \"./Math/index.ts\";\nexport * as Miscellaneous from \"./Miscellaneous/index.ts\";\nexport * as Npm from \"./Npm/index.ts\";\nexport * as Path from \"./Path/index.ts\";\nexport * as Record from \"./Record/index.ts\";\nexport * as String from \"./String/index.ts\";\nexport * as TsConfig from \"./TsConfig/index.ts\";\nexport * as Tuple from \"./Tuple/index.ts\";\nexport * as Type from \"./Type/index.ts\";\n", "/**\n * Utilities for creating and working with arrays, including a custom {@link TArray | TArray type}.\n *\n * @note This module will likely be deprecated; the\n * {@link https://effect-ts.github.io/effect/effect/Array.ts.html | effect Array module} is\n * recommended instead.\n *\n * @module @sorrell/utilities/array\n * @experimental\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/* eslint-disable-next-line @typescript-eslint/no-unused-vars */\nimport type { TArray } from \"./Array.Types.ts\";\nexport * from \"./Array.ts\";\nexport * from \"./Array.Types.ts\";\n", "/**\n * @file      Array.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport type { FilteredArray, Options, TArrayType } from \"./Array.Types.ts\";\nimport type { NoOptions } from \"../Generic/Option/Option.Types.ts\";\n/**\n * Filter out all instances of `undefined` from a given {@link Array:param}.\n * @param Array - The array to filter.\n *\n * @template ElementType - The type of the elements in the array.\n *\n * @returns {TArrayType<Exclude<ElementType, undefined>, Exclude<OptionsType, Options.MaybeDefined>>}\n * A new `Array` of type `Exclude<ElementType, undefined>` and `OptionsType` that is the given\n * {@link OptionsType}, with the {@link Options.MaybeDefined} option removed.\n *\n * @example With the given {@link ElementType} including `undefined`.\n * ```typescript\n * const MaybeOddNumbers: TArray<number | undefined> = [ 1, 3, undefined, 5 ];\n * const OddNumbers: TArray<number> = FilterDefined(MaybeOddNumbers);\n * ```\n * @example With the given {@link OptionsType} including `Options.MaybeDefined`.\n * ```typescript\n * const MaybeOddNumbers: TArray<number, Options.MaybeDefined> = [ 1, 3, undefined, 5 ];\n * const OddNumbers: TArray<number> = FilterDefined(MaybeOddNumbers);\n * ```\n */\nexport function FilterDefined<ElementType, OptionsType extends Options = NoOptions, ArraySize extends number = number>(Array: TArrayType<ElementType, OptionsType | Options.MaybeDefined, ArraySize>): FilteredArray<ElementType>;\nexport function FilterDefined<ElementType, OptionsType extends Options = NoOptions, ArraySize extends number = number>(Array: TArrayType<ElementType | undefined, OptionsType, ArraySize>): FilteredArray<ElementType>;\nexport function FilterDefined<ElementType, OptionsType extends Options = NoOptions, ArraySize extends number = number>(Array: TArrayType<ElementType | undefined, OptionsType | Options.MaybeDefined, ArraySize>): FilteredArray<ElementType>;\nexport function FilterDefined<ElementType, OptionsType extends Options = NoOptions, ArraySize extends number = number>(Array: TArrayType<ElementType | undefined, OptionsType | Options.MaybeDefined, ArraySize>): FilteredArray<ElementType> {\n    return Array.filter((Element: ElementType | undefined): boolean => {\n        return Element !== undefined;\n    }) as FilteredArray<ElementType>;\n}\n", "/**\n * Utilities for creating and working with `async` functions and {@link Promise | Promises}.\n *\n * @module @sorrell/utilities/async\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Async.ts\";\nexport * from \"./Async.Types.ts\";\n", "/**\n * @file      Utility.Types.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/**\n * A simple wrapper to allow passing primitives to functions by-reference.\n *\n * @template Type - The type of the value wrapped by this.\n */\nexport type Ref<Type> = {\n    Ref: Type | undefined;\n};\n/**\n * The opposite of {@link NonNullable}: the union of a given {@link Type}, `null`, and `undefined`.\n *\n * @template Type - The nontrivial type in this union.\n */\nexport type TNullable<Type> = Type | null | undefined;\n/** An error that is thrown in default implementations of `abstract` `class`es. */\nexport class AbstractMethodCallError extends Error {\n    public constructor(ClassName?: string) {\n        super(ClassName);\n    }\n}\n/**\n * A \"safe\" intersection of two types, such that if exactly one\n * of the two types is `never`, then this evaluates to the other type.\n * This evaluates to the intersection of the two types iff *both*\n * type parameters.\n *\n * @template LeftType - The first type parameter.\n * @template RightType - The second type parameter.\n */\nexport type TSafeIntersection<LeftType, RightType> = [\n    LeftType\n] extends [\n    never\n] ? [\n    RightType\n] extends [\n    never\n] ? never : RightType : [\n    RightType\n] extends [\n    never\n] ? LeftType : (LeftType & RightType);\n", "/**\n * @file      Async.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { AbstractMethodCallError, type TNullable } from \"../Miscellaneous/Utility.Types.ts\";\nimport type { TOnFulfilled, TOnRejected, TPromiseCtorArgument, TTryResult, TTrySource } from \"./Async.Types.ts\";\nimport type { TFunction } from \"../Functional/Functional.Types.ts\";\n/**\n * Implements \"Errors-as-values\" for `async` functions and `Promise<DataType>`s.\n *\n * If the `async` function or `Promise<DataType>` returns/resolves, then the `Error`\n * property of the returned object will be `undefined`, and the result of the\n * `async` function or `Promise<DataType>` will reside in the `Data` property of the\n * returned object.\n *\n * Similarly, if the `async` function or `Promise<DataType>` throws, then the `Data`\n * property of the returned object is `undefined`, and the `Error` property is what\n * was thrown to the `catch` block.\n *\n * @template DataType - The type of the data that the `async` function or `Promise<DataType>`.\n * @param Source - The `async` function or `Promise` to evaluate.\n *\n * @returns {TTryResult<DataType>} A {@link TTryResult} containing either the result\n * ({@link TTryResult.Data}) or error {@link TTryResult.Error}.\n *\n * @example\n * // With an `async` function,\n * async function GetName(): Promise<string> { ... }\n * // Or, with a `Promise`,\n * const GetName: Promise<string> = new Promise<string>(...);\n *\n * // For both of the above cases, `Try` behaves the same:\n * const { Data: Name, Error: NameError } = await Try(GetName);\n * // If `GetName` returned,\n * // `typeof Name` <- `\"string\"`\n * // `typeof NameError` <- `\"undefined\"`\n * // If `GetName` threw,\n * // `typeof Name` <- `\"undefined\"`\n * // `NameError !== undefined` <- `true` (Unless `GetName` threw `undefined`).\n */\nexport async function Try<DataType>(Source: TTrySource<DataType>): Promise<TTryResult<DataType>> {\n    try {\n        const Data: DataType = typeof Source === \"function\"\n            ? await Source()\n            : await Source;\n        return {\n            Data,\n            Error: undefined\n        };\n    }\n    catch (ErrorValue: unknown) {\n        return {\n            Data: undefined,\n            Error: ErrorValue\n        };\n    }\n}\n/**\n * A cleaner way of using `Array.prototype.map` with an `async` function.\n *\n * @template ArgumentElementType - The type of the given {@link Elements}.\n * @template ReturnElementType - The type of the `Array` returned by this.\n *\n * @param Elements - The `Array` that will be transformed.\n * @param Mapper - The function that maps each {@link ArgumentElementType}\n * to a {@link ReturnElementType}.\n *\n * @returns {Array<ReturnElementType>} An `Array` of {@link ReturnElementType}.\n *\n * @example\n * In an `async` function,\n * ```typescript\n * const ArgumentElements: Array<ArgumentElementType> = [ ... ];\n * const ToReturnElement = async (Element: ArgumentElementType): Promise<ReturnElementType> => ...;\n * const ReturnElements: Array<ReturnElementType> = await Map(ArgumentElements, ToReturnElement);\n * ```\n */\nexport async function Map<ArgumentElementType, ReturnElementType>(Elements: Array<ArgumentElementType>, Mapper: ((Element: ArgumentElementType) => Promise<ReturnElementType>)): Promise<Array<ReturnElementType>> {\n    const MapperWrapped = async (Element: ArgumentElementType): Promise<ReturnElementType> => {\n        return Mapper(Element);\n    };\n    const Out: Array<Promise<ReturnElementType>> = Elements.map(MapperWrapped);\n    return await Promise.all(Out);\n}\n/**\n * An abstract implementation of {@link PromiseLike}.  This exists only to maintain the\n * project's naming convention.\n */\nexport abstract class TPromiseLike<ResolveType> implements PromiseLike<ResolveType> {\n    public then<ResultType = ResolveType, RejectType = never>(_OnFulfilled?: TOnFulfilled<ResolveType, ResultType>, _OnRejected?: TOnRejected<RejectType>): TPromiseLike<ResultType | RejectType> {\n        throw new AbstractMethodCallError(\"TPromiseLike\");\n    }\n}\n/**\n * The {@link TypeError} that is thrown by the constructor of {@link TPromise}\n * iff it receives an argument that is not a {@link TPromiseCtorArgument}.\n * It does not provide any additional information (in particular, it does not\n * add any properties, and it does not set any properties inherited from\n * {@link TypeError}).\n *\n * @note While the argument type of {@link TPromise}'s constructor is checked at runtime,\n * the type checker should prevent the error described by this from happening.\n */\nexport class FPromiseInstantiationError extends TypeError {\n    public constructor() {\n        super();\n    }\n}\n/**\n * A `then`-able wrapper of {@link Promise}.\n *\n * @template ResolveType - The type to which this resolves, if it does resolve.\n */\nexport class TPromise<ResolveType> extends TPromiseLike<ResolveType> implements PromiseLike<ResolveType> {\n    public constructor(Argument: TPromiseCtorArgument<ResolveType>) {\n        super();\n        if (typeof Argument === \"function\") {\n            this.Underlying = new Promise<ResolveType>(Argument);\n        }\n        else {\n            if (Argument instanceof TPromise) {\n                this.Underlying = Argument.Raw();\n            }\n            else if (Argument instanceof Promise) {\n                this.Underlying = Argument;\n            }\n        }\n        throw new FPromiseInstantiationError();\n    }\n    private readonly Underlying: Promise<ResolveType>;\n    /**\n     * This class's extension of {@link Promise!then}.\n     *\n     * @template ResultType - The type to which the value underlying the {@link TPromise} returned by this\n     * will resolve, if the {@link TPromise} resolves.\n     *\n     * @template RejectType - The type to which the value underlying the {@link TPromise} returned by this\n     * will reject, if the {@link TPromise} rejects.\n     *\n     * @param OnFulfilled - The callback that is called when the underlying {@link Promise} resolves,\n     * if it resolves.\n     *\n     * @param OnRejected - The callback that is called when the underlying {@link Promise} rejects,\n     * if it rejects.\n     *\n     * @returns {TPromise<ResultType | RejectType>} A new {@link TPromise} of the result of the\n     * given callbacks.\n     *\n     * @example\n     * ```typescript\n     * const Example: TPromise<string> = new TPromise<string>((Resolve, Reject) =>\n     * {\n     *     if (Math.random() < 0.5)\n     *     {\n     *         Resolve(\"Success\");\n     *     }\n     *     else\n     *     {\n     *         Reject(\"Error\");\n     *     }\n     * });\n     *\n     * Example.then(\n     *     (Value: string): void =>\n     *     {\n     *         // `Value` <- `\"Success\"`\n     *     },\n     *     (Reason: unknown): void =>\n     *     {\n     *         // `Reason` <- `\"Error\"`\n     *     }\n     * );\n     * ```\n     */\n    public Then<ResultType = ResolveType, RejectType = never>(OnFulfilled: TOnFulfilled<ResolveType, ResultType>, OnRejected?: TOnRejected<RejectType>): TPromise<ResultType | RejectType> {\n        return new TPromise<ResultType | RejectType>(this.Underlying.then(OnFulfilled, OnRejected));\n    }\n    public override then<ResultType = ResolveType, RejectType = never>(OnFulfilled?: TOnFulfilled<ResolveType, ResultType>, OnRejected?: TOnRejected<RejectType>): TPromise<ResultType | RejectType> {\n        return new TPromise<ResultType | RejectType>(this.Underlying.then(OnFulfilled, OnRejected));\n    }\n    public Catch<ResultType = never>(OnRejected?: TNullable<TOnRejected<ResolveType>>): TPromiseLike<ResolveType | ResultType> {\n        return new TPromise<ResolveType | ResultType>(this.Underlying.catch(OnRejected));\n    }\n    public Finally(OnFinally?: TNullable<TFunction>): TPromise<ResolveType> {\n        return new TPromise(this.Underlying.finally(OnFinally));\n    }\n    public static Resolve<ResolveType>(Value: ResolveType | PromiseLike<ResolveType>): TPromise<Awaited<ResolveType>> {\n        return new TPromise(Promise.resolve(Value));\n    }\n    public static Reject<ResolveType = unknown>(Reason?: unknown): TPromise<ResolveType> {\n        return new TPromise(Promise.reject<ResolveType>(Reason));\n    }\n    public Raw(): Promise<ResolveType> {\n        return this.Underlying;\n    }\n}\n;\n", "/**\n * @file      Complex.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { MathBuiltin } from \"./Complex.Internal\";\nimport { Operator } from \"tsover-runtime\";\n/**\n * Elements of the complex plane, $\\mathbf{C} = \\mathbf{R}[x] / [ x^2 + 1 ]$.\n */\nexport class FComplex {\n    public readonly Re: number;\n    public readonly Im: number;\n    public static Zero: FComplex = new FComplex(0, 0);\n    /**\n     * The copy constructor for {@link FComplex} numbers.\n     *\n     * @param Z - The existing {@link FComplex} number to copy.\n     *\n     * @example\n     * ```typescript\n     * const Z: FComplex = 3 + 2 * i;\n     * const W: FComplex = new FComplex(Z);\n     * // `W.Re === Z.Re` <- `true`\n     * // `W.Im === Z.Im` <- `true`\n     * ```\n     */\n    public constructor(Z: FComplex);\n    /**\n     * Construct an {@link FComplex} number by specifying the real\n     * and imaginary components.\n     *\n     * @param A - The real component of the {@link FComplex} number.\n     * @param B - The imaginary component of the {@link FComplex} number.\n     *\n     * @example\n     * ```typescript\n     * const Theta: number = 0.5;\n     * const OnUnitDisk: FComplex = new FComplex(Math.sin(Theta), Math.cos(Theta));\n     * ```\n     */\n    public constructor(A: number, B: number);\n    public constructor(A: FComplex | number, B: number = 0) {\n        if (typeof A === \"number\") {\n            this.Re = A;\n            this.Im = B;\n        }\n        else {\n            this.Re = A.Re;\n            this.Im = A.Im;\n        }\n    }\n    /**\n     * Get the modulus of this {@link FComplex} number.\n     *\n     * @returns {number} The modulus of this {@link FComplex} number.\n     */\n    public get Mod(): number {\n        return MathBuiltin.sqrt((this.Re ** 2) + (this.Im ** 2));\n    }\n    /**\n     * Get the modulus of this {@link FComplex} number.\n     *\n     * @returns {number} The modulus of this {@link FComplex} number.\n     */\n    public get Theta(): number {\n        const Out: number = MathBuiltin.atan2(this.Im, this.Re);\n        if (Out < 0) {\n            return Out + 2 * MathBuiltin.PI;\n        }\n        return Out;\n    }\n    [Operator.star](A: FComplex, B: FComplex): FComplex;\n    [Operator.star](A: FComplex, B: number): FComplex;\n    [Operator.star](A: number, B: FComplex): FComplex;\n    [Operator.star](A: FComplex | number, B: number | FComplex): FComplex {\n        if (typeof A === \"number\") {\n            return new FComplex((B as FComplex).Re * A, (B as FComplex).Im * A);\n        }\n        else if (typeof B === \"number\") {\n            return new FComplex((A as FComplex).Re * B, (A as FComplex).Im * B);\n        }\n        else {\n            return new FComplex((((A as FComplex).Re + (B as FComplex).Re) -\n                ((A as FComplex).Im + (B as FComplex).Im)), (((A as FComplex).Re + (B as FComplex).Im) +\n                ((B as FComplex).Re + (A as FComplex).Im)));\n        }\n    }\n    [Operator.plus](A: FComplex, B: FComplex): FComplex;\n    [Operator.plus](A: FComplex, B: number): FComplex;\n    [Operator.plus](A: number, B: FComplex): FComplex;\n    [Operator.plus](A: FComplex | number, B: number | FComplex): FComplex {\n        if (typeof A === \"number\") {\n            return new FComplex(A + (B as FComplex).Re, (B as FComplex).Im);\n        }\n        else if (typeof B === \"number\") {\n            return new FComplex((A as FComplex).Re + B, (A as FComplex).Im);\n        }\n        else {\n            return new FComplex((A as FComplex).Re + (B as FComplex).Re, (A as FComplex).Im + (B as FComplex).Im);\n        }\n    }\n}\nexport /**\n       * The imaginary unit.\n       */ const i: FComplex = new FComplex(0, 1);\n", "/**\n * @file      Complex.Internal.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport const MathBuiltin: typeof Math = Math;\n", "/**\n * Utilities for using `effect`.  In particular, for defining {@link Effect | effect types}.\n *\n * @module @sorrell/utilities/effect\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/* eslint-disable-next-line @typescript-eslint/no-unused-vars */\nimport type { Effect } from \"effect/Effect\";\nexport * from \"./Effect.ts\";\nexport * from \"./Effect.Types.ts\";\nexport * as Platform from \"./Platform/index.ts\";\n", "/**\n * @file      Effect.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/* eslint-disable jsdoc/require-example */\nimport type { AnyFunction } from \"../HigherKind/HigherKind.Types.ts\";\nimport { Effect } from \"effect\";\nimport type { TFunction } from \"../Functional/index.ts\";\n/**\n * Transform a given {@link InFunction:param} into a function of the same\n * {@link ArgumentVectorType | argument vector}, such that the transformed\n * function returns a call to {@link Effect.sync}, which calls the given\n * {@link InFunction:param} with the argument vector that is passed when called.\n *\n * @param InFunction - The given function that is called by {@link Effect.sync} when\n * the {@link Effect.Effect | effect} returned by *this* function is yielded.\n *\n * @template ArgumentVectorType - The type of the {@link ArgumentVector} that is used to call\n * the given {@link InFunction:param}.\n *\n * @template ReturnType - The type returned by the given {@link InFunction:param}, which is wrapped\n * into an {@link Effect.Effect | effect}.\n *\n * @returns {TFunction.Safe<ArgumentVectorType, Effect.Effect<ReturnType>>} An {@link Effect.Effect}\n * that returns the value of the original {@link InFunction:param}.  This effect never errors, and has\n * no requirements.\n */\nexport function MakeSyncCallback<ArgumentVectorType extends ReadonlyArray<unknown>, ReturnType>(InFunction: TFunction.Safe<ArgumentVectorType, ReturnType>): TFunction.Safe<ArgumentVectorType, Effect.Effect<ReturnType>>;\n/**\n * Transform a given {@link InFunction:param} into a function of the same argument vector,\n * such that the transformed function returns a call to {@link Effect.sync}, which calls the given\n * {@link InFunction:param} with the argument vector that is passed when called.\n *\n * @param InFunction - The given function that is called by {@link Effect.sync} when\n * the {@link Effect.Effect | effect} returned by *this* function is yielded.\n *\n * @template FunctionType - The type of the given {@link InFunction:param}.  This overload\n * allows you to determine this type (and therefore the type returned by this) via inferring,\n * or via the `typeof` operator with the given {@link InFunction:param}.\n *\n * @returns {TFunction.Safe<ArgumentVectorType, Effect.Effect<ReturnType>>} An {@link Effect.Effect}\n * that returns the value of the original {@link InFunction:param}.  This effect never errors, and has\n * no requirements.\n */\nexport function MakeSyncCallback<FunctionType extends TFunction.Safe<ReadonlyArray<unknown>, unknown>>(InFunction: FunctionType): TFunction.Safe<Parameters<typeof InFunction>, Effect.Effect<ReturnType<typeof InFunction>>>;\nexport function MakeSyncCallback<ArgumentVectorType extends ReadonlyArray<unknown>, ReturnType>(InFunction: TFunction.Safe<ArgumentVectorType, ReturnType>): TFunction.Safe<ArgumentVectorType, Effect.Effect<ReturnType>> {\n    return function (...ArgumentVector: ArgumentVectorType): Effect.Effect<ReturnType> {\n        return MakeSync(InFunction, ...ArgumentVector);\n    };\n}\n/**\n * Wrap a given {@link InFunction:param} with {@link Effect.sync} such that the function is\n * always called with the given {@link ArgumentVector}.\n *\n * @param InFunction - The function to call via {@link Effect.sync}.\n * @param ArgumentVector - The argument vector passed to the given {@link InFunction:param}.\n *\n * @template ArgumentVectorType - The type of the {@link ArgumentVector} that is used to call\n * the given {@link InFunction:param}.\n *\n * @template ReturnType - The type returned by the given {@link InFunction:param}, which is wrapped\n * into an {@link Effect.Effect | effect}.\n *\n * @returns {Effect.Effect<ReturnType>} An {@link Effect.Effect | effect} that returns the\n * result of calling the given {@link InFunction} with the given {@link ArgumentVector}.  It\n * never errors and has no requirements.\n */\nexport function MakeSync<ArgumentVectorType extends ReadonlyArray<unknown>, ReturnType>(InFunction: TFunction.Safe<ArgumentVectorType, ReturnType>, ...ArgumentVector: ArgumentVectorType): Effect.Effect<ReturnType>;\n/**\n * Wrap a given {@link InFunction:param} with {@link Effect.sync} such that the function is\n * always called with the given {@link ArgumentVector}.\n *\n * @param InFunction - The given function that is called by {@link Effect.sync} with the given\n * {@link ArgumentVector} when the {@link Effect.Effect | effect} returned by *this* function is yielded.\n *\n * @param ArgumentVector - The argument vector to pass to the given {@link InFunction | function} when\n * the {@link Effect.Effect | effect} returned by this is yielded.\n *\n * @template FunctionType - The type of the given {@link InFunction:param}.  This overload\n * allows you to determine this type (and therefore the type returned by this) via inferring,\n * or via the `typeof` operator with the given {@link InFunction:param}.\n *\n * @returns {TFunction.Safe<Parameters<typeof InFunction>, Effect.Effect<ReturnType<typeof InFunction>>>}\n * An {@link Effect.Effect}\n * that returns the value of the original {@link InFunction:param}.  This effect never errors, and has\n * no requirements.\n */\nexport function MakeSync<FunctionType extends TFunction.Safe<ReadonlyArray<unknown>, unknown>>(InFunction: FunctionType, ...ArgumentVector: Parameters<typeof InFunction>): Effect.Effect<ReturnType<typeof InFunction>>;\nexport function MakeSync(InFunction: AnyFunction, ...ArgumentVector: ReadonlyArray<unknown>): Effect.Effect<ReturnType<typeof InFunction>> {\n    return Effect.sync((): unknown => InFunction(...(ArgumentVector as Parameters<typeof InFunction>)));\n}\n", "/**\n * Utilities for using {@link https://effect-ts.github.io/effect/docs/platform | \\@effect/platform}.\n *\n * @module @sorrell/utilities/effect/platform\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Platform.ts\";\n", "/**\n * @file      Platform.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { Data } from \"effect\";\nimport type { Kind } from \"../../FileSystem/FileSystem.Types.ts\";\n/**\n * An error in which a given {@link Kind | filesystem object} was expected to exist\n * at a given {@link Path}, but the object was not found.\n *\n * @property {string} Path - The path where an object of the given {@link Kind} was expected,\n * but was not found.\n *\n * @property {Kind} Kind - The kind of object that was expected at the given {@link Path},\n * but was not found.\n */\nexport class PathNotFoundError extends Data.TaggedError(\"PathNotFoundError\")<Readonly<{\n    Path: string;\n    Kind: Kind;\n}>> {\n}\n/**\n * An error in which a {@link Kind | filesystem object} meeting a given\n * {@link Criteria | set of criteria} could not be found.\n *\n * @property {string} LastSearchResult - The last path that was tested when searching for\n * a {@link Kind | filesystem object} of a given {@link Criteria | set of criteria}.\n * but was not found.\n *\n * @property {string} Criteria - A human-readable description of the criteria defining the search\n * from which an error of this type originated.\n *\n * @property {Kind} Kind - The kind of object that was expected at the given {@link Path},\n * but was not found.\n */\nexport class SearchExhaustedError extends Data.TaggedError(\"SearchExhaustedError\")<Readonly<{\n    LastSearchResult?: string;\n    Criteria: string;\n    Kind: Kind;\n}>> {\n}\n", "/**\n * Utilities for working with files and directories.\n *\n * @module @sorrell/utilities/fs\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./FileSystem.ts\";\nexport * from \"./FileSystem.Types.ts\";\nexport * as Effect from \"./Effect/index.ts\";\nexport * as Module from \"./Module/index.ts\";\n", "/**\n * @file      FileSystem.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n// @TODO TEMPORARY\n/* eslint-disable jsdoc/require-jsdoc */\nimport * as FileSystem from \"node:fs/promises\";\nimport * as Path from \"node:path\";\nimport type { Dirent, Stats } from \"node:fs\";\nimport { basename, dirname, extname, join } from \"path\";\nimport { type FFileExtension } from \"./FileSystem.Types.ts\";\nimport { type FileHandle } from \"fs/promises\";\nimport { promises as Fs } from \"fs\";\nimport { constants as FsConstants } from \"fs\";\nimport os from \"os\";\n/* eslint-disable jsdoc/require-example */\n/**\n * Determine whether an object exists at the given {@link Path}.\n *\n * @param Path - The path to check for the existence of an object within the current file system.\n * @returns {Promise<boolean>} Whether there is an object at the given {@link Path}.\n */\nasync function PathExists(Path: string): Promise<boolean> {\n    try {\n        await Fs.access(Path, FsConstants.F_OK);\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/**\n * Determine whether the given {@link Extension | file extension} is valid on the current platform.\n *\n * @param Extension - The {@link FFileExtension | file extension} to test.\n * @returns {boolean} Whether the file extension is valid on the current platform.\n */\nexport function IsSupportedFileExtension(Extension: FFileExtension): boolean {\n    let NormalizedExtension: string = Extension.slice(1);\n    if (NormalizedExtension.startsWith(\".\")) {\n        NormalizedExtension = NormalizedExtension.slice(1);\n    }\n    if (NormalizedExtension.length === 0) {\n        return false;\n    }\n    if (NormalizedExtension.includes(\"/\")\n        || NormalizedExtension.includes(\"\\\\\")\n        || NormalizedExtension.includes(\"\\0\")) {\n        return false;\n    }\n    if (os.platform() === \"win32\") {\n        /* eslint-disable-next-line no-control-regex */\n        const HasIllegalCharacters: boolean = /[<>:\"/\\\\|?*\\x00-\\x1F]/u.test(NormalizedExtension);\n        if (HasIllegalCharacters) {\n            return false;\n        }\n        if (/[ .]$/u.test(NormalizedExtension)) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Given a path at which we wish to create a new file, check if a file at that\n * path already exists, and if so, then append `(${ number })` before the file\n * extension, consistent with the Windows Explorer handles conflicting file\n * names when pasting files.\n *\n * @param InPath - The path from which a safe path is derived.\n *\n * @returns {Promise<string>} The path derived from the given {@link InPath | path}\n * at which no object yet exists.\n */\nexport async function GetSafeNewPath(InPath: string): Promise<string> {\n    const DirectoryPath: string = dirname(InPath);\n    const Extension: string = extname(InPath);\n    const FileName: string = basename(InPath);\n    const BaseFileName: string = Extension === \"\"\n        ? FileName\n        : basename(InPath, Extension);\n    let CandidatePath: string = InPath;\n    let Index: number = 1;\n    while (await PathExists(CandidatePath)) {\n        const CandidateFileName: string = `${BaseFileName} (${Index})${Extension}`;\n        CandidatePath = join(DirectoryPath, CandidateFileName);\n        Index++;\n    }\n    return CandidatePath;\n}\n/* eslint-disable-next-line @typescript-eslint/typedef */\nexport const ReservedWindowsFileNames = [\n    \"CON\",\n    \"PRN\",\n    \"AUX\",\n    \"NUL\",\n    \"COM1\",\n    \"COM2\",\n    \"COM3\",\n    \"COM4\",\n    \"COM5\",\n    \"COM6\",\n    \"COM7\",\n    \"COM8\",\n    \"COM9\",\n    \"LPT1\",\n    \"LPT2\",\n    \"LPT3\",\n    \"LPT4\",\n    \"LPT5\",\n    \"LPT6\",\n    \"LPT7\",\n    \"LPT8\",\n    \"LPT9\"\n] as const;\n/* eslint-disable no-control-regex */\nexport /** A regular expression describing the characters that are not permitted in file names. */ const InvalidCharacters: RegExp = /[<>:\"/\\\\|?*\\u0000-\\u001F]/u;\n/* eslint-enable no-control-regex */\n/**\n * Determines whether the given {@link FileName} is valid within the given {@link DirectoryPath}.\n *\n * @remarks This *does* attempt to create a file at the desired path.  The file is\n * temporary iff `!PersistNewFile`, and is never created when this function\n * returns `false`.\n *\n * @param DirectoryPath - The path to the directory in which you wish to check.\n * @param FileName - The desired file name.\n * @param PersistNewFile - If specified, whether to keep the otherwise-temporary file\n * created at the desired path.  This defaults to `false`.\n * @param Extension - If provided, the function will only return `true` if\n * `FileName.endsWith(Extension)` *and* the `Extension` is a valid file extension.\n *\n * @returns {Promise<boolean>} Whether a file of the given `FileName` can be created in `DirectoryPath`.\n */\nexport async function IsValidFileNameOnSystem(DirectoryPath: string, FileName: string, PersistNewFile: boolean = false, Extension: FFileExtension | undefined = undefined): Promise<boolean> {\n    const ExtensionSafe: FFileExtension | null | \"\" = Extension !== undefined\n        ? (Extension.startsWith(\".\") && IsSupportedFileExtension(Extension))\n            ? Extension\n            : null\n        : \"\";\n    const IsExtensionImproper: boolean = (ExtensionSafe === null ||\n        ExtensionSafe === \".\" ||\n        !FileName.endsWith(ExtensionSafe));\n    if (IsExtensionImproper) {\n        return false;\n    }\n    const FilePath: string = join(DirectoryPath, FileName);\n    try {\n        const ThisFileHandle: FileHandle = await Fs.open(FilePath, \"wx\");\n        await ThisFileHandle.close();\n        if (!PersistNewFile) {\n            await Fs.unlink(FilePath);\n        }\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/**\n * Write a text file to a given {@link Path} having contents {@link Contents}.\n *\n * @param Path - The path of the file that will be written.\n * @param Contents - The text contents of the file to write.\n *\n * @returns {Promise<void>} A {@link Promise} that resolves when the call to {@link Fs.writeFile} resolves.\n *\n * @example\n * ```typescript\n * import { WriteTextFile } from \"@sorrell/utilities/fs\";\n * import { resolve } from \"path\";\n *\n * const MyReadMe: string = \"# ReadMe\\n\\nThis package accomplishes...\\n\";\n * const MyReadMePath: string = resolve(\".\");\n *\n * await WriteTextFile(MyReadMePath, MyReadMe);\n * ```\n */\nexport async function WriteTextFile(Path: string, Contents: string): Promise<void> {\n    await Fs.writeFile(Path, Contents, { encoding: \"utf-8\" });\n}\ntype DeletePhase = \"Scanning\" | \"Deleting\" | \"Done\";\ntype DeleteEntryKind = \"File\" | \"Directory\" | \"Other\";\ntype DeleteEntry = {\n    EntryPath: string;\n    Kind: DeleteEntryKind;\n    Size: number;\n};\ntype DeleteProgress = {\n    Phase: DeletePhase;\n    CurrentPath: string | null;\n    DiscoveredEntries: number;\n    TotalEntries: number;\n    DeletedEntries: number;\n    TotalBytes: number;\n    DeletedBytes: number;\n};\ntype DeleteWithProgressOptions = {\n    OnProgress?: (Progress: DeleteProgress) => void;\n    Signal?: AbortSignal;\n};\nfunction IsMissingFileError(ErrorValue: unknown): boolean {\n    return (typeof ErrorValue === \"object\" &&\n        ErrorValue !== null &&\n        \"code\" in ErrorValue &&\n        ErrorValue.code === \"ENOENT\");\n}\nfunction CloneProgress(Progress: DeleteProgress): DeleteProgress {\n    return { ...Progress };\n}\nasync function BuildDeletionPlan(RootPath: string, Progress: DeleteProgress, Options: DeleteWithProgressOptions): Promise<Array<DeleteEntry>> {\n    const Entries: Array<DeleteEntry> = [];\n    /* eslint-disable-next-line jsdoc/require-jsdoc */\n    async function Visit(CurrentPath: string): Promise<void> {\n        Options.Signal?.throwIfAborted();\n        Progress.Phase = \"Scanning\";\n        Progress.CurrentPath = CurrentPath;\n        Options.OnProgress?.(CloneProgress(Progress));\n        let Stats: Stats;\n        try {\n            Stats = await FileSystem.lstat(CurrentPath);\n        }\n        catch (ErrorValue) {\n            if (IsMissingFileError(ErrorValue)) {\n                return;\n            }\n            throw ErrorValue;\n        }\n        if (Stats.isDirectory()) {\n            const Children: Array<Dirent<string>> = await FileSystem.readdir(CurrentPath, {\n                withFileTypes: true\n            });\n            for (const Child of Children) {\n                await Visit(Path.join(CurrentPath, Child.name));\n            }\n            Entries.push({\n                EntryPath: CurrentPath,\n                Kind: \"Directory\",\n                Size: 0\n            });\n        }\n        else {\n            const Size: number = Stats.isFile() ? Stats.size : 0;\n            Entries.push({\n                EntryPath: CurrentPath,\n                Kind: Stats.isFile() ? \"File\" : \"Other\",\n                Size\n            });\n            Progress.TotalBytes += Size;\n        }\n        Progress.DiscoveredEntries = Entries.length;\n        Options.OnProgress?.(CloneProgress(Progress));\n    }\n    await Visit(RootPath);\n    return Entries;\n}\nexport async function DeleteWithProgress(RootPath: string, Options: DeleteWithProgressOptions = {}): Promise<void> {\n    const Progress: DeleteProgress = {\n        CurrentPath: null,\n        DeletedBytes: 0,\n        DeletedEntries: 0,\n        DiscoveredEntries: 0,\n        Phase: \"Scanning\",\n        TotalBytes: 0,\n        TotalEntries: 0\n    };\n    const Entries: Array<DeleteEntry> = await BuildDeletionPlan(RootPath, Progress, Options);\n    Progress.Phase = \"Deleting\";\n    Progress.TotalEntries = Entries.length;\n    Progress.CurrentPath = null;\n    Options.OnProgress?.(CloneProgress(Progress));\n    for (const Entry of Entries) {\n        Options.Signal?.throwIfAborted();\n        Progress.CurrentPath = Entry.EntryPath;\n        Options.OnProgress?.(CloneProgress(Progress));\n        try {\n            if (Entry.Kind === \"Directory\") {\n                await FileSystem.rmdir(Entry.EntryPath);\n            }\n            else {\n                await FileSystem.unlink(Entry.EntryPath);\n            }\n        }\n        catch (ErrorValue) {\n            if (!IsMissingFileError(ErrorValue)) {\n                throw ErrorValue;\n            }\n        }\n        Progress.DeletedEntries += 1;\n        Progress.DeletedBytes += Entry.Size;\n        Options.OnProgress?.(CloneProgress(Progress));\n    }\n    Progress.Phase = \"Done\";\n    Progress.CurrentPath = null;\n    Options.OnProgress?.(CloneProgress(Progress));\n}\nconst TsJsExtensions: Set<string> = new Set([\n    \".ts\",\n    \".tsx\",\n    \".mts\",\n    \".cts\",\n    \".js\",\n    \".jsx\",\n    \".mjs\",\n    \".cjs\"\n]);\nexport function IsValidFileSubpath(DirectoryPath: string, FilePath: string): boolean {\n    if (IsValidDirectoryPath(DirectoryPath) === false) {\n        return false;\n    }\n    if (IsValidExtensionlessFilePath(FilePath) === false) {\n        return false;\n    }\n    if (Path.isAbsolute(FilePath) === false) {\n        return true;\n    }\n    return IsPathContainedUnderDirectory(DirectoryPath, FilePath);\n}\n;\nconst IsValidDirectoryPath = (DirectoryPath: string): boolean => {\n    if (DirectoryPath.trim() === \"\") {\n        return false;\n    }\n    const NormalizedDirectoryPath: string = Path.normalize(DirectoryPath);\n    const DirectoryBaseName: string = Path.basename(NormalizedDirectoryPath);\n    return IsValidPathSegment(DirectoryBaseName);\n};\nconst IsValidExtensionlessFilePath = (FilePath: string): boolean => {\n    if (FilePath.trim() === \"\") {\n        return false;\n    }\n    const NormalizedFilePath: string = Path.normalize(FilePath);\n    if (NormalizedFilePath.endsWith(Path.sep)) {\n        return false;\n    }\n    const FileName: string = Path.basename(NormalizedFilePath);\n    if (IsValidFileName(FileName) === false) {\n        return false;\n    }\n    const Extension: string = Path.extname(FileName).toLowerCase();\n    return TsJsExtensions.has(Extension) === false;\n};\nexport function IsPathContainedUnderDirectory(ParentPath: string, ChildPath: string): boolean {\n    const ResolvedParentPath: string = Path.resolve(ParentPath);\n    const ResolvedChildPath: string = Path.resolve(ChildPath);\n    const RelativePath: string = Path.relative(ResolvedParentPath, ResolvedChildPath);\n    if (RelativePath === \"\") {\n        return false;\n    }\n    if (RelativePath === \"..\") {\n        return false;\n    }\n    if (RelativePath.startsWith(`..${Path.sep}`)) {\n        return false;\n    }\n    return Path.isAbsolute(RelativePath) === false;\n}\n;\nfunction IsValidFileName(FileName: string): boolean {\n    if (IsValidPathSegment(FileName) === false) {\n        return false;\n    }\n    if (FileName === \".\" || FileName === \"..\") {\n        return false;\n    }\n    return true;\n}\n;\nconst IsValidPathSegment = (PathSegment: string): boolean => {\n    if (PathSegment.trim() === \"\") {\n        return false;\n    }\n    /* eslint-disable-next-line no-control-regex */\n    if (/[<>:\"/\\\\|?*\\x00-\\x1F]/u.test(PathSegment)) {\n        return false;\n    }\n    if (/[. ]$/u.test(PathSegment)) {\n        return false;\n    }\n    return ReservedWindowsFileNames.every((Reserved: string): boolean => {\n        return !PathSegment.includes(Reserved);\n    });\n};\n/* eslint-enable jsdoc/require-example */\n", "/**\n * Utilities for using `effect` to work with files and directories.\n *\n * @module @sorrell/utilities/fs/effect\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./FileSystem.Effect.ts\";\n", "/**\n * @file      FileSystem.Effect.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport /** The temporary dummy export for the {@link fs/effect} module. */ const __FileSystem_Dummy_Export: \"__FileSystem_Dummy_Export\" = \"__FileSystem_Dummy_Export\" as const;\n", "/**\n * Utilities for working JavaScript/TypeScript module files.\n *\n * @module @sorrell/utilities/fs/module\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * as Extension from \"./Extension.ts\";\nexport * from \"./Module.ts\";\n", "/**\n * @file      Extension.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/* eslint-disable jsdoc/require-example */\n/* eslint-disable @typescript-eslint/typedef */\nexport /**\n       * The valid file extensions for TypeScript *source* modules.\n       */ const Source = [\n    \".ts\",\n    \".tsx\",\n    \".mts\",\n    \".cts\"\n] as const;\nexport /**\n       * The valid file extensions for TypeScript *declaration* modules.\n       */ const Declaration = [\n    \".d.ts\",\n    \".d.mts\",\n    \".d.cts\"\n] as const;\nexport /**\n       * The valid file extensions for *any* TypeScript module.\n       */ const Any = [\n    \".ts\",\n    \".tsx\",\n    \".mts\",\n    \".cts\",\n    \".d.ts\",\n    \".d.mts\",\n    \".d.cts\"\n] as const;\n/* eslint-enable @typescript-eslint/typedef */\nexport /**\n       * A {@link RegExp | regular expression} that describes all file names\n       * with a valid extension.\n       */ const IsValidRegExp: RegExp = /\\.(ts|tsx|mts|cts|d\\.ts|d\\.mts|d\\.cts)$/iu;\n/**\n * Determine whether a given {@link In | string} is a {@link Any | valid TypeScript module extension}.\n *\n * @param In - The string to test.\n *\n * @returns {In is Any} Whether the given {@link In | string} is a valid TypeScript module extension.\n */\nexport function IsValid(In: string): In is Any {\n    return IsValidRegExp.test(In);\n}\n/** The type of any valid TypeScript module file extension. */\nexport type Any = typeof Any[number];\n/** The type of any valid TypeScript *declaration* module file extension. */\nexport type Declaration = typeof Declaration[number];\n/** The type of any valid TypeScript *source* module file extension. */\nexport type Source = typeof Source[number];\n/** Specify how file extensions should be used in the context of module file names. */\nexport type Policy = \n/** An extension name is required in the given context. */\n\"Require\"\n/** Extension names are *banned* in the given context. */\n | \"Disallow\"\n/** An extension name is required *and* must be one of the extensions in this {@link ReadonlyArray}. */\n | ReadonlyArray<Any>;\n", "/**\n * @file      String.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { dfs } from \"effect/Graph\";\nimport { FilterDefined } from \"../Array\";\n/**\n * @module String\n * Functions for manipulating strings.\n */\n// @TODO TEMPORARY.\n/* eslint-disable jsdoc/require-example */\n/**\n * Does the given {@link TestString} contain only letters?\n * This is equivalent to Python's\n * {@link https://docs.python.org/3/library/stdtypes.html#str.isalpha | isalpha} function.\n *\n * @remarks This is an alias for {@link IsAlpha}.\n *\n * @param TestString - The string that you wish to test.\n *\n * @returns {boolean} Whether the given string contains *only* (Latin alphabet) letters.\n */\nexport function IsLetters(TestString: string): boolean {\n    return /^[a-zA-Z]*$/.test(TestString);\n}\n/**\n * Does the given {@link TestString} contain only letters?\n * This is equivalent to Python's\n * {@link https://docs.python.org/3/library/stdtypes.html#str.isalpha | isalpha} function.\n *\n * @param TestString - The string that you wish to test.\n *\n * @returns {boolean} Whether the given string contains *only* (Latin alphabet) letters.\n */\nexport function IsAlpha(TestString: string): boolean {\n    return IsLetters(TestString);\n}\n/**\n * Does the given {@link TestString} contain only digits?\n *\n * This is equivalent to Python's\n * {@link https://docs.python.org/3/library/stdtypes.html#str.isnumeric | isnumeric} function.\n *\n * @param TestString - The string that you wish to test.\n *\n * @returns {boolean} Whether the given string contains *only* numeric digits.\n */\nexport function IsNumeric(TestString: string): boolean {\n    return /^\\d+$/.test(TestString);\n}\n/**\n * This function provides a convenient way to define long strings across multiple lines.\n * The linebreaks and leading indentation are removed from the final string.\n * Please see the example below for how this is to be done.\n *\n * @param Content - The given string to dedent.\n * @param IndentLength - The number of spaces for which this function will check.  This\n * is necessary only if the number of spaces used in the {@link Content} is not a multiple\n * of two.\n *\n * @returns {string} The given {@link Content}, but with the spaces at the beginning\n * of each line (excluding the first line if no spaces exist in the first line) removed.\n *\n * @example\n * ```typescript\n * import { Dedent } from \"@sorrell/utilities/string\";\n *\n * const MyLongString: string = Dedent(`Lorem ipsum dolor sit amet, consectetur adipiscing elit,\n *             sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad\n *                 minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea\n *             commodo consequat.`);\n *\n * // `MyLongString` <- `\"Lorem ipsum dolor sit amet, consectetur adipiscing elit, \\\n * sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad \\\n *     minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea \\\n * commodo consequat.\"`\n * ```\n */\nexport function Dedent(Content: string, IndentLength?: number): string {\n    const WhitespaceSubstring: string = ((): string => {\n        if (IndentLength !== undefined) {\n            return \"\\n\" + \" \".repeat(IndentLength);\n        }\n        let WhitespaceSubstring: string = \"\\n\";\n        while (true) {\n            const TestString: string = WhitespaceSubstring + \"  \";\n            if (Content.includes(TestString)) {\n                WhitespaceSubstring = TestString;\n            }\n            else {\n                break;\n            }\n        }\n        return WhitespaceSubstring;\n    })();\n    return Content.replaceAll(WhitespaceSubstring, \"\");\n}\n/**\n * Given a {@link ReadonlyArray} of `string`s (and possibly `undefined`), join the `string`s\n * with a given {@link Separator} `string`.\n *\n * @param StringArray - The {@link ReadonlyArray} of `string`s, and possibly `undefined`.\n * @param Separator - The `string` passed to {@link Array.join} on the filtered {@link StringArray}.\n *\n * @returns {string} The joined `string`s in the given {@link StringArray}, separated by\n * the given {@link Separator}.\n */\nexport function JoinDefined<ElementType extends string | undefined>(StringArray: ReadonlyArray<ElementType>, Separator: string): string {\n    const IsDefined = <Type>(Element: Type): boolean => Element !== undefined;\n    const DefinedOnly: ReadonlyArray<string> = StringArray.filter(IsDefined) as ReadonlyArray<string>;\n    return DefinedOnly.join(Separator);\n}\nexport function GetUtf8ByteLength(Text: string): number {\n    return new TextEncoder().encode(Text).length;\n}\n", "/**\n * @file      Module.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/* eslint-disable jsdoc/require-example */\nimport * as Extension from \"./Extension.ts\";\nimport { InvalidCharacters, ReservedWindowsFileNames } from \"../FileSystem.ts\";\nimport { GetUtf8ByteLength } from \"../../String/String.ts\";\nexport namespace FileName {\n    /**\n     * For a given {@link FileName} and {@link ExtensionPolicy:param}, determine whether\n     * the given {@link FileName} is a valid TypeScript module file name.\n     *\n     * @param FileName - The file name to test.\n     *\n     * @param ExtensionPolicy - How the file extension (or lack of file extension) should affect\n     * the validity of the given {@link FileName}.\n     *\n     * @returns {boolean} Whether the given {@link FileName} is a valid name for a TypeScript module.\n     */\n    export function IsValid(FileName: string, ExtensionPolicy: Extension.Policy = \"Disallow\"): boolean {\n        if (FileName.length === 0) {\n            return false;\n        }\n        if (FileName === \".\" || FileName === \"..\") {\n            return false;\n        }\n        const DoesExtensionSatisfyPolicy: boolean = ((ExtensionPolicy === \"Disallow\" && !Extension.IsValidRegExp.test(FileName)) ||\n            (ExtensionPolicy === \"Require\" && Extension.IsValidRegExp.test(FileName)) ||\n            (Array.isArray(ExtensionPolicy) && ExtensionPolicy.some(FileName.endsWith)));\n        if (!DoesExtensionSatisfyPolicy) {\n            return false;\n        }\n        if (FileName.endsWith(\".\") || FileName.endsWith(\" \")) {\n            return false;\n        }\n        if (GetUtf8ByteLength(FileName) > 255) {\n            return false;\n        }\n        if (InvalidCharacters.test(FileName)) {\n            return false;\n        }\n        const FileNameWithoutDots: string | undefined = FileName.split(\".\")[0]?.toUpperCase();\n        const FileNameContainsWindowsReserved: boolean = (FileNameWithoutDots !== undefined &&\n            (ReservedWindowsFileNames as ReadonlyArray<string>).includes(FileNameWithoutDots));\n        if (FileNameContainsWindowsReserved) {\n            return false;\n        }\n        return true;\n    }\n}\n", "/**\n * Utilities that enable functional programming patterns in TypeScript.\n *\n * @remarks\n * This should be seen as a supplement to {@link https://effect.website/docs/ | effect};\n * it is not a total solution for implementing functional patterns in a TypeScript codebase.\n *\n * Additionally, some contents of this module have been migrated to\n * the {@link https://www.npmjs.com/package/@sorrell/functional | \\@sorrell/functional} package.\n *\n * @module @sorrell/utilities/functional\n * @experimental\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Functional.ts\";\nexport * from \"./Functional.Types.ts\";\n", "/**\n * @file      Functional.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/* eslint-disable jsdoc/require-example */\n/**\n * The identity mapping, for some {@link Array} of {@link ArgumentVector | given arguments}.\n *\n * @param ArgumentVector - The {@link Array} of given arguments.\n * @returns {typeof ArgumentVector} The {@link Array} of given arguments.\n */\nexport function Identity<ArgumentType>(...ArgumentVector: Array<ArgumentType>): typeof ArgumentVector {\n    return ArgumentVector;\n}\n/* eslint-enable jsdoc/require-example */\n", "/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/**\n * @module Math\n * Functions, types, and classes for mathematical computations.\n */\nexport * as Complex from \"./Index.Complex.ts\";\nexport * as Vector from \"./Vector.ts\";\nexport * from \"./Math.ts\";\nexport * from \"./Math.Types.ts\";\n", "/**\n * @file      Index.Complex.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Complex.ts\";\nexport * from \"./Complex.Types.ts\";\n", "/**\n * @file      Vector.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { Operator } from \"tsover-runtime\";\n/** A representation of elements in $\\mathbf{R}^2$. */\nexport class FVector2D {\n    /** The $x$-component of this vector. */\n    public readonly X: number;\n    /** The $y$-component of this vector. */\n    public readonly Y: number;\n    /** The identity of $\\mathbf{R}^2$ *wrt* addition. */\n    public static Zero: FVector2D = new FVector2D(0, 0);\n    /**\n     * Construct a vector by specifying both components.\n     *\n     * @param Value - The value of both the {@link FVector2D!X | x}- and\n     * {@link FVector2D!Y ? y}-components.\n     */\n    public constructor(Value: number);\n    /**\n     * Construct a vector by specifying both components.\n     *\n     * @param X - The value of the {@link FVector2D!X} component.\n     * @param Y - The value of the {@link FVector2D!Y} component.\n     */\n    public constructor(X: number, Y: number);\n    public constructor(X: number = 0, Y: number = X) {\n        this.X = X;\n        this.Y = Y;\n    }\n    /**\n     * Get a representation of this vector as a `string`.\n     *\n     * @returns {string} The string representation of this vector.\n     */\n    public toString(): string {\n        return `(${this.X}, ${this.Y})`;\n    }\n    /**\n     * Perform per-component addition of two {@link FVector2D}s.\n     *\n     * @param Left - The left-hand operand.\n     * @param Right - The right-hand operand.\n     *\n     * @returns {FVector2D} The per-component sum of {@link Left} and {@link Right}.\n     *\n     * @example\n     * ```typescript\n     * \"use tsover\";\n     *\n     * const A: FVector2D = new FVector2D(1, -1);\n     * const B: FVector2D = new FVector2D(-3, 5);\n     *\n     * const C: FVector2D = A + B;\n     * // `C` <- `(-2, 4)`\n     * ```\n     */\n    [Operator.plus](Left: FVector2D, Right: FVector2D): FVector2D {\n        return new FVector2D(Left.X + Right.X, Left.Y + Right.Y);\n    }\n    [Operator.minus](A: FVector2D, B: FVector2D): FVector2D {\n        return new FVector2D(A.X - B.X, A.Y - B.Y);\n    }\n    [Operator.preMinus](Vector: FVector2D): FVector2D {\n        return new FVector2D(-1 * Vector.X, -1 * Vector.Y);\n    }\n    /**\n     * Perform scalar multiplication of an {@link FVector2D} and a `number` value.\n     * Exactly one of the two arguments must be a `number`, and the other an\n     * {@link FVector2D}.\n     *\n     * @param Left - The left-hand operand (either a `number` or an {@link FVector2D}).\n     * @param Left - The right-hand operand (either a `number` or an {@link FVector2D}).\n     *\n     * @returns {FVector2D} The per-component sum of {@link Left} and {@link Right}.\n     */\n    [Operator.star](Left: number, Right: FVector2D): FVector2D;\n    [Operator.star](Left: FVector2D, Right: number): FVector2D;\n    [Operator.star](Left: FVector2D | number, Right: FVector2D | number): FVector2D | typeof Operator.deferOperation {\n        if (typeof Left === \"number\" && Right instanceof FVector2D) {\n            return new FVector2D(Left * Right.X, Left * Right.Y);\n        }\n        if (typeof Right === \"number\" && Left instanceof FVector2D) {\n            return new FVector2D(Left.X * Right, Left.Y * Right);\n        }\n        return Operator.deferOperation;\n    }\n    public get length(): number {\n        return Math.sqrt((this.X ** 2) + (this.Y ** 2));\n    }\n    public get Length(): number {\n        return this.length;\n    }\n}\n/** A representation of elements in $\\mathbf{R}^3$. */\nexport class FVector {\n    public readonly X: number;\n    public readonly Y: number;\n    public readonly Z: number;\n    /** Constructs the zero {@link FVector}. */\n    public constructor();\n    /**\n     * Constructs an {@link FVector} with all components set to {@link Value}.\n     *\n     * @param Value - The value of all components of the new {@link FVector}.\n     */\n    public constructor(Value: number);\n    /**\n     * Constructs an {@link FVector} with all components set to {@link Value}.\n     *\n     * @param X - The value of the {@link FVector!X} component.\n     * @param Y - The value of the {@link FVector!Y} component.\n     * @param Z - The value of the {@link FVector!Z} component.\n     */\n    public constructor(X: number, Y: number, Z: number);\n    public constructor(X: number = 0, Y: number = X, Z: number = X) {\n        this.X = X;\n        this.Y = Y;\n        this.Z = Z;\n    }\n    [Operator.plus](Left: FVector, Right: FVector): FVector {\n        return new FVector(Left.X + Right.X, Left.Y + Right.Y, Left.Z + Right.Z);\n    }\n    [Operator.minus](A: FVector, B: FVector): FVector {\n        return new FVector(A.X - B.X, A.Y - B.Y, A.Z - B.Z);\n    }\n    [Operator.preMinus](Vector: FVector): FVector {\n        return new FVector(-1 * Vector.X, -1 * Vector.Y, -1 * Vector.Z);\n    }\n    [Operator.star](Left: number, Right: FVector): FVector;\n    [Operator.star](Left: FVector, Right: number): FVector;\n    [Operator.star](Left: FVector | number, Right: FVector | number): FVector | typeof Operator.deferOperation {\n        if (typeof Left === \"number\" && Right instanceof FVector) {\n            return new FVector(Left * Right.X, Left * Right.Y, Left * Right.Z);\n        }\n        if (typeof Right === \"number\" && Left instanceof FVector) {\n            return new FVector(Left.X * Right, Left.Y * Right, Left.Z * Right);\n        }\n        return Operator.deferOperation;\n    }\n    public get length(): number {\n        return Math.sqrt((this.X ** 2) + (this.Y ** 2) + (this.Z ** 2));\n    }\n    public get Length(): number {\n        return this.length;\n    }\n}\n", "/**\n * @file      Math.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/* eslint-disable */\nexport const __DummyExport_Number: \"DummyExport\" = \"DummyExport\" as const;\n", "/**\n * Miscellaneous helper types and utilities.\n *\n * @module @sorrell/utilities/misc\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Utility.Types.ts\";\n", "/**\n * Utilities for working with `npm` (NodeJS) packages.\n * Many of these likely work with packages of other NodeJS\n * package managers and adjacent runtimes (*e.g.*, `bun` or `deno`).\n *\n * @module @sorrell/utilities/npm\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Npm.ts\";\nexport * from \"./Npm.Error.ts\";\n", "/**\n * @file      Npm.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { promises as Fs, constants as FsConstants } from \"fs\";\nimport { PackageJsonParseError, RootDirectoryNotFoundError } from \"./Npm.Error.ts\";\nimport { dirname, join } from \"path\";\nimport type { IPackageJson } from \"package-json-type\";\nimport { IsValidDependencyImportSpecifierParts } from \"./Npm.Internal.ts\";\nimport Process from \"process\";\n/**\n * Get the `package.json` of the Node.js project in which the\n * given path, or the current working directory, resides.\n *\n * @param Path - The given path from which to look for a root directory.\n *\n * @throws {RootDirectoryNotFoundError | PackageJsonParseError} An error\n * describing either failure to identify a root directory, or failing to\n * parse the discovered `package.json`.\n *\n * @returns {Promise<IPackageJson>} The {@link IPackageJson} of {@link Path}\n * if provided, otherwise of `process.cwd()`.\n *\n * @example\n * Suppose `process.cwd() === \"./MyPackage\"`,\n * ```typescript\n * const PackageJson: IPackageJson = await GetPackageJson();\n * // `PackageJson` <- *The parsed `package.json` of `MyPackage`.*\n * ```\n */\nexport async function GetPackageJson(Path?: string): Promise<IPackageJson> {\n    const RootDirectory: string = await GetPackageRootDirectory(Path);\n    const PackageJsonPath: string = join(RootDirectory, \"package.json\");\n    const FileContents: string = await Fs.readFile(PackageJsonPath, \"utf-8\");\n    const PackageJson: IPackageJson = await (async (): Promise<IPackageJson> => {\n        try {\n            return JSON.parse(FileContents) as IPackageJson;\n        }\n        catch (Cause: unknown) {\n            throw new PackageJsonParseError({ Cause, Path: PackageJsonPath });\n        }\n    })();\n    return PackageJson;\n}\n/**\n * Get the root directory of the Node.js project in which the\n * current working directory resides.\n *\n * @param Path - The given path from which to look for a root directory.\n *\n * @throws {RootDirectoryNotFoundError} An error iff the root directory\n * of a NodeJS package could not be found.\n *\n * @returns {Promise<string>} The path to the root directory of the package\n * containing {@link Path} if specified, otherwise containing `process.cwd()`.\n *\n * @example\n * Suppose `process.cwd()` is any one of the following,\n *   - `/home/alex/myPackage`,\n *   - `/home/alex/myPackage/src/MyModule`,\n *   - `/home/alex/myPackage/resource/Images`,\n *\n * then,\n *\n * ```typescript\n * const Root: string = await GetPackageRootDirectory();\n * // `Root` <- `\"/home/alex/myPackage\"`\n * ```\n *\n * @example\n * Suppose `TestPath === \"/home/alex/Documents\"` is *not* a NodeJS package root\n * (of course, neither are `/home/alex` or `/home`).  Then,\n *\n * ```typescript\n * const TestPath: string = \"/home/alex/Documents\";\n * let Root: string | undefined = undefined;\n * try\n * {\n *     Root = await GetPackageRootDirectory(TestPath);\n * }\n * catch (Error: unknown)\n * {\n *      // `Error instanceof RootDirectoryNotFound`\n * }\n *\n * // `Root` <- `undefined`\n * ```\n *\n * @example\n * Suppose `process.cwd() === /home/alex/Downloads`, which is *not* a NodeJS package\n * (of course, neither are `/home/alex` or `/home`).  Then,\n *\n * ```typescript\n * let Root: string | undefined = undefined;\n * try\n * {\n *     Root = await GetPackageRootDirectory();\n * }\n * catch (Error: unknown)\n * {\n *      // `Error instanceof RootDirectoryNotFound`\n * }\n * // `Root` <- `undefined`\n * ```\n */\nexport async function GetPackageRootDirectory(Path?: string): Promise<string> {\n    let CurrentDirectory: string = await Fs.realpath(Path ?? Process.cwd());\n    while (true) {\n        const PackageJsonPath: string = join(CurrentDirectory, \"package.json\");\n        const PackageJsonExists: boolean = await (async (): Promise<boolean> => {\n            try {\n                await Fs.access(PackageJsonPath, FsConstants.F_OK);\n                return true;\n            }\n            catch {\n                return false;\n            }\n        })();\n        if (PackageJsonExists) {\n            return CurrentDirectory;\n        }\n        const ParentDirectory: string = dirname(CurrentDirectory);\n        if (ParentDirectory === CurrentDirectory) {\n            throw new RootDirectoryNotFoundError({ Path });\n        }\n        CurrentDirectory = ParentDirectory;\n    }\n}\n/* eslint-disable jsdoc/require-example */\n/**\n * Determine whether a given {@link ImportSpecifier} is valid.  That is, whether\n * it consists of a valid package name, possibly followed by a `/`-delimited path\n * that may be specified by the package's `\"exports\"` property in its `package.json`.\n *\n * @param ImportSpecifier - The `import` specifier `string` to test.\n *\n * @returns {boolean} Whether the given {@link ImportSpecifier} is a valid `string`\n * to use in an `import` statement.\n */\nexport function IsValidDependencyImportSpecifier(ImportSpecifier: string): boolean {\n    if (ImportSpecifier.length === 0) {\n        return false;\n    }\n    if (ImportSpecifier.trim() !== ImportSpecifier) {\n        return false;\n    }\n    if (ImportSpecifier.includes(\"\\\\\")) {\n        return false;\n    }\n    if (ImportSpecifier.startsWith(\".\") || ImportSpecifier.startsWith(\"/\")) {\n        return false;\n    }\n    if (ImportSpecifier.includes(\":\")) {\n        return false;\n    }\n    if (ImportSpecifier.includes(\"//\")) {\n        return false;\n    }\n    const ImportSpecifierParts: ReadonlyArray<string> = ImportSpecifier.split(\"/\");\n    if (ImportSpecifier.startsWith(\"@\")) {\n        return IsValidDependencyImportSpecifierParts(ImportSpecifierParts, true);\n    }\n    return IsValidDependencyImportSpecifierParts(ImportSpecifierParts, false);\n}\n;\n/* eslint-enable jsdoc/require-example */\n", "/**\n * @file      Npm.Error.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { Data } from \"effect\";\n/**\n * An error describing that {@link GetPackageJson} failed to parse the discovered `package.json` file.\n *\n * @property {string | undefined} Path - The `Path` argument passed to the effect returning this error,\n * if one was given.\n * @property {unknown} Cause - The cause of this error.\n */\nexport class PackageJsonParseError extends Data.TaggedError(\"PackageJsonParseError\")<{\n    readonly Path: string | undefined;\n    readonly Cause: unknown;\n}> {\n}\n/**\n * An error describing that {@link GetPackageRootDirectory} failed.\n *\n * @property {string | undefined} Path - The `Path` argument passed to the effect returning\n * this error, if one was given.\n */\nexport class RootDirectoryNotFoundError extends Data.TaggedError(\"RootDirectoryNotFound\")<{\n    readonly Path: string | undefined;\n}> {\n}\n", "/**\n * @file      Npm.Internal.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/* eslint-disable jsdoc/require-example */\n/**\n * For a given unscoped package, determine whether the {@link Parts | ordered parts} of\n * a given import specifier of the unscoped package are valid.\n *\n * @param Parts - The parts of the import specifier to test.\n *\n * @param IsScoped - Whether the parts comprise an import specifier of a scoped `npm` package.\n *\n * @returns {boolean} Whether the ordered {@link Parts | import specifier parts} are valid.\n */\nexport function IsValidDependencyImportSpecifierParts(Parts: ReadonlyArray<string>, IsScoped: boolean): boolean {\n    if (IsScoped) {\n        const [ScopeName, PackageName, ...PackageSubpathParts] = Parts;\n        if (ScopeName === undefined || PackageName === undefined) {\n            return false;\n        }\n        if (IsValidScopeName(ScopeName) === false) {\n            return false;\n        }\n        if (IsValidPackageName(PackageName, true) === false) {\n            return false;\n        }\n        return PackageSubpathParts.every(IsValidPackageSubpathPart);\n    }\n    else {\n        const [PackageName, ...PackageSubpathParts] = Parts;\n        if (PackageName === undefined) {\n            return false;\n        }\n        if (IsValidPackageName(PackageName, false) === false) {\n            return false;\n        }\n        return PackageSubpathParts.every(IsValidPackageSubpathPart);\n    }\n}\n;\n/**\n * Determine whether a given {@link PackageName} is valid.\n *\n * @param PackageName - The package name whose validity is tested.\n *\n * @param IsScoped - Whether the given {@link PackageName} should be scoped.\n *\n * @returns {boolean} Whether the given {@link PackageName} is valid.\n */\nfunction IsValidPackageName(PackageName: string, IsScoped: boolean): boolean {\n    if (IsScoped) {\n        if (PackageName.length === 0) {\n            return false;\n        }\n        return IsValidNpmNamePart(PackageName);\n    }\n    else {\n        if (PackageName.length === 0 || PackageName.length > 214) {\n            return false;\n        }\n        if (PackageName.startsWith(\".\") || PackageName.startsWith(\"_\")) {\n            return false;\n        }\n        return IsValidNpmNamePart(PackageName);\n    }\n}\n;\n/**\n * Determine whether the given {@link ScopeName} is valid.\n *\n * @param ScopeName - The scope name to test.\n * @returns {boolean} Whether the given {@link ScopeName} is valid.\n */\nfunction IsValidScopeName(ScopeName: string): boolean {\n    if (ScopeName.length < 2) {\n        return false;\n    }\n    if (ScopeName.startsWith(\"@\") === false) {\n        return false;\n    }\n    return IsValidNpmNamePart(ScopeName.slice(1));\n}\n;\n/**\n * Determine whether the given {@link NamePart | part of an npm package name} is valid.\n *\n * @param NamePart - The name part to test.\n *\n * @returns {boolean} Whether the given {@link NamePart} is valid.\n */\nfunction IsValidNpmNamePart(NamePart: string): boolean {\n    if (NamePart.length === 0) {\n        return false;\n    }\n    if (NamePart !== NamePart.toLowerCase()) {\n        return false;\n    }\n    return /^[a-z0-9._~!$&'()*+,;=-]+$/u.test(NamePart);\n}\n;\n/**\n * Determine whether the given {@link Part | part of an npm package name} is a valid\n * part of a subpath within an `npm` package name.\n *\n * @param Part - The subpath part to test.\n *\n * @returns {boolean} Whether the given {@link NamePart} is valid.\n */\nfunction IsValidPackageSubpathPart(Part: string): boolean {\n    if (Part.length === 0) {\n        return false;\n    }\n    if (Part === \".\" || Part === \"..\") {\n        return false;\n    }\n    return /^[A-Za-z0-9._~!$&'()*+,;=@-]+$/u.test(Part);\n}\n;\n/* eslint-enable jsdoc/require-example */\n", "/**\n * Utilities for working with paths.\n *\n * @module @sorrell/utilities/path\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Path.ts\";\n", "/**\n * @file      Path.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { join } from \"path\";\nimport { Operator } from \"tsover-runtime\";\nexport class FPath {\n    public readonly Raw: string;\n    public toString(): string {\n        return this.Raw;\n    }\n    public constructor(String: string);\n    public constructor(Other: FPath);\n    public constructor(Argument: string | FPath) {\n        if (typeof Argument === \"string\") {\n            this.Raw = Argument;\n        }\n        else {\n            this.Raw = Argument.Raw;\n        }\n    }\n    [Operator.slash](A: FPath, B: FPath): FPath;\n    [Operator.slash](A: string, B: FPath): FPath;\n    [Operator.slash](A: FPath, B: string): FPath;\n    [Operator.slash](A: FPath | string, B: FPath | string): FPath {\n        if (typeof A === \"string\") {\n            return new FPath(join(A, (B as FPath).Raw));\n        }\n        else if (typeof B === \"string\") {\n            return new FPath(join((A as FPath).Raw, B));\n        }\n        else {\n            return new FPath(join((A as FPath).Raw, (B as FPath).Raw));\n        }\n    }\n}\n", "/**\n * Utilities for working with {@link Record | Records}.\n *\n * @note This is intended to be a small collection of helpers; consider\n * {@link https://effect-ts.github.io/effect/typeclass/data/Record.ts.html | the Record module in effect}\n * as a \"primary\" module for tools for working with Records.\n *\n * @module @sorrell/utilities/record\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Record.ts\";\nexport type { RecordNonNullable as NonNullable } from \"./Record.Meta.ts\";\nexport * from \"./Record.Types.ts\";\n", "/**\n * @file      Record.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport type { FlatMapper, FromPath, Mapper, Path, Walkable } from \"./Record.Types.ts\";\nimport type { Ref } from \"../Miscellaneous/Utility.Types.ts\";\n// @TODO Write example for `SetPropertyFromPath`.\n/* eslint-disable jsdoc/require-example */\n/**\n * Set a value within a given {@link InRecord | Record} at a given {@link Path} to be a given\n * {@link Value}.\n *\n * @param InRecord - The {@link Record} that holds the value with path {@link Path} to be retrieved\n * by this function.\n * @param Path - The {@link PathType} that describes the property to be retrieved by this.\n * @param Value - The value to be set at the given {@link Path} of the given {@link InRecord | Record}.\n *\n * @throws {Error} An {@link Error} iff the given {@link Path} is an {@link Array}, rather than a\n * `.`-delimited `string`.\n */\nexport function SetPropertyFromPath<RecordType extends Walkable, PathType extends Path<RecordType>>(InRecord: RecordType, Path: PathType, Value: FromPath<RecordType, PathType>): void {\n    type FProperty = FromPath<RecordType, PathType>;\n    if (Array.isArray(Path)) {\n        throw new Error(\"SetPropertyFromPath does not support Array-based paths yet.\");\n    }\n    const PathSplit: Array<string> = Path.split(\".\");\n    const Last: string | undefined = PathSplit.pop();\n    if (Last === undefined) {\n        return;\n    }\n    if (PathSplit.length === 0) {\n        if (!Array.isArray(Path)) {\n            ((InRecord.Ref as Record<string, unknown>)[(Path as string)]) = Value;\n        }\n    }\n    const Recurrence = (In: unknown): unknown | undefined => {\n        const NextPropertyNameBase: string | undefined = PathSplit.shift();\n        if (NextPropertyNameBase !== undefined) {\n            const NextPropertyName: string | number = isNaN(parseInt(NextPropertyNameBase))\n                ? NextPropertyNameBase\n                : parseInt(NextPropertyNameBase);\n            const Out: unknown = (In as Record<string, unknown>)[NextPropertyName] as unknown;\n            return Recurrence(Out);\n        }\n        else {\n            return In;\n        }\n    };\n    const PropertyRef: Ref<FProperty> = Recurrence(InRecord) as Ref<FProperty>;\n    const LastTyped: string | number = isNaN(parseInt(Last))\n        ? Last\n        : parseInt(Last);\n    (PropertyRef.Ref as Record<string, unknown>)[LastTyped] = Value;\n}\n;\n/* eslint-enable jsdoc/require-example */\n// @TODO Write example for `GetPropertyFromPath`.\n/* eslint-disable jsdoc/require-example */\n/**\n * Get a value within a given {@link InRecord | Record} at a given {@link Path}.\n *\n * @param InRecord - The {@link Record} that holds the value with path {@link Path} to be retrieved\n * by this function.\n * @param Path - The {@link PathType} that describes the property to be retrieved by this.\n *\n * @throws {Error} An {@link Error} iff the given {@link Path} is an {@link Array}, rather than a\n * `.`-delimited `string`.\n *\n * @returns {FromPath<RecordType, PathType>} The value in the {@link InRecord} at the given {@link Path}.\n */\nexport function GetPropertyFromPath<RecordType extends Record<string, unknown>, PathType extends Path<RecordType>>(InRecord: RecordType, Path: PathType): FromPath<RecordType, PathType> {\n    if (Array.isArray(Path)) {\n        throw new Error(\"GetPropertyFromPath does not support Array-based paths yet.\");\n    }\n    const PathSplit: Array<string> = Path.split(\".\");\n    const Recurrence = (In: unknown, Index: number = 0): unknown => {\n        const Key: string | number | undefined = isNaN(parseInt(PathSplit[Index] || \"\"))\n            ? PathSplit[Index]\n            : parseInt(PathSplit[Index] || \"\");\n        if (Key !== undefined) {\n            const Next: unknown = (In as Record<string, unknown>)[Key];\n            if (Index !== PathSplit.length - 1) {\n                return Recurrence(Next, Index + 1);\n            }\n            else {\n                return Next;\n            }\n        }\n        else {\n            return undefined;\n        }\n    };\n    return Recurrence(InRecord) as FromPath<RecordType, PathType>;\n}\n;\n/* eslint-enable jsdoc/require-example */\n/**\n * Creates a {@link Ref} of a given {@link Type}.  Useful for passing\n * primitives to functions by-reference.\n *\n * @template Type - The type of the value wrapped by the returned {@link Ref}.\n *\n * @returns {Ref<Type>} A {@link Ref} of the given {@link Type}.\n */\nexport function MakeRef<Type>(): Ref<Type> {\n    return {\n        Ref: undefined\n    } as Ref<Type>;\n}\n;\n// @TODO Write example for `MapRecord`.\n/* eslint-disable jsdoc/require-example */\n/**\n * Maps a {@link Record} to an {@link Array}.\n *\n * @param InRecord - The {@link Record} over which this function maps.\n * @param InFunction - The {@link FlatMapTransformer | transformer} that maps\n * the record to an {@link Array}.\n *\n * @returns {Array<ElementType>} An {@link Array} of elements, mapped from the given {@link InRecord}.\n */\nexport function Map<KeyType extends PropertyKey, PropertyType, ElementType>(InRecord: Record<KeyType, PropertyType>, InFunction: Mapper<KeyType, PropertyType, ElementType>): Array<ElementType> {\n    return Object.keys(InRecord).map((InKey: string, Index: number): ElementType => {\n        const Key: KeyType = InKey as KeyType;\n        return InFunction(Key, InRecord[Key], Index);\n    });\n}\n;\n/* eslint-enable jsdoc/require-example */\n// @TODO Write example for `FlatMap`.\n/* eslint-disable jsdoc/require-example */\n/**\n * Maps a {@link Record} to an {@link Array}.\n *\n * @param InRecord - The {@link Record} over which this function maps.\n * @param InFunction - The {@link FlatMapTransformer | transformer} that maps\n * the record to an {@link Array}.\n *\n * @returns {Array<ElementType>} An {@link Array} of elements, mapped from the given {@link InRecord}.\n */\nexport function FlatMap<KeyType extends PropertyKey, PropertyType, ElementType>(InRecord: Record<KeyType, PropertyType>, InFunction: FlatMapper<KeyType, PropertyType, ElementType>): Array<ElementType> {\n    return Object.keys(InRecord).flatMap((InKey: string, Index: number): Array<ElementType> => {\n        const Key: KeyType = InKey as KeyType;\n        const Transform: ElementType | Array<ElementType> = InFunction(Key, InRecord[Key], Index);\n        return Array.isArray(Transform)\n            ? Transform\n            : [Transform];\n    });\n}\n/* eslint-enable jsdoc/require-example */\n", "/**\n * Utilities for working with `string`s.\n *\n * @module @sorrell/utilities/string\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./String.ts\";\n", "/**\n * Utilities for working with `tsconfig.json` files.  This module\n * primarily exports types equivalent to the types of values encountered\n * in `tsconfig.json` files that are not exported by the `typescript` package.\n *\n * @module @sorrell/utilities/tsconfig\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./TsConfig.Types.ts\";\n", "/**\n * Utilities for working with tuple types.\n *\n * @module @sorrell/utilities/tuple\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Tuple.Types.ts\";\n", "/**\n * Utilities for working with type definitions in TypeScript modules.\n *\n * @note The functions provided by this module require the `typescript` peer dependency.\n *\n * @module @sorrell/utilities/type\n */\n/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Test.ts\";\nexport * from \"./Test.Types.ts\";\nexport * from \"./Utility.Types.ts\";\n", "/**\n * @file      Test.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/* eslint-disable jsdoc/require-example */\nimport TypeScript from \"typescript\";\n/**\n * Determine whether a given {@link TypeName} is a valid type name in TypeScript.\n *\n * @param TypeName - The type name to test.\n *\n * @returns {boolean} Whether the given {@link TypeName} is valid.\n */\nexport function IsValidTypeName(TypeName: string): boolean {\n    if (TypeName.length === 0) {\n        return false;\n    }\n    if (TypeName.trim() !== TypeName) {\n        return false;\n    }\n    const FileName: string = \"TypeNameValidation.ts\";\n    const SourceText: string = `type ${TypeName} = unknown;`;\n    const CompilerOptions: TypeScript.CompilerOptions = {\n        noEmit: true,\n        skipLibCheck: true,\n        target: TypeScript.ScriptTarget.Latest\n    };\n    const DefaultCompilerHost: TypeScript.CompilerHost = TypeScript.createCompilerHost(CompilerOptions, true);\n    const CompilerHost: TypeScript.CompilerHost = {\n        ...DefaultCompilerHost,\n        getSourceFile: (RequestedFileName: string, LanguageVersion: TypeScript.ScriptTarget | TypeScript.CreateSourceFileOptions, OnError: (Message: string) => void | undefined, ShouldCreateNewSourceFile: boolean | undefined): TypeScript.SourceFile | undefined => {\n            if (RequestedFileName === FileName) {\n                return TypeScript.createSourceFile(FileName, SourceText, LanguageVersion, true, TypeScript.ScriptKind.TS);\n            }\n            return DefaultCompilerHost.getSourceFile(RequestedFileName, LanguageVersion, OnError, ShouldCreateNewSourceFile);\n        }\n    };\n    const Program: TypeScript.Program = TypeScript.createProgram([FileName], CompilerOptions, CompilerHost);\n    const SourceFile: TypeScript.SourceFile | undefined = Program.getSourceFile(FileName);\n    if (SourceFile === undefined) {\n        return false;\n    }\n    if (Program.getSyntacticDiagnostics(SourceFile).length > 0) {\n        return false;\n    }\n    const [Statement] = SourceFile.statements;\n    if (SourceFile.statements.length !== 1 ||\n        Statement === undefined ||\n        TypeScript.isTypeAliasDeclaration(Statement) === false) {\n        return false;\n    }\n    return Statement.name.getText(SourceFile) === TypeName;\n}\n"],
  "mappings": "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",
  "names": ["Array", "Source", "Data", "import_effect", "Effect_exports", "import_fs", "Path", "Fs", "FsConstants", "os", "FileName", "FileName", "FileName", "Effect_exports", "WhitespaceSubstring", "FileName", "IsValid", "import_tsover_runtime", "import_fs", "import_effect", "import_path", "Path", "Fs", "Process", "FsConstants", "import_path", "import_tsover_runtime", "Map", "Path", "Path", "Map", "FileName", "TypeScript"]
}