adaptive-extender 0.2.13 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
-## 0.2.13 (20.08.2025)
-- Added import support for `commonjs` modules.
+## 0.5.0 (19.09.2025)
+- Added [timespan]() module.
+- Improved module separation.
+- Optimized `Color.newBlack`.
+- Added tests.
+- Fixed multiple bugs.
+- Improved documentation and function descriptions.
+- Split many functions into overloads for optimal usage.
+
+## 0.4.0 (26.08.2025)
+- Improved package structure.
+- Configured package for the latest stable ES version.
+- Added modules [vector](), [vector-1](), [vector-2](), [vector-3]().
+
+## 0.2.14 (20.08.2025)
+- Added import support for `CommonJS` modules.
 
 ## 0.2.8 (16.08.2025)
 - Fixed root import error.

package/README.md

@@ -3,3 +3,12 @@
 Adaptive library for JS/TS development environments
 
 [Change log](./CHANGELOG.md)
+
+```powershell
+npm install
+npm link
+cd test
+npm link adaptive-extender
+cd ../
+npm start
+```

package/{core → dist/core}/array.d.ts

@@ -18,11 +18,11 @@ declare global {
         /**
          * Combines elements from multiple iterables into tuples.
          * Iteration stops when the shortest iterable is exhausted.
-         * @returns A generator yielding tuples.
+         * @returns An iterator yielding tuples.
          */
         zip<T extends unknown[]>(...iterables: {
             [K in keyof T]: Iterable<T[K]>;
-        }): Generator<T, void>;
+        }): IteratorObject<T, void>;
     }
     interface Array<T> {
         /**

package/{core → dist/core}/array.js

@@ -37,4 +37,6 @@ Array.prototype.resize = function (length, _default) {
     this.length = length;
     return this;
 };
+//#endregion
+export {};
 //# sourceMappingURL=array.js.map

package/dist/core/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","sourceRoot":"","sources":["../../src/core/array.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,OAAO,aAAa,CAAC;AAErB,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;AA2CvB,KAAK,CAAC,MAAM,GAAG,UAAU,MAAW,EAAE,OAAe,UAAU;IAC9D,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;QAAE,MAAM,IAAI,SAAS,CAAC,+BAA+B,IAAI,YAAY,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACxH,OAAO,MAAM,CAAC;AACf,CAAC,CAAC;AAEF,KAAK,CAAC,KAAK,GAAG,UAAU,GAAW,EAAE,GAAW;IAC/C,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;IACjB,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,GAAG,GAAG,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC;QAChD,KAAK,CAAC,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC,CAAC;AAEF,KAAK,CAAC,GAAG,GAAG,QAAQ,CAAC,EAAsB,GAAG,SAA6C;IAC1F,MAAM,SAAS,GAAG,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IACzE,OAAO,IAAI,EAAE,CAAC;QACb,MAAM,OAAO,GAAG,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;QAC3D,IAAI,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC;YAAE,MAAM;QAC/C,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,CAAM,CAAC;IAChD,CAAC;AACF,CAAC,CAAC;AAEF,KAAK,CAAC,SAAS,CAAC,IAAI,GAAG,UAAU,MAAc,EAAE,MAAc;IAC9D,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IACvB,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IACvB,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC/B,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5B,IAAI,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;AAC1B,CAAC,CAAC;AAEF,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,UAAwB,MAAc,EAAE,QAAW;IAC3E,OAAO,MAAM,GAAG,IAAI,CAAC,MAAM;QAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACjD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACrB,OAAO,IAAI,CAAC;AACb,CAAC,CAAC;AACF,YAAY;AAEZ,OAAO,EAAG,CAAC"}

package/{core → dist/core}/boolean.js

@@ -5,4 +5,6 @@ Boolean.import = function (source, name = "[source]") {
         throw new TypeError(`Unable to import boolean from ${name} due its ${typename(source)} type`);
     return source.valueOf();
 };
+//#endregion
+export {};
 //# sourceMappingURL=boolean.js.map

package/dist/core/boolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.js","sourceRoot":"","sources":["../../src/core/boolean.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,OAAO,aAAa,CAAC;AAgBrB,OAAO,CAAC,MAAM,GAAG,UAAU,MAAW,EAAE,OAAe,UAAU;IAChE,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,SAAS;QAAE,MAAM,IAAI,SAAS,CAAC,iCAAiC,IAAI,YAAY,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACjI,OAAO,MAAM,CAAC,OAAO,EAAE,CAAC;AACzB,CAAC,CAAC;AACF,YAAY;AAEZ,OAAO,EAAG,CAAC"}

package/{core → dist/core}/color.d.ts

@@ -160,92 +160,74 @@ declare class Color {
     toString(options: Partial<ColorProperties>): string;
     /**
      * Transparent color preset.
-     * @readonly
      */
     static get newTransparent(): Color;
     /**
      * Maroon color preset.
-     * @readonly
      */
     static get newMaroon(): Color;
     /**
      * Red color preset.
-     * @readonly
      */
     static get newRed(): Color;
     /**
      * Orange color preset.
-     * @readonly
      */
     static get newOrange(): Color;
     /**
      * Yellow color preset.
-     * @readonly
      */
     static get newYellow(): Color;
     /**
      * Olive color preset.
-     * @readonly
      */
     static get newOlive(): Color;
     /**
      * Green color preset.
-     * @readonly
      */
     static get newGreen(): Color;
     /**
      * Purple color preset.
-     * @readonly
      */
     static get newPurple(): Color;
     /**
      * Fuchsia color preset.
-     * @readonly
      */
     static get newFuchsia(): Color;
     /**
      * Lime color preset.
-     * @readonly
      */
     static get newLime(): Color;
     /**
      * Teal color preset.
-     * @readonly
      */
     static get newTeal(): Color;
     /**
      * Aqua color preset.
-     * @readonly
      */
     static get newAqua(): Color;
     /**
      * Blue color preset.
-     * @readonly
      */
     static get newBlue(): Color;
     /**
      * Navy color preset.
-     * @readonly
      */
     static get newNavy(): Color;
     /**
      * Black color preset.
-     * @readonly
      */
     static get newBlack(): Color;
     /**
      * Gray color preset.
-     * @readonly
      */
     static get newGray(): Color;
     /**
      * Silver color preset.
-     * @readonly
      */
     static get newSilver(): Color;
     /**
      * White color preset.
-     * @readonly
      */
     static get newWhite(): Color;
     /**
@@ -365,5 +347,5 @@ declare class Color {
      */
     pass(scale: number): Color;
 }
-export { ColorProperties };
-export { ColorFormats, Color };
+export { ColorFormats };
+export { type ColorProperties, Color };

package/dist/core/color.js

@@ -0,0 +1,524 @@
+"use strict";
+import "./number.js";
+import "./string.js";
+const { min, max, trunc, abs } = Math;
+//#region Color formats
+/**
+ * Represents available color formats.
+ */
+var ColorFormats;
+(function (ColorFormats) {
+    ColorFormats["rgb"] = "RGB";
+    ColorFormats["hsl"] = "HSL";
+    ColorFormats["hex"] = "HEX";
+})(ColorFormats || (ColorFormats = {}));
+/**
+ * Represents a color in RGB, HSL, or HEX format with support for alpha channel,
+ * conversion between formats, creation from components, and parsing from strings.
+ */
+class Color {
+    //#region Properties
+    #rgb = new Uint8ClampedArray([0, 0, 0]);
+    /**
+     * Gets the red color component.
+     */
+    get red() {
+        return this.#rgb[0];
+    }
+    /**
+     * Sets the red color component.
+     */
+    set red(value) {
+        if (!Number.isFinite(value))
+            return;
+        this.#rgb[0] = value;
+        Color.#RGBtoHSL(this.#rgb, this.#hsl);
+    }
+    /**
+     * Gets the green color component.
+     */
+    get green() {
+        return this.#rgb[1];
+    }
+    /**
+     * Sets the green color component.
+     */
+    set green(value) {
+        if (!Number.isFinite(value))
+            return;
+        this.#rgb[1] = value;
+        Color.#RGBtoHSL(this.#rgb, this.#hsl);
+    }
+    /**
+     * Gets the blue color component.
+     */
+    get blue() {
+        return this.#rgb[2];
+    }
+    /**
+     * Sets the blue color component.
+     */
+    set blue(value) {
+        if (!Number.isFinite(value))
+            return;
+        this.#rgb[2] = value;
+        Color.#RGBtoHSL(this.#rgb, this.#hsl);
+    }
+    #hsl = new Uint16Array([0, 0, 0]);
+    /**
+     * Gets the hue color component.
+     */
+    get hue() {
+        return this.#hsl[0];
+    }
+    /**
+     * Sets the hue color component.
+     */
+    set hue(value) {
+        if (!Number.isFinite(value))
+            return;
+        this.#hsl[0] = value.mod(360);
+        Color.#HSLtoRGB(this.#hsl, this.#rgb);
+    }
+    /**
+     * Gets the saturation color component.
+     */
+    get saturation() {
+        return this.#hsl[1];
+    }
+    /**
+     * Sets the saturation color component.
+     */
+    set saturation(value) {
+        if (!Number.isFinite(value))
+            return;
+        this.#hsl[1] = value.clamp(0, 100);
+        Color.#HSLtoRGB(this.#hsl, this.#rgb);
+    }
+    /**
+     * Gets the lightness color component.
+     */
+    get lightness() {
+        return this.#hsl[2];
+    }
+    /**
+     * Sets the lightness color component.
+     */
+    set lightness(value) {
+        if (!Number.isFinite(value))
+            return;
+        this.#hsl[2] = value.clamp(0, 100);
+        Color.#HSLtoRGB(this.#hsl, this.#rgb);
+    }
+    #alpha = 1;
+    /**
+     * Gets the alpha color component.
+     */
+    get alpha() {
+        return this.#alpha;
+    }
+    /**
+     * Sets the alpha color component.
+     */
+    set alpha(value) {
+        if (!Number.isFinite(value))
+            return;
+        this.#alpha = value.clamp(0, 1);
+    }
+    //#endregion
+    //#region Builders
+    static #patternRGB = /^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i;
+    static #patternRGBA = /^rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\S+)\s*\)$/i;
+    static #patternHSL = /^hsl\(\s*(\d+)(?:deg)?\s*,\s*(\d+)(?:%)?\s*,\s*(\d+)(?:%)?\s*\)$/i;
+    static #patternHSLA = /^hsla\(\s*(\d+)(?:deg)?\s*,\s*(\d+)(?:%)?\s*,\s*(\d+)(?:%)?\s*,\s*(\S+)\s*\)$/i;
+    static #patternHEX = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i;
+    static #patternHEXA = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i;
+    static #variations = Object.values(ColorFormats).flatMap(format => [{ format, deep: false }, { format, deep: true }]);
+    constructor(source) {
+        if (!(source instanceof Color))
+            return;
+        this.#rgb = Uint8ClampedArray.from(source.#rgb);
+        this.#hsl = Uint16Array.from(source.#hsl);
+        this.#alpha = source.#alpha;
+    }
+    static fromRGB(red, green, blue, alpha = 1) {
+        if (!Number.isFinite(red))
+            throw new Error(`The red ${red} must be a finite number`);
+        if (!Number.isFinite(green))
+            throw new Error(`The green ${green} must be a finite number`);
+        if (!Number.isFinite(blue))
+            throw new Error(`The blue ${blue} must be a finite number`);
+        if (!Number.isFinite(alpha))
+            throw new Error(`The alpha ${alpha} must be a finite number`);
+        const color = new Color();
+        color.#rgb[0] = red;
+        color.#rgb[1] = green;
+        color.#rgb[2] = blue;
+        color.#alpha = alpha.clamp(0, 1);
+        Color.#RGBtoHSL(color.#rgb, color.#hsl);
+        return color;
+    }
+    static fromHSL(hue, saturation, lightness, alpha = 1) {
+        if (!Number.isFinite(hue))
+            throw new Error(`The hue ${hue} must be a finite number`);
+        if (!Number.isFinite(saturation))
+            throw new Error(`The saturation ${saturation} must be a finite number`);
+        if (!Number.isFinite(lightness))
+            throw new Error(`The lightness ${lightness} must be a finite number`);
+        if (!Number.isFinite(alpha))
+            throw new Error(`The alpha ${alpha} must be a finite number`);
+        const color = new Color();
+        hue %= 360;
+        if (hue < 0)
+            hue += 360;
+        color.#hsl[0] = hue;
+        color.#hsl[1] = saturation.clamp(0, 100);
+        color.#hsl[2] = lightness.clamp(0, 100);
+        color.#alpha = alpha.clamp(0, 1);
+        Color.#HSLtoRGB(color.#hsl, color.#rgb);
+        return color;
+    }
+    static #parse(string, deep, format) {
+        switch (format) {
+            case ColorFormats.rgb:
+                {
+                    const regex = (deep ? Color.#patternRGBA : Color.#patternRGB);
+                    const match = regex.exec(string.trim());
+                    if (match === null)
+                        throw new SyntaxError(`Invalid ${format} color '${string}' syntax`);
+                    const [, red, green, blue, alpha] = match.map(part => Number(part));
+                    return Color.fromRGB(red, green, blue, deep ? alpha : 1);
+                }
+                ;
+            case ColorFormats.hsl:
+                {
+                    const regex = (deep ? Color.#patternHSLA : Color.#patternHSL);
+                    const match = regex.exec(string.trim());
+                    if (match === null)
+                        throw new SyntaxError(`Invalid ${format} color '${string}' syntax`);
+                    const [, hue, saturation, lightness, alpha] = match.map(part => Number(part));
+                    return Color.fromHSL(hue, saturation, lightness, deep ? alpha : 1);
+                }
+                ;
+            case ColorFormats.hex:
+                {
+                    const regex = (deep ? Color.#patternHEXA : Color.#patternHEX);
+                    const match = regex.exec(string.trim());
+                    if (match === null)
+                        throw new SyntaxError(`Invalid ${format} color '${string}' syntax`);
+                    const [, red, green, blue, alpha] = match.map(part => Number.parseInt(part, 16));
+                    return Color.fromRGB(red, green, blue, deep ? (alpha / 255) : 1);
+                }
+                ;
+            default: throw new Error(`Invalid '${format}' format for color`);
+        }
+    }
+    static tryParse(string, options = {}) {
+        let variations = Color.#variations;
+        for (const key in options) {
+            const value = Reflect.get(options, key);
+            if (value === undefined)
+                continue;
+            variations = variations.filter(properties => Reflect.get(properties, key) === value);
+        }
+        for (const { format, deep } of variations) {
+            try {
+                return Color.#parse(string, deep, format);
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+    static parse(string, options = {}) {
+        const color = Color.tryParse(string, options);
+        if (color === null)
+            throw new SyntaxError(`Unable to parse '${string}' of any selected variation`);
+        return color;
+    }
+    //#endregion
+    //#region Converters
+    static #toChannel(offset, hue, saturation, lightness) {
+        const sector = (offset + hue) % 12;
+        return lightness - (saturation * min(lightness, 1 - lightness)) * min(sector - 3, 9 - sector).clamp(-1, 1);
+    }
+    /**
+     * @param hsl [0 - 360], [0 - 100], [0 - 100]
+     * @param rgb [0 - 255], [0 - 255], [0 - 255]
+     */
+    static #HSLtoRGB(hsl, rgb) {
+        const hue = hsl[0] / 30;
+        const saturation = hsl[1] / 100;
+        const lightness = hsl[2] / 100;
+        rgb[0] = Color.#toChannel(0, hue, saturation, lightness) * 255;
+        rgb[1] = Color.#toChannel(8, hue, saturation, lightness) * 255;
+        rgb[2] = Color.#toChannel(4, hue, saturation, lightness) * 255;
+    }
+    static #toHue(maximum, red, green, blue, difference) {
+        switch (maximum) {
+            case red: return (green - blue) / difference + 0;
+            case green: return (blue - red) / difference + 2;
+            case blue: return (red - green) / difference + 4;
+            default: throw new Error(`Invalid '${maximum}' maximum for colors`);
+        }
+    }
+    /**
+     * @param rgb [0 - 255], [0 - 255], [0 - 255]
+     * @param hsl [0 - 360], [0 - 100], [0 - 100]
+     */
+    static #RGBtoHSL(rgb, hsl) {
+        const red = rgb[0] / 255;
+        const green = rgb[1] / 255;
+        const blue = rgb[2] / 255;
+        const minimum = min(red, green, blue);
+        const maximum = max(red, green, blue);
+        const difference = maximum - minimum;
+        let hue = Color.#toHue(maximum, red, green, blue, difference);
+        hue = difference && hue;
+        if (hue < 0)
+            hue += 6;
+        hsl[0] = hue * 60;
+        const median = 1 - abs(maximum + minimum - 1);
+        hsl[1] = (median && (difference / median)) * 100;
+        hsl[2] = (maximum + minimum) / 2 * 100;
+    }
+    static #toHEXString(byte) {
+        return byte.toString(16).padStart(2, "0");
+    }
+    toString(options = {}) {
+        let { format, deep } = options;
+        format ??= ColorFormats.rgb;
+        deep ??= true;
+        switch (format) {
+            case ColorFormats.rgb: return `rgb${deep ? "a" : String.empty}(${this.red}, ${this.green}, ${this.blue}${deep ? `, ${this.alpha}` : String.empty})`;
+            case ColorFormats.hsl: return `hsl${deep ? "a" : String.empty}(${this.hue}deg, ${this.saturation}%, ${this.lightness}%${deep ? `, ${this.alpha}` : String.empty})`;
+            case ColorFormats.hex: return `#${Color.#toHEXString(this.red)}${Color.#toHEXString(this.green)}${Color.#toHEXString(this.blue)}${deep ? Color.#toHEXString(trunc(this.alpha * 255)) : String.empty}`;
+            default: throw new Error(`Invalid '${format}' format for color`);
+        }
+    }
+    //#endregion
+    //#region Presets
+    /**
+     * Transparent color preset.
+     */
+    static get newTransparent() { return Color.fromRGB(0, 0, 0, 0); }
+    ;
+    /**
+     * Maroon color preset.
+     */
+    static get newMaroon() { return Color.fromRGB(128, 0, 0); }
+    ;
+    /**
+     * Red color preset.
+     */
+    static get newRed() { return Color.fromRGB(255, 0, 0); }
+    ;
+    /**
+     * Orange color preset.
+     */
+    static get newOrange() { return Color.fromRGB(255, 165, 0); }
+    ;
+    /**
+     * Yellow color preset.
+     */
+    static get newYellow() { return Color.fromRGB(255, 255, 0); }
+    ;
+    /**
+     * Olive color preset.
+     */
+    static get newOlive() { return Color.fromRGB(128, 128, 0); }
+    ;
+    /**
+     * Green color preset.
+     */
+    static get newGreen() { return Color.fromRGB(0, 128, 0); }
+    ;
+    /**
+     * Purple color preset.
+     */
+    static get newPurple() { return Color.fromRGB(128, 0, 128); }
+    ;
+    /**
+     * Fuchsia color preset.
+     */
+    static get newFuchsia() { return Color.fromRGB(255, 0, 255); }
+    ;
+    /**
+     * Lime color preset.
+     */
+    static get newLime() { return Color.fromRGB(0, 255, 0); }
+    ;
+    /**
+     * Teal color preset.
+     */
+    static get newTeal() { return Color.fromRGB(0, 128, 128); }
+    ;
+    /**
+     * Aqua color preset.
+     */
+    static get newAqua() { return Color.fromRGB(0, 255, 255); }
+    ;
+    /**
+     * Blue color preset.
+     */
+    static get newBlue() { return Color.fromRGB(0, 0, 255); }
+    ;
+    /**
+     * Navy color preset.
+     */
+    static get newNavy() { return Color.fromRGB(0, 0, 128); }
+    ;
+    /**
+     * Black color preset.
+     */
+    static get newBlack() { return new Color(); }
+    ;
+    /**
+     * Gray color preset.
+     */
+    static get newGray() { return Color.fromRGB(128, 128, 128); }
+    ;
+    /**
+     * Silver color preset.
+     */
+    static get newSilver() { return Color.fromRGB(192, 192, 192); }
+    ;
+    /**
+     * White color preset.
+     */
+    static get newWhite() { return Color.fromRGB(255, 255, 255); }
+    ;
+    static mix(first, second, ratio = 0.5) {
+        if (!Number.isFinite(ratio))
+            throw new Error(`The ratio ${ratio} must be a finite number`);
+        ratio = ratio.clamp(0, 1);
+        const red = first.red + (second.red - first.red) * ratio;
+        const green = first.green + (second.green - first.green) * ratio;
+        const blue = first.blue + (second.blue - first.blue) * ratio;
+        const alpha = first.alpha + (second.alpha - first.alpha) * ratio;
+        return Color.fromRGB(red, green, blue, alpha);
+    }
+    grayscale(scale = 1) {
+        if (!Number.isFinite(scale))
+            throw new Error(`The scale ${scale} must be a finite number`);
+        scale = scale.clamp(0, 1);
+        const { red, green, blue } = this;
+        const achromatic = (red + green + blue) / 3;
+        this.#rgb[0] = red + (achromatic - red) * scale;
+        this.#rgb[1] = green + (achromatic - green) * scale;
+        this.#rgb[2] = blue + (achromatic - blue) * scale;
+        Color.#RGBtoHSL(this.#rgb, this.#hsl);
+        return this;
+    }
+    redEmphasis(scale = 1) {
+        if (!Number.isFinite(scale))
+            throw new Error(`The scale ${scale} must be a finite number`);
+        scale = scale.clamp(0, 1);
+        const { green, blue } = this;
+        const average = (green + blue) / 2;
+        this.#rgb[1] = green + (average - green) * scale;
+        this.#rgb[2] = blue + (average - blue) * scale;
+        Color.#RGBtoHSL(this.#rgb, this.#hsl);
+        return this;
+    }
+    greenEmphasis(scale = 1) {
+        if (!Number.isFinite(scale))
+            throw new Error(`The scale ${scale} must be a finite number`);
+        scale = scale.clamp(0, 1);
+        const { red, blue } = this;
+        const average = (red + blue) / 2;
+        this.#rgb[0] = red + (average - red) * scale;
+        this.#rgb[2] = blue + (average - blue) * scale;
+        Color.#RGBtoHSL(this.#rgb, this.#hsl);
+        return this;
+    }
+    blueEmphasis(scale = 1) {
+        if (!Number.isFinite(scale))
+            throw new Error(`The scale ${scale} must be a finite number`);
+        scale = scale.clamp(0, 1);
+        const { red, green } = this;
+        const average = (red + green) / 2;
+        this.#rgb[0] = red + (average - red) * scale;
+        this.#rgb[1] = green + (average - green) * scale;
+        Color.#RGBtoHSL(this.#rgb, this.#hsl);
+        return this;
+    }
+    invert(scale = 1) {
+        if (!Number.isFinite(scale))
+            throw new Error(`The scale ${scale} must be a finite number`);
+        scale = scale.clamp(0, 1);
+        const { red, green, blue } = this;
+        this.#rgb[0] = red + ((255 - red) - red) * scale;
+        this.#rgb[1] = green + ((255 - green) - green) * scale;
+        this.#rgb[2] = blue + ((255 - blue) - blue) * scale;
+        Color.#RGBtoHSL(this.#rgb, this.#hsl);
+        return this;
+    }
+    sepia(scale = 1) {
+        if (!Number.isFinite(scale))
+            throw new Error(`The scale ${scale} must be a finite number`);
+        scale = scale.clamp(0, 1);
+        const { red, green, blue } = this;
+        const redness = (red * 0.393) + (green * 0.769) + (blue * 0.189);
+        const greenness = (red * 0.349) + (green * 0.686) + (blue * 0.168);
+        const blueness = (red * 0.272) + (green * 0.534) + (blue * 0.131);
+        this.#rgb[0] = red + (redness - red) * scale;
+        this.#rgb[1] = green + (greenness - green) * scale;
+        this.#rgb[2] = blue + (blueness - blue) * scale;
+        Color.#RGBtoHSL(this.#rgb, this.#hsl);
+        return this;
+    }
+    /**
+     * Rotates the hue of the current color by the given angle in degrees.
+     * @param angle Rotation angle in degrees.
+     * @returns The modified current color.
+     * @throws {Error} If `angle` is not a finite number.
+     */
+    rotate(angle) {
+        if (!Number.isFinite(angle))
+            throw new Error(`The angle ${angle} must be a finite number`);
+        this.hue += angle;
+        return this;
+    }
+    /**
+     * Sets the saturation of the current color by scale.
+     * @param scale Saturation scale [0 - 1].
+     * @returns The modified current color.
+     * @throws {Error} If `scale` is not a finite number.
+     */
+    saturate(scale) {
+        if (!Number.isFinite(scale))
+            throw new Error(`The scale ${scale} must be a finite number`);
+        this.saturation = 100 * scale;
+        return this;
+    }
+    /**
+     * Sets the lightness of the current color by scale.
+     * @param scale Lightness scale [0 - 1].
+     * @returns The modified current color.
+     * @throws {Error} If `scale` is not a finite number.
+     */
+    illuminate(scale) {
+        if (!Number.isFinite(scale))
+            throw new Error(`The scale ${scale} must be a finite number`);
+        this.lightness = 100 * scale;
+        return this;
+    }
+    /**
+     * Sets the alpha of the current color.
+     * @param scale Alpha value [0 - 1].
+     * @returns The modified current color.
+     * @throws {Error} If `scale` is not a finite number.
+     */
+    pass(scale) {
+        if (!Number.isFinite(scale))
+            throw new Error(`The scale ${scale} must be a finite number`);
+        this.alpha = scale;
+        return this;
+    }
+}
+//#endregion
+export { ColorFormats };
+export { Color };
+//# sourceMappingURL=color.js.map