toolbox-x 1.0.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!) The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the license notice for easier identification
+   within third-party archives.
+
+   Copyright 2025 - present Nazmul Hassan
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/Color-B3mgF9Dh.d.cts

@@ -0,0 +1,486 @@
+/**
+ * Copyright 2026 - present Nazmul Hassan
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { $ as Maybe, V as Branded, rn as Percent } from "./object-Blq0Amdv.cjs";
+import { t as CSS_COLORS } from "./css-colors-Bx947Ng3.cjs";
+
+//#region src/types/colors.d.ts
+/** - A string, number for generating color. */
+type ColorInput = string | number;
+/** - An array of strings/numbers or nested arrays of strings/numbers for generating colors. */
+type ColorInputArray = Array<ColorInput | ColorInputArray>;
+/**
+ * * Represents a hexadecimal color code.
+ * * Format: `#3C6945`
+ */
+type Hex = `#${string}`;
+/**
+ * * Represents a hexadecimal color code.
+ * * Format: `#3C6945`
+ */
+type Hex6 = Branded<Hex, 'Hex6'>;
+/**
+ * * Represents an RGB color string.
+ * * Format: `rgb(R, G, B)`
+ *
+ * - R (Red): 0-255
+ * - G (Green): 0-255
+ * - B (Blue): 0-255
+ */
+type RGB = `rgb(${number}, ${number}, ${number})` | `rgb(${number},${number},${number})`;
+/**
+ * * Represents an HSL color string.
+ * * Format: `hsl(H, S%, L%)`
+ *
+ * - H (Hue): 0-360
+ * - S (Saturation): 0-100%
+ * - L (Lightness): 0-100%
+ */
+type HSL = `hsl(${number}, ${number}%, ${number}%)` | `hsl(${number},${number}%,${number}%)`;
+/**
+ * * Represents a hexadecimal color code with optional alpha channel.
+ * * Format: `#3C6945FF`
+ */
+type Hex8 = Branded<Hex, 'Hex8'>;
+/**
+ * * Represents an RGBA color string, now includes optional alpha (opacity).
+ * * Format: `rgba(R, G, B, A)`
+ */
+type RGBA = `rgba(${number}, ${number}, ${number}, ${number})` | `rgba(${number},${number},${number},${number})`;
+/**
+ * * Represents an HSLA color string with optional alpha channel.
+ * * Format: `hsla(H, S%, L%, A)`
+ */
+type HSLA = `hsla(${number}, ${number}%, ${number}%, ${number})` | `hsla(${number},${number}%,${number}%,${number})`;
+/** Represents an object with `hex` (`hex6`) and `rgb` color */
+type RandomHexRGB = {
+  /** Represents a hexadecimal color code. */hex: Hex6; /** Represents an RGB color string. */
+  rgb: RGB;
+};
+/** Basic color type: `hex`, `rgb` or `hsl`. */
+type $ColorType = 'hex' | 'rgb' | 'hsl';
+/** Options for random color generation. */
+interface RandomColorOptions<C extends $ColorType> {
+  /** The type of expected return type of color: `hex`, `rgb` or `hsl`. Default is `'hex'`. */
+  colorType?: C | $ColorType;
+  /** The maximum number of recent colors to store in memory. Default is `16`. */
+  maxColors?: number;
+}
+/** Infers random color type (`Hex6`, `RGB`, or `HSL`) based on the provided color type `C`. */
+type RandomColor<C extends Maybe<$ColorType> = undefined> = C extends undefined | 'hex' ? Hex6 : C extends 'hsl' ? HSL : C extends 'rgb' ? RGB : Hex6;
+/** * Union type representing a color in Hex6, RGB, or HSL format. */
+type ColorTypeSolid = Hex6 | RGB | HSL;
+/** * Union type representing a color in Hex8, RGBA, or HSLA format. */
+type ColorTypeAlpha = Hex8 | RGBA | HSLA;
+/** * Union of Alpha & Solid `Hex`, `RGB` and `HSL` */
+type ColorType = Hex | Hex6 | RGB | HSL | Hex8 | RGBA | HSLA;
+/** - Colors Object that includes `Hex8`, `RGBA` and `HSLA` formats of the same color. */
+interface SolidColors {
+  /** Represents a normal Hex color */
+  hex: Hex6;
+  /** Represents a normal RGB color */
+  rgb: RGB;
+  /** Represents a normal HSL color */
+  hsl: HSL;
+}
+/** - Colors Object that includes `Hex`, `RGB` and `HSL` formats of the same color. */
+interface AlphaColors {
+  /** Represents a Hex color with alpha channel */
+  hex8: Hex8;
+  /** Represents a RGBA color with alpha channel */
+  rgba: RGBA;
+  /** Represents a HSLA color with alpha channel */
+  hsla: HSLA;
+}
+/** * Represents a tuple of three numerical values corresponding to RGB or HSL color components. */
+type SolidValues = [number, number, number];
+/** * Represents a tuple of four numerical values corresponding to RGBA or HSLA color components. */
+type AlphaValues = [number, number, number, number];
+/**
+ * * Represents the converted color formats for a given color type.
+ *
+ * - If the input is `Hex`, the output includes `RGB` and `HSL`.
+ * - If the input is `RGB`, the output includes `Hex` and `HSL`.
+ * - If the input is `HSL`, the output includes `Hex` and `RGB`.
+ */
+interface ConvertedColors<T extends ColorType> extends Record<string, ColorType> {
+  /** - The Hex representation (excluded if the input is already Hex). */
+  hex: T extends Hex6 | ColorTypeAlpha ? never : Hex6;
+  /** - The RGB representation (excluded if the input is already RGB). */
+  rgb: T extends RGB | ColorTypeAlpha ? never : RGB;
+  /** - The HSL representation (excluded if the input is already HSL). */
+  hsl: T extends HSL | ColorTypeAlpha ? never : HSL;
+  /** - The Hex8 representation with opacity (excluded if the input is already Hex8). */
+  hex8: T extends Hex8 | ColorTypeSolid ? never : Hex8;
+  /** - The RGBA representation (excluded if the input is already RGBA). */
+  rgba: T extends RGBA | ColorTypeSolid ? never : RGBA;
+  /** - The HSLA representation (excluded if the input is already HSLA). */
+  hsla: T extends HSLA | ColorTypeSolid ? never : HSLA;
+}
+/** Represents an alpha value between 0 and 1 */
+type AlphaValue = Branded<number, 'AlphaValue'>;
+/** An Object representing all the colors from `Color` constructor. */
+interface Colors {
+  /** - `Hex` color (e.g., `#ff5733`) */
+  hex: Hex6;
+  /** - `Hex8` color (Hex with opacity, e.g., `#ff573380`) */
+  hex8: Hex8;
+  /** - `RGB` color (e.g., `rgb(255, 87, 51)`) */
+  rgb: RGB;
+  /** - `RGBA` color (e.g., `rgba(255, 87, 51, 1)`) */
+  rgba: RGBA;
+  /** - `HSL` color (e.g., `hsl(14, 100%, 60%)`) */
+  hsl: HSL;
+  /** - `HSLA` color (e.g., `hsla(14, 100%, 60%, 1)`) */
+  hsla: HSLA;
+}
+/** Analogous colors  */
+type Analogous = [Color, Color, Color];
+/** Triad color */
+type Triad = [Color, Color, Color];
+/** Tetrad color */
+type Tetrad = [Color, Color, Color, Color];
+/** CSS named color, also includes different response colors */
+type CSSColor = keyof typeof CSS_COLORS;
+//#endregion
+//#region src/colors/Color.d.ts
+/**
+ * @class Represents a color in {@link Hex6 Hex}, {@link Hex8}, {@link RGB}, {@link RGBA}, {@link HSL}, and {@link HSLA} formats.
+ *
+ * @remarks
+ * - Instance methods allow transforming, adjusting, and deriving new colors.
+ * - Static methods provide format validation and type-guard–style checks for supported color representations.
+ *
+ * @property `hex`  - {@link Hex6 Hex} color representation (without alpha).
+ * @property `hex8` - {@link Hex8} color representation including alpha.
+ * @property `rgb`  - {@link RGB} color representation (without alpha).
+ * @property `rgba` - {@link RGBA} color representation including alpha.
+ * @property `hsl`  - {@link HSL} color representation (without alpha).
+ * @property `hsla` - {@link HSLA} color representation including alpha.
+ */
+declare class Color {
+  #private;
+  readonly hex: Hex6;
+  readonly hex8: Hex8;
+  readonly rgb: RGB;
+  readonly rgba: RGBA;
+  readonly hsl: HSL;
+  readonly hsla: HSLA;
+  /**
+   * * Creates a new `Color` instance with a random color and automatically converts the generated color to all other supported formats: {@link Hex6 Hex}, {@link Hex8}, {@link RGB}, {@link RGBA}, {@link HSL}, and {@link HSLA}.
+   *
+   * @description
+   * The `Color` class generates a random color in six common color representations:
+   * - {@link Hex6 Hex} (e.g., `#ff5733`)
+   * - {@link Hex8} (Hex with opacity, e.g., `#ff573380`)
+   * - {@link RGB} (e.g., `rgb(255, 87, 51)`)
+   * - {@link RGBA} (e.g., `rgba(255, 87, 51, 1)`)
+   * - {@link HSL} (e.g., `hsl(14, 100%, 60%)`)
+   * - {@link HSLA} (e.g., `hsla(14, 100%, 60%, 1)`)
+   *
+   * @remarks
+   * - Instance methods allow transforming, adjusting, and deriving new colors.
+   * - Static methods provide format validation and type-guard–style checks for supported color representations.
+   *
+   * @example
+   * // Generate a random color
+   * const randomColor = new Color();
+   * console.log(randomColor.hex, randomColor.rgb, randomColor.hsl);
+   *
+   * @returns Instance of `Color`.
+   */
+  constructor();
+  /**
+   * * Creates a new `Color` instance with the input color and automatically converts it to all other supported formats: {@link Hex6 Hex}, {@link Hex8}, {@link RGB}, {@link RGBA}, {@link HSL}, and {@link HSLA}.
+   *
+   * @description
+   * The `Color` class allows seamless transformation between six common color representations:
+   * - {@link Hex6 Hex} (e.g., `#ff5733`)
+   * - {@link Hex8} (Hex with opacity, e.g., `#ff573380`)
+   * - {@link RGB} (e.g., `rgb(255, 87, 51)`)
+   * - {@link RGBA} (e.g., `rgba(255, 87, 51, 1)`)
+   * - {@link HSL} (e.g., `hsl(14, 100%, 60%)`)
+   * - {@link HSLA} (e.g., `hsla(14, 100%, 60%, 1)`)
+   *
+   * You can create a color from any of these formats, and the class will populate the rest.
+   *
+   * @remarks
+   * - Instance methods allow transforming, adjusting, and deriving new colors.
+   * - Static methods provide format validation and type-guard–style checks for supported color representations.
+   *
+   * @param color - A color string in any supported format (`Hex`, `Hex8`, `RGB`, `RGBA`, `HSL`, or `HSLA`) to convert in all other formats (includes the current format).
+   *
+   * @example
+   * // Convert an existing Hex color to all other formats
+   * const color = new Color("#ff5733");
+   * console.log(color.rgb); // 'rgb(255, 87, 51)'
+   * console.log(color.hsl); // 'hsl(14, 100%, 60%)'
+   * console.log(color.rgba); // 'rgba(255, 87, 51, 1)'
+   * console.log(color.hsla); // 'hsla(14, 100%, 60%, 1)'
+   * console.log(color.hex8); // '#FF5733FF'
+   *
+   * @example
+   * // Handle a color with alpha
+   * const alphaColor = new Color("rgba(255, 0, 0, 0.5)");
+   * console.log(alphaColor.hex8); // '#FF000080'
+   * console.log(alphaColor.hsla); // 'hsla(0, 100%, 50%, 0.5)'
+   *
+   * @returns Instance of `Color`.
+   */
+  constructor(color: ColorType);
+  /**
+   * * Creates a new `Color` instance using a standard (CSS) named color and automatically converts it to all other supported formats: {@link Hex6 Hex}, {@link Hex8}, {@link RGB}, {@link RGBA}, {@link HSL}, and {@link HSLA}.
+   *
+   * @description
+   * This allows you to use any valid named color from standard `150+` CSS color names (e.g., `"red"`, `"blue"`, `"rebeccapurple"`)
+   *
+   * @param color - A named color string from standard `150+` CSS color names ({@link CSSColor}).
+   *
+   * @remarks
+   * - Instance methods allow transforming, adjusting, and deriving new colors.
+   * - Static methods provide format validation and type-guard–style checks for supported color representations.
+   *
+   * @example
+   * // Using a CSS named color
+   * const sky = new Color("skyblue");
+   * console.log(sky.hex); // '#87CEEB'
+   * console.log(sky.rgba); // 'rgba(135, 206, 235, 1)'
+   *
+   * @returns Instance of `Color`.
+   */
+  constructor(color: CSSColor);
+  /**
+   * * Creates a new `Color` instance and automatically converts the input color to all other supported formats: {@link Hex6 Hex}, {@link Hex8}, {@link RGB}, {@link RGBA}, {@link HSL}, and {@link HSLA}.
+   *
+   * @description
+   * The `Color` class allows seamless transformation between six common color representations:
+   * - {@link Hex6 Hex} (e.g., `#ff5733`)
+   * - {@link Hex8} (Hex with opacity, e.g., `#ff573380`)
+   * - {@link RGB} (e.g., `rgb(255, 87, 51)`)
+   * - {@link RGBA} (e.g., `rgba(255, 87, 51, 1)`)
+   * - {@link HSL} (e.g., `hsl(14, 100%, 60%)`)
+   * - {@link HSLA} (e.g., `hsla(14, 100%, 60%, 1)`)
+   *
+   * You can create a color from any of these formats, and the class will populate the rest.
+   * If no color is passed, a random color will be generated.
+   *
+   * @remarks
+   * - Instance methods allow transforming, adjusting, and deriving new colors.
+   * - Static methods provide format validation and type-guard–style checks for supported color representations.
+   *
+   * @param color - An optional input color string in any supported format (`Hex`, `Hex8`, `RGB`, `RGBA`, `HSL`, or `HSLA`) or a named color string from standard `150+` CSS color names ({@link CSSColor}) to convert in all other (includes the current format) formats.
+   *
+   * @example
+   * // Convert an existing Hex color to all other formats
+   * const color = new Color("#ff5733");
+   * console.log(color.rgb); // 'rgb(255, 87, 51)'
+   * console.log(color.hsl); // 'hsl(14, 100%, 60%)'
+   * console.log(color.rgba); // 'rgba(255, 87, 51, 1)'
+   * console.log(color.hsla); // 'hsla(14, 100%, 60%, 1)'
+   * console.log(color.hex8); // '#FF5733FF'
+   *
+   * @example
+   * // Handle a color with alpha
+   * const alphaColor = new Color("rgba(255, 0, 0, 0.5)");
+   * console.log(alphaColor.hex8); // '#FF000080'
+   * console.log(alphaColor.hsla); // 'hsla(0, 100%, 50%, 0.5)'
+   *
+   * @example
+   * // Generate a random color
+   * const randomColor = new Color();
+   * console.log(randomColor.hex, randomColor.rgb, randomColor.hsl);
+   *
+   * @example
+   * // Using a CSS named color
+   * const sky = new Color("skyblue");
+   * console.log(sky.hex); // '#87CEEB'
+   * console.log(sky.rgba); // 'rgba(135, 206, 235, 1)'
+   *
+   * @returns Instance of `Color`.
+   */
+  constructor(color?: ColorType | CSSColor);
+  /** Iterates over the color representations (`Hex`, `RGB`, `HSL`). */
+  [Symbol.iterator](): Generator<Hex6 | Hex8 | RGB | RGBA | HSL | HSLA, void, unknown>;
+  /**
+   * @instance Applies or modifies the opacity of a color and returns a new instance.
+   *
+   * @remarks
+   * - For solid colors ({@link Hex6}/{@link RGB}/{@link HSL}): Adds an alpha channel with the specified opacity.
+   * - For alpha colors ({@link Hex8}/{@link RGBA}/{@link HSLA}): Updates the existing alpha channel.
+   *
+   * @param opacity - A number between `0-100` representing the opacity percentage.
+   * @returns A new instance of `Color` containing all color formats with the applied opacity.
+   *
+   * @example
+   * const color = new Color("#ff0000");
+   * const alpha50 = color.applyOpacity(50); // 50% opacity
+   * console.log(alpha50.rgba); // rgba(255, 0, 0, 0.5)
+   *
+   * @example
+   * const alphaColor = new Color("#ff000080"); // Color with 50% opacity
+   * const alpha75 = alphaColor.applyOpacity(75); // Change to 75% opacity
+   * console.log(alpha75.hex8); // #FF0000BF
+   */
+  applyOpacity(opacity: Percent): Color;
+  /**
+   * @instance Darkens the color by reducing the lightness by the given percentage.
+   * @param percent - The percentage to darken (`0–100`).
+   * @returns A new `Color` instance with the modified darkness.
+   */
+  applyDarkness(percent: Percent): Color;
+  /**
+   * @instance Lightens the color by increasing the lightness by the given percentage.
+   * @param percent - The percentage to brighten (`0–100`).
+   * @returns A new `Color` instance with the modified lightness.
+   */
+  applyBrightness(percent: Percent): Color;
+  /**
+   * @instance Reduces the saturation of the color to make it appear duller.
+   * @param percent - The percentage to reduce saturation (`0–100`).
+   * @returns A new `Color` instance with the modified saturation.
+   */
+  applyDullness(percent: Percent): Color;
+  /**
+   * @instance Softens the color toward white by reducing saturation and increasing lightness based on a percentage.
+   *
+   * @remarks
+   * This creates a soft UI-like white shade effect (similar to some UI libraries' light color scale).
+   *
+   * @param percent - Value from `0` to `100` representing how far to push the color toward white.
+   * @returns A new `Color` instance shifted toward white.
+   */
+  applyWhiteShade(percent: Percent): Color;
+  /**
+   * @instance Blends the current color with another color based on the given weight.
+   *
+   * @remarks
+   * If any of the input colors has opacity (alpha channel), it might be lost or distorted from the generated alpha variants of the respective color formats.
+   *
+   * @param other - The color in any of 6 ({@link Hex6 Hex}, {@link Hex8}, {@link RGB}, {@link RGBA}, {@link HSL} or {@link HSLA}) formats or a {@link CSSColor} to blend with.
+   * @param weight - A number from `0` to `1` indicating the weight of the other color. Defaults to `0.5`.
+   *               - `weight = 0` → only the original color.
+   *               - `weight = 1` → only the other color.
+   *               - `weight = 0.5` → equal blend between the two.
+   * @returns A new `Color` instance representing the blended result, with proper alpha blending.
+   */
+  blendWith(other: ColorType | CSSColor, weight?: number): Color;
+  /**
+   * @instance Calculates the contrast ratio between this color and another color (WCAG).
+   * @param other - The other color to compare against.
+   * @returns A number representing the contrast ratio (rounded to 2 decimal places).
+   */
+  contrastRatio(other: ColorType | CSSColor): number;
+  /**
+   * @instance Returns the complementary color by rotating the hue 180 degrees.
+   * @returns A new `Color` that is the complement of the current color.
+   */
+  getComplementaryColor(): Color;
+  /**
+   * @instance Generates a color scheme of analogous colors, including the base color.
+   *
+   * @remarks
+   * Analogous colors are next to each other on the color wheel (±30°).
+   *
+   * @returns An array of three `Color` instances: `[base, left, right]`.
+   */
+  getAnalogousColors(): Analogous;
+  /**
+   * @instance Generates a color triad scheme including the base color.
+   *
+   * @remarks
+   * Triadic colors are evenly spaced (120° apart) on the color wheel.
+   *
+   * @returns An array of three `Color` instances: `[base, triad1, triad2]`.
+   */
+  getTriadColors(): Triad;
+  /**
+   * @instance Generates a tetradic color scheme including the base color.
+   *
+   * @remarks
+   * Tetradic colors form a rectangle on the color wheel (90° apart).
+   *
+   * @returns An array of four `Color` instances: `[base, tetrad1, tetrad2, tetrad3]`.
+   */
+  getTetradColors(): Tetrad;
+  /**
+   * @instance Gets the `WCAG` accessibility rating between this and another color.
+   * @param other - The other color to test contrast against.
+   * @returns `'Fail'`, `'AA'`, or `'AAA'` based on `WCAG 2.1` contrast standards.
+   */
+  getWCAGRating(other: ColorType | CSSColor): 'Fail' | 'AA' | 'AAA';
+  /**
+   * @instance Determines if the color is light based on its perceived brightness.
+   * @param threshold Optional brightness threshold (`0–255`). Defaults to `127.5`.
+   * @remarks The brightness {@link threshold} is clamped to the valid *RGB range* (`0–255`) to prevent invalid comparisons.
+   * @returns `true` if light, `false` if dark.
+   */
+  isLightColor(threshold?: number): boolean;
+  /**
+   * @static Checks if a color is in {@link Hex6} format.
+   *
+   * @param color Color to check.
+   * @returns Boolean: `true` if it's a {@link Hex6} color, `false` if not.
+   */
+  static isHex6(color: string): color is Hex6;
+  /**
+   * @static Checks if a color is in {@link Hex8} format.
+   *
+   * @param color Color to check.
+   * @returns Boolean: `true` if it's a {@link Hex8} color, `false` if not.
+   */
+  static isHex8(color: string): color is Hex8;
+  /**
+   * @static Checks if a color is in {@link RGB} format and within valid ranges.
+   *
+   * @param color Color to check.
+   * @returns `true` if it's a {@link RGB} color, `false` if not.
+   */
+  static isRGB(color: string): color is RGB;
+  /**
+   * @static Checks if a color is in {@link RGBA} format and within valid ranges.
+   *
+   * @param color Color to check.
+   * @returns `true` if it's a {@link RGBA} color, `false` if not.
+   */
+  static isRGBA(color: string): color is RGBA;
+  /**
+   * @static Checks if a color is in {@link HSL} format and within valid ranges.
+   *
+   * @param color Color to check.
+   * @returns `true` if it's a {@link HSL} color, `false` if not.
+   */
+  static isHSL(color: string): color is HSL;
+  /**
+   * @static Checks if a color is in {@link HSLA} format and within valid ranges.
+   *
+   * @param color Color to check.
+   * @returns `true` if it's a {@link HSLA} color, `false` if not.
+   */
+  static isHSLA(color: string): color is HSLA;
+  /**
+   * @static Checks if a color is a valid CSS color name ({@link CSSColor}).
+   *
+   * @remarks
+   * - This method checks against a predefined list of CSS color names.
+   * - It does not validate format types like `Hex`, `RGB`, or `HSL` or their alpha channels.
+   *
+   * @param color - The color to check.
+   * @returns `true` if the color is a valid CSS color name, `false` otherwise.
+   */
+  static isCSSColor(color: string): color is CSSColor;
+}
+//#endregion
+export { RandomColorOptions as C, Tetrad as D, SolidValues as E, Triad as O, RandomColor as S, SolidColors as T, Hex as _, AlphaValues as a, RGB as b, ColorInput as c, ColorTypeAlpha as d, ColorTypeSolid as f, HSLA as g, HSL as h, AlphaValue as i, ColorInputArray as l, ConvertedColors as m, $ColorType as n, Analogous as o, Colors as p, AlphaColors as r, CSSColor as s, Color as t, ColorType as u, Hex6 as v, RandomHexRGB as w, RGBA as x, Hex8 as y };