nhb-toolbox 3.9.73 → 4.0.0

package/dist/cjs/array/basics.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLastArrayElement = exports.shuffleArray = exports.isInvalidOrEmptyArray = exports.filterArrayOfObjects = exports.flattenArray = void 0;
+/**
+ * * Flattens a nested array recursively or wraps any non-array data type in an array.
+ *
+ * @param input - The input value, which can be a nested array or a non-array value.
+ * @returns A fully flattened array of type `Flatten<T>`. If the input is not an array, it wraps it in a single-element array.
+ */
+const flattenArray = (input) => {
+    if (!Array.isArray(input))
+        return [input];
+    return input.reduce((acc, item) => {
+        // If item is an array, recursively flatten it; otherwise, add it directly.
+        return acc.concat(Array.isArray(item) ? (0, exports.flattenArray)(item) : [item]);
+    }, []);
+};
+exports.flattenArray = flattenArray;
+/**
+ * * Filters an array of objects based on multiple conditions for specified keys.
+ *
+ * @param array - The array of objects to filter.
+ * @param conditions - An object where keys represent the property names and values represent filter conditions.
+ *                     The conditions can be a function `(value: T[K]) => boolean`.
+ * @returns The filtered array of objects.
+ * @throws `Error` If the input is not a valid array.
+ */
+const filterArrayOfObjects = (array, conditions) => {
+    if (!Array.isArray(array)) {
+        throw new Error('The provided input is not a valid array!');
+    }
+    return array.filter((item) => Object.entries(conditions).every(([key, conditionFn]) => {
+        if (typeof conditionFn === 'function') {
+            return conditionFn(item[key]);
+        }
+        return true;
+    }));
+};
+exports.filterArrayOfObjects = filterArrayOfObjects;
+/**
+ * * Checks if a value is an empty array or an array with only empty values.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is not an array, an empty array, or an array containing only `null`, `undefined`, empty objects, or empty arrays.
+ */
+const isInvalidOrEmptyArray = (value) => {
+    if (!Array.isArray(value))
+        return true;
+    if (value.length === 0)
+        return true;
+    return value.every((item) => item == null ||
+        (Array.isArray(item) && item.length === 0) ||
+        (typeof item === 'object' && Object.keys(item || {}).length === 0));
+};
+exports.isInvalidOrEmptyArray = isInvalidOrEmptyArray;
+/**
+ * * Shuffle the elements of an array.
+ *
+ * @param array Array to shuffle.
+ * @returns Shuffled array.
+ */
+const shuffleArray = (array) => {
+    if ((0, exports.isInvalidOrEmptyArray)(array))
+        return array;
+    const shuffled = structuredClone(array);
+    for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    }
+    return shuffled;
+};
+exports.shuffleArray = shuffleArray;
+/**
+ * * Get the last element of an array.
+ *
+ * @param array Array to get the last element from.
+ * @returns The last element or `undefined` if the array is empty.
+ */
+const getLastArrayElement = (array) => {
+    return array?.length > 0 ? array[array?.length - 1] : undefined;
+};
+exports.getLastArrayElement = getLastArrayElement;

package/dist/cjs/array/sort.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortAnArray = sortAnArray;
+const non_primitives_1 = require("../guards/non-primitives");
+const primitives_1 = require("../guards/primitives");
+const utils_1 = require("./utils");
+/**
+ * * Sorts an array of strings, numbers, booleans, or objects based on the provided options.
+ *
+ * - If the array contains strings, it sorts them alphabetically.
+ * - If the array contains numbers, it sorts them numerically.
+ * - If the array contains booleans, it sorts them by their boolean value.
+ * - If the array contains objects, it sorts them by the specified field in the options `sortByField`.
+ *
+ * @param array - The array to sort.
+ * @param options - Sorting options for objects.
+ * @returns The sorted array.
+ */
+function sortAnArray(array, options) {
+    if (!(0, non_primitives_1.isValidArray)(array))
+        return array;
+    // Check if the array contains strings
+    if ((0, non_primitives_1.isArrayOfType)(array, primitives_1.isString)) {
+        return [...array].sort((a, b) => options?.sortOrder === 'desc' ?
+            (0, utils_1.naturalSort)(b, a)
+            : (0, utils_1.naturalSort)(a, b));
+    }
+    // Check if the array contains numbers
+    if ((0, non_primitives_1.isArrayOfType)(array, primitives_1.isNumber)) {
+        return [...array].sort((a, b) => options?.sortOrder === 'desc' ? b - a : a - b);
+    }
+    // Check if the array contains booleans
+    if ((0, non_primitives_1.isArrayOfType)(array, primitives_1.isBoolean)) {
+        return [...array].sort((a, b) => options?.sortOrder === 'desc' ?
+            Number(b) - Number(a)
+            : Number(a) - Number(b));
+    }
+    // Handle array of objects
+    if ((0, non_primitives_1.isArrayOfType)(array, non_primitives_1.isObject) && options && 'sortByField' in options) {
+        return [...array].sort((a, b) => {
+            const _getKeyValue = (obj, path) => {
+                return path
+                    .split('.')
+                    .reduce((acc, key) => acc?.[key], obj);
+            };
+            const keyA = _getKeyValue(a, options?.sortByField);
+            const keyB = _getKeyValue(b, options?.sortByField);
+            if (keyA == null || keyB == null) {
+                return keyA == null ? 1 : -1;
+            }
+            if (typeof keyA === 'string' && typeof keyB === 'string') {
+                return options?.sortOrder === 'desc' ?
+                    (0, utils_1.naturalSort)(keyB, keyA)
+                    : (0, utils_1.naturalSort)(keyA, keyB);
+            }
+            if (typeof keyA === 'number' && typeof keyB === 'number') {
+                return options?.sortOrder === 'desc' ?
+                    keyB - keyA
+                    : keyA - keyB;
+            }
+            if (typeof keyA === 'boolean' && typeof keyB === 'boolean') {
+                return options?.sortOrder === 'desc' ?
+                    Number(keyB) - Number(keyA)
+                    : Number(keyA) - Number(keyB);
+            }
+            return 0;
+        });
+    }
+    return array;
+}

package/dist/cjs/array/transform.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOptionsArray = void 0;
+exports.removeDuplicatesFromArray = removeDuplicatesFromArray;
+exports.splitArray = splitArray;
+exports.rotateArray = rotateArray;
+exports.moveArrayElement = moveArrayElement;
+const utils_1 = require("../utils");
+/**
+ * * Converts an array of objects into a formatted array of options.
+ *
+ * @param data - An array of objects to convert into options.
+ * @param config - The configuration object to specify the keys for the `value` (firstFieldName) and `label` (secondFieldName) fields and rename as needed.
+ * @returns An array of options, where each option has `value` and `label` fields as default or as specified by user in the config options.
+ */
+const createOptionsArray = (data, config) => {
+    const { firstFieldKey, secondFieldKey, firstFieldName = 'value', secondFieldName = 'label', } = config || {};
+    if (data && data.length) {
+        return data.map((datum) => ({
+            [firstFieldName]: String(datum[firstFieldKey] ?? ''),
+            [secondFieldName]: String(datum[secondFieldKey] ?? ''),
+        }));
+    }
+    else {
+        return [];
+    }
+};
+exports.createOptionsArray = createOptionsArray;
+/**
+ * * Removes duplicate values from an array, supporting deep comparison for objects and arrays.
+ *
+ * @param array - The array from which duplicates need to be removed.
+ * @returns A new array with duplicates removed.
+ */
+function removeDuplicatesFromArray(array) {
+    return array.filter((item, index, self) => index === self.findIndex((el) => (0, utils_1.isDeepEqual)(el, item)));
+}
+/**
+ * * Splits an array into chunks of a given size.
+ *
+ * @param arr The array to split.
+ * @param chunkSize The size of each chunk.
+ * @returns An array of chunked arrays.
+ */
+function splitArray(arr, chunkSize) {
+    const result = [];
+    for (let i = 0; i < arr.length; i += chunkSize) {
+        result.push(arr.slice(i, i + chunkSize));
+    }
+    return result;
+}
+/**
+ * * Rotates an array left or right by a given number of steps.
+ *
+ * @param arr The array to rotate.
+ * @param steps The number of positions to rotate (positive: right, negative: left).
+ * @returns The rotated array.
+ */
+function rotateArray(arr, steps) {
+    const length = arr.length;
+    if (length === 0)
+        return arr;
+    const offset = ((steps % length) + length) % length;
+    return arr.slice(-offset).concat(arr.slice(0, -offset));
+}
+/**
+ * * Moves an element within an array from one index to another.
+ *
+ * @param arr The array to modify.
+ * @param fromIndex The index of the element to move.
+ * @param toIndex The new index for the element.
+ * @returns A new array with the element moved.
+ */
+function moveArrayElement(arr, fromIndex, toIndex) {
+    const newArr = [...arr];
+    const [item] = newArr.splice(fromIndex, 1);
+    newArr.splice(toIndex, 0, item);
+    return newArr;
+}

package/dist/cjs/array/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/array/utils.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.naturalSort = naturalSort;
+/**
+ * * Compare two strings using natural sorting (e.g., "file2" < "file10").
+ * Optionally supports case-insensitive and locale-aware string chunk comparisons.
+ *
+ * @param a - The first string to compare.
+ * @param b - The second string to compare.
+ * @param options - Optional settings to configure comparison behavior.
+ * @param options.caseInsensitive - If true, compares string chunks without case sensitivity. Defaults to `true`.
+ * @param options.localeAware - If true, uses localeCompare for string chunk comparisons. Defaults to `false`.
+ * @returns A negative number if `a` comes before `b`, a positive number if `a` comes after `b`, or 0 if equal.
+ */
+function naturalSort(a, b, options) {
+    const { caseInsensitive = true, localeAware = false } = options || {};
+    /**
+     * * Splits a string into an array of number and non-number chunks.
+     * @param str - The string to split.
+     * @returns An array of string and number parts.
+     */
+    const _createChunks = (str) => {
+        const chunks = [];
+        let current = '';
+        let isNumeric = false;
+        for (const char of str) {
+            const charIsNum = !Number.isNaN(Number(char));
+            if (current.length === 0) {
+                current = char;
+                isNumeric = charIsNum;
+                continue;
+            }
+            if (charIsNum === isNumeric) {
+                current += char;
+            }
+            else {
+                chunks.push(isNumeric ? Number(current) : current);
+                current = char;
+                isNumeric = charIsNum;
+            }
+        }
+        if (current.length > 0) {
+            chunks.push(isNumeric ? Number(current) : current);
+        }
+        return chunks;
+    };
+    const aChunks = _createChunks(a);
+    const bChunks = _createChunks(b);
+    for (let i = 0; i < Math.min(aChunks.length, bChunks.length); i++) {
+        let aChunk = aChunks[i];
+        let bChunk = bChunks[i];
+        // Normalize string chunks if case-insensitive
+        if (caseInsensitive &&
+            typeof aChunk === 'string' &&
+            typeof bChunk === 'string') {
+            aChunk = aChunk.toLowerCase();
+            bChunk = bChunk.toLowerCase();
+        }
+        // Compare types: number vs string
+        if (typeof aChunk !== typeof bChunk) {
+            return typeof aChunk === 'string' ? 1 : -1;
+        }
+        // Compare same-type chunks
+        if (aChunk !== bChunk) {
+            if (typeof aChunk === 'number' && typeof bChunk === 'number') {
+                return aChunk - bChunk;
+            }
+            if (typeof aChunk === 'string' && typeof bChunk === 'string') {
+                if (localeAware) {
+                    const cmp = aChunk.localeCompare(bChunk, undefined, {
+                        sensitivity: caseInsensitive ? 'accent' : 'variant',
+                    });
+                    if (cmp !== 0)
+                        return cmp;
+                }
+                return aChunk < bChunk ? -1 : 1;
+            }
+        }
+    }
+    return aChunks.length - bChunks.length;
+}

package/dist/cjs/colors/Color.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color = void 0;
+const convert_1 = require("./convert");
+const helpers_1 = require("./helpers");
+const random_1 = require("./random");
+const hsl = (0, random_1.generateRandomHSLColor)();
+const { hex, rgb } = (0, convert_1.convertColorCode)(hsl);
+/**
+ * * Class representing a color and its conversions among `Hex`, `Hex8` `RGB`, `RGBA`, `HSL` and `HSLA` formats.
+ * * It has 1 instance method `applyOpacity()` to apply opacity to `Hex`, `Hex8` `RGB`, `RGBA`, `HSL` or `HSLA` color.
+ * * It has 6 static methods that can be used to check if a color is in `Hex`, `Hex8` `RGB`, `RGBA`, `HSL` or `HSLA` format.
+ *
+ * @property hex - The color in `Hex` format.
+ * @property hex8 - The color in `Hex8` format.
+ * @property rgb - The color in `RGB` format.
+ * @property rgba - The color in `RGBA` format.
+ * @property hsl - The color in `HSL` format.
+ * @property hsla - The color in `HSLA` format.
+ */
+class Color {
+    hex;
+    hex8;
+    rgb;
+    rgba;
+    hsl;
+    hsla;
+    /**
+     * * Creates a new `Color` instance and automatically converts the input color to all other supported formats: `Hex`, `Hex8`, `RGB`, `RGBA`, `HSL`, and `HSLA`.
+     *
+     * @description
+     * The `Color` class allows seamless transformation between six common color representations:
+     * - `Hex` (e.g., `#ff5733`)
+     * - `Hex8` (Hex with opacity, e.g., `#ff573380`)
+     * - `RGB` (e.g., `rgb(255, 87, 51)`)
+     * - `RGBA` (e.g., `rgba(255, 87, 51, 1)`)
+     * - `HSL` (e.g., `hsl(14, 100%, 60%)`)
+     * - `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.
+     *
+     * Additionally:
+     * - Use `.applyOpacity(opacity)` to modify or add opacity to the color.
+     * - Use static methods like `Color.isHex6(color)` to validate color strings.
+     *
+     * @param toConvert - An optional input color string in any supported format (`Hex`, `Hex8`, `RGB`, `RGBA`, `HSL`, or `HSLA`) 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);
+     *
+     * @returns Instance of `Color`.
+     */
+    constructor(toConvert) {
+        if (toConvert) {
+            const colors = this.#convertColorToOthers(toConvert);
+            if ('hex8' in colors) {
+                // Extract alpha color values (Hex8, RGBA, HSLA)
+                const rgbaValues = (0, helpers_1._extractAlphaColorValues)(colors.rgba);
+                const hslaValues = (0, helpers_1._extractAlphaColorValues)(colors.hsla);
+                this.hex = colors.hex8.toUpperCase().slice(0, 7);
+                this.hex8 = colors.hex8.toUpperCase();
+                this.rgb = `rgb(${rgbaValues[0]}, ${rgbaValues[1]}, ${rgbaValues[2]})`;
+                this.rgba = colors.rgba;
+                this.hsl = `hsl(${hslaValues[0]}, ${hslaValues[1]}%, ${hslaValues[2]}%)`;
+                this.hsla = colors.hsla;
+            }
+            else {
+                // Extract solid color values (Hex, RGB, HSL)
+                const rgbValues = (0, helpers_1._extractSolidColorValues)(colors.rgb);
+                const hslValues = (0, helpers_1._extractSolidColorValues)(colors.hsl);
+                this.hex = colors.hex.toUpperCase();
+                this.hex8 =
+                    `${colors.hex.toUpperCase()}${(0, helpers_1._convertOpacityToHex)(100)}`;
+                this.rgb = colors.rgb;
+                this.rgba = `rgba(${rgbValues[0]}, ${rgbValues[1]}, ${rgbValues[2]}, 1)`;
+                this.hsl = colors.hsl;
+                this.hsla = `hsla(${hslValues[0]}, ${hslValues[1]}%, ${hslValues[2]}%, 1)`;
+            }
+        }
+        else {
+            const rgbValues = (0, helpers_1._extractSolidColorValues)(rgb);
+            const hslValues = (0, helpers_1._extractSolidColorValues)(hsl);
+            // Generate random colors
+            this.hex = hex.toUpperCase();
+            this.hex8 =
+                `${hex.toUpperCase()}${(0, helpers_1._convertOpacityToHex)(100)}`;
+            this.rgb = rgb;
+            this.rgba = `rgba(${rgbValues[0]}, ${rgbValues[1]}, ${rgbValues[2]}, 1)`;
+            this.hsl = hsl;
+            this.hsla = `hsla(${hslValues[0]}, ${hslValues[1]}%, ${hslValues[2]}%, 1)`;
+        }
+    }
+    /** - 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;
+    }
+    /**
+     * * Applies or modifies the opacity of a color.
+     * - For solid colors (Hex6/RGB/HSL): Adds an alpha channel with the specified opacity
+     * - For alpha colors (Hex8/RGBA/HSLA): Updates the existing alpha channel
+     *
+     * @param opacity - A number between 0-100 representing the opacity percentage
+     * @returns An object 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) {
+        const validOpacity = Math.min(100, Math.max(0, opacity));
+        const alphaHex = (0, helpers_1._convertOpacityToHex)(opacity);
+        const alphaDecimal = validOpacity / 100;
+        const rgbValues = (0, helpers_1._extractSolidColorValues)(this.rgb);
+        const hslValues = (0, helpers_1._extractSolidColorValues)(this.hsl);
+        return {
+            hex: this.hex.slice(0, 7).toUpperCase(),
+            hex8: `${this.hex.slice(0, 7)}${alphaHex}`.toUpperCase(),
+            rgb: `rgb(${rgbValues[0]}, ${rgbValues[1]}, ${rgbValues[2]})`,
+            rgba: `rgba(${rgbValues[0]}, ${rgbValues[1]}, ${rgbValues[2]}, ${alphaDecimal})`,
+            hsl: `hsl(${hslValues[0]}, ${hslValues[1]}%, ${hslValues[2]}%)`,
+            hsla: `hsla(${hslValues[0]}, ${hslValues[1]}%, ${hslValues[2]}%, ${alphaDecimal})`,
+        };
+    }
+    /**
+     * @static Checks if a color is in `Hex6` format.
+     *
+     * @param color Color to check.
+     * @returns Boolean: `true` if it's a `Hex6` color, `false` if not.
+     */
+    static isHex6(color) {
+        return /^#[0-9A-Fa-f]{6}$/.test(color);
+    }
+    /**
+     * @static Checks if a color is in `Hex8` format.
+     *
+     * @param color Color to check.
+     * @returns Boolean: `true` if it's a `Hex8` color, `false` if not.
+     */
+    static isHex8(color) {
+        return /^#[0-9A-Fa-f]{8}$/.test(color);
+    }
+    /**
+     * @static Checks if a color is in `RGB` format.
+     *
+     * @param color Color to check.
+     * @returns Boolean: `true` if it's an `RGB` color, `false` if not.
+     */
+    static isRGB(color) {
+        return /^rgb\(\d{1,3},\s*\d{1,3},\s*\d{1,3}\)$/.test(color);
+    }
+    /**
+     * @static Checks if a color is in `RGBA` format.
+     *
+     * @param color Color to check.
+     * @returns Boolean: `true` if it's an `RGBA` color, `false` if not.
+     */
+    static isRGBA(color) {
+        return /^rgba\(\d{1,3},\s*\d{1,3},\s*\d{1,3},\s*(0|1|0?\.\d+)\)$/.test(color);
+    }
+    /**
+     * @static Checks if a color is in `HSL` format.
+     *
+     * @param color Color to check.
+     * @returns Boolean: `true` if it's an `HSL` color, `false` if not.
+     */
+    static isHSL(color) {
+        return /^hsl\(\d{1,3},\s*\d{1,3}%,\s*\d{1,3}%\)$/.test(color);
+    }
+    /**
+     * @static Checks if a color is in `HSLA` format.
+     *
+     * @param color Color to check.
+     * @returns Boolean: `true` if it's an `HSLA` color, `false` if not.
+     */
+    static isHSLA(color) {
+        return /^hsla\(\d{1,3},\s*\d{1,3}%,\s*\d{1,3}%,\s*(0|1|0?\.\d+)\)$/.test(color);
+    }
+    /**
+     * @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 } = (0, convert_1.convertColorCode)(color);
+            return { hex: color, rgb, hsl };
+        }
+        else if (Color.isRGB(color)) {
+            const { hex, hsl } = (0, convert_1.convertColorCode)(color);
+            return { hex, rgb: color, hsl };
+        }
+        else if (Color.isHSL(color)) {
+            const { hex, rgb } = (0, convert_1.convertColorCode)(color);
+            return { hex, rgb, hsl: color };
+        }
+        else if (Color.isHex8(color)) {
+            const { rgba, hsla } = (0, convert_1.convertColorCode)(color);
+            return { hex8: color, rgba, hsla };
+        }
+        else if (Color.isRGBA(color)) {
+            const { hex8, hsla } = (0, convert_1.convertColorCode)(color);
+            return { hex8, rgba: color, hsla };
+        }
+        else if (Color.isHSLA(color)) {
+            const { hex8, rgba } = (0, convert_1.convertColorCode)(color);
+            return { hex8, rgba, hsla: color };
+        }
+        throw new Error(`Unrecognized color format: ${color}`);
+    }
+}
+exports.Color = Color;

package/dist/cjs/colors/constants.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberColorPalette = exports.alphabetColorPalette = void 0;
+/** Colors based on the ASCII value of the letter. */
+exports.alphabetColorPalette = [
+    '#00094C',
+    '#00376E',
+    '#005600',
+    '#024647',
+    '#423067',
+    '#55188E',
+    '#00453E',
+    '#00516C',
+    '#263E0D',
+    '#0F6F3F',
+    '#730073',
+    '#053636',
+    '#253654',
+    '#4682B4',
+    '#3253B6',
+    '#43616C',
+    '#036C44',
+    '#30784F',
+    '#601C1C',
+    '#690000',
+    '#005B00',
+    '#BF0E6C',
+    '#008080',
+    '#475F47',
+    '#546F1C',
+    '#824809',
+];
+/** Colors based on the index of numbers. */
+exports.numberColorPalette = [
+    '#893213',
+    '#A44C15',
+    '#8B4513',
+    '#8A1D33',
+    '#3B543B',
+    '#342656',
+    '#A43522',
+    '#04605F',
+    '#B5680A',
+    '#6437B3',
+];