@gesslar/toolkit 3.14.0 → 3.14.1

package/types/browser/lib/Notify.d.ts

@@ -0,0 +1,60 @@
+declare const _default: {
+    /** @type {string} Display name for debugging. */
+    name: string;
+    /**
+     * Emits a CustomEvent without expecting a return value.
+     *
+     * @param {string} type - Event name to dispatch.
+     * @param {unknown} [payload] - Value assigned to `event.detail`.
+     * @param {boolean | NotifyEventOptions} [options] - CustomEvent options or boolean to set `bubbles`.
+     * @returns {void}
+     */
+    emit(type: string, payload?: unknown, options?: boolean | NotifyEventOptions): void;
+    /**
+     * Emits a CustomEvent and returns the detail for simple request/response flows.
+     *
+     * @param {string} type - Event name to dispatch.
+     * @param {unknown} [payload] - Value assigned to `event.detail`.
+     * @param {boolean | NotifyEventOptions} [options] - CustomEvent options or boolean to set `bubbles`.
+     * @returns {unknown} The detail placed on the CustomEvent.
+     */
+    request(type: string, payload?: unknown, options?: boolean | NotifyEventOptions): unknown;
+    /**
+     * Registers a listener for the given event type on an HTMLElement (or
+     * window, if not specified).
+     *
+     * @param {string} type - Event name to listen for.
+     * @param {(evt: Notify) => void} handler - Listener callback.
+     * @param {HTMLElement | Window} [element] - The object to which to attach the handler. Default is window.
+     * @param {boolean | object} [options] - Options to pass to addEventListener.
+     * @returns {() => void} Dispose function to unregister the handler.
+     */
+    on(type: string, handler: (evt: /*elided*/ any) => void, element?: HTMLElement | Window, options?: boolean | object): () => void;
+    /**
+     * Removes a previously registered listener for the given event type.
+     *
+     * @param {string} type - Event name to remove.
+     * @param {(evt: Notify) => void} handler - Listener callback to detach.
+     * @param {HTMLElement | Window} [element] - The object from which to remove the handler. Default is window.
+     * @param {boolean | object} [options] - Options to pass to removeEventListener.
+     * @returns {void}
+     */
+    off(type: string, handler: (evt: /*elided*/ any) => void, element?: HTMLElement | Window, options?: boolean | object): void;
+    "__#private@#buildEventInit"(detail: any, options: any): any;
+};
+export default _default;
+export type NotifyEventOptions = {
+    /**
+     * - Whether the event bubbles up the DOM tree.
+     */
+    bubbles?: boolean;
+    /**
+     * - Whether the event can be canceled.
+     */
+    cancelable?: boolean;
+    /**
+     * - Whether the event can cross the shadow DOM boundary.
+     */
+    composed?: boolean;
+};
+//# sourceMappingURL=Notify.d.ts.map

package/types/browser/lib/Notify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Notify.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Notify.js"],"names":[],"mappings":";IAaE,iDAAiD;UAAtC,MAAM;IAGjB;;;;;;;OAOG;eAJQ,MAAM,YACN,OAAO,YACP,OAAO,GAAG,kBAAkB,GAC1B,IAAI;IAOjB;;;;;;;OAOG;kBAJQ,MAAM,YACN,OAAO,YACP,OAAO,GAAG,kBAAkB,GAC1B,OAAO;IASpB;;;;;;;;;OASG;aALQ,MAAM,WACN,CAAC,GAAG,gBAAQ,KAAK,IAAI,YACrB,WAAW,GAAG,MAAM,YACpB,OAAO,GAAG,MAAM,GACd,MAAM,IAAI;IAcvB;;;;;;;;OAQG;cALQ,MAAM,WACN,CAAC,GAAG,gBAAQ,KAAK,IAAI,YACrB,WAAW,GAAG,MAAM,YACpB,OAAO,GAAG,MAAM,GACd,IAAI;;;;;;;;cAjEL,OAAO;;;;iBACP,OAAO;;;;eACP,OAAO"}

package/types/browser/lib/Promised.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Utility class providing helper functions for working with Promises,
+ * including settling, filtering, and extracting values from promise results.
+ */
+export default class Promised {
+    /**
+     * 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 await(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<{status: 'fulfilled'|'rejected', value?: unknown, reason?: unknown}>>} Results of all settled promises with status and value/reason
+     */
+    static settle(promises: Array<Promise<unknown>>): Promise<Array<{
+        status: "fulfilled" | "rejected";
+        value?: unknown;
+        reason?: unknown;
+    }>>;
+    /**
+     * Checks if any result in the settled promise array is rejected.
+     *
+     * @param {Array<{status: 'fulfilled'|'rejected', value?: unknown, reason?: unknown}>} settled - Array of settled promise results
+     * @returns {boolean} True if any result is rejected, false otherwise
+     */
+    static hasRejected(settled: Array<{
+        status: "fulfilled" | "rejected";
+        value?: unknown;
+        reason?: unknown;
+    }>): boolean;
+    /**
+     * Checks if any result in the settled promise array is fulfilled.
+     *
+     * @param {Array<{status: 'fulfilled'|'rejected', value?: unknown, reason?: unknown}>} settled - Array of settled promise results
+     * @returns {boolean} True if any result is fulfilled, false otherwise
+     */
+    static hasFulfilled(settled: Array<{
+        status: "fulfilled" | "rejected";
+        value?: unknown;
+        reason?: unknown;
+    }>): boolean;
+    /**
+     * Filters and returns all rejected results from a settled promise array.
+     *
+     * @param {Array<{status: 'fulfilled'|'rejected', value?: unknown, reason?: unknown}>} settled - Array of settled promise results
+     * @returns {Array<{status: 'rejected', reason: unknown}>} Array of rejected results
+     */
+    static rejected(settled: Array<{
+        status: "fulfilled" | "rejected";
+        value?: unknown;
+        reason?: unknown;
+    }>): Array<{
+        status: "rejected";
+        reason: unknown;
+    }>;
+    /**
+     * Filters and returns all fulfilled results from a settled promise array.
+     *
+     * @param {Array<{status: 'fulfilled'|'rejected', value?: unknown, reason?: unknown}>} result - Array of settled promise results
+     * @returns {Array<{status: 'fulfilled', value: unknown}>} Array of fulfilled results
+     */
+    static fulfilled(result: Array<{
+        status: "fulfilled" | "rejected";
+        value?: unknown;
+        reason?: unknown;
+    }>): Array<{
+        status: "fulfilled";
+        value: unknown;
+    }>;
+    /**
+     * Extracts the rejection reasons from a settled promise array.
+     *
+     * @param {Array<{status: 'fulfilled'|'rejected', value?: unknown, reason?: unknown}>} settled - Array of settled promise results
+     * @returns {Array<unknown>} Array of rejection reasons
+     */
+    static reasons(settled: Array<{
+        status: "fulfilled" | "rejected";
+        value?: unknown;
+        reason?: unknown;
+    }>): Array<unknown>;
+    /**
+     * Extracts the values from fulfilled results in a settled promise array.
+     *
+     * @param {Array<{status: 'fulfilled'|'rejected', value?: unknown, reason?: unknown}>} settled - Array of settled promise results
+     * @returns {Array<unknown>} Array of fulfilled values
+     */
+    static values(settled: Array<{
+        status: "fulfilled" | "rejected";
+        value?: unknown;
+        reason?: unknown;
+    }>): Array<unknown>;
+    /**
+     * Throws a Tantrum containing all rejection reasons from settled promises.
+     *
+     * @param {string} message - Error message. Defaults to "GIGO"
+     * @param {Array<{status: 'fulfilled'|'rejected', value?: unknown, reason?: unknown}>} settled - Array of settled promise results
+     * @throws {Tantrum} Throws a Tantrum error with rejection reasons
+     */
+    static throw(message: string, settled: Array<{
+        status: "fulfilled" | "rejected";
+        value?: unknown;
+        reason?: unknown;
+    }>): void;
+    /**
+     * 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>;
+}
+//# sourceMappingURL=Promised.d.ts.map

package/types/browser/lib/Promised.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Promised.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Promised.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IACE;;;;;;OAMG;IACH,uBAHW,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GACrB,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAInC;IAED;;;;;;OAMG;IACH,wBAHW,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GACrB,OAAO,CAAC,KAAK,CAAC;QAAC,MAAM,EAAE,WAAW,GAAC,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC,CAAC,CAI/F;IAED;;;;;OAKG;IACH,4BAHW,KAAK,CAAC;QAAC,MAAM,EAAE,WAAW,GAAC,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC,GACxE,OAAO,CAInB;IAED;;;;;OAKG;IACH,6BAHW,KAAK,CAAC;QAAC,MAAM,EAAE,WAAW,GAAC,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC,GACxE,OAAO,CAInB;IAED;;;;;OAKG;IACH,yBAHW,KAAK,CAAC;QAAC,MAAM,EAAE,WAAW,GAAC,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC,GACxE,KAAK,CAAC;QAAC,MAAM,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAC,CAAC,CAIxD;IAED;;;;;OAKG;IACH,yBAHW,KAAK,CAAC;QAAC,MAAM,EAAE,WAAW,GAAC,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC,GACxE,KAAK,CAAC;QAAC,MAAM,EAAE,WAAW,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAC,CAAC,CAIxD;IAED;;;;;OAKG;IACH,wBAHW,KAAK,CAAC;QAAC,MAAM,EAAE,WAAW,GAAC,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC,GACxE,KAAK,CAAC,OAAO,CAAC,CAO1B;IAED;;;;;OAKG;IACH,uBAHW,KAAK,CAAC;QAAC,MAAM,EAAE,WAAW,GAAC,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC,GACxE,KAAK,CAAC,OAAO,CAAC,CAO1B;IAED;;;;;;OAMG;IACH,sBAJW,MAAM,WACN,KAAK,CAAC;QAAC,MAAM,EAAE,WAAW,GAAC,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC,QAQpF;IAED;;;;;;OAMG;IACH,sBAHW,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GACrB,OAAO,CAAC,OAAO,CAAC,CAI5B;CACF"}

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

@@ -0,0 +1,63 @@
+/**
+ * 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
+     * @param {boolean} [isNested] - Whether this is a nested error report
+     */
+    report(nerdMode?: boolean, isNested?: boolean): void;
+    #private;
+}
+import Tantrum from "./Tantrum.js";
+//# sourceMappingURL=Sass.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Sass.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Sass.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH;IAgIE;;;;;;;;OAQG;IACH,mBALW,KAAK,WACL,MAAM,GACJ,IAAI,CAahB;IAED;;;;;;;;OAQG;IACH,sBAJW,MAAM,UACN,KAAK,GAAC,IAAI,GAAC,OAAO,GAChB,IAAI,CAchB;IAvKD;;;;;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;;;;;;OAMG;IACH,kBAHW,OAAO,aACP,OAAO,QAyCjB;;CA6EF;oBAjLmB,cAAc"}

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

@@ -0,0 +1,52 @@
+/**
+ * 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
+     * @param {boolean} [isNested] - Whether this is a nested error report
+     */
+    report(nerdMode?: boolean, isNested?: boolean): void;
+    #private;
+}
+import Sass from "./Sass.js";
+//# sourceMappingURL=Tantrum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Tantrum.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Tantrum.js"],"names":[],"mappings":"AAaA;;;GAGG;AACH;IAwFE;;;;;;OAMG;IACH,sBAJW,MAAM,WACN,KAAK,CAAC,KAAK,GAAC,IAAI,CAAC,GACf,OAAO,CAOnB;IAhGD;;;;;;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;;;;;OAKG;IACH,kBAHW,OAAO,aACP,OAAO,QAmBjB;;CAeF;iBA3GgB,WAAW"}

package/types/browser/lib/Time.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Utility class for timing operations and promise-based delays.
+ * Provides methods for creating cancellable timeout promises.
+ */
+export default class Time {
+    /**
+     * Creates a promise that resolves after a specified delay.
+     * The returned promise includes a timerId property that can be used with cancel().
+     *
+     * @param {number} delay - Delay in milliseconds before resolving (must be >= 0)
+     * @param {unknown} [value] - Optional value to resolve with after the delay
+     * @returns {Promise<unknown> & {timerId: number}} Promise that resolves with the value after delay, extended with timerId property
+     * @throws {Sass} If delay is not a number or is negative
+     * @example
+     * // Wait 1 second then continue
+     * await Time.after(1000)
+     *
+     * // Wait 1 second then get a value
+     * const result = await Time.after(1000, 'done')
+     *
+     * // Create a cancellable delay
+     * const promise = Time.after(5000, 'data')
+     * Time.cancel(promise) // Cancel before it resolves
+     */
+    static after(delay: number, value?: unknown): Promise<unknown> & {
+        timerId: number;
+    };
+    /**
+     * Cancels a promise created by Time.after() by clearing its timeout.
+     * If the promise has already resolved or is not a Time.after() promise, this is a no-op.
+     *
+     * @param {Promise<unknown> & {timerId?: number}} promise - Promise returned from Time.after() to cancel
+     * @returns {void}
+     * @example
+     * const promise = Time.after(5000, 'data')
+     * Time.cancel(promise) // Prevents the promise from resolving
+     */
+    static cancel(promise: Promise<unknown> & {
+        timerId?: number;
+    }): void;
+}
+//# sourceMappingURL=Time.d.ts.map

package/types/browser/lib/Time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Time.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Time.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IACE;;;;;;;;;;;;;;;;;;OAkBG;IACH,oBAfW,MAAM,UACN,OAAO,GACL,OAAO,CAAC,OAAO,CAAC,GAAG;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAwBhD;IAED;;;;;;;;;OASG;IACH,uBANW,OAAO,CAAC,OAAO,CAAC,GAAG;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC,GACnC,IAAI,CAQhB;CACF"}

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

@@ -0,0 +1,90 @@
+/**
+ * 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 {unknown} options - Additional parsing options
+     */
+    constructor(string: string, options: unknown);
+    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 {unknown} Object containing specs, length, and string representation
+     */
+    toJSON(): unknown;
+    /**
+     * 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 {unknown} 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: unknown): boolean;
+    match(value: any, options: any): unknown[];
+    #private;
+}
+//# sourceMappingURL=TypeSpec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TypeSpec.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/TypeSpec.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAGE;;;;;OAKG;IACH,oBAHW,MAAM,WACN,OAAO,EAUjB;IAJC,aAAwB;IACxB,eAAgC;IAChC,6BAA2C;IAI7C;;;;OAIG;IACH,YAFa,MAAM,CAQlB;IAED;;;;OAIG;IACH,UAFa,OAAO,CASnB;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,WACP,OAAO,GAEL,OAAO,CAInB;IAED,2CA6DC;;CAmDF"}

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

@@ -0,0 +1,62 @@
+/**
+ * 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;
+    /**
+     * 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/types/browser/lib/Util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Util.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Util.js"],"names":[],"mappings":"AAGA;;;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,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/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/types/browser/lib/Valid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Valid.d.ts","sourceRoot":"","sources":["../../../src/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/types/browser/lib/vendor/dompurify.esm.d.ts

@@ -0,0 +1,29 @@
+export { purify as default };
+declare function purify(root: any): {
+    (root: any): /*elided*/ any;
+    version: string;
+    removed: any[];
+    isSupported: boolean;
+    sanitize(dirty: any, ...args: any[]): any;
+    setConfig(...args: any[]): void;
+    clearConfig(): void;
+    isValidAttribute(tag: any, attr: any, value: any): boolean;
+    addHook(entryPoint: any, hookFunction: any): void;
+    removeHook(entryPoint: any, hookFunction: any): any;
+    removeHooks(entryPoint: any): void;
+    removeAllHooks(): void;
+};
+declare namespace purify {
+    let version: string;
+    let removed: any[];
+    let isSupported: boolean;
+    function sanitize(dirty: any, ...args: any[]): any;
+    function setConfig(...args: any[]): void;
+    function clearConfig(): void;
+    function isValidAttribute(tag: any, attr: any, value: any): boolean;
+    function addHook(entryPoint: any, hookFunction: any): void;
+    function removeHook(entryPoint: any, hookFunction: any): any;
+    function removeHooks(entryPoint: any): void;
+    function removeAllHooks(): void;
+}
+//# sourceMappingURL=dompurify.esm.d.ts.map

package/types/browser/lib/vendor/dompurify.esm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dompurify.esm.d.ts","sourceRoot":"","sources":["../../../../src/browser/lib/vendor/dompurify.esm.js"],"names":[],"mappings":";AA0UE;;;;;;;;;;;;;EAA+C;;;;;IA+9B/C,mDAiJC;IACD,yCAIC;IACD,6BAGC;IACD,oEAUC;IACD,2DAMC;IACD,6DAQC;IACD,4CAEC;IACD,gCAEC"}

package/types/node/index.d.ts

@@ -0,0 +1,21 @@
+export { default as Collection } from "../browser/lib/Collection.js";
+export { default as Data } from "../browser/lib/Data.js";
+export { default as Promised } from "../browser/lib/Promised.js";
+export { default as Time } from "../browser/lib/Time.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 DirectoryObject } from "./lib/DirectoryObject.js";
+export { default as FileObject } from "./lib/FileObject.js";
+export { default as FS } from "./lib/FileSystem.js";
+export { default as Glog } from "./lib/Glog.js";
+export { default as Notify } from "./lib/Notify.js";
+export { default as TempDirectoryObject } from "./lib/TempDirectoryObject.js";
+export { default as Term } from "./lib/Term.js";
+export { default as VFileObject } from "./lib/VFileObject.js";
+export { default as VDirectoryObject } from "./lib/VDirectoryObject.js";
+export { default as Disposer, Disposer as DisposerClass } from "../browser/lib/Disposer.js";
+//# sourceMappingURL=index.d.ts.map

package/types/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/node/index.js"],"names":[],"mappings":""}

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

@@ -0,0 +1,27 @@
+/**
+ * File system cache with automatic invalidation based on modification time.
+ * Provides intelligent caching of parsed JSON5/YAML files with mtime-based
+ * cache invalidation to optimize performance for repeated file access.
+ *
+ * The cache eliminates redundant file reads and parsing when multiple processes
+ * access the same dependency files, while ensuring data freshness through
+ * modification time checking.
+ */
+export default class Cache {
+    /**
+     * Loads and caches parsed file data with automatic invalidation based on
+     * modification time.
+     *
+     * Implements a sophisticated caching strategy that checks file modification
+     * times to determine whether cached data is still valid, ensuring data
+     * freshness while optimizing performance for repeated file access during
+     * parallel processing.
+     *
+     * @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: import("./FileObject.js").FileObject): Promise<unknown>;
+    #private;
+}
+//# sourceMappingURL=Cache.d.ts.map

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

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