toolbox-x 1.0.0

package/dist/colors.mjs

@@ -0,0 +1,547 @@
+/**
+ * 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 { a as isNonEmptyString, c as isNumber, d as isString } from "./primitives-KsFUp3kQ.mjs";
+import { t as CSS_COLORS } from "./css-colors-DfUW3nTR.mjs";
+import { c as _applyOpacity, l as _generateRandomHSL, n as isHSL, o as isRGB, r as isHSLA, s as isRGBA, u as _isSimilarToLast } from "./guards-3kaUX66g.mjs";
+import { _ as extractSolidColorValues, a as convertHexToRgb, c as convertHslaToHex8, d as convertRgbToHsl, f as convertRgbToRgba, g as extractAlphaColorValues, h as applyOpacityToHex, i as convertHexToHsl, l as convertHslaToRgba, m as convertRgbaToHsla, n as convertHex8ToHsla, o as convertHslToHex, p as convertRgbaToHex8, r as convertHex8ToRgba, s as convertHslToRgb, t as convertColorCode, u as convertRgbToHex, v as percentToHex } from "./convert-DhaUoPVU.mjs";
+import { n as NUMBER_COLOR_PALETTE, t as ALPHABET_COLOR_PALETTE } from "./constants-DAfRxaa8.mjs";
+
+//#region src/colors/random.ts
+/** Track previously generated colors. */
+const generatedColors = /* @__PURE__ */ new Set();
+/** Array of recently generated colors. */
+const recentColors = [];
+/**
+* * Utility to generate a unique random HSL color.
+*
+* @param maxColors - The maximum number of recent colors to store in memory. Default is `16`.
+* @returns Generated unique random color in `HSL` format.
+*/
+const generateRandomHSLColor = (maxColors = 16) => {
+	let color;
+	do
+		color = _generateRandomHSL();
+	while (generatedColors.has(color) || _isSimilarToLast(recentColors, color));
+	generatedColors.add(color);
+	recentColors.push(color);
+	if (recentColors?.length > maxColors) recentColors?.shift();
+	return color;
+};
+/**
+* @deprecated For optimized performance and more flexibility, please consider using {@link generateRandomColor}.
+*
+* * Utility to generate a unique random color in `Hex6` and `RGB` format.
+*
+* @param maxColors - The maximum number of recent colors to store in memory. Default is `16`.
+* @returns An object of generated unique random color in both `Hex` and `RGB` formats.
+*/
+const generateRandomColorInHexRGB = (maxColors = 16) => {
+	return convertColorCode(generateRandomHSLColor(maxColors));
+};
+/**
+* * Generates a random unique color in one of three formats: `Hex6`, `RGB`, or `HSL`.
+*
+* @remarks
+* - If no `options` or `colorType` option is provided, the function defaults to returning a color in `Hex6` format.
+* - The `colorType` option determines the return type:
+*   - `'hex'` → returns a `Hex6` string e.g. `'#34E2EF'`
+*   - `'rgb'` → returns an `RGB` string e.g. `'hsl(223, 96%, 53%)'`
+*   - `'hsl'` → returns an `HSL` string e.g. `'rgb(235, 159, 45)'`
+* - The `maxColors` option controls how many recently generated colors are kept in memory to prevent repetition.
+*   By default, this value is `16`. Increasing it allows more unique color variations before repeating.
+*
+* @param options - Configuration options for random color generation, including `colorType` and `maxColors`.
+* @returns A random unique color in the specified format (`Hex6`, `RGB`, or `HSL`).
+*
+* @example
+* const hex = generateRandomColor();
+* // hex value with inferred type: Hex6
+*
+* const rgb = generateRandomColor({ colorType: 'rgb' });
+* // rgb value with inferred type: RGB
+*
+* const hsl = generateRandomColor({ colorType: 'hsl', maxColors: 32 });
+* // hsl value with inferred type: HSL, with a larger unique color memory pool
+*/
+function generateRandomColor(options) {
+	const { colorType = "hex", maxColors = 16 } = options ?? {};
+	const hsl = generateRandomHSLColor(maxColors);
+	const hslValues = extractSolidColorValues(hsl);
+	switch (colorType) {
+		case "hsl": return hsl;
+		case "rgb": return convertHslToRgb(...hslValues);
+		default: return convertHslToHex(...hslValues);
+	}
+}
+
+//#endregion
+//#region src/colors/Color.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.
+*/
+var Color = class Color {
+	hex;
+	hex8;
+	rgb;
+	rgba;
+	hsl;
+	hsla;
+	/**
+	* * 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}.
+	*
+	* @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.
+	*/
+	constructor(color) {
+		if (color) {
+			const $color = color.trim();
+			if (Color.isCSSColor($color)) {
+				const { hex, hex8, rgb, rgba, hsl, hsla } = new Color(CSS_COLORS[$color]);
+				this.hex = hex;
+				this.hex8 = hex8;
+				this.rgb = rgb;
+				this.rgba = rgba;
+				this.hsl = hsl;
+				this.hsla = hsla;
+			} else {
+				const colors = this.#convertColorToOthers($color);
+				if ("hex8" in colors) {
+					const [r, g, b] = extractAlphaColorValues(colors.rgba);
+					const [h, s, l] = extractAlphaColorValues(colors.hsla);
+					this.hex = colors.hex8.toUpperCase().slice(0, 7);
+					this.hex8 = colors.hex8.toUpperCase();
+					this.rgb = `rgb(${r}, ${g}, ${b})`;
+					this.rgba = colors.rgba;
+					this.hsl = `hsl(${h}, ${s}%, ${l}%)`;
+					this.hsla = colors.hsla;
+				} else {
+					this.hex = colors.hex.toUpperCase();
+					this.hex8 = this.#hex6ToHex8(colors.hex);
+					this.rgb = colors.rgb;
+					this.rgba = this.#rgbToRGBA(colors.rgb);
+					this.hsl = colors.hsl;
+					this.hsla = this.#hslToHSLA(colors.hsl);
+				}
+			}
+		} else {
+			const hsl = generateRandomHSLColor();
+			const { hex, rgb } = convertColorCode(hsl);
+			this.hex = hex.toUpperCase();
+			this.hex8 = this.#hex6ToHex8(hex);
+			this.rgb = rgb;
+			this.rgba = this.#rgbToRGBA(rgb);
+			this.hsl = hsl;
+			this.hsla = this.#hslToHSLA(hsl);
+		}
+	}
+	/** Iterates over the color representations (`Hex`, `RGB`, `HSL`). */
+	*[Symbol.iterator]() {
+		yield this.hex;
+		yield this.hex8;
+		yield this.rgb;
+		yield this.rgba;
+		yield this.hsl;
+		yield this.hsla;
+	}
+	/**
+	* @private Convert `Hex6` color format to `Hex8` by applying `100%` opacity.
+	* @param hex `Hex6` color to convert to `Hex8`.
+	*/
+	#hex6ToHex8(hex) {
+		return `${hex.toUpperCase()}${percentToHex(100)}`;
+	}
+	/**
+	* @private Convert `RGB` color format to `RGBA`.
+	* @param rgb `RGB` color to convert to `RGBA`.
+	*/
+	#rgbToRGBA(rgb) {
+		const [r, g, b] = extractSolidColorValues(rgb);
+		return `rgba(${r}, ${g}, ${b}, 1)`;
+	}
+	/**
+	* @private Convert `HSL` color format to `HSLA`.
+	* @param hsl `HSL` color to convert to `HSLA`.
+	*/
+	#hslToHSLA(hsl) {
+		const [h, s, l] = extractSolidColorValues(hsl);
+		return `hsla(${h}, ${s}%, ${l}%, 1)`;
+	}
+	/**
+	* @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) {
+		return new Color(`${this.hex.slice(0, 7)}${percentToHex(opacity)}`.toUpperCase());
+	}
+	/**
+	* @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) {
+		const [h, s, l, a] = extractAlphaColorValues(this.hsla);
+		return new Color(`hsl(${h}, ${s}%, ${Math.max(0, l - percent)}%)`).applyOpacity(a * 100);
+	}
+	/**
+	* @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) {
+		const [h, s, l, a] = extractAlphaColorValues(this.hsla);
+		return new Color(`hsl(${h}, ${s}%, ${Math.min(100, l + percent)}%)`).applyOpacity(a * 100);
+	}
+	/**
+	* @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) {
+		const [h, s, l, a] = extractAlphaColorValues(this.hsla);
+		return new Color(`hsl(${h}, ${Math.max(0, s - percent)}%, ${l}%)`).applyOpacity(a * 100);
+	}
+	/**
+	* @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) {
+		const [h, s, l, a] = extractAlphaColorValues(this.hsla);
+		return new Color(`hsl(${h}, ${Math.max(0, s - s * percent / 100)}%, ${Math.min(100, l + (100 - l) * percent / 100)}%)`).applyOpacity(a * 100);
+	}
+	/**
+	* @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, weight = .5) {
+		const w = Math.max(0, Math.min(1, weight));
+		const converted = Color.isCSSColor(other) ? new Color(other) : new Color(other);
+		const [r1, b1, g1, a1] = extractAlphaColorValues(this.rgba);
+		const [r2, b2, g2, a2] = extractAlphaColorValues(converted.rgba);
+		const alpha = Math.round((a1 * (1 - w) + a2 * w) * 100) / 100;
+		const blendChannel = (c1, c2) => {
+			return Math.round((c1 * a1 * (1 - w) + c2 * a2 * w) / alpha);
+		};
+		return new Color(`rgba(${blendChannel(r1, r2)}, ${blendChannel(g1, g2)}, ${blendChannel(b1, b2)}, ${alpha})`);
+	}
+	/**
+	* @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) {
+		const newColor = Color.isCSSColor(other) ? new Color(other) : new Color(other);
+		const luminance = (rgb) => {
+			const [r, g, b] = extractSolidColorValues(rgb).map((v) => {
+				const c = v / 255;
+				return c <= .03928 ? c / 12.92 : Math.pow((c + .055) / 1.055, 2.4);
+			});
+			return .2126 * r + .7152 * g + .0722 * b;
+		};
+		const lum1 = luminance(this.rgb);
+		const lum2 = luminance(newColor.rgb);
+		const brighter = Math.max(lum1, lum2);
+		const darker = Math.min(lum1, lum2);
+		const ratio = (brighter + .05) / (darker + .05);
+		return Math.round(ratio * 100) / 100;
+	}
+	/**
+	* @instance Returns the complementary color by rotating the hue 180 degrees.
+	* @returns A new `Color` that is the complement of the current color.
+	*/
+	getComplementaryColor() {
+		const [h, s, l, a] = extractAlphaColorValues(this.hsla);
+		return new Color(`hsl(${(h + 180) % 360}, ${s}%, ${l}%)`).applyOpacity(a * 100);
+	}
+	/**
+	* @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() {
+		const [h, s, l, a] = extractAlphaColorValues(this.hsla);
+		const left = `hsl(${(h + 330) % 360}, ${s}%, ${l}%)`;
+		const right = `hsl(${(h + 30) % 360}, ${s}%, ${l}%)`;
+		return [
+			this,
+			new Color(left),
+			new Color(right)
+		].map((c) => c.applyOpacity(a * 100));
+	}
+	/**
+	* @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() {
+		const [h, s, l, a] = extractAlphaColorValues(this.hsla);
+		const c1 = `hsl(${(h + 120) % 360}, ${s}%, ${l}%)`;
+		const c2 = `hsl(${(h + 240) % 360}, ${s}%, ${l}%)`;
+		return [
+			this,
+			new Color(c1),
+			new Color(c2)
+		].map((c) => c.applyOpacity(a * 100));
+	}
+	/**
+	* @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() {
+		const [h, s, l, a] = extractAlphaColorValues(this.hsla);
+		const c1 = `hsl(${(h + 90) % 360}, ${s}%, ${l}%)`;
+		const c2 = `hsl(${(h + 180) % 360}, ${s}%, ${l}%)`;
+		const c3 = `hsl(${(h + 270) % 360}, ${s}%, ${l}%)`;
+		return [
+			this,
+			new Color(c1),
+			new Color(c2),
+			new Color(c3)
+		].map((c) => c.applyOpacity(a * 100));
+	}
+	/**
+	* @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) {
+		const ratio = this.contrastRatio(other);
+		if (ratio >= 7) return "AAA";
+		if (ratio >= 4.5) return "AA";
+		return "Fail";
+	}
+	/**
+	* @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 = 127.5) {
+		const [r, g, b] = extractSolidColorValues(this.rgb);
+		return (r * 299 + g * 587 + b * 114) / 1e3 > Math.min(255, Math.max(0, threshold));
+	}
+	/**
+	* @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) {
+		return /^#[0-9A-Fa-f]{6}$/.test(color?.trim());
+	}
+	/**
+	* @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) {
+		return /^#[0-9A-Fa-f]{8}$/.test(color?.trim());
+	}
+	/**
+	* @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) {
+		return isRGB(color);
+	}
+	/**
+	* @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) {
+		return isRGBA(color);
+	}
+	/**
+	* @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) {
+		return isHSL(color);
+	}
+	/**
+	* @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) {
+		return isHSLA(color);
+	}
+	/**
+	* @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) {
+		return isNonEmptyString(color) && color in CSS_COLORS;
+	}
+	/**
+	* @private Converts the given color to all other formats while preserving the original.
+	*
+	* @param color - The color to convert.
+	* @returns An object containing `Hex`, `RGB`, and `HSL` representations.
+	*/
+	#convertColorToOthers(color) {
+		if (Color.isHex6(color)) {
+			const { rgb, hsl } = convertColorCode(color);
+			return {
+				hex: color,
+				rgb,
+				hsl
+			};
+		} else if (Color.isRGB(color)) {
+			const { hex, hsl } = convertColorCode(color);
+			return {
+				hex,
+				rgb: color,
+				hsl
+			};
+		} else if (Color.isHSL(color)) {
+			const { hex, rgb } = convertColorCode(color);
+			return {
+				hex,
+				rgb,
+				hsl: color
+			};
+		} else if (Color.isHex8(color)) {
+			const { rgba, hsla } = convertColorCode(color);
+			return {
+				hex8: color,
+				rgba,
+				hsla
+			};
+		} else if (Color.isRGBA(color)) {
+			const { hex8, hsla } = convertColorCode(color);
+			return {
+				hex8,
+				rgba: color,
+				hsla
+			};
+		} else if (Color.isHSLA(color)) {
+			const { hex8, rgba } = convertColorCode(color);
+			return {
+				hex8,
+				rgba,
+				hsla: color
+			};
+		}
+		throw new TypeError(`${color} is not a valid color!`, { cause: "Unrecognized Color Format" });
+	}
+};
+
+//#endregion
+//#region src/colors/initials.ts
+/**
+*  * Generates a hex color (`Hex8` format) based on the first character (initial) of a string or number; or an array of hex colors based on the first character (initial) of an array of strings/numbers or even nested arrays of strings/numbers.
+*
+* - For numbers, it uses 10 predefined colors (0-9).
+* - For letters, it uses 26 predefined colors (A-Z).
+* - For empty array it returns all 36 colors.
+* - Invalid characters and inputs are handled with a fallback color.
+* @param input - A string, number, or an array of strings/numbers or even nested arrays of strings/numbers.
+* @param opacity - A value from 0 to 100 representing the opacity percentage.
+* @returns A hex color for a string/number, or an array of hex colors for each element of the provided array.
+*/
+function getColorForInitial(input = "", opacity = 100) {
+	let initial;
+	const hexOpacity = percentToHex(opacity);
+	const NUMBERS = "0123456789";
+	const DEFAULT = "#010514";
+	if (!input) return _applyOpacity(DEFAULT, hexOpacity);
+	if (isString(input)) {
+		initial = input[0];
+		if (NUMBERS.includes(initial)) return _applyOpacity(NUMBER_COLOR_PALETTE[parseInt(initial, 10)], hexOpacity);
+		const index = initial.toUpperCase().charCodeAt(0) - "A".charCodeAt(0);
+		if (index >= 0 && index < ALPHABET_COLOR_PALETTE?.length) return _applyOpacity(ALPHABET_COLOR_PALETTE[index], hexOpacity);
+		return _applyOpacity(DEFAULT, hexOpacity);
+	} else if (isNumber(input)) {
+		initial = input.toString()[0];
+		if (NUMBERS.includes(initial)) return _applyOpacity(NUMBER_COLOR_PALETTE[parseInt(initial, 10)], hexOpacity);
+		return _applyOpacity(DEFAULT, hexOpacity);
+	} else if (Array.isArray(input)) {
+		if (input?.length < 1) return [...ALPHABET_COLOR_PALETTE, ...NUMBER_COLOR_PALETTE].map((color) => _applyOpacity(color, hexOpacity));
+		return input.map((el) => {
+			if (Array.isArray(el)) return getColorForInitial(el, opacity);
+			return getColorForInitial(el, opacity);
+		}).flat();
+	}
+	return _applyOpacity(DEFAULT, hexOpacity);
+}
+
+//#endregion
+export { Color, Color as Colour, applyOpacityToHex, convertColorCode, convertHex8ToHsla, convertHex8ToRgba, convertHexToHsl, convertHexToRgb, convertHslToHex, convertHslToRgb, convertHslaToHex8, convertHslaToRgba, convertRgbToHex, convertRgbToHsl, convertRgbToRgba, convertRgbaToHex8, convertRgbaToHsla, extractAlphaColorValues, extractSolidColorValues, generateRandomColor, generateRandomColor as getRandomColor, generateRandomColorInHexRGB, generateRandomHSLColor as generateRandomHSL, generateRandomHSLColor, generateRandomHSLColor as getRandomHSL, getColorForInitial, percentToHex };

package/dist/constants-2gAw23_7.mjs

@@ -0,0 +1,144 @@
+/**
+ * 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.
+ */
+
+//#region src/string/constants.ts
+/** List of conjunctions, prepositions, auxiliary verbs and articles in lowercase as array of strings */
+const LOWERCASE = /* @__PURE__ */ Object.freeze([
+	"and",
+	"but",
+	"or",
+	"nor",
+	"for",
+	"so",
+	"yet",
+	"after",
+	"although",
+	"as",
+	"because",
+	"before",
+	"even",
+	"if",
+	"once",
+	"since",
+	"than",
+	"that",
+	"though",
+	"unless",
+	"until",
+	"when",
+	"whenever",
+	"where",
+	"whereas",
+	"wherever",
+	"whether",
+	"while",
+	"about",
+	"above",
+	"across",
+	"after",
+	"against",
+	"along",
+	"among",
+	"around",
+	"as",
+	"at",
+	"before",
+	"behind",
+	"below",
+	"beneath",
+	"beside",
+	"between",
+	"beyond",
+	"but",
+	"by",
+	"concerning",
+	"considering",
+	"despite",
+	"down",
+	"during",
+	"except",
+	"following",
+	"for",
+	"from",
+	"in",
+	"inside",
+	"into",
+	"like",
+	"minus",
+	"near",
+	"of",
+	"off",
+	"on",
+	"onto",
+	"opposite",
+	"out",
+	"outside",
+	"over",
+	"past",
+	"per",
+	"plus",
+	"regarding",
+	"round",
+	"save",
+	"since",
+	"than",
+	"through",
+	"throughout",
+	"till",
+	"to",
+	"toward",
+	"towards",
+	"under",
+	"underneath",
+	"unlike",
+	"until",
+	"up",
+	"upon",
+	"versus",
+	"via",
+	"with",
+	"within",
+	"without",
+	"a",
+	"an",
+	"the",
+	"am",
+	"are",
+	"be",
+	"been",
+	"being",
+	"can",
+	"could",
+	"do",
+	"does",
+	"did",
+	"had",
+	"has",
+	"have",
+	"is",
+	"may",
+	"might",
+	"must",
+	"shall",
+	"should",
+	"was",
+	"were",
+	"will",
+	"would"
+]);
+
+//#endregion
+export { LOWERCASE as t };