@gesslar/toolkit 3.14.0 → 3.14.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileSystem.d.ts","sourceRoot":"","sources":["../../../src/node/lib/FileSystem.js"],"names":[],"mappings":"AA0BA;;GAEG;AACH;IACE,kCAAwB;IACxB,uCAAkC;IAClC,mBAAsB;IAsBtB;;;;;;OAMG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;;;OAUG;IACH,oCAJW,UAAU,GAAC,eAAe,MAC1B,UAAU,GAAC,eAAe,GACxB,MAAM,CAYlB;IAED;;;;;;;;;OASG;IACH,oCALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CA0BlB;IAED;;;;;;;;OAQG;IACH,6BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAmClB;IAED;;;;;;;;;;;;OAYG;IACH,+BATW,MAAM,aACN,MAAM,GACJ,OAAO,CAcnB;IAED;;;;;;;;;;;;;;OAcG;IACH,4BATW,MAAM,MACN,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,IAAI,CAwBvB;IAED;;;;;;;;;;;;;;;OAeG;IACH,+BAXW,MAAM,MACN,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,IAAI,CA+BvB;IAED;;;;;OAKG;IAEH;;;;;;;OAOG;IACH,2BAJW,MAAM;;;;cATH,MAAM;;;;aACN,MAAM;;;;aACN,MAAM;MAenB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,gDAZW,UAAU,GAAC,eAAe,GACxB,MAAM,CAiClB;IAED;;;;;;;;;;;;;OAaG;IACH,uCARW,MAAM,0BACN,OAAO,GACL,MAAM,CAkBlB;IA/VD;;;;;;;;;OASG;IACH,kCAJW,UAAU,GAAC,eAAe,GACxB,MAAM,CAWlB;CA8UF;yBAjXa,OAAO,iBAAiB,EAAE,OAAO;8BACjC,OAAO,sBAAsB,EAAE,OAAO"}

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

@@ -0,0 +1,228 @@
+export namespace loggerColours {
+    let debug: string[];
+    let info: string;
+    let warn: string;
+    let error: string;
+    let reset: string;
+}
+export namespace logSymbols {
+    let debug_1: string;
+    export { debug_1 as debug };
+    let info_1: string;
+    export { info_1 as info };
+    let warn_1: string;
+    export { warn_1 as warn };
+    let error_1: string;
+    export { error_1 as error };
+    export let success: string;
+}
+declare const _default: typeof Glog;
+export default _default;
+declare class Glog {
+    static logLevel: number;
+    static logPrefix: string;
+    static colors: any;
+    static stackTrace: boolean;
+    static name: string;
+    static tagsAsStrings: boolean;
+    static setLogPrefix(prefix: any): typeof Glog;
+    static setLogLevel(level: any): typeof Glog;
+    static withName(name: any): typeof Glog;
+    static withColors(colors?: {
+        debug: string[];
+        info: string;
+        warn: string;
+        error: string;
+        reset: string;
+    }): typeof Glog;
+    static withStackTrace(enabled?: boolean): typeof Glog;
+    static withTagsAsStrings(enabled?: boolean): typeof Glog;
+    static create(options?: {}): Glog;
+    static execute(...args: any[]): void;
+    /**
+     * Static version of colorize for global usage
+     *
+     * @param {Array<string>} strings - Template strings
+     * @param {...unknown} values - Template values
+     */
+    static colorize(strings: Array<string>, ...values: unknown[]): void;
+    /**
+     * Static success method
+     *
+     * @param {string} message - Success message to log
+     * @param {...unknown} args - Additional arguments to log
+     */
+    static success(message: string, ...args: unknown[]): void;
+    /**
+     * Static group method - start a console group for indented output
+     *
+     * @param {...unknown} args - Optional group label
+     */
+    static group(...args: unknown[]): void;
+    /**
+     * Static groupEnd method - end the current console group
+     */
+    static groupEnd(): void;
+    /**
+     * Static groupDebug - start a debug-tagged group
+     *
+     * @param {string} message - Group label
+     * @param {number} [level=1] - Debug level
+     */
+    static groupDebug(message: string, level?: number): void;
+    /**
+     * Static groupInfo - start an info-tagged group
+     *
+     * @param {string} message - Group label
+     */
+    static groupInfo(message: string): void;
+    /**
+     * Static groupSuccess - start a success-tagged group
+     *
+     * @param {string} message - Group label
+     */
+    static groupSuccess(message: string): void;
+    /**
+     * Static table method
+     *
+     * @param {object | Array} data - Object or array to display
+     * @param {string | object} [labelOrOptions] - Optional label (string) or options (object)
+     * @param {object} [options] - Optional options when label is provided
+     * @param {Array<string>} [options.properties] - Column properties to display
+     * @param {boolean} [options.showHeader=false] - Whether to show the header row
+     * @param {boolean} [options.quotedStrings=false] - Whether to show quotes around strings
+     */
+    static table(data: object | any[], labelOrOptions?: string | object, options?: {
+        properties?: Array<string>;
+        showHeader?: boolean;
+        quotedStrings?: boolean;
+    }): void;
+    /**
+     * Set a color alias for convenient usage
+     *
+     * @param {string} alias - Alias name
+     * @param {string} colorCode - Color code (e.g., "{F196}" or "{<B}")
+     * @returns {Glog} The Glog class for chaining.
+     */
+    static setAlias(alias: string, colorCode: string): Glog;
+    /**
+     * Static raw logger that outputs without name/tag formatting
+     *
+     * @returns {object} Raw logger interface
+     */
+    static get raw(): object;
+    constructor(options?: {});
+    setOptions(options: any): this;
+    withName(name: any): this;
+    withLogLevel(level: any): this;
+    withPrefix(prefix: any): this;
+    withColors(colors?: {
+        debug: string[];
+        info: string;
+        warn: string;
+        error: string;
+        reset: string;
+    }): this;
+    withStackTrace(enabled?: boolean): this;
+    withTagsAsStrings(enabled?: boolean): this;
+    noDisplayName(): this;
+    get name(): string;
+    get debugLevel(): number;
+    get options(): {
+        name: string;
+        debugLevel: number;
+        prefix: string;
+        colors: any;
+        stackTrace: boolean;
+    };
+    extractFileFunction(): string;
+    newDebug(tag: any): any;
+    /**
+     * Log a debug message with specified verbosity level.
+     * Level 0 means debug OFF - use levels 1-4 for actual debug output.
+     * Debug messages only show when logLevel > 0.
+     *
+     * @param {string} message - Debug message to log
+     * @param {number} level - Debug verbosity level (1-4, default: 1)
+     * @param {...unknown} arg - Additional arguments to log
+     * @throws {Error} If level < 1 (level 0 = debug OFF)
+     */
+    debug(message: string, level?: number, ...arg: unknown[]): void;
+    info(message: any, ...arg: any[]): void;
+    warn(message: any, ...arg: any[]): void;
+    error(message: any, ...arg: any[]): void;
+    execute(...args: any[]): void;
+    /**
+     * Log a colorized message using template literals
+     *
+     * @param {Array<string>} strings - Template strings
+     * @param {...unknown} values - Template values
+     * @example logger.colorize`{success}Operation completed{/} in {bold}${time}ms{/}`
+     */
+    colorize(strings: Array<string>, ...values: unknown[]): void;
+    /**
+     * Log a success message with green color
+     *
+     * @param {string} message - Success message
+     * @param {...unknown} args - Additional arguments
+     */
+    success(message: string, ...args: unknown[]): void;
+    /**
+     * Start a console group for indented output
+     *
+     * @param {...unknown} args - Optional group label
+     */
+    group(...args: unknown[]): void;
+    /**
+     * End the current console group
+     */
+    groupEnd(): void;
+    /**
+     * Start a debug-tagged group
+     *
+     * @param {string} message - Group label
+     * @param {number} [level=1] - Debug level
+     */
+    groupDebug(message: string, level?: number): void;
+    /**
+     * Start an info-tagged group
+     *
+     * @param {string} message - Group label
+     */
+    groupInfo(message: string): void;
+    /**
+     * Start a success-tagged group
+     *
+     * @param {string} message - Group label
+     */
+    groupSuccess(message: string): void;
+    /**
+     * Display tabular data as a table
+     *
+     * @param {object | Array} data - Object or array to display
+     * @param {string | object} [labelOrOptions] - Optional label (string) or options (object)
+     * @param {object} [options] - Optional options when label is provided
+     * @param {Array<string>} [options.properties] - Column properties to display
+     * @param {boolean} [options.showHeader=false] - Whether to show the header row
+     * @param {boolean} [options.quotedStrings=false] - Whether to show quotes around strings
+     */
+    table(data: object | any[], labelOrOptions?: string | object, options?: {
+        properties?: Array<string>;
+        showHeader?: boolean;
+        quotedStrings?: boolean;
+    }): void;
+    /**
+     * Get access to the colours template function for instance usage
+     *
+     * @returns {import('@gesslar/colours')} The colours template function from \@gesslar/colours
+     */
+    get colours(): any;
+    /**
+     * Get a raw logger that outputs without name/tag formatting
+     *
+     * @returns {object} Raw logger interface
+     */
+    get raw(): object;
+    #private;
+}
+//# sourceMappingURL=Glog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Glog.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Glog.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAsDA;IAEE,wBAAmB;IACnB,yBAAqB;IACrB,mBAAoB;IACpB,2BAAyB;IACzB,oBAAgB;IAChB,8BAA4B;IAgD5B,8CAIC;IAED,4CAIC;IAED,wCAIC;IAED;;;;;;oBAIC;IAED,sDAIC;IAED,yDAIC;IAID,kCAEC;IA6KD,qCAoBC;IAuBD;;;;;OAKG;IACH,yBAHW,KAAK,CAAC,MAAM,CAAC,aACV,OAAO,EAAA,QAOpB;IAqBD;;;;;OAKG;IACH,wBAHW,MAAM,WACH,OAAO,EAAA,QAWpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAOpB;IAED;;OAEG;IACH,wBAEC;IAED;;;;;OAKG;IACH,2BAHW,MAAM,UACN,MAAM,QAahB;IAED;;;;OAIG;IACH,0BAFW,MAAM,QAYhB;IAED;;;;OAIG;IACH,6BAFW,MAAM,QAWhB;IAyFD;;;;;;;;;OASG;IACH,mBAPW,MAAM,QAAQ,mBACd,MAAM,GAAG,MAAM,YAEvB;QAAgC,UAAU,GAAlC,KAAK,CAAC,MAAM,CAAC;QACK,UAAU,GAA5B,OAAO;QACW,aAAa,GAA/B,OAAO;KACjB,QAkBA;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,aACN,MAAM,GACJ,IAAI,CAMhB;IA8BD;;;;OAIG;IACH,kBAFa,MAAM,CAclB;IAxkBD,0BAgBC;IAID,+BAUC;IA8CD,0BAIC;IAED,+BAIC;IAED,8BAIC;IAED;;;;;;aAIC;IAED,wCAIC;IAED,2CAIC;IAED,sBAIC;IAID,mBAEC;IAED,yBAEC;IAED;;;;;;MAQC;IA8BD,8BAGC;IAED,wBAQC;IA8BD;;;;;;;;;OASG;IACH,eALW,MAAM,UACN,MAAM,UACH,OAAO,EAAA,QAapB;IAED,wCAGC;IAED,wCAGC;IAED,yCAGC;IA0BD,8BAEC;IAID;;;;;;OAMG;IACH,kBAJW,KAAK,CAAC,MAAM,CAAC,aACV,OAAO,EAAA,QAQpB;IAeD;;;;;OAKG;IACH,iBAHW,MAAM,WACH,OAAO,EAAA,QAapB;IA0FD;;;;OAIG;IACH,eAFc,OAAO,EAAA,QASpB;IAED;;OAEG;IACH,iBAEC;IAED;;;;;OAKG;IACH,oBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAFW,MAAM,QAahB;IAED;;;;;;;;;OASG;IACH,YAPW,MAAM,QAAQ,mBACd,MAAM,GAAG,MAAM,YAEvB;QAAgC,UAAU,GAAlC,KAAK,CAAC,MAAM,CAAC;QACK,UAAU,GAA5B,OAAO;QACW,aAAa,GAA/B,OAAO;KACjB,QAkBA;IA4CD;;;;OAIG;IACH,mBAEC;IAED;;;;OAIG;IACH,WAFa,MAAM,CAclB;;CAoBF"}

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

@@ -0,0 +1,46 @@
+export namespace loggerColours {
+    let debug: string[];
+    let info: string;
+    let warn: string;
+    let error: string;
+    let reset: string;
+}
+/**
+ * Logger class
+ *
+ * Log levels:
+ * - debug: Debugging information
+ *   - Debug levels
+ *     - 0: No/critical debug information, not error level, but, should be
+ *          logged
+ *     - 1: Basic debug information, startup, shutdown, etc
+ *     - 2: Intermediate debug information, discovery, starting to get more
+ *         detailed
+ *     - 3: Detailed debug information, parsing, processing, etc
+ *     - 4: Very detailed debug information, nerd mode!
+ * - warn: Warning information
+ * - info: Informational information
+ * - error: Error information
+ */
+export default class Logger {
+    constructor(options: any);
+    vscodeError: any;
+    vscodeWarn: any;
+    vscodeInfo: any;
+    get name(): any;
+    get debugLevel(): number;
+    get options(): {
+        name: any;
+        debugLevel: number;
+    };
+    setOptions(options: any): void;
+    lastStackLine(error?: Error, stepsRemoved?: number): any;
+    extractFileFunction(level?: number): any;
+    newDebug(tag: any): any;
+    debug(message: any, level?: number, ...arg: any[]): void;
+    warn(message: any, ...arg: any[]): void;
+    info(message: any, ...arg: any[]): void;
+    error(message: any, ...arg: any[]): void;
+    #private;
+}
+//# sourceMappingURL=Logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Logger.js"],"names":[],"mappings":";;;;;;;AA4CA;;;;;;;;;;;;;;;;GAgBG;AAEH;IAIE,0BAYC;IALK,iBAAiD;IACjD,gBAAkD;IAClD,gBAAsD;IAK5D,gBAEC;IAED,yBAEC;IAED;;;MAKC;IAED,+BAGC;IAWD,yDAIC;IAED,yCAsCC;IAED,wBAKC;IAED,yDAGC;IAED,wCAGC;IAED,wCAGC;IAED,yCAGC;;CACF"}

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

@@ -0,0 +1,54 @@
+declare const _default: {
+    /** @type {string} Display name for debugging. */
+    name: string;
+    /** @type {EventEmitter} Internal event emitter */
+    "__#private@#emitter": EventEmitter;
+    /**
+     * Emits an event without expecting a return value.
+     *
+     * @param {string} type - Event name to dispatch.
+     * @param {unknown} [payload] - Data to send with the event.
+     * @returns {void}
+     */
+    emit(type: string, payload?: unknown): void;
+    /**
+     * Emits an event and returns the payload for simple request/response flows.
+     * Listeners can mutate the payload object to provide responses.
+     *
+     * @param {string} type - Event name to dispatch.
+     * @param {unknown} [payload] - Data to send with the event (will be returned).
+     * @returns {unknown} The payload after listeners have processed it.
+     */
+    request(type: string, payload?: unknown): unknown;
+    /**
+     * Registers a listener for the given event type.
+     *
+     * @param {string} type - Event name to listen for.
+     * @param {(payload: unknown) => void} handler - Listener callback.
+     * @param {EventEmitter} [emitter] - The EventEmitter to attach to. Default is internal emitter.
+     * @param {NotifyEventOptions} [options] - Options for the listener.
+     * @returns {() => void} Dispose function to unregister the handler.
+     */
+    on(type: string, handler: (payload: unknown) => void, emitter?: EventEmitter, options?: NotifyEventOptions): () => void;
+    /**
+     * Removes a previously registered listener for the given event type.
+     *
+     * @param {string} type - Event name to remove.
+     * @param {(payload: unknown) => void} handler - Listener callback to detach.
+     * @param {EventEmitter} [emitter] - The EventEmitter from which to remove. Default is internal emitter.
+     * @returns {void}
+     */
+    off(type: string, handler: (payload: unknown) => void, emitter?: EventEmitter): void;
+};
+export default _default;
+export type NotifyEventOptions = {
+    /**
+     * - Whether the listener should be invoked only once.
+     */
+    once?: boolean;
+    /**
+     * - An AbortSignal to remove the listener.
+     */
+    signal?: AbortSignal;
+};
+//# sourceMappingURL=Notify.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Notify.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Notify.js"],"names":[],"mappings":";IAqBE,iDAAiD;UAAtC,MAAM;IAGjB,kDAAkD;2BAAvC,YAAY;IAGvB;;;;;;OAMG;eAHQ,MAAM,YACN,OAAO,GACL,IAAI;IASjB;;;;;;;OAOG;kBAHQ,MAAM,YACN,OAAO,GACL,OAAO;IAWpB;;;;;;;;OAQG;aALQ,MAAM,WACN,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,YAC1B,YAAY,YACZ,kBAAkB,GAChB,MAAM,IAAI;IAgBvB;;;;;;;OAOG;cAJQ,MAAM,WACN,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,YAC1B,YAAY,GACV,IAAI;;;;;;;WA3EL,OAAO;;;;aACP,WAAW"}

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

@@ -0,0 +1,9 @@
+/**
+ * Custom error class for toolkit errors.
+ * Provides error chaining, trace management, and formatted error reporting.
+ */
+export default class Sass extends BrowserSass {
+    #private;
+}
+import { Sass as BrowserSass } from "../../browser/index.js";
+//# sourceMappingURL=Sass.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Sass.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Sass.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH;;CAgFC;oCAvFiC,wBAAwB"}

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

@@ -0,0 +1,9 @@
+/**
+ * Custom aggregate error class that extends AggregateError.
+ * Automatically wraps plain errors in Sass instances for consistent reporting.
+ */
+export default class Tantrum extends BrowserTantrum {
+    constructor(message: any, errors?: any[]);
+}
+import { Tantrum as BrowserTantrum } from "../../browser/index.js";
+//# sourceMappingURL=Tantrum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Tantrum.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Tantrum.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH;IACE,0CAEC;CA0BF;0CArCuC,wBAAwB"}

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

@@ -0,0 +1,42 @@
+/**
+ * TempDirectoryObject extends VDirectoryObject with the cap set to
+ * the OS's temporary directory. Temporary directories are created
+ * synchronously during construction and exist immediately.
+ *
+ * All path operations are validated to ensure they remain within the temp
+ * directory hierarchy for security.
+ *
+ * @augments VDirectoryObject
+ */
+export default class TempDirectoryObject extends VDirectoryObject {
+    /**
+     * TempDirectoryObject does not support fromCwd() since it is specifically
+     * designed to work within the OS temporary directory tree.
+     *
+     * @throws {Sass} Always throws an error
+     */
+    static fromCwd(): void;
+    get isTemporary(): boolean;
+    get cap(): any;
+    /**
+     * Recursively removes a temporary directory and all its contents.
+     *
+     * This method will delete all files and subdirectories within this directory,
+     * then delete the directory itself. It only works on directories explicitly
+     * marked as temporary for safety.
+     *
+     * @async
+     * @returns {Promise<void>}
+     * @throws {Sass} If the directory is not marked as temporary
+     * @throws {Sass} If the directory deletion fails
+     * @example
+     * const tempDir = new TempDirectoryObject("my-temp")
+     * await tempDir.assureExists()
+     * // ... use the directory ...
+     * await tempDir.remove() // Recursively deletes everything
+     */
+    remove(): Promise<void>;
+    #private;
+}
+import VDirectoryObject from "./VDirectoryObject.js";
+//# sourceMappingURL=TempDirectoryObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TempDirectoryObject.d.ts","sourceRoot":"","sources":["../../../src/node/lib/TempDirectoryObject.js"],"names":[],"mappings":"AAiBA;;;;;;;;;GASG;AACH;IAgIE;;;;;OAKG;IACH,uBAEC;IA1ED,2BAEC;IAwBD,eAEC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,UATa,OAAO,CAAC,IAAI,CAAC,CAWzB;;CA0BF;6BAzJ4B,uBAAuB"}

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

@@ -0,0 +1,127 @@
+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;
+    /**
+     * Start a console group for indented output.
+     *
+     * @param {...unknown} [arg] - Optional group label.
+     */
+    static group(...arg?: unknown[]): void;
+    /**
+     * End the current console group.
+     */
+    static groupEnd(): void;
+    /**
+     * Display tabular data as a table.
+     *
+     * @param {object | Array} tabularData - Object or array to display.
+     * @param {object} [options] - Table options.
+     * @param {Array<string>} [options.properties] - Optional column properties to display.
+     * @param {boolean} [options.showHeader=false] - Whether to show the header row with column names.
+     * @param {boolean} [options.quotedStrings=false] - Whether to show quotes around strings.
+     */
+    static table(tabularData: object | any[], options?: {
+        properties?: Array<string>;
+        showHeader?: boolean;
+        quotedStrings?: boolean;
+    }): 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/types/node/lib/Term.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Term.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Term.js"],"names":[],"mappings":"AAOA;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;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;OAEG;IACH,wBAEC;IAED;;;;;;;;OAQG;IACH,0BANW,MAAM,QAAQ,YAEtB;QAAgC,UAAU,GAAlC,KAAK,CAAC,MAAM,CAAC;QACK,UAAU,GAA5B,OAAO;QACW,aAAa,GAA/B,OAAO;KACjB,QA2DA;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/types/node/lib/Util.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Utility class providing common helper functions for string manipulation,
+ * timing, hashing, and option parsing.
+ */
+export default class Util extends BrowserUtil {
+    /**
+     * 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>;
+    /**
+     * 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.
+     * If it walks like an EventEmitter and quacks like an EventEmitter...
+     *
+     * @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, but no grapes.
+     */
+    static asyncEmitQuack(emitter: object, event: string, ...args: unknown[]): Promise<void>;
+    /**
+     * Retrieves an environment variable and parses it as JSON5.
+     *
+     * This method fetches the value of the specified environment variable and
+     * attempts to parse it using JSON5. If the variable doesn't exist or is
+     * empty, the default value is returned. If parsing fails, an error is
+     * thrown.
+     *
+     * Example:
+     *   // export MY_CONFIG='{"debug": true, timeout: 5000}'
+     *   Util.getEnv("MY_CONFIG", {debug: false})
+     *   → {debug: true, timeout: 5000}
+     *
+     * Edge cases:
+     *   - If the environment variable doesn't exist, returns the default value
+     *   - If the value is an empty string, returns the default value
+     *   - If JSON5 parsing fails, throws a Sass error with context
+     *
+     * @param {string} ev - Name of the environment variable to retrieve
+     * @param {unknown} [def=undefined] - Default value if variable doesn't exist or is empty
+     * @returns {unknown} Parsed JSON5 value or default
+     * @throws {Sass} If JSON5 parsing fails
+     */
+    static getEnv(ev: string, def?: unknown): unknown;
+}
+import { Util as BrowserUtil } from "../../browser/index.js";
+//# sourceMappingURL=Util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Util.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Util.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH;IACE;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mCAHW,MAAM,GACJ,KAAK,CAAC,MAAM,CAAC,CAazB;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;;;;;;;;;;OAUG;IACH,+BALW,MAAM,SACN,MAAM,WACH,OAAO,EAAA,GACR,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,kBALW,MAAM,QACN,OAAO,GACL,OAAO,CAmBnB;CACF;oCApMiC,wBAAwB"}