@gesslar/toolkit 0.8.0 → 1.0.2

package/src/types/browser/lib/Data.d.ts

@@ -0,0 +1,206 @@
+export default class Data {
+    /**
+     * Array of JavaScript primitive type names.
+     * Includes basic types and object categories from the typeof operator.
+     *
+     * @type {Array<string>}
+     */
+    static primitives: Array<string>;
+    /**
+     * Array of JavaScript constructor names for built-in objects.
+     * Includes common object types and typed arrays.
+     *
+     * @type {Array<string>}
+     */
+    static constructors: Array<string>;
+    /**
+     * Combined array of all supported data types (primitives and constructors in
+     * lowercase).
+     *
+     * Used for type validation throughout the utility functions.
+     *
+     * @type {Array<string>}
+     */
+    static dataTypes: Array<string>;
+    /**
+     * Array of type names that can be checked for emptiness.
+     * These types have meaningful empty states that can be tested.
+     *
+     * @type {Array<string>}
+     */
+    static emptyableTypes: Array<string>;
+    /**
+     * Appends a string to another string if it does not already end with it.
+     *
+     * @param {string} string - The string to append to
+     * @param {string} append - The string to append
+     * @returns {string} The appended string
+     */
+    static appendString(string: string, append: string): string;
+    /**
+     * Prepends a string to another string if it does not already start with it.
+     *
+     * @param {string} string - The string to prepend to
+     * @param {string} prepend - The string to prepend
+     * @returns {string} The prepended string
+     */
+    static prependString(string: string, prepend: string): string;
+    /**
+     * Creates a type spec from a string. A type spec is an array of objects
+     * defining the type of a value and whether an array is expected.
+     *
+     * @param {string} string - The string to parse into a type spec.
+     * @param {object} options - Additional options for parsing.
+     * @returns {Array<object>} An array of type specs.
+     */
+    static newTypeSpec(string: string, options: object): Array<object>;
+    /**
+     * Checks if a value is of a specified type
+     *
+     * @param {unknown} value The value to check
+     * @param {string|TypeSpec} type The type to check for
+     * @param {object} options Additional options for checking
+     * @returns {boolean} Whether the value is of the specified type
+     */
+    static isType(value: unknown, type: string | TypeSpec, options?: object): boolean;
+    /**
+     * Checks if a type is valid
+     *
+     * @param {string} type - The type to check
+     * @returns {boolean} Whether the type is valid
+     */
+    static isValidType(type: string): boolean;
+    /**
+     * Checks if a value is of a specified type. Unlike the type function, this
+     * function does not parse the type string, and only checks for primitive
+     * or constructor types.
+     *
+     * @param {unknown} value - The value to check
+     * @param {string} type - The type to check for
+     * @returns {boolean} Whether the value is of the specified type
+     */
+    static isBaseType(value: unknown, type: string): boolean;
+    /**
+     * Returns the type of a value, whether it be a primitive, object, or function.
+     *
+     * @param {unknown} value - The value to check
+     * @returns {string} The type of the value
+     */
+    static typeOf(value: unknown): string;
+    /**
+     * Checks a value is undefined or null.
+     *
+     * @param {unknown} value The value to check
+     * @returns {boolean} Whether the value is undefined or null
+     */
+    static isNothing(value: unknown): boolean;
+    /**
+     * Checks if a value is empty. This function is used to check if an object,
+     * array, or string is empty. Null and undefined values are considered empty.
+     *
+     * @param {unknown} value The value to check
+     * @param {boolean} checkForNothing Whether to check for null or undefined
+     *                                  values
+     * @returns {boolean} Whether the value is empty
+     */
+    static isEmpty(value: unknown, checkForNothing?: boolean): boolean;
+    /**
+     * Freezes an object and all of its properties recursively.
+     *
+     * @param {object} obj The object to freeze.
+     * @returns {object} The frozen object.
+     */
+    static deepFreezeObject(obj: object): object;
+    /**
+     * Ensures that a nested path of objects exists within the given object.
+     * Creates empty objects along the path if they don't exist.
+     *
+     * @param {object} obj - The object to check/modify
+     * @param {Array<string>} keys - Array of keys representing the path to ensure
+     * @returns {object} Reference to the deepest nested object in the path
+     */
+    static assureObjectPath(obj: object, keys: Array<string>): object;
+    /**
+     * Sets a value in a nested object structure using an array of keys; creating
+     * the structure if it does not exist.
+     *
+     * @param {object} obj - The target object to set the value in
+     * @param {Array<string>} keys - Array of keys representing the path to the target property
+     * @param {unknown} value - The value to set at the target location
+     */
+    static setNestedValue(obj: object, keys: Array<string>, value: unknown): void;
+    /**
+     * Deeply merges two or more objects. Arrays are replaced, not merged.
+     *
+     * @param {...object} sources - Objects to merge (left to right)
+     * @returns {object} The merged object
+     */
+    static mergeObject(...sources: object[]): object;
+    /**
+     * Filters an array asynchronously using a predicate function.
+     * Applies the predicate to all items in parallel and returns filtered results.
+     *
+     * @param {Array<unknown>} arr - The array to filter
+     * @param {(value: unknown) => Promise<boolean>} predicate - Async predicate function that returns a promise resolving to boolean
+     * @returns {Promise<Array<unknown>>} Promise resolving to the filtered array
+     */
+    static asyncFilter(arr: Array<unknown>, predicate: (value: unknown) => Promise<boolean>): Promise<Array<unknown>>;
+    /**
+     * Ensures a value is within a specified range.
+     *
+     * @param {number} val - The value to check.
+     * @param {number} min - The minimum value.
+     * @param {number} max - The maximum value.
+     * @returns {number} The value, constrained within the range of `min` to `max`.
+     */
+    static clamp(val: number, min: number, max: number): number;
+    /**
+     * Checks if a value is within a specified range (inclusive).
+     *
+     * @param {number} val - The value to check.
+     * @param {number} min - The minimum value (inclusive).
+     * @param {number} max - The maximum value (inclusive).
+     * @returns {boolean} True if the value is within the range, false otherwise.
+     */
+    static clamped(val: number, min: number, max: number): boolean;
+    /**
+     * Checks if a value is a plain object - created with object literals {},
+     * new Object(), or Object.create(null).
+     *
+     * Distinguishes plain objects from objects created by custom constructors, built-ins,
+     * or primitives. Plain objects only have Object.prototype or null in their prototype chain.
+     *
+     * @param {unknown} value - The value to check
+     * @returns {boolean} True if the value is a plain object, false otherwise
+     *
+     * @example
+     * isPlainObject({}) // true
+     * isPlainObject(new Object()) // true
+     * isPlainObject(Object.create(null)) // true
+     * isPlainObject([]) // false
+     * isPlainObject(new Date()) // false
+     * isPlainObject(null) // false
+     * isPlainObject("string") // false
+     * isPlainObject(class Person{}) // false
+     */
+    static isPlainObject(value: unknown): boolean;
+    /**
+     * Checks if a value is binary data.
+     * Returns true for ArrayBuffer, TypedArrays (Uint8Array, Int16Array, etc.),
+     * Blob, and Node Buffer instances.
+     *
+     * @param {unknown} value - The value to check
+     * @returns {boolean} True if the value is binary data, false otherwise
+     * @example
+     * Data.isBinary(new Uint8Array([1, 2, 3])) // true
+     * Data.isBinary(new ArrayBuffer(10)) // true
+     * Data.isBinary(Buffer.from('hello')) // true
+     * Data.isBinary(new Blob(['text'])) // true
+     * Data.isBinary('string') // false
+     * Data.isBinary({}) // false
+     * Data.isBinary(undefined) // false
+     */
+    static isBinary(value: unknown): boolean;
+}
+import TypeSpec from "./TypeSpec.js";
+//# sourceMappingURL=Data.d.ts.map

package/src/types/browser/lib/Data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Data.d.ts","sourceRoot":"","sources":["../../../browser/lib/Data.js"],"names":[],"mappings":"AAUA;IACA;;;;;OAKG;IACD,mBAFQ,KAAK,CAAC,MAAM,CAAC,CAgBnB;IAEF;;;;;OAKG;IACH,qBAFU,KAAK,CAAC,MAAM,CAAC,CAmBrB;IAEF;;;;;;;OAOG;IACH,kBAFU,KAAK,CAAC,MAAM,CAAC,CAKrB;IAEF;;;;;OAKG;IACH,uBAFU,KAAK,CAAC,MAAM,CAAC,CAE6C;IAEpE;;;;;;OAMG;IACH,4BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,6BAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,2BAJW,MAAM,WACN,MAAM,GACJ,KAAK,CAAC,MAAM,CAAC,CAIzB;IAED;;;;;;;OAOG;IACH,qBALW,OAAO,QACP,MAAM,GAAC,QAAQ,YACf,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;OAKG;IACH,yBAHW,MAAM,GACJ,OAAO,CASnB;IAED;;;;;;;;OAQG;IACH,yBAJW,OAAO,QACP,MAAM,GACJ,OAAO,CAwBnB;IAED;;;;;OAKG;IACH,qBAHW,OAAO,GACL,MAAM,CAclB;IAED;;;;;OAKG;IACH,wBAHW,OAAO,GACL,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,sBALW,OAAO,oBACP,OAAO,GAEL,OAAO,CA2BnB;IAED;;;;;OAKG;IACH,6BAHW,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,QACN,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CAiBlB;IAED;;;;;;;OAOG;IACH,2BAJW,MAAM,QACN,KAAK,CAAC,MAAM,CAAC,SACb,OAAO,QAMjB;IAED;;;;;OAKG;IACH,+BAHc,MAAM,EAAA,GACP,MAAM,CAqBlB;IAED;;;;;;;OAOG;IACH,wBAJW,KAAK,CAAC,OAAO,CAAC,aACd,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAClC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAMnC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,OACN,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,oBALW,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,4BAbW,OAAO,GACL,OAAO,CA+BnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,uBAXW,OAAO,GACL,OAAO,CAgBnB;CACF;qBA5aoB,eAAe"}

package/src/types/browser/lib/Sass.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Custom error class for toolkit errors.
+ * Provides error chaining, trace management, and formatted error reporting.
+ */
+export default class Sass extends Error {
+    /**
+     * Creates an Sass from an existing Error object with additional
+     * trace message.
+     *
+     * @param {Error} error - The original error object
+     * @param {string} message - Additional trace message to add
+     * @returns {Sass} New Sass instance with trace from the original error
+     * @throws {Sass} If the first parameter is not an Error instance
+     */
+    static from(error: Error, message: string): Sass;
+    /**
+     * Factory method to create or enhance Sass instances.
+     * If error parameter is provided, enhances existing Sass or wraps
+     * other errors. Otherwise creates a new Sass instance.
+     *
+     * @param {string} message - The error message
+     * @param {Error|Sass|Tantrum} [error] - Optional existing error to wrap or enhance
+     * @returns {Sass} New or enhanced Sass instance
+     */
+    static "new"(message: string, error?: Error | Sass | Tantrum): Sass;
+    /**
+     * Creates a new Sass instance.
+     *
+     * @param {string} message - The error message
+     * @param {...unknown} [arg] - Additional arguments passed to parent Error constructor
+     */
+    constructor(message: string, ...arg?: unknown[]);
+    /**
+     * Adds a message to the beginning of the trace array.
+     *
+     * @param {string} message - The trace message to add
+     */
+    set trace(message: string);
+    /**
+     * Gets the error trace array.
+     *
+     * @returns {Array<string>} Array of trace messages
+     */
+    get trace(): Array<string>;
+    /**
+     * Adds a trace message and returns this instance for chaining.
+     *
+     * @param {string} message - The trace message to add
+     * @returns {this} This Sass instance for method chaining
+     */
+    addTrace(message: string): this;
+    /**
+     * Reports the error to the console with formatted output.
+     * Optionally includes detailed stack trace information.
+     *
+     * @param {boolean} [nerdMode] - Whether to include detailed stack trace
+     */
+    report(nerdMode?: boolean): void;
+    #private;
+}
+import Tantrum from "./Tantrum.js";
+//# sourceMappingURL=Sass.d.ts.map

package/src/types/browser/lib/Sass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sass.d.ts","sourceRoot":"","sources":["../../../browser/lib/Sass.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH;IA2GE;;;;;;;;OAQG;IACH,mBALW,KAAK,WACL,MAAM,GACJ,IAAI,CAWhB;IAED;;;;;;;;OAQG;IACH,sBAJW,MAAM,UACN,KAAK,GAAC,IAAI,GAAC,OAAO,GAChB,IAAI,CAchB;IAhJD;;;;;OAKG;IACH,qBAHW,MAAM,WACH,OAAO,EAAA,EAMpB;IAWD;;;;OAIG;IACH,mBAFW,MAAM,EAIhB;IAhBD;;;;OAIG;IACH,aAFa,KAAK,CAAC,MAAM,CAAC,CAIzB;IAWD;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;;;OAKG;IACH,kBAFW,OAAO,QAqBjB;;CA2EF;oBA1JmB,cAAc"}

package/src/types/browser/lib/Tantrum.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Custom aggregate error class that extends AggregateError.
+ * Automatically wraps plain errors in Sass instances for consistent reporting.
+ */
+export default class Tantrum extends AggregateError {
+    /**
+     * Factory method to create a Tantrum instance.
+     *
+     * @param {string} message - The aggregate error message
+     * @param {Array<Error|Sass>} errors - Array of errors to aggregate
+     * @returns {Tantrum} New Tantrum instance
+     */
+    static "new"(message: string, errors?: Array<Error | Sass>): Tantrum;
+    /**
+     * Creates a new Tantrum instance.
+     *
+     * @param {string} message - The aggregate error message
+     * @param {Array<Error|Sass>} errors - Array of errors to aggregate
+     * @param {Sass} sass - Sass constructor
+     */
+    constructor(message: string, errors?: Array<Error | Sass>, sass?: Sass);
+    /**
+     * Adds a trace message and returns this instance for chaining.
+     *
+     * @param {string} message - The trace message to add
+     * @param {Error|Sass} [_error] - Optional error (currently unused, reserved for future use)
+     * @returns {this} This Tantrum instance for method chaining
+     */
+    addTrace(message: string, _error?: Error | Sass): this;
+    /**
+     * Adds a message to the beginning of the trace array.
+     *
+     * @param {string} message - The trace message to add
+     */
+    set trace(message: string);
+    /**
+     * Gets the error trace array.
+     *
+     * @returns {Array<string>} Array of trace messages
+     */
+    get trace(): Array<string>;
+    /**
+     * Reports all aggregated errors to the console with formatted output.
+     *
+     * @param {boolean} [nerdMode] - Whether to include detailed stack traces
+     */
+    report(nerdMode?: boolean): void;
+    #private;
+}
+import Sass from "./Sass.js";
+//# sourceMappingURL=Tantrum.d.ts.map

package/src/types/browser/lib/Tantrum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tantrum.d.ts","sourceRoot":"","sources":["../../../browser/lib/Tantrum.js"],"names":[],"mappings":"AAaA;;;GAGG;AACH;IAoFE;;;;;;OAMG;IACH,sBAJW,MAAM,WACN,KAAK,CAAC,KAAK,GAAC,IAAI,CAAC,GACf,OAAO,CAOnB;IA5FD;;;;;;OAMG;IACH,qBAJW,MAAM,WACN,KAAK,CAAC,KAAK,GAAC,IAAI,CAAC,SACjB,IAAI,EAkBd;IAED;;;;;;OAMG;IACH,kBAJW,MAAM,WACN,KAAK,GAAC,IAAI,GACR,IAAI,CAShB;IAWD;;;;OAIG;IACH,mBAFW,MAAM,EAIhB;IAhBD;;;;OAIG;IACH,aAFa,KAAK,CAAC,MAAM,CAAC,CAIzB;IAWD;;;;OAIG;IACH,kBAFW,OAAO,QAgBjB;;CAeF;iBAvGgB,WAAW"}

package/src/types/browser/lib/TypeSpec.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Type specification class for parsing and validating complex type definitions.
+ * Supports union types, array types, and validation options.
+ */
+export default class TypeSpec {
+    /**
+     * Creates a new TypeSpec instance.
+     *
+     * @param {string} string - The type specification string (e.g., "string|number", "object[]")
+     * @param {object} options - Additional parsing options
+     */
+    constructor(string: string, options: object);
+    specs: any[];
+    length: number;
+    stringRepresentation: string;
+    /**
+     * Returns a string representation of the type specification.
+     *
+     * @returns {string} The type specification as a string (e.g., "string|number[]")
+     */
+    toString(): string;
+    /**
+     * Returns a JSON representation of the TypeSpec.
+     *
+     * @returns {object} Object containing specs, length, and string representation
+     */
+    toJSON(): object;
+    /**
+     * Executes a provided function once for each type specification.
+     *
+     * @param {function(unknown): void} callback - Function to execute for each spec
+     */
+    forEach(callback: (arg0: unknown) => void): void;
+    /**
+     * Tests whether all type specifications pass the provided test function.
+     *
+     * @param {function(unknown): boolean} callback - Function to test each spec
+     * @returns {boolean} True if all specs pass the test
+     */
+    every(callback: (arg0: unknown) => boolean): boolean;
+    /**
+     * Tests whether at least one type specification passes the provided test function.
+     *
+     * @param {function(unknown): boolean} callback - Function to test each spec
+     * @returns {boolean} True if at least one spec passes the test
+     */
+    some(callback: (arg0: unknown) => boolean): boolean;
+    /**
+     * Creates a new array with all type specifications that pass the provided test function.
+     *
+     * @param {function(unknown): boolean} callback - Function to test each spec
+     * @returns {Array<unknown>} New array with filtered specs
+     */
+    filter(callback: (arg0: unknown) => boolean): Array<unknown>;
+    /**
+     * Creates a new array populated with the results of calling the provided function on every spec.
+     *
+     * @param {function(unknown): unknown} callback - Function to call on each spec
+     * @returns {Array<unknown>} New array with mapped values
+     */
+    map(callback: (arg0: unknown) => unknown): Array<unknown>;
+    /**
+     * Executes a reducer function on each spec, resulting in a single output value.
+     *
+     * @param {function(unknown, unknown): unknown} callback - Function to execute on each spec
+     * @param {unknown} initialValue - Initial value for the accumulator
+     * @returns {unknown} The final accumulated value
+     */
+    reduce(callback: (arg0: unknown, arg1: unknown) => unknown, initialValue: unknown): unknown;
+    /**
+     * Returns the first type specification that satisfies the provided testing function.
+     *
+     * @param {function(unknown): boolean} callback - Function to test each spec
+     * @returns {object|undefined} The first spec that matches, or undefined
+     */
+    find(callback: (arg0: unknown) => boolean): object | undefined;
+    /**
+     * Tests whether a value matches any of the type specifications.
+     * Handles array types, union types, and empty value validation.
+     *
+     * @param {unknown} value - The value to test against the type specifications
+     * @param {object} options - Validation options
+     * @param {boolean} options.allowEmpty - Whether empty values are allowed
+     * @returns {boolean} True if the value matches any type specification
+     */
+    matches(value: unknown, options: {
+        allowEmpty: boolean;
+    }): boolean;
+    match(value: any, options: any): unknown[];
+    #private;
+}
+//# sourceMappingURL=TypeSpec.d.ts.map

package/src/types/browser/lib/TypeSpec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeSpec.d.ts","sourceRoot":"","sources":["../../../browser/lib/TypeSpec.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAGE;;;;;OAKG;IACH,oBAHW,MAAM,WACN,MAAM,EAUhB;IAJC,aAAwB;IACxB,eAAgC;IAChC,6BAA2C;IAI7C;;;;OAIG;IACH,YAFa,MAAM,CAQlB;IAED;;;;OAIG;IACH,UAFa,MAAM,CASlB;IAED;;;;OAIG;IACH,kBAFW,CAAS,IAAO,EAAP,OAAO,KAAG,IAAI,QAIjC;IAED;;;;;OAKG;IACH,gBAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,OAAO,CAInB;IAED;;;;;OAKG;IACH,eAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,OAAO,CAInB;IAED;;;;;OAKG;IACH,iBAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,KAAK,CAAC,OAAO,CAAC,CAI1B;IAED;;;;;OAKG;IACH,cAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,KAAK,CAAC,OAAO,CAAC,CAI1B;IAED;;;;;;OAMG;IACH,iBAJW,CAAS,IAAO,EAAP,OAAO,EAAE,IAAO,EAAP,OAAO,KAAG,OAAO,gBACnC,OAAO,GACL,OAAO,CAInB;IAED;;;;;OAKG;IACH,eAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;OAQG;IACH,eALW,OAAO,WAEf;QAAyB,UAAU,EAA3B,OAAO;KACf,GAAU,OAAO,CAInB;IAED,2CAkDC;;CAiCF"}

package/src/types/browser/lib/Util.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Utility class providing common helper functions for string manipulation,
+ * timing, and option parsing.
+ */
+export default class Util {
+    /**
+     * Capitalizes the first letter of a string.
+     *
+     * @param {string} text - The text to capitalize
+     * @returns {string} Text with first letter capitalized
+     */
+    static capitalize(text: string): string;
+    /**
+     * Measure wall-clock time for an async function.
+     *
+     * @template T
+     * @param {() => Promise<T>} fn - Thunk returning a promise.
+     * @returns {Promise<{result: T, cost: number}>} Object containing result and elapsed ms (number, 1 decimal).
+     */
+    static time<T>(fn: () => Promise<T>): Promise<{
+        result: T;
+        cost: number;
+    }>;
+    /**
+     * Right-align a string inside a fixed width (left pad with spaces).
+     * If the string exceeds width it is returned unchanged.
+     *
+     * @param {string|number} text - Text to align.
+     * @param {number} width - Target field width (default 80).
+     * @returns {string} Padded string.
+     */
+    static rightAlignText(text: string | number, width?: number): string;
+    /**
+     * Centre-align a string inside a fixed width (pad with spaces on left).
+     * If the string exceeds width it is returned unchanged.
+     *
+     * @param {string|number} text - Text to align.
+     * @param {number} width - Target field width (default 80).
+     * @returns {string} Padded string with text centred.
+     */
+    static centreAlignText(text: string | number, width?: number): string;
+    /**
+     * Asynchronously awaits all promises in parallel.
+     * Wrapper around Promise.all for consistency with other utility methods.
+     *
+     * @param {Array<Promise<unknown>>} promises - Array of promises to await
+     * @returns {Promise<Array<unknown>>} Results of all promises
+     */
+    static awaitAll(promises: Array<Promise<unknown>>): Promise<Array<unknown>>;
+    /**
+     * Settles all promises (both fulfilled and rejected) in parallel.
+     * Wrapper around Promise.allSettled for consistency with other utility methods.
+     *
+     * @param {Array<Promise<unknown>>} promises - Array of promises to settle
+     * @returns {Promise<Array<object>>} Results of all settled promises with status and value/reason
+     */
+    static settleAll(promises: Array<Promise<unknown>>): Promise<Array<object>>;
+    /**
+     * Checks if any result in the settled promise array is rejected.
+     *
+     * @param {Array<object>} result - Array of settled promise results.
+     * @returns {boolean} True if any result is rejected, false otherwise.
+     */
+    static anyRejected(result: Array<object>): boolean;
+    /**
+     * Filters and returns all rejected results from a settled promise array.
+     *
+     * @param {Array<object>} result - Array of settled promise results.
+     * @returns {Array<object>} Array of rejected results.
+     */
+    static settledAndRejected(result: Array<object>): Array<object>;
+    /**
+     * Extracts the rejection reasons from an array of rejected promise results.
+     *
+     * @param {Array<object>} rejected - Array of rejected results.
+     * @returns {Array<unknown>} Array of rejection reasons.
+     */
+    static rejectedReasons(rejected: Array<object>): Array<unknown>;
+    /**
+     * Throws a Sass error containing all rejection reasons from settled promises.
+     *
+     * @param {string} [_message] - Optional error message. Defaults to "GIGO"
+     * @param {Array<object>} rejected - Array of rejected results.
+     * @throws {Error} Throws a Sass error with rejection reasons.
+     */
+    static throwRejected(_message?: string, rejected: Array<object>): void;
+    /**
+     * Filters and returns all fulfilled results from a settled promise array.
+     *
+     * @param {Array<object>} result - Array of settled promise results.
+     * @returns {Array<object>} Array of fulfilled results.
+     */
+    static settledAndFulfilled(result: Array<object>): Array<object>;
+    /**
+     * Extracts the values from all fulfilled results in a settled promise array.
+     *
+     * @param {Array<object>} result - Array of settled promise results.
+     * @returns {Array<unknown>} Array of fulfilled values.
+     */
+    static fulfilledValues(result: Array<object>): Array<unknown>;
+    /**
+     * Returns the first promise to resolve or reject from an array of promises.
+     * Wrapper around Promise.race for consistency with other utility methods.
+     *
+     * @param {Array<Promise<unknown>>} promises - Array of promises to race
+     * @returns {Promise<unknown>} Result of the first settled promise
+     */
+    static race(promises: Array<Promise<unknown>>): Promise<unknown>;
+    /**
+     * Determine the Levenshtein distance between two string values
+     *
+     * @param {string} a The first value for comparison.
+     * @param {string} b The second value for comparison.
+     * @returns {number} The Levenshtein distance
+     */
+    static levenshteinDistance(a: string, b: string): number;
+    /**
+     * Determine the closest match between a string and allowed values
+     * from the Levenshtein distance.
+     *
+     * @param {string} input The input string to resolve
+     * @param {Array<string>} allowedValues The values which are permitted
+     * @param {number} [threshold] Max edit distance for a "close match"
+     * @returns {string} Suggested, probable match.
+     */
+    static findClosestMatch(input: string, allowedValues: Array<string>, threshold?: number): string;
+    static regexify(input: any, trim?: boolean, flags?: any[]): RegExp;
+}
+//# sourceMappingURL=Util.d.ts.map

package/src/types/browser/lib/Util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Util.d.ts","sourceRoot":"","sources":["../../../browser/lib/Util.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IACE;;;;;OAKG;IACH,wBAHW,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;;OAMG;IACH,YAJa,CAAC,MACH,MAAM,OAAO,CAAC,CAAC,CAAC,GACd,OAAO,CAAC;QAAC,MAAM,EAAE,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAQ9C;IAED;;;;;;;OAOG;IACH,4BAJW,MAAM,GAAC,MAAM,UACb,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,GAAC,MAAM,UACb,MAAM,GACJ,MAAM,CAalB;IAED;;;;;;OAMG;IACH,0BAHW,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GACrB,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAInC;IAED;;;;;;OAMG;IACH,2BAHW,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GACrB,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAIlC;IAED;;;;;OAKG;IACH,2BAHW,KAAK,CAAC,MAAM,CAAC,GACX,OAAO,CAInB;IAED;;;;;OAKG;IACH,kCAHW,KAAK,CAAC,MAAM,CAAC,GACX,KAAK,CAAC,MAAM,CAAC,CAIzB;IAED;;;;;OAKG;IACH,iCAHW,KAAK,CAAC,MAAM,CAAC,GACX,KAAK,CAAC,OAAO,CAAC,CAI1B;IAED;;;;;;OAMG;IACH,gCAJW,MAAM,YACN,KAAK,CAAC,MAAM,CAAC,QAKvB;IAED;;;;;OAKG;IACH,mCAHW,KAAK,CAAC,MAAM,CAAC,GACX,KAAK,CAAC,MAAM,CAAC,CAIzB;IAED;;;;;OAKG;IACH,+BAHW,KAAK,CAAC,MAAM,CAAC,GACX,KAAK,CAAC,OAAO,CAAC,CAI1B;IAED;;;;;;OAMG;IACH,sBAHW,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GACrB,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;;;OAMG;IACH,8BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAsBlB;IAED;;;;;;;;OAQG;IACH,+BALW,MAAM,iBACN,KAAK,CAAC,MAAM,CAAC,cACb,MAAM,GACJ,MAAM,CAwBlB;IAED,mEAiBC;CACF"}

package/src/types/browser/lib/Valid.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Validation utility class providing type checking and assertion methods.
+ */
+export default class Valid {
+    /**
+     * Validates a value against a type. Uses Data.isType.
+     *
+     * @param {unknown} value - The value to validate
+     * @param {string} type - The expected type in the form of "object", "object[]", "object|object[]"
+     * @param {object} [options] - Additional options for validation.
+     */
+    static type(value: unknown, type: string, options?: object): void;
+    /**
+     * Asserts a condition
+     *
+     * @param {boolean} condition - The condition to assert
+     * @param {string} message - The message to display if the condition is not
+     *                           met
+     * @param {number} [arg] - The argument to display if the condition is not
+     *                         met (optional)
+     */
+    static assert(condition: boolean, message: string, arg?: number): void;
+    static "__#private@#restrictedProto": string[];
+    /**
+     * Protects against prototype pollution by checking keys for dangerous property names.
+     * Throws if any restricted prototype properties are found in the keys array.
+     *
+     * @param {Array<string>} keys - Array of property keys to validate
+     * @throws {Sass} If any key matches restricted prototype properties (__proto__, constructor, prototype)
+     */
+    static prototypePollutionProtection(keys: Array<string>): void;
+}
+//# sourceMappingURL=Valid.d.ts.map

package/src/types/browser/lib/Valid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Valid.d.ts","sourceRoot":"","sources":["../../../browser/lib/Valid.js"],"names":[],"mappings":"AAWA;;GAEG;AACH;IACE;;;;;;OAMG;IACH,mBAJW,OAAO,QACP,MAAM,YACN,MAAM,QAQhB;IAED;;;;;;;;OAQG;IACH,yBANW,OAAO,WACP,MAAM,QAEN,MAAM,QAkBhB;IAED,+CAAmE;IAEnE;;;;;;OAMG;IACH,0CAHW,KAAK,CAAC,MAAM,CAAC,QAYvB;CACF"}

package/src/types/index.d.ts

@@ -1,17 +1,17 @@
-export { default as FileObject } from "./lib/FileObject.js";
-export { default as DirectoryObject } from "./lib/DirectoryObject.js";
-export { default as FS } from "./lib/FS.js";
+export { default as Collection } from "./browser/lib/Collection.js";
+export { default as Data } from "./browser/lib/Data.js";
+export { default as Type } from "./browser/lib/TypeSpec.js";
+export { default as Valid } from "./lib/Valid.js";
+export { default as Sass } from "./lib/Sass.js";
+export { default as Tantrum } from "./lib/Tantrum.js";
+export { default as Util } from "./lib/Util.js";
 export { default as Cache } from "./lib/Cache.js";
-export { default as Collection } from "./lib/Collection.js";
 export { default as Contract } from "./lib/Contract.js";
-export { default as Data } from "./lib/Data.js";
+export { default as DirectoryObject } from "./lib/DirectoryObject.js";
+export { default as FileObject } from "./lib/FileObject.js";
+export { default as FS } from "./lib/FS.js";
 export { default as Glog } from "./lib/Glog.js";
-export { default as Sass } from "./lib/Sass.js";
 export { default as Schemer } from "./lib/Schemer.js";
-export { default as Tantrum } from "./lib/Tantrum.js";
 export { default as Term } from "./lib/Term.js";
 export { default as Terms } from "./lib/Terms.js";
-export { default as Type } from "./lib/TypeSpec.js";
-export { default as Util } from "./lib/Util.js";
-export { default as Valid } from "./lib/Valid.js";
 //# sourceMappingURL=index.d.ts.map

package/src/types/lib/Cache.d.ts

@@ -17,12 +17,11 @@ export default class Cache {
      * freshness while optimizing performance for repeated file access during
      * parallel processing.
      *
-     * @param {FileObject} fileObject - The file object to load and cache
+     * @param {import("./FileObject.js").FileObject} fileObject - The file object to load and cache
      * @returns {Promise<unknown>} The parsed file data (JSON5 or YAML)
      * @throws {Sass} If the file cannot be found or accessed
      */
-    loadCachedData(fileObject: FileObject): Promise<unknown>;
+    loadCachedData(fileObject: import("./FileObject.js").FileObject): Promise<unknown>;
     #private;
 }
-import FileObject from "./FileObject.js";
 //# sourceMappingURL=Cache.d.ts.map

package/src/types/lib/Cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../lib/Cache.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH;IAoBE;;;;;;;;;;;;OAYG;IACH,2BAJW,UAAU,GACR,OAAO,CAAC,OAAO,CAAC,CA6B5B;;CACF;uBAxEsB,iBAAiB"}
+{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../lib/Cache.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IAoBE;;;;;;;;;;;;OAYG;IACH,2BAJW,OAAO,iBAAiB,EAAE,UAAU,GAClC,OAAO,CAAC,OAAO,CAAC,CA6B5B;;CACF"}