@gesslar/toolkit 0.6.0 → 0.7.0

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

@@ -0,0 +1,50 @@
+/**
+ * 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
+     */
+    constructor(message: string, errors?: Array<Error | 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 terminal 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/lib/Tantrum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tantrum.d.ts","sourceRoot":"","sources":["../../lib/Tantrum.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IAgFE;;;;;;OAMG;IACH,sBAJW,MAAM,WACN,KAAK,CAAC,KAAK,GAAC,IAAI,CAAC,GACf,OAAO,CAOnB;IAzFD;;;;;OAKG;IACH,qBAHW,MAAM,WACN,KAAK,CAAC,KAAK,GAAC,IAAI,CAAC,EAgB3B;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;iBApGgB,WAAW"}

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

@@ -0,0 +1,103 @@
+export default class Term {
+    /**
+     * Log an informational message.
+     *
+     * @param {...unknown} [arg] - Values to log.
+     */
+    static log(...arg?: unknown[]): void;
+    /**
+     * Log an informational message.
+     *
+     * @param {...unknown} [arg] - Values to log.
+     */
+    static info(...arg?: unknown[]): void;
+    /**
+     * Log a warning message.
+     *
+     * @param {...unknown} [arg] - Warning text / object.
+     */
+    static warn(...arg?: unknown[]): void;
+    /**
+     * Log an error message (plus optional details).
+     *
+     * @param {...unknown} [arg] - Values to log.
+     */
+    static error(...arg?: unknown[]): void;
+    /**
+     * Log a debug message (no-op unless console.debug provided/visible by env).
+     *
+     * @param {...unknown} [arg] - Values to log.
+     */
+    static debug(...arg?: unknown[]): void;
+    /**
+     * Emit a status line to the terminal.
+     *
+     * Accepts either a plain string or an array of message segments (see
+     * `terminalMessage()` for formatting options). If `silent` is true, output
+     * is suppressed.
+     *
+     * This is a convenient shortcut for logging status updates, with optional
+     * formatting and easy suppression.
+     *
+     * @param {string | Array<string | [string, string]>} args - Message or segments.
+     * @param {object} [options] - Behaviour flags.
+     * @param {boolean} options.silent - When true, suppress output.
+     * @returns {void}
+     */
+    static status(args: string | Array<string | [string, string]>, { silent }?: {
+        silent: boolean;
+    }): void;
+    /**
+     * Constructs a formatted status line.
+     *
+     * Input forms:
+     *  - string: printed as-is
+     *  - array: each element is either:
+     *    - a plain string (emitted unchanged), or
+     *    - a tuple: [level, text] where `level` maps to an ansiColors alias
+     *        (e.g. success, info, warn, error, modified).
+     *    - a tuple: [level, text, [openBracket,closeBracket]] where `level` maps to an ansiColors alias
+     *        (e.g. success, info, warn, error, modified). These are rendered as
+     *        colourised bracketed segments: [TEXT].
+     *
+     * The function performs a shallow validation: tuple elements must both be
+     * strings; otherwise a TypeError is thrown. Nested arrays beyond depth 1 are
+     * not supported.
+     *
+     * Recursion: array input is normalised into a single string then re-dispatched
+     * through `status` to leverage the string branch (keeps logic DRY).
+     *
+     * @param {string | Array<string | [string, string] | [string, string, string]>} argList - Message spec.
+     * @returns {void}
+     */
+    static terminalMessage(argList: string | Array<string | [string, string] | [string, string, string]>): void;
+    /**
+     * Construct a single coloured bracketed segment from a tuple specifying
+     * the style level and the text. The first element ("level") maps to an
+     * `ansiColors` alias (e.g. success, info, warn, error, modified) and is
+     * used both for the inner text colour and to locate its matching
+     * "-bracket" alias for the surrounding square brackets. The second
+     * element is the raw text to display.
+     *
+     * Input validation: every element of `parts` must be a string; otherwise
+     * an `Sass` error is thrown. (Additional elements beyond the first two are
+     * ignored – the method destructures only the first pair.)
+     *
+     * Example:
+     *  terminalBracket(["success", "COMPILED"]) → "[COMPILED]" with coloured
+     *  brackets + inner text (assuming colour support is available in the
+     *  terminal).
+     *
+     * This method does not append trailing spaces; callers are responsible for
+     * joining multiple segments with appropriate separators.
+     *
+     * @param {Array<string>} parts - Tuple: [level, text]. Additional entries ignored.
+     * @returns {string} Colourised bracketed segment (e.g. "[TEXT]").
+     * @throws {Sass} If any element of `parts` is not a string.
+     */
+    static terminalBracket([level, text, brackets]: Array<string>): string;
+    static resetTerminal(): Promise<void>;
+    static clearLines(num: any): Promise<void>;
+    static directWrite(output: any): Promise<any>;
+}
+//# sourceMappingURL=Term.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Term.d.ts","sourceRoot":"","sources":["../../lib/Term.js"],"names":[],"mappings":"AAKA;IACE;;;;OAIG;IACH,oBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,qBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,qBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,eAEjD;QAAyB,MAAM,EAAvB,OAAO;KACf,GAAU,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gCAHW,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,GAClE,IAAI,CA4BhB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,gDAJW,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CASlB;IAED,sCAGC;IAED,2CAEC;IAED,8CAIC;CACF"}

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

@@ -0,0 +1,24 @@
+/**
+ * Terms represents an interface definition - what an action promises to provide or accept.
+ * It's just the specification, not the negotiation. Contract handles the negotiation.
+ */
+export default class Terms {
+    /**
+     * Parses terms data, handling file references
+     *
+     * @param {string|object} termsData - Terms data or reference
+     * @param {DirectoryObject?} directoryObject - Directory context for file resolution
+     * @returns {object} Parsed terms data
+     */
+    static parse(termsData: string | object, directoryObject: DirectoryObject | null): object;
+    constructor(definition: any);
+    /**
+     * Get the terms definition
+     *
+     * @returns {object} The terms definition
+     */
+    get definition(): object;
+    #private;
+}
+import DirectoryObject from "./DirectoryObject.js";
+//# sourceMappingURL=Terms.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Terms.d.ts","sourceRoot":"","sources":["../../lib/Terms.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAOE;;;;;;OAMG;IACH,wBAJW,MAAM,GAAC,MAAM,mBACb,eAAe,OAAC,GACd,MAAM,CAmClB;IA5CD,6BAEC;IA4CD;;;;OAIG;IACH,kBAFa,MAAM,CAIlB;;CAEF;4BArE2B,sBAAsB"}

package/src/types/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): false | unknown[];
+    #private;
+}
+//# sourceMappingURL=TypeSpec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TypeSpec.d.ts","sourceRoot":"","sources":["../../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,mDAkDC;;CAiCF"}

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

@@ -0,0 +1,197 @@
+/**
+ * Utility class providing common helper functions for string manipulation,
+ * timing, hashing, 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;
+    /**
+     * Compute sha256 hash (hex) of the provided string.
+     *
+     * @param {string} s - Input string.
+     * @returns {string} 64-char hexadecimal digest.
+     */
+    static hashOf(s: string): string;
+    /**
+     * Extracts canonical option names from a Commander-style options object.
+     *
+     * Each key in the input object is a string containing one or more option
+     * forms, separated by commas (e.g. "-w, --watch"). This function splits each
+     * key, trims whitespace, and parses out the long option name (e.g. "watch")
+     * for each entry. If no long option ("--") is present, the short option (e.g.
+     * "v" from "-v") will be included in the result array. If both are present,
+     * the long option is preferred.
+     *
+     * Example:
+     *   generateOptionNames({"-w, --watch": "desc", "-v": "desc"})
+     *   → ["watch", "v"]
+     *
+     * Edge cases:
+     *   - If a key contains only a short option ("-v"), that short name will be
+     *     included in the result.
+     *   - If multiple long options are present, only the first is used.
+     *   - If the option string is malformed, may return undefined for that entry
+     *     (filtered out).
+     *
+     * @param {object} object - Mapping of option strings to descriptions.
+     * @returns {Array<string>} Array of canonical option names (long preferred, short if no long present).
+     */
+    static generateOptionNames(object: object): Array<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>;
+    /**
+     * Private method that performs the actual async emission logic.
+     * Handles listener execution, error aggregation, and result processing.
+     *
+     * @param {object} emitter - The emitter object (already validated)
+     * @param {string} event - The event name to emit
+     * @param {...unknown} args - Arguments to pass to event listeners
+     * @returns {Promise<void>} Resolves when all listeners have completed
+     */
+    static "__#private@#performAsyncEmit"(emitter: object, event: string, ...args: unknown[]): Promise<void>;
+    /**
+     * Emits an event asynchronously and waits for all listeners to complete.
+     * Unlike the standard EventEmitter.emit() which is synchronous, this method
+     * properly handles async event listeners by waiting for all of them to
+     * resolve or reject using Promise.allSettled().
+     *
+     * Uses strict instanceof checking to ensure the emitter is a genuine EventEmitter.
+     *
+     * @param {EventEmitter} emitter - The EventEmitter instance to emit on
+     * @param {string} event - The event name to emit
+     * @param {...unknown} args - Arguments to pass to event listeners
+     * @returns {Promise<void>} Resolves when all listeners have completed
+     */
+    static asyncEmit(emitter: EventEmitter, event: string, ...args: unknown[]): Promise<void>;
+    /**
+     * Emits an event asynchronously and waits for all listeners to complete.
+     * Like asyncEmit, but uses duck typing for more flexible emitter validation.
+     * Accepts any object that has the required EventEmitter-like methods.
+     *
+     * @param {object} emitter - Any object with EventEmitter-like interface
+     * @param {string} event - The event name to emit
+     * @param {...unknown} args - Arguments to pass to event listeners
+     * @returns {Promise<void>} Resolves when all listeners have completed
+     */
+    static asyncEmitAnon(emitter: object, event: string, ...args: unknown[]): Promise<void>;
+    /**
+     * 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;
+}
+import { EventEmitter } from "node:events";
+//# sourceMappingURL=Util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Util.d.ts","sourceRoot":"","sources":["../../lib/Util.js"],"names":[],"mappings":"AAOA;;;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;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mCAHW,MAAM,GACJ,KAAK,CAAC,MAAM,CAAC,CAazB;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;;;;;;;;OAQG;IACH,+CALW,MAAM,SACN,MAAM,WACH,OAAO,EAAA,GACR,OAAO,CAAC,IAAI,CAAC,CAmBzB;IAED;;;;;;;;;;;;OAYG;IACH,0BALW,YAAY,SACZ,MAAM,WACH,OAAO,EAAA,GACR,OAAO,CAAC,IAAI,CAAC,CAqBzB;IAED;;;;;;;;;OASG;IACH,8BALW,MAAM,SACN,MAAM,WACH,OAAO,EAAA,GACR,OAAO,CAAC,IAAI,CAAC,CAyBzB;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;6BAjZ0B,aAAa"}

package/src/types/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/lib/Valid.d.ts.map

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