@versatiles/style 5.5.2 → 5.7.0

package/dist/index.js

@@ -1,71 +1,188 @@
+/**
+ * The abstract `Color` class provides a blueprint for color manipulation and conversion.
+ * It includes methods for converting between different color models ({@link HSL}, {@link HSV}, {@link RGB}),
+ * as well as various color transformations such as inversion, rotation, saturation, and blending.
+ *
+ * @abstract
+ */
+/**
+ * Abstract class representing a color.
+ */
 class Color {
+    /**
+     * Parses a color from a string or another Color instance.
+     * @param input - The input color as a string or Color instance.
+     * @returns The parsed Color instance.
+     */
     static parse;
+    /**
+     * The HSL color model.
+     */
     static HSL;
+    /**
+     * The HSV color model.
+     */
     static HSV;
+    /**
+     * The RGB color model.
+     */
     static RGB;
-    static random;
+    /**
+     * Converts the color to a hexadecimal string.
+     * @returns The hexadecimal representation of the color.
+     */
     asHex() {
-        return this.toRGB().asHex();
-    }
-    toHSL() {
-        return this.asHSL();
-    }
-    toHSV() {
-        return this.asHSV();
-    }
-    toRGB() {
-        return this.asRGB();
+        return this.asRGB().asHex();
     }
+    /**
+     * Inverts the luminosity of the color.
+     * @returns A new HSL color with inverted luminosity.
+     */
     invertLuminosity() {
-        return this.toHSL().invertLuminosity();
+        return this.asHSL().invertLuminosity();
     }
+    /**
+     * Rotates the hue of the color by a given offset.
+     * @param offset - The amount to rotate the hue.
+     * @returns A new HSL color with the hue rotated.
+     */
     rotateHue(offset) {
-        return this.toHSL().rotateHue(offset);
+        return this.asHSL().rotateHue(offset);
     }
+    /**
+     * Saturates the color by a given ratio.
+     * @param ratio - The ratio to saturate the color.
+     * @returns A new HSL color with increased saturation.
+     */
     saturate(ratio) {
-        return this.toHSL().saturate(ratio);
+        return this.asHSL().saturate(ratio);
     }
+    /**
+     * Applies gamma correction to the color.
+     * @param value - The gamma correction value.
+     * @returns A new RGB color with gamma correction applied.
+     */
     gamma(value) {
-        return this.toRGB().gamma(value);
+        return this.asRGB().gamma(value);
     }
+    /**
+     * Inverts the color.
+     * @returns A new RGB color with inverted values.
+     */
     invert() {
-        return this.toRGB().invert();
+        return this.asRGB().invert();
     }
+    /**
+     * Adjusts the contrast of the color.
+     * @param value - The contrast adjustment value.
+     * @returns A new RGB color with adjusted contrast.
+     */
     contrast(value) {
-        return this.toRGB().contrast(value);
+        return this.asRGB().contrast(value);
     }
+    /**
+     * Adjusts the brightness of the color.
+     * @param value - The brightness adjustment value.
+     * @returns A new RGB color with adjusted brightness.
+     */
     brightness(value) {
-        return this.toRGB().brightness(value);
+        return this.asRGB().brightness(value);
     }
+    /**
+     * Lightens the color by a given value.
+     * @param value - The amount to lighten the color.
+     * @returns A new RGB color that is lightened.
+     */
     lighten(value) {
-        return this.toRGB().lighten(value);
+        return this.asRGB().lighten(value);
     }
+    /**
+     * Darkens the color by a given value.
+     * @param value - The amount to darken the color.
+     * @returns A new RGB color that is darkened.
+     */
     darken(value) {
-        return this.toRGB().darken(value);
+        return this.asRGB().darken(value);
     }
+    /**
+     * Tints the color by blending it with another color.
+     * @param value - The blend ratio.
+     * @param tintColor - The color to blend with.
+     * @returns A new RGB color that is tinted.
+     */
     tint(value, tintColor) {
-        return this.toRGB().tint(value, tintColor);
+        return this.asRGB().tint(value, tintColor);
+    }
+    /**
+     * Blends the color with another color.
+     * @param value - The blend ratio.
+     * @param blendColor - The color to blend with.
+     * @returns A new RGB color that is blended.
+     */
+    blend(value, blendColor) {
+        return this.asRGB().blend(value, blendColor);
     }
+    /**
+     * Sets the hue of the color.
+     * @param value - The new hue value.
+     * @returns A new HSV color with the hue set.
+     */
     setHue(value) {
-        return this.toHSV().setHue(value);
+        return this.asHSV().setHue(value);
     }
 }
 
-function clamp(num, min, max) {
-    return Math.min(Math.max(min, num), max);
+function clamp(value, min, max) {
+    if (value == null || isNaN(value))
+        return min;
+    if (value < min)
+        return min;
+    if (value > max)
+        return max;
+    return value;
 }
-function mod(num, max) {
-    return ((num % max) + max) % max;
+function mod(value, max) {
+    value = value % max;
+    if (value < 0)
+        value += max;
+    if (value == 0)
+        return 0;
+    return value;
 }
 function formatFloat(num, precision) {
     return num.toFixed(precision).replace(/0+$/, '').replace(/\.$/, '');
 }
 
+/**
+ * Represents an RGB color with optional alpha transparency.
+ *
+ * @extends Color
+ */
 class RGB extends Color {
-    r = 0; // between 0 and 255
-    g = 0; // between 0 and 255
-    b = 0; // between 0 and 255
-    a = 1; // between 0 and 1
+    /**
+     * Red component (0-255).
+     */
+    r;
+    /**
+     * Green component (0-255).
+     */
+    g;
+    /**
+     * Blue component (0-255).
+     */
+    b;
+    /**
+     * Alpha component (0-1).
+     */
+    a;
+    /**
+     * Creates an instance of RGB.
+     *
+     * @param r - Red component (0-255).
+     * @param g - Green component (0-255).
+     * @param b - Blue component (0-255).
+     * @param a - Alpha component (0-1), defaults to 1.
+     */
     constructor(r, g, b, a = 1) {
         super();
         this.r = clamp(r, 0, 255);
@@ -73,15 +190,35 @@ class RGB extends Color {
         this.b = clamp(b, 0, 255);
         this.a = clamp(a, 0, 1);
     }
+    /**
+     * Creates a clone of the current RGB color.
+     *
+     * @returns A new RGB instance with the same color values.
+     */
     clone() {
         return new RGB(this.r, this.g, this.b, this.a);
     }
+    /**
+     * Returns the RGB color as an array.
+     *
+     * @returns An array containing the red, green, blue, and alpha components.
+     */
     asArray() {
         return [this.r, this.g, this.b, this.a];
     }
+    /**
+     * Rounds the RGB color components to the nearest integer.
+     *
+     * @returns A new RGB instance with rounded color values.
+     */
     round() {
         return new RGB(Math.round(this.r), Math.round(this.g), Math.round(this.b), Math.round(this.a * 1000) / 1000);
     }
+    /**
+     * Returns the RGB color as a string.
+     *
+     * @returns A string representation of the RGB color in either `rgb` or `rgba` format.
+     */
     asString() {
         if (this.a === 1) {
             return `rgb(${this.r.toFixed(0)},${this.g.toFixed(0)},${this.b.toFixed(0)})`;
@@ -90,6 +227,11 @@ class RGB extends Color {
             return `rgba(${this.r.toFixed(0)},${this.g.toFixed(0)},${this.b.toFixed(0)},${formatFloat(this.a, 3)})`;
         }
     }
+    /**
+     * Returns the RGB color as a hexadecimal string.
+     *
+     * @returns A string representation of the RGB color in hexadecimal format.
+     */
     asHex() {
         const r = Math.round(this.r).toString(16).padStart(2, '0');
         const g = Math.round(this.g).toString(16).padStart(2, '0');
@@ -102,6 +244,11 @@ class RGB extends Color {
             return `#${r}${g}${b}${a}`.toUpperCase();
         }
     }
+    /**
+     * Converts the RGB color to an HSL color.
+     *
+     * @returns An HSL instance representing the same color.
+     */
     asHSL() {
         const r = this.r / 255;
         const g = this.g / 255;
@@ -132,6 +279,11 @@ class RGB extends Color {
         return new HSL(h, s * 100, l * 100, this.a);
     }
     ;
+    /**
+     * Converts the RGB color to an HSV color.
+     *
+     * @returns An HSV instance representing the same color.
+     */
     asHSV() {
         const r = this.r / 255;
         const g = this.g / 255;
@@ -161,12 +313,29 @@ class RGB extends Color {
         }
         return new HSV(h * 360, s * 100, v * 100, this.a);
     }
+    /**
+     * Returns the RGB color.
+     *
+     * @returns The current RGB instance.
+     */
     asRGB() {
         return this.clone();
     }
+    /**
+     * Returns the RGB color.
+     *
+     * @returns The current RGB instance.
+     */
     toRGB() {
         return this;
     }
+    /**
+     * Parses a string or Color instance into an RGB color.
+     *
+     * @param input - The input string or Color instance to parse.
+     * @returns A new RGB instance representing the parsed color.
+     * @throws Will throw an error if the input string is not a valid RGB color string.
+     */
     static parse(input) {
         if (input instanceof Color)
             return input.asRGB();
@@ -206,6 +375,12 @@ class RGB extends Color {
         }
         throw new Error(`Invalid RGB color string: "${input}"`);
     }
+    /**
+     * Adjusts the gamma of the RGB color.
+     *
+     * @param value - The gamma value to apply.
+     * @returns A new RGB instance with the adjusted gamma.
+     */
     gamma(value) {
         if (value < 1e-3)
             value = 1e-3;
@@ -213,9 +388,20 @@ class RGB extends Color {
             value = 1e3;
         return new RGB(Math.pow(this.r / 255, value) * 255, Math.pow(this.g / 255, value) * 255, Math.pow(this.b / 255, value) * 255, this.a);
     }
+    /**
+     * Inverts the RGB color.
+     *
+     * @returns A new RGB instance with the inverted color values.
+     */
     invert() {
         return new RGB(255 - this.r, 255 - this.g, 255 - this.b, this.a);
     }
+    /**
+     * Adjusts the contrast of the RGB color.
+     *
+     * @param value - The contrast value to apply.
+     * @returns A new RGB instance with the adjusted contrast.
+     */
     contrast(value) {
         if (value < 0)
             value = 0;
@@ -223,6 +409,12 @@ class RGB extends Color {
             value = 1e6;
         return new RGB(clamp((this.r - 127.5) * value + 127.5, 0, 255), clamp((this.g - 127.5) * value + 127.5, 0, 255), clamp((this.b - 127.5) * value + 127.5, 0, 255), this.a);
     }
+    /**
+     * Adjusts the brightness of the RGB color.
+     *
+     * @param value - The brightness value to apply.
+     * @returns A new RGB instance with the adjusted brightness.
+     */
     brightness(value) {
         if (value < -1)
             value = -1;
@@ -232,30 +424,90 @@ class RGB extends Color {
         const b = (value < 0) ? 0 : 255 * value;
         return new RGB(this.r * a + b, this.g * a + b, this.b * a + b, this.a);
     }
+    /**
+     * Tints the RGB color with another color.
+     *
+     * @param value - The tint value to apply.
+     * @param tintColor - The color to use for tinting.
+     * @returns A new RGB instance with the applied tint.
+     */
     tint(value, tintColor) {
         if (value < 0)
             value = 0;
         if (value > 1)
             value = 1;
-        const rgbNew = this.setHue(tintColor.toHSV().h).toRGB();
+        const rgbNew = this.setHue(tintColor.asHSV().h).asRGB();
         return new RGB(this.r * (1 - value) + value * rgbNew.r, this.g * (1 - value) + value * rgbNew.g, this.b * (1 - value) + value * rgbNew.b, this.a);
     }
+    /**
+     * Blends the RGB color with another color.
+     *
+     * @param value - The blend value to apply.
+     * @param blendColor - The color to blend with.
+     * @returns A new RGB instance with the blended color.
+     */
+    blend(value, blendColor) {
+        value = clamp(value ?? 0, 0, 1);
+        const rgbNew = blendColor.asRGB();
+        return new RGB(this.r * (1 - value) + value * rgbNew.r, this.g * (1 - value) + value * rgbNew.g, this.b * (1 - value) + value * rgbNew.b, this.a);
+    }
+    /**
+     * Lightens the RGB color.
+     *
+     * @param ratio - The ratio to lighten the color by.
+     * @returns A new RGB instance with the lightened color.
+     */
     lighten(ratio) {
         return new RGB(clamp(255 - (255 - this.r) * (1 - ratio), 0, 255), clamp(255 - (255 - this.g) * (1 - ratio), 0, 255), clamp(255 - (255 - this.b) * (1 - ratio), 0, 255), this.a);
     }
+    /**
+     * Darkens the RGB color.
+     *
+     * @param ratio - The ratio to darken the color by.
+     * @returns A new RGB instance with the darkened color.
+     */
     darken(ratio) {
         return new RGB(clamp(this.r * (1 - ratio), 0, 255), clamp(this.g * (1 - ratio), 0, 255), clamp(this.b * (1 - ratio), 0, 255), this.a);
     }
+    /**
+     * Fades the RGB color by reducing its alpha value.
+     *
+     * @param value - The fade value to apply.
+     * @returns A new RGB instance with the faded color.
+     */
     fade(value) {
         return new RGB(this.r, this.g, this.b, this.a * (1 - value));
     }
 }
 
+/**
+ * Represents a color in the HSV (Hue, Saturation, Value) color space.
+ * Extends the base `Color` class.
+ */
 class HSV extends Color {
-    h = 0; // between 0 and 360
-    s = 0; // between 0 and 100
-    v = 0; // between 0 and 100
-    a = 1; // between 0 and 1
+    /**
+     * The hue component of the color, in the range [0, 360].
+     */
+    h;
+    /**
+     * The saturation component of the color, in the range [0, 100].
+     */
+    s;
+    /**
+     * The value (brightness) component of the color, in the range [0, 100].
+     */
+    v;
+    /**
+     * The alpha (opacity) component of the color, in the range [0, 1].
+     */
+    a;
+    /**
+     * Constructs a new HSV color.
+     * @param h - The hue component, in the range [0, 360].
+     * @param s - The saturation component, in the range [0, 100].
+     * @param v - The value (brightness) component, in the range [0, 100].
+     * @param a - The alpha (opacity) component, in the range [0, 1]. Defaults to 1.
+     */
     constructor(h, s, v, a = 1) {
         super();
         this.h = mod(h, 360);
@@ -263,18 +515,38 @@ class HSV extends Color {
         this.v = clamp(v, 0, 100);
         this.a = clamp(a, 0, 1);
     }
+    /**
+     * Returns the HSV color as an array of numbers.
+     * @returns An array containing the hue, saturation, value, and alpha components.
+     */
     asArray() {
         return [this.h, this.s, this.v, this.a];
     }
+    /**
+     * Returns a new HSV color with the components rounded to the nearest integer.
+     * @returns A new HSV color with rounded components.
+     */
     round() {
         return new HSV(Math.round(this.h), Math.round(this.s), Math.round(this.v), Math.round(this.a * 1000) / 1000);
     }
+    /**
+     * Returns the color as a string representation.
+     * @returns A string representation of the color.
+     */
     asString() {
         return this.asHSL().asString();
     }
+    /**
+     * Creates a new HSV color that is a copy of the current color.
+     * @returns A new HSV color that is a clone of the current color.
+     */
     clone() {
         return new HSV(this.h, this.s, this.v, this.a);
     }
+    /**
+     * Converts the HSV color to an HSL color.
+     * @returns An HSL representation of the color.
+     */
     asHSL() {
         const s = this.s / 100;
         const v = this.v / 100;
@@ -282,12 +554,24 @@ class HSV extends Color {
         const q = k < 1 ? k : 2 - k;
         return new HSL(this.h, q == 0 ? 0 : 100 * s * v / q, 100 * k / 2, this.a);
     }
+    /**
+     * Returns the current HSV color.
+     * @returns The current HSV color.
+     */
     asHSV() {
         return this.clone();
     }
+    /**
+     * Returns the current HSV color.
+     * @returns The current HSV color.
+     */
     toHSV() {
         return this;
     }
+    /**
+     * Converts the HSV color to an RGB color.
+     * @returns An RGB representation of the color.
+     */
     asRGB() {
         const h = this.h / 360; // Normalize h to range [0, 1]
         const s = this.s / 100; // Normalize s to range [0, 1]
@@ -339,19 +623,52 @@ class HSV extends Color {
         // Convert to RGB in the 0-255 range and return
         return new RGB(r * 255, g * 255, b * 255, this.a);
     }
+    /**
+     * Fades the color by a given value.
+     * @param value - The amount to fade the color by, in the range [0, 1].
+     * @returns A new HSV color with the alpha component faded by the given value.
+     */
     fade(value) {
         return new HSV(this.h, this.s, this.v, this.a * (1 - value));
     }
+    /**
+     * Sets the hue component of the color.
+     * @param value - The new hue value, in the range [0, 360].
+     * @returns A new HSV color with the updated hue component.
+     */
     setHue(value) {
         return new HSV(value, this.s, this.v, this.a);
     }
 }
 
+/**
+ * Represents a color in the HSL (Hue, Saturation, Lightness) color space.
+ * Extends the base `Color` class.
+ */
 class HSL extends Color {
-    h = 0; // between 0 and 360
-    s = 0; // between 0 and 100
-    l = 0; // between 0 and 100
-    a = 1; // between 0 and 1
+    /**
+     * The hue component of the color, in the range [0, 360].
+     */
+    h;
+    /**
+     * The saturation component of the color, in the range [0, 100].
+     */
+    s;
+    /**
+     * The lightness component of the color, in the range [0, 100].
+     */
+    l;
+    /**
+     * The alpha (opacity) component of the color, in the range [0, 1].
+     */
+    a;
+    /**
+     * Creates a new HSL color.
+     * @param h - The hue component, in the range [0, 360].
+     * @param s - The saturation component, in the range [0, 100].
+     * @param l - The lightness component, in the range [0, 100].
+     * @param a - The alpha (opacity) component, in the range [0, 1]. Defaults to 1.
+     */
     constructor(h, s, l, a = 1) {
         super();
         this.h = mod(h, 360);
@@ -359,15 +676,31 @@ class HSL extends Color {
         this.l = clamp(l, 0, 100);
         this.a = clamp(a, 0, 1);
     }
+    /**
+     * Returns the HSL color as an array of numbers.
+     * @returns An array containing the hue, saturation, lightness, and alpha components.
+     */
     asArray() {
         return [this.h, this.s, this.l, this.a];
     }
+    /**
+     * Returns a new HSL color with rounded components.
+     * @returns A new HSL color with rounded hue, saturation, lightness, and alpha components.
+     */
     round() {
         return new HSL(Math.round(this.h), Math.round(this.s), Math.round(this.l), Math.round(this.a * 1000) / 1000);
     }
+    /**
+     * Creates a copy of the current HSL color.
+     * @returns A new HSL color with the same components as the current color.
+     */
     clone() {
         return new HSL(this.h, this.s, this.l, this.a);
     }
+    /**
+     * Returns the HSL color as a CSS-compatible string.
+     * @returns A string representing the HSL color in CSS format.
+     */
     asString() {
         if (this.a === 1) {
             return `hsl(${this.h.toFixed(0)},${this.s.toFixed(0)}%,${this.l.toFixed(0)}%)`;
@@ -376,18 +709,34 @@ class HSL extends Color {
             return `hsla(${this.h.toFixed(0)},${this.s.toFixed(0)}%,${this.l.toFixed(0)}%,${formatFloat(this.a, 3)})`;
         }
     }
+    /**
+     * Returns the current HSL color.
+     * @returns The current HSL color.
+     */
     asHSL() {
         return this.clone();
     }
+    /**
+     * Returns the current HSL color.
+     * @returns The current HSL color.
+     */
     toHSL() {
         return this;
     }
+    /**
+     * Converts the HSL color to an HSV color.
+     * @returns A new HSV color representing the same color.
+     */
     asHSV() {
         const s = this.s / 100, l = this.l / 100;
         const v = l + s * Math.min(l, 1 - l);
         const sv = v === 0 ? 0 : 2 * (1 - l / v);
         return new HSV(this.h, sv * 100, v * 100, this.a);
     }
+    /**
+     * Converts the HSL color to an RGB color.
+     * @returns A new RGB color representing the same color.
+     */
     asRGB() {
         const h = this.h / 360;
         const s = this.s / 100;
@@ -413,6 +762,12 @@ class HSL extends Color {
         // Convert to RGB in the 0-255 range and return
         return new RGB(255 * hueToRgb(h + 1 / 3), 255 * hueToRgb(h), 255 * hueToRgb(h - 1 / 3), this.a);
     }
+    /**
+     * Parses a string or Color object into an HSL color.
+     * @param input - The input string or Color object to parse.
+     * @returns A new HSL color parsed from the input.
+     * @throws Will throw an error if the input string is not a valid HSL color string.
+     */
     static parse(input) {
         if (input instanceof Color)
             return input.asHSL();
@@ -427,150 +782,39 @@ class HSL extends Color {
         }
         throw new Error(`Invalid HSL color string: "${input}"`);
     }
+    /**
+     * Inverts the lightness component of the HSL color.
+     * @returns A new HSL color with the lightness component inverted.
+     */
     invertLuminosity() {
         return new HSL(this.h, this.s, 100 - this.l, this.a);
     }
+    /**
+     * Rotates the hue component of the HSL color by a given offset.
+     * @param offset - The amount to rotate the hue by, in degrees.
+     * @returns A new HSL color with the hue rotated by the given offset.
+     */
     rotateHue(offset) {
         return new HSL(mod(this.h + offset, 360), this.s, this.l, this.a);
     }
+    /**
+     * Increases the saturation of the HSL color by a given ratio.
+     * @param ratio - The ratio by which to increase the saturation.
+     * @returns A new HSL color with increased saturation.
+     */
     saturate(ratio) {
         return new HSL(this.h, clamp(this.s * (1 + ratio), 0, 100), this.l, this.a);
     }
+    /**
+     * Decreases the alpha (opacity) of the HSL color by a given value.
+     * @param value - The value by which to decrease the alpha.
+     * @returns A new HSL color with decreased alpha.
+     */
     fade(value) {
         return new HSL(this.h, this.s, this.l, this.a * (1 - value));
     }
 }
 
-let colorDictionary = new Map();
-function randomColor(options) {
-    if (colorDictionary.size === 0)
-        colorDictionary = initColorDictionary();
-    options ??= {};
-    let seed = inputToSeed(options.seed);
-    const H = pickHue(options);
-    const S = pickSaturation(H, options);
-    const V = pickBrightness(H, S, options);
-    return new HSV(H, S, V, options.opacity ?? 1);
-    function pickHue(options) {
-        return mod(randomWithin(getHueRange(options.hue)), 360);
-        function getHueRange(hue) {
-            if (typeof hue === 'number') {
-                hue = mod(hue, 360);
-                return [hue, hue];
-            }
-            if (typeof hue === 'string') {
-                const color = colorDictionary.get(hue);
-                if (color?.hueRange)
-                    return color.hueRange;
-            }
-            return [0, 360];
-        }
-    }
-    function pickSaturation(hue, options) {
-        if (options.hue === 'monochrome')
-            return 0;
-        if (options.luminosity === 'random')
-            return randomWithin([0, 100]);
-        let [sMin, sMax] = getColorInfo(hue).saturationRange;
-        if (options.saturation === 'strong')
-            return sMax;
-        switch (options.luminosity) {
-            case 'bright':
-                sMin = 55;
-                break;
-            case 'dark':
-                sMin = sMax - 10;
-                break;
-            case 'light':
-                sMax = 55;
-                break;
-        }
-        return randomWithin([sMin, sMax]);
-    }
-    function pickBrightness(h, s, options) {
-        let bMin = getMinimumBrightness(h, s), bMax = 100;
-        if (typeof options.luminosity === 'number') {
-            bMin = options.luminosity;
-            bMax = options.luminosity;
-        }
-        else {
-            switch (options.luminosity) {
-                case 'dark':
-                    bMax = Math.min(100, bMin + 20);
-                    break;
-                case 'light':
-                    bMin = (bMax + bMin) / 2;
-                    break;
-                case 'random':
-                    bMin = 0;
-                    bMax = 100;
-                    break;
-            }
-        }
-        return randomWithin([bMin, bMax]);
-        function getMinimumBrightness(h, s) {
-            const { lowerBounds } = getColorInfo(h);
-            for (let i = 0; i < lowerBounds.length - 1; i++) {
-                const [s1, v1] = lowerBounds[i];
-                const [s2, v2] = lowerBounds[i + 1];
-                if (s >= s1 && s <= s2) {
-                    const m = (v2 - v1) / (s2 - s1), b = v1 - m * s1;
-                    return m * s + b;
-                }
-            }
-            return 0;
-        }
-    }
-    function randomWithin(range) {
-        //Seeded random algorithm from http://indiegamr.com/generate-repeatable-random-numbers-in-js/
-        seed = (seed * 9301 + 49297) % 233280;
-        return Math.floor(range[0] + seed / 233280.0 * (range[1] - range[0]));
-    }
-}
-function inputToSeed(input) {
-    if (input == null)
-        return 0;
-    if (typeof input === 'number')
-        return input;
-    let i = 0;
-    for (let p = 0; p < input.length; p++)
-        i = (i * 0x101 + input.charCodeAt(p)) % 0x100000000;
-    return i;
-}
-function initColorDictionary() {
-    const dict = new Map();
-    const defineColor = (name, hueRange, lowerBounds) => {
-        const [greyest] = lowerBounds;
-        const colorful = lowerBounds[lowerBounds.length - 1];
-        dict.set(name, {
-            hueRange,
-            lowerBounds,
-            saturationRange: [greyest[0], colorful[0]],
-            brightnessRange: [colorful[1], greyest[1]],
-        });
-    };
-    defineColor('monochrome', null, [[0, 0], [100, 0]]);
-    defineColor('red', [-26, 18], [[20, 100], [30, 92], [40, 89], [50, 85], [60, 78], [70, 70], [80, 60], [90, 55], [100, 50]]);
-    defineColor('orange', [18, 46], [[20, 100], [30, 93], [40, 88], [50, 86], [60, 85], [70, 70], [100, 70]]);
-    defineColor('yellow', [46, 62], [[25, 100], [40, 94], [50, 89], [60, 86], [70, 84], [80, 82], [90, 80], [100, 75]]);
-    defineColor('green', [62, 178], [[30, 100], [40, 90], [50, 85], [60, 81], [70, 74], [80, 64], [90, 50], [100, 40]]);
-    defineColor('blue', [178, 257], [[20, 100], [30, 86], [40, 80], [50, 74], [60, 60], [70, 52], [80, 44], [90, 39], [100, 35]]);
-    defineColor('purple', [257, 282], [[20, 100], [30, 87], [40, 79], [50, 70], [60, 65], [70, 59], [80, 52], [90, 45], [100, 42]]);
-    defineColor('pink', [282, 334], [[20, 100], [30, 90], [40, 86], [60, 84], [80, 80], [90, 75], [100, 73]]);
-    return dict;
-}
-function getColorInfo(hue) {
-    hue = mod(hue, 360);
-    if (hue >= 334)
-        hue -= 360;
-    for (const color of colorDictionary.values()) {
-        if (color.hueRange && hue >= color.hueRange[0] && hue <= color.hueRange[1]) {
-            return color;
-        }
-    }
-    throw Error('Color hue value not found');
-}
-
 Color.parse = function (input) {
     if (input instanceof Color)
         return input;
@@ -592,7 +836,6 @@ Color.parse = function (input) {
 Color.HSL = HSL;
 Color.HSV = HSV;
 Color.RGB = RGB;
-Color.random = randomColor;
 
 const maxzoom = 14;
 function getShortbreadTemplate() {
@@ -796,7 +1039,6 @@ function getShortbreadLayers(option) {
                     });
                 });
                 // no links
-                const noDrivewayExpression = ['!=', 'service', 'driveway'];
                 ['track', 'pedestrian', 'service', 'living_street', 'residential', 'unclassified'].forEach(t => {
                     results.push({
                         id: prefix + 'street-' + t.replace(/_/g, '') + suffix,
@@ -805,7 +1047,6 @@ function getShortbreadLayers(option) {
                         filter: ['all',
                             ['==', 'kind', t],
                             ...filter,
-                            ...(t === 'service') ? [noDrivewayExpression] : [], // ignore driveways
                         ],
                     });
                 });
@@ -820,7 +1061,6 @@ function getShortbreadLayers(option) {
                                 ['==', 'kind', t],
                                 ['==', 'bicycle', 'designated'],
                                 ...filter,
-                                ...(t === 'service') ? [noDrivewayExpression] : [], // ignore driveways
                             ],
                         });
                     });
@@ -853,8 +1093,9 @@ function getShortbreadLayers(option) {
             });
             // separate outline for trains
             [':outline', ''].forEach(suffix => {
-                // transport
-                ['rail', 'light_rail', 'subway', 'narrow_gauge', 'tram', 'funicular', 'monorail', 'bus_guideway', 'busway'].reverse().forEach((t) => {
+                // with service distinction
+                ['rail', 'light_rail', 'subway', 'narrow_gauge', 'tram'].reverse().forEach((t) => {
+                    // main rail
                     results.push({
                         id: prefix + 'transport-' + t.replace(/_/g, '') + suffix,
                         type: 'line',
@@ -865,6 +1106,29 @@ function getShortbreadLayers(option) {
                             ...filter,
                         ],
                     });
+                    // service rail (crossover, siding, spur, yard)
+                    results.push({
+                        id: prefix + 'transport-' + t.replace(/_/g, '') + '-service' + suffix,
+                        type: 'line',
+                        'source-layer': 'streets',
+                        filter: ['all',
+                            ['in', 'kind', t],
+                            ['has', 'service'],
+                            ...filter,
+                        ],
+                    });
+                });
+                // other transport
+                ['funicular', 'monorail', 'bus_guideway', 'busway'].reverse().forEach((t) => {
+                    results.push({
+                        id: prefix + 'transport-' + t.replace(/_/g, '') + suffix,
+                        type: 'line',
+                        'source-layer': 'streets',
+                        filter: ['all',
+                            ['in', 'kind', t],
+                            ...filter,
+                        ],
+                    });
                 });
                 if (c === 'street') {
                     // aerialway, no bridges, above street evel
@@ -1377,7 +1641,7 @@ function expand (str, isTop) {
     const isOptions = m.body.indexOf(',') >= 0;
     if (!isSequence && !isOptions) {
       // {a},b}
-      if (m.post.match(/,.*\}/)) {
+      if (m.post.match(/,(?!,).*\}/)) {
         str = m.pre + '{' + m.body + escClose + m.post;
         return expand(str)
       }
@@ -1828,6 +2092,13 @@ function decorate(layers, rules, recolor) {
     }
 }
 
+/**
+ * Module for applying various color transformations such as hue rotation, saturation, contrast, brightness,
+ * tinting, and blending. These transformations are defined through the `RecolorOptions` interface.
+ */
+/**
+ * Returns the default recolor settings.
+ */
 function getDefaultRecolorFlags() {
     return {
         invertBrightness: false,
@@ -1838,70 +2109,90 @@ function getDefaultRecolorFlags() {
         brightness: 0,
         tint: 0,
         tintColor: '#FF0000',
+        blend: 0,
+        blendColor: '#000000',
     };
 }
+/**
+ * Checks if the given options object contains any active recolor transformations.
+ * @param opt The recolor options to validate.
+ */
 function isValidRecolorOptions(opt) {
     if (!opt)
         return false;
-    if ((opt.invertBrightness != null) && opt.invertBrightness)
-        return true;
-    if ((opt.rotate != null) && (opt.rotate !== 0))
-        return true;
-    if ((opt.saturate != null) && (opt.saturate !== 0))
-        return true;
-    if ((opt.gamma != null) && (opt.gamma !== 1))
-        return true;
-    if ((opt.contrast != null) && (opt.contrast !== 1))
-        return true;
-    if ((opt.brightness != null) && (opt.brightness !== 0))
-        return true;
-    if ((opt.tint != null) && (opt.tint !== 0))
-        return true;
-    if ((opt.tintColor != null) && (opt.tintColor !== '#FF0000'))
-        return true;
-    return false;
+    return (opt.invertBrightness ||
+        (opt.rotate != null && opt.rotate !== 0) ||
+        (opt.saturate != null && opt.saturate !== 0) ||
+        (opt.gamma != null && opt.gamma !== 1) ||
+        (opt.contrast != null && opt.contrast !== 1) ||
+        (opt.brightness != null && opt.brightness !== 0) ||
+        (opt.tint != null && opt.tint !== 0) ||
+        (opt.tintColor != null && opt.tintColor !== '#FF0000') ||
+        (opt.blend != null && opt.blend !== 0) ||
+        (opt.blendColor != null && opt.blendColor !== '#000000'));
 }
+/**
+ * Caches recolored colors to optimize performance.
+ */
 class CachedRecolor {
     skip;
     opt;
     cache;
+    /**
+     * Creates a cached recolor instance.
+     * @param opt Optional recolor options.
+     */
     constructor(opt) {
         this.skip = !isValidRecolorOptions(opt);
         this.cache = new Map();
         this.opt = opt;
     }
+    /**
+     * Applies cached recoloring to a given color.
+     * @param color The color to recolor.
+     * @returns The recolored color, either from cache or newly computed.
+     */
     do(color) {
         if (this.skip)
             return color;
         const key = color.asHex();
-        const result = this.cache.get(key);
-        if (result)
-            return result;
-        color = recolor(color, this.opt);
-        this.cache.set(key, color);
-        return color;
+        if (this.cache.has(key))
+            return this.cache.get(key);
+        const recolored = recolor(color, this.opt);
+        this.cache.set(key, recolored);
+        return recolored;
     }
 }
+/**
+ * Applies the specified recoloring transformations to a single color.
+ * @param color The original color.
+ * @param opt Optional recolor options.
+ * @returns A new `Color` instance with applied transformations.
+ */
 function recolor(color, opt) {
     if (!isValidRecolorOptions(opt))
         return color;
-    if (opt.invertBrightness ?? false)
+    if (opt.invertBrightness)
         color = color.invertLuminosity();
-    if ((opt.rotate !== undefined) && (opt.rotate !== 0))
+    if (opt.rotate)
         color = color.rotateHue(opt.rotate);
-    if ((opt.saturate !== undefined) && (opt.saturate !== 0))
+    if (opt.saturate)
         color = color.saturate(opt.saturate);
-    if ((opt.gamma !== undefined) && (opt.gamma !== 1))
+    if (opt.gamma != null && opt.gamma != 1)
         color = color.gamma(opt.gamma);
-    if ((opt.contrast !== undefined) && (opt.contrast !== 1))
+    if (opt.contrast != null && opt.contrast != 1)
         color = color.contrast(opt.contrast);
-    if ((opt.brightness !== undefined) && (opt.brightness !== 0))
+    if (opt.brightness)
         color = color.brightness(opt.brightness);
-    if ((opt.tint !== undefined) && (opt.tintColor !== undefined) && (opt.tint !== 0))
+    if (opt.tint && opt.tintColor != null)
         color = color.tint(opt.tint, Color.parse(opt.tintColor));
+    if (opt.blend && opt.blendColor != null)
+        color = color.blend(opt.blend, Color.parse(opt.blendColor));
     return color;
 }
 
+const styleBuilderColorKeys = ['agriculture', 'boundary', 'building', 'buildingbg', 'burial', 'commercial', 'construction', 'cycle', 'danger', 'disputed', 'education', 'foot', 'glacier', 'grass', 'hospital', 'industrial', 'label', 'labelHalo', 'land', 'leisure', 'motorway', 'motorwaybg', 'park', 'parking', 'poi', 'prison', 'rail', 'residential', 'rock', 'sand', 'shield', 'street', 'streetbg', 'subway', 'symbol', 'trunk', 'trunkbg', 'waste', 'water', 'wetland', 'wood'];
+
 // StyleBuilder class definition
 class StyleBuilder {
     #sourceName = 'versatiles-shortbread';
@@ -2005,8 +2296,7 @@ class StyleBuilder {
     }
     transformDefaultColors(callback) {
         const colors = this.getColors(this.defaultColors);
-        let key;
-        for (key in colors) {
+        for (const key of styleBuilderColorKeys) {
             this.defaultColors[key] = callback(colors[key]);
         }
     }
@@ -2463,15 +2753,26 @@ class Colorful extends StyleBuilder {
                 size: { 12: 1, 14: 2, 16: 5, 18: 24, 19: 60, 20: 120 },
                 opacity: { 12: 0, 13: 1 },
             },
-            // service and tracks
-            '{bridge-,tunnel-,}street-{service,track}:outline': {
+            // tracks
+            '{bridge-,tunnel-,}street-track:outline': {
                 size: { 14: 2, 16: 4, 18: 18, 19: 48, 20: 96 },
                 opacity: { 14: 0, 15: 1 },
             },
-            '{bridge-,tunnel-,}street-{service,track}': {
+            '{bridge-,tunnel-,}street-track': {
                 size: { 14: 1, 16: 3, 18: 16, 19: 44, 20: 88 },
                 opacity: { 14: 0, 15: 1 },
             },
+            // service
+            '{bridge-,tunnel-,}street-service:outline': {
+                size: { 14: 1, 16: 3, 18: 12, 19: 32, 20: 48 },
+                opacity: { 15: 0, 16: 1 },
+                color: colors.streetbg.lighten(0.3),
+            },
+            '{bridge-,tunnel-,}street-service': {
+                size: { 14: 1, 16: 2, 18: 10, 19: 28, 20: 40 },
+                opacity: { 15: 0, 16: 1 },
+                color: colors.street.darken(0.03),
+            },
             // ways
             '{bridge-,tunnel-,}way-*:outline': {
                 size: { 15: 0, 16: 5, 18: 7, 19: 12, 20: 22 },
@@ -2511,7 +2812,8 @@ class Colorful extends StyleBuilder {
             },
             // cycle streets overlay
             '{bridge-,tunnel-,}street-{tertiary,tertiary-link,unclassified,residential,livingstreet,pedestrian}-bicycle': {
-                lineCap: 'butt',
+                lineJoin: 'round',
+                lineCap: 'round',
                 color: colors.cycle,
             },
             // pedestrian
@@ -2527,11 +2829,25 @@ class Colorful extends StyleBuilder {
             // rail, lightrail
             '{tunnel-,bridge-,}transport-{rail,lightrail}:outline': {
                 color: colors.rail,
-                size: { 8: 1, 13: 1, 15: 3, 16: 4, 18: 8, 19: 11, 20: 14 },
+                minzoom: 8,
+                size: { 8: 1, 13: 1, 15: 1, 20: 14 },
             },
             '{tunnel-,bridge-,}transport-{rail,lightrail}': {
                 color: colors.rail.lighten(0.25),
-                size: { 8: 1, 13: 1, 15: 2, 16: 3, 18: 6, 19: 8, 20: 10 },
+                minzoom: 14,
+                size: { 14: 0, 15: 1, 20: 10 },
+                lineDasharray: [2, 2],
+            },
+            // rail-service, lightrail-service
+            '{tunnel-,bridge-,}transport-{rail,lightrail}-service:outline': {
+                color: colors.rail,
+                minzoom: 14,
+                size: { 14: 0, 15: 1, 16: 1, 20: 14 },
+            },
+            '{tunnel-,bridge-,}transport-{rail,lightrail}-service': {
+                color: colors.rail.lighten(0.25),
+                minzoom: 15,
+                size: { 15: 0, 16: 1, 20: 10 },
                 lineDasharray: [2, 2],
             },
             // subway
@@ -2707,7 +3023,7 @@ class Colorful extends StyleBuilder {
             'marking-oneway{-reverse,}': {
                 minzoom: 16,
                 image: 'basics:marking-arrow',
-                opacity: { 16: 0, 17: 0.7 },
+                opacity: { 16: 0, 17: 0.4, 20: 0.4 },
                 font: fonts.regular,
             },
             // TODO: bicycle and pedestrian
@@ -2983,6 +3299,14 @@ class Graybeard extends Colorful {
     }
 }
 
+class Shadow extends Colorful {
+    name = 'Shadow';
+    constructor() {
+        super();
+        this.transformDefaultColors(color => color.saturate(-1).invert().brightness(0.2));
+    }
+}
+
 class Neutrino extends Colorful {
     name = 'Neutrino';
     defaultFonts = {
@@ -3402,6 +3726,7 @@ function getStyleBuilder(styleBuilder) {
 const colorful = getStyleBuilder(Colorful);
 const eclipse = getStyleBuilder(Eclipse);
 const graybeard = getStyleBuilder(Graybeard);
+const shadow = getStyleBuilder(Shadow);
 const neutrino = getStyleBuilder(Neutrino);
 getStyleBuilder(Empty);
 
@@ -3492,6 +3817,147 @@ function isRasterTileJSONSpecification(spec) {
     return true;
 }
 
+let colorDictionary = new Map();
+function randomColor(options) {
+    if (colorDictionary.size === 0)
+        colorDictionary = initColorDictionary();
+    options ??= {};
+    let seed = inputToSeed(options.seed);
+    const H = pickHue(options);
+    const S = pickSaturation(H, options);
+    const V = pickBrightness(H, S, options);
+    return new HSV(H, S, V, options.opacity ?? 1);
+    function pickHue(options) {
+        return mod(randomWithin(getHueRange(options.hue)), 360);
+        function getHueRange(hue) {
+            if (typeof hue === 'number') {
+                hue = mod(hue, 360);
+                return [hue, hue];
+            }
+            if (typeof hue === 'string') {
+                const color = colorDictionary.get(hue);
+                if (color?.hueRange)
+                    return color.hueRange;
+            }
+            return [0, 360];
+        }
+    }
+    function pickSaturation(hue, options) {
+        if (options.hue === 'monochrome')
+            return 0;
+        if (options.luminosity === 'random')
+            return randomWithin([0, 100]);
+        let [sMin, sMax] = getColorInfo(hue).saturationRange;
+        if (options.saturation === 'strong')
+            return sMax;
+        switch (options.luminosity) {
+            case 'bright':
+                sMin = 55;
+                break;
+            case 'dark':
+                sMin = sMax - 10;
+                break;
+            case 'light':
+                sMax = 55;
+                break;
+        }
+        return randomWithin([sMin, sMax]);
+    }
+    function pickBrightness(h, s, options) {
+        let bMin = getMinimumBrightness(h, s), bMax = 100;
+        if (typeof options.luminosity === 'number') {
+            bMin = options.luminosity;
+            bMax = options.luminosity;
+        }
+        else {
+            switch (options.luminosity) {
+                case 'dark':
+                    bMax = Math.min(100, bMin + 20);
+                    break;
+                case 'light':
+                    bMin = (bMax + bMin) / 2;
+                    break;
+                case 'random':
+                    bMin = 0;
+                    bMax = 100;
+                    break;
+            }
+        }
+        return randomWithin([bMin, bMax]);
+        function getMinimumBrightness(h, s) {
+            const { lowerBounds } = getColorInfo(h);
+            for (let i = 0; i < lowerBounds.length - 1; i++) {
+                const [s1, v1] = lowerBounds[i];
+                const [s2, v2] = lowerBounds[i + 1];
+                if (s >= s1 && s <= s2) {
+                    const m = (v2 - v1) / (s2 - s1), b = v1 - m * s1;
+                    return m * s + b;
+                }
+            }
+            return 0;
+        }
+    }
+    function randomWithin(range) {
+        //Seeded random algorithm from http://indiegamr.com/generate-repeatable-random-numbers-in-js/
+        seed = (seed * 9301 + 49297) % 233280;
+        return Math.floor(range[0] + seed / 233280.0 * (range[1] - range[0]));
+    }
+}
+function inputToSeed(input) {
+    if (input == null)
+        return 0;
+    if (typeof input === 'number')
+        return input;
+    let i = 0;
+    for (let p = 0; p < input.length; p++)
+        i = (i * 0x101 + input.charCodeAt(p)) % 0x100000000;
+    return i;
+}
+function initColorDictionary() {
+    const dict = new Map();
+    const defineColor = (name, hueRange, lowerBounds) => {
+        const [greyest] = lowerBounds;
+        const colorful = lowerBounds[lowerBounds.length - 1];
+        dict.set(name, {
+            hueRange,
+            lowerBounds,
+            saturationRange: [greyest[0], colorful[0]],
+            brightnessRange: [colorful[1], greyest[1]],
+        });
+    };
+    defineColor('monochrome', null, [[0, 0], [100, 0]]);
+    defineColor('red', [-26, 18], [[20, 100], [30, 92], [40, 89], [50, 85], [60, 78], [70, 70], [80, 60], [90, 55], [100, 50]]);
+    defineColor('orange', [18, 46], [[20, 100], [30, 93], [40, 88], [50, 86], [60, 85], [70, 70], [100, 70]]);
+    defineColor('yellow', [46, 62], [[25, 100], [40, 94], [50, 89], [60, 86], [70, 84], [80, 82], [90, 80], [100, 75]]);
+    defineColor('green', [62, 178], [[30, 100], [40, 90], [50, 85], [60, 81], [70, 74], [80, 64], [90, 50], [100, 40]]);
+    defineColor('blue', [178, 257], [[20, 100], [30, 86], [40, 80], [50, 74], [60, 60], [70, 52], [80, 44], [90, 39], [100, 35]]);
+    defineColor('purple', [257, 282], [[20, 100], [30, 87], [40, 79], [50, 70], [60, 65], [70, 59], [80, 52], [90, 45], [100, 42]]);
+    defineColor('pink', [282, 334], [[20, 100], [30, 90], [40, 86], [60, 84], [80, 80], [90, 75], [100, 73]]);
+    return dict;
+}
+function getColorInfo(hue) {
+    hue = mod(hue, 360);
+    if (hue >= 334)
+        hue -= 360;
+    for (const color of colorDictionary.values()) {
+        if (color.hueRange && hue >= color.hueRange[0] && hue <= color.hueRange[1]) {
+            return color;
+        }
+    }
+    throw Error('Color hue value not found');
+}
+
+/**
+ * Generates a style specification based on the provided TileJSON specification and optional parameters.
+ *
+ * @param {TileJSONSpecification} tileJSON - The TileJSON specification to generate the style from.
+ * @param {GuessStyleOptions} [options] - Optional parameters to customize the style generation.
+ * @param {string} [options.baseUrl] - Base URL to resolve tile URLs.
+ * @param {string} [options.glyphs] - URL template for glyphs.
+ * @param {string} [options.sprite] - URL template for sprites.
+ * @returns {StyleSpecification} The generated style specification.
+ * @throws {Error} If the provided TileJSON specification is invalid.
+ */
 function guessStyle(tileJSON, options) {
     tileJSON = deepClone(tileJSON);
     if (options && options.baseUrl) {
@@ -3537,6 +4003,23 @@ function getShortbreadStyle(spec, builderOption) {
         sprite: builderOption.sprite,
     });
 }
+/**
+ * Generates a Mapbox GL style specification based on the provided TileJSON vector specification.
+ *
+ * @param {TileJSONSpecificationVector} spec - The TileJSON vector specification containing vector layers.
+ * @returns {StyleSpecification} The generated Mapbox GL style specification.
+ *
+ * This function creates a style specification with background, circle, line, and fill layers.
+ * It assigns colors to the layers based on the vector layer IDs using predefined rules for hue, luminosity, and saturation.
+ *
+ * The resulting style specification includes:
+ * - A white background layer.
+ * - Circle layers for point features.
+ * - Line layers for line features.
+ * - Fill layers for polygon features.
+ *
+ * The source for the layers is created using the `sourceFromSpec` function with the provided vector specification.
+ */
 function getInspectorStyle(spec) {
     const sourceName = 'vectorSource';
     const layers = { background: [], circle: [], line: [], fill: [] };
@@ -3561,7 +4044,7 @@ function getInspectorStyle(spec) {
             saturation = 'strong';
             luminosity = 'light';
         }
-        const color = Color.random({
+        const color = randomColor({
             hue,
             luminosity,
             saturation,
@@ -3634,12 +4117,94 @@ function sourceFromSpec(spec, type) {
     return source;
 }
 
+/**
+ * This library provides everything you need to build a map style.
+ *
+ * You can use it in the browser:
+ * ```html
+ * <html>
+ *   <head>
+ *     <script src="https://tiles.versatiles.org/assets/lib/versatiles-style/versatiles-style.js"></script>
+ *   </head>
+ *   <body>
+ *     <!-- ... -->
+ *     <script>
+ *       const style = VersatilesStyle.colorful();
+ *       // ...
+ *     </script>
+ *   </body>
+ * </html>
+ * ```
+ *
+ * or in Node.js:
+ * ```shell
+ * npm i @versatiles/style
+ * ```
+ * ```
+ * import { colorful } from 'versatiles-style';
+ * // OR: const { colorful } = require('versatiles-style');
+ * const style = colorful();
+ * ```
+ *
+ * You probably want to use one of the following functions:
+ *
+ * ---
+ *
+ * ## Generate a style for OpenStreetMap data:
+ *
+ * To generate a style from scratch you can use on of the prepared style functions:
+ * - {@link colorful}
+ * - {@link eclipse}
+ * - {@link graybeard}
+ * - {@link neutrino}
+ * - {@link shadow}
+ *
+ * Each function accepts optional {@link StyleBuilderOptions} as argument to customize the style.
+ *
+ * Example:
+ * ```
+ * import { colorful } from 'versatiles-style';
+ * const style = colorful({
+ *   baseUrl: 'https://tiles.example.org',
+ *   recolor: {
+ *     blend: 0.5,
+ *     blendColor: '#FFF', // make all colors lighter
+ *   }
+ * });
+ * ```
+ *
+ * ---
+ *
+ * ## Guess a style based on a TileJSON:
+ *
+ * To guess a style from a TileJSON you can use {@link guessStyle}.
+ * This function needs a {@link TileJSONSpecification} and an optional {@link GuessStyleOptions} object.
+ * Example:
+ * ```
+ * import { guessStyle } from 'versatiles-style';
+ * const style = guessStyle(tilejson);
+ * ```
+ *
+ * ---
+ *
+ * ## Please help us to improve this library:
+ *
+ * This library is used in quite some projects of the VersaTiles ecosystem but it is still in an early stage.
+ * We are always looking for feedback, contributions, ideas, bug reports and help with the documentation.
+ *
+ * If you have any suggestions, please [open an issue](https://github.com/versatiles-org/versatiles-style/issues) or a pull request on [GitHub](https://github.com/versatiles-org/versatiles-style).
+ *
+ * If you want to know more about the VersaTiles project, please visit [versatiles.org](https://versatiles.org).
+ *
+ * @module
+ */
 const styles = {
     colorful,
     eclipse,
     graybeard,
+    shadow,
     neutrino,
 };
 
-export { Color, colorful, eclipse, graybeard, guessStyle, neutrino, styles };
+export { Color, colorful, eclipse, graybeard, guessStyle, neutrino, shadow, styles };
 //# sourceMappingURL=index.js.map