@promptbook/anthropic-claude 0.102.0-9 → 0.103.0-0

package/esm/index.es.js

@@ -19,7 +19,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.102.0-9';
+const PROMPTBOOK_ENGINE_VERSION = '0.103.0-0';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -67,6 +67,895 @@ function $deepFreeze(objectValue) {
  * TODO: [🧠] Is there a way how to meaningfully test this utility
  */
 
+/**
+ * @private util of `@promptbook/color`
+ * @de
+ */
+class TakeChain {
+    constructor(value) {
+        this.value = value;
+    }
+    then(callback) {
+        const newValue = callback(this.value);
+        return take(newValue);
+    }
+}
+
+/**
+ * A function that takes an initial value and returns a proxy object with chainable methods.
+ *
+ * @param {*} initialValue - The initial value.
+ * @returns {Proxy<WithTake<TValue>>} - A proxy object with a `take` method.
+ *
+ * @private util of `@promptbook/color`
+ * @deprecated [🤡] Use some better functional library instead of `TakeChain`
+ */
+function take(initialValue) {
+    if (initialValue instanceof TakeChain) {
+        return initialValue;
+    }
+    return new Proxy(new TakeChain(initialValue), {
+        get(target, property, receiver) {
+            if (Reflect.has(target, property)) {
+                return Reflect.get(target, property, receiver);
+            }
+            else if (Reflect.has(initialValue, property)) {
+                return Reflect.get(initialValue, property, receiver);
+            }
+            else {
+                return undefined;
+            }
+        },
+    });
+}
+
+/**
+ * 🎨 List of all 140 color names which are supported by CSS
+ *
+ * @public exported from `@promptbook/color`
+ */
+const CSS_COLORS = {
+    transparent: 'rgba(0,0,0,0)',
+    aliceblue: '#f0f8ff',
+    antiquewhite: '#faebd7',
+    aqua: '#00ffff',
+    aquamarine: '#7fffd4',
+    azure: '#f0ffff',
+    beige: '#f5f5dc',
+    bisque: '#ffe4c4',
+    black: '#000000',
+    blanchedalmond: '#ffebcd',
+    blue: '#0000ff',
+    blueviolet: '#8a2be2',
+    brown: '#a52a2a',
+    burlywood: '#deb887',
+    cadetblue: '#5f9ea0',
+    chartreuse: '#7fff00',
+    chocolate: '#d2691e',
+    coral: '#ff7f50',
+    cornflowerblue: '#6495ed',
+    cornsilk: '#fff8dc',
+    crimson: '#dc143c',
+    cyan: '#00ffff',
+    darkblue: '#00008b',
+    darkcyan: '#008b8b',
+    darkgoldenrod: '#b8860b',
+    darkgray: '#a9a9a9',
+    darkgrey: '#a9a9a9',
+    darkgreen: '#006400',
+    darkkhaki: '#bdb76b',
+    darkmagenta: '#8b008b',
+    darkolivegreen: '#556b2f',
+    darkorange: '#ff8c00',
+    darkorchid: '#9932cc',
+    darkred: '#8b0000',
+    darksalmon: '#e9967a',
+    darkseagreen: '#8fbc8f',
+    darkslateblue: '#483d8b',
+    darkslategray: '#2f4f4f',
+    darkslategrey: '#2f4f4f',
+    darkturquoise: '#00ced1',
+    darkviolet: '#9400d3',
+    deeppink: '#ff1493',
+    deepskyblue: '#00bfff',
+    dimgray: '#696969',
+    dimgrey: '#696969',
+    dodgerblue: '#1e90ff',
+    firebrick: '#b22222',
+    floralwhite: '#fffaf0',
+    forestgreen: '#228b22',
+    fuchsia: '#ff00ff',
+    gainsboro: '#dcdcdc',
+    ghostwhite: '#f8f8ff',
+    gold: '#ffd700',
+    goldenrod: '#daa520',
+    gray: '#808080',
+    grey: '#808080',
+    green: '#008000',
+    greenyellow: '#adff2f',
+    honeydew: '#f0fff0',
+    hotpink: '#ff69b4',
+    indianred: '#cd5c5c',
+    indigo: '#4b0082',
+    ivory: '#fffff0',
+    khaki: '#f0e68c',
+    lavender: '#e6e6fa',
+    lavenderblush: '#fff0f5',
+    lawngreen: '#7cfc00',
+    lemonchiffon: '#fffacd',
+    lightblue: '#add8e6',
+    lightcoral: '#f08080',
+    lightcyan: '#e0ffff',
+    lightgoldenrodyellow: '#fafad2',
+    lightgray: '#d3d3d3',
+    lightgrey: '#d3d3d3',
+    lightgreen: '#90ee90',
+    lightpink: '#ffb6c1',
+    lightsalmon: '#ffa07a',
+    lightseagreen: '#20b2aa',
+    lightskyblue: '#87cefa',
+    lightslategray: '#778899',
+    lightslategrey: '#778899',
+    lightsteelblue: '#b0c4de',
+    lightyellow: '#ffffe0',
+    lime: '#00ff00',
+    limegreen: '#32cd32',
+    linen: '#faf0e6',
+    magenta: '#ff00ff',
+    maroon: '#800000',
+    mediumaquamarine: '#66cdaa',
+    mediumblue: '#0000cd',
+    mediumorchid: '#ba55d3',
+    mediumpurple: '#9370db',
+    mediumseagreen: '#3cb371',
+    mediumslateblue: '#7b68ee',
+    mediumspringgreen: '#00fa9a',
+    mediumturquoise: '#48d1cc',
+    mediumvioletred: '#c71585',
+    midnightblue: '#191970',
+    mintcream: '#f5fffa',
+    mistyrose: '#ffe4e1',
+    moccasin: '#ffe4b5',
+    navajowhite: '#ffdead',
+    navy: '#000080',
+    oldlace: '#fdf5e6',
+    olive: '#808000',
+    olivedrab: '#6b8e23',
+    orange: '#ffa500',
+    orangered: '#ff4500',
+    orchid: '#da70d6',
+    palegoldenrod: '#eee8aa',
+    palegreen: '#98fb98',
+    paleturquoise: '#afeeee',
+    palevioletred: '#db7093',
+    papayawhip: '#ffefd5',
+    peachpuff: '#ffdab9',
+    peru: '#cd853f',
+    pink: '#ffc0cb',
+    plum: '#dda0dd',
+    powderblue: '#b0e0e6',
+    purple: '#800080',
+    rebeccapurple: '#663399',
+    red: '#ff0000',
+    rosybrown: '#bc8f8f',
+    royalblue: '#4169e1',
+    saddlebrown: '#8b4513',
+    salmon: '#fa8072',
+    sandybrown: '#f4a460',
+    seagreen: '#2e8b57',
+    seashell: '#fff5ee',
+    sienna: '#a0522d',
+    silver: '#c0c0c0',
+    skyblue: '#87ceeb',
+    slateblue: '#6a5acd',
+    slategray: '#708090',
+    slategrey: '#708090',
+    snow: '#fffafa',
+    springgreen: '#00ff7f',
+    steelblue: '#4682b4',
+    tan: '#d2b48c',
+    teal: '#008080',
+    thistle: '#d8bfd8',
+    tomato: '#ff6347',
+    turquoise: '#40e0d0',
+    violet: '#ee82ee',
+    wheat: '#f5deb3',
+    white: '#ffffff',
+    whitesmoke: '#f5f5f5',
+    yellow: '#ffff00',
+    yellowgreen: '#9acd32',
+};
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * Validates that a channel value is a valid number within the range of 0 to 255.
+ * Throws an error if the value is not valid.
+ *
+ * @param channelName - The name of the channel being validated.
+ * @param value - The value of the channel to validate.
+ * @throws Will throw an error if the value is not a valid channel number.
+ *
+ * @private util of `@promptbook/color`
+ */
+function checkChannelValue(channelName, value) {
+    if (typeof value !== 'number') {
+        throw new Error(`${channelName} channel value is not number but ${typeof value}`);
+    }
+    if (isNaN(value)) {
+        throw new Error(`${channelName} channel value is NaN`);
+    }
+    if (Math.round(value) !== value) {
+        throw new Error(`${channelName} channel is not whole number, it is ${value}`);
+    }
+    if (value < 0) {
+        throw new Error(`${channelName} channel is lower than 0, it is ${value}`);
+    }
+    if (value > 255) {
+        throw new Error(`${channelName} channel is greater than 255, it is ${value}`);
+    }
+}
+/**
+ * TODO: [🧠][🚓] Is/which combination it better to use asserts/check, validate or is utility function?
+ */
+
+/**
+ * Color object represents an RGB color with alpha channel
+ *
+ * Note: There is no fromObject/toObject because the most logical way to serialize color is as a hex string (#009edd)
+ *
+ * @public exported from `@promptbook/color`
+ */
+class Color {
+    /**
+     * Creates a new Color instance from miscellaneous formats
+     * - It can receive Color instance and just return the same instance
+     * - It can receive color in string format for example `#009edd`, `rgb(0,158,221)`, `rgb(0%,62%,86.7%)`, `hsl(197.1,100%,43.3%)`
+     *
+     * Note: This is not including fromImage because detecting color from an image is heavy task which requires async stuff and we cannot safely determine with overloading if return value will be a promise
+     *
+     * @param color
+     * @returns Color object
+     */
+    static from(color) {
+        if (color instanceof Color) {
+            return take(color);
+        }
+        else if (Color.isColor(color)) {
+            return take(color);
+        }
+        else if (typeof color === 'string') {
+            return Color.fromString(color);
+        }
+        else {
+            console.error({ color });
+            throw new Error(`Can not create color from given object`);
+        }
+    }
+    /**
+     * Creates a new Color instance from miscellaneous string formats
+     *
+     * @param color as a string for example `#009edd`, `rgb(0,158,221)`, `rgb(0%,62%,86.7%)`, `hsl(197.1,100%,43.3%)`, `red`, `darkgrey`,...
+     * @returns Color object
+     */
+    static fromString(color) {
+        if (CSS_COLORS[color]) {
+            return Color.fromString(CSS_COLORS[color]);
+            // -----
+        }
+        else if (Color.isHexColorString(color)) {
+            return Color.fromHex(color);
+            // -----
+        }
+        else if (/^hsl\(\s*(\d+)\s*,\s*(\d+(?:\.\d+)?%)\s*,\s*(\d+(?:\.\d+)?%)\)$/.test(color)) {
+            return Color.fromHsl(color);
+            // -----
+        }
+        else if (/^rgb\((\s*[0-9-.%]+\s*,?){3}\)$/.test(color)) {
+            // TODO: [0] Should be fromRgbString and fromRgbaString one or two functions
+            return Color.fromRgbString(color);
+            // -----
+        }
+        else if (/^rgba\((\s*[0-9-.%]+\s*,?){4}\)$/.test(color)) {
+            return Color.fromRgbaString(color);
+            // -----
+        }
+        else {
+            throw new Error(`Can not create a new Color instance from string "${color}".`);
+        }
+    }
+    /**
+     * Gets common color
+     *
+     * @param key as a css string like `midnightblue`
+     * @returns Color object
+     */
+    static get(key) {
+        if (!CSS_COLORS[key]) {
+            throw new Error(`"${key}" is not a common css color.`);
+        }
+        return Color.fromString(CSS_COLORS[key]);
+    }
+    /**
+     * Creates a new Color instance from average color of given image
+     *
+     * @param image as a source for example `data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAA1JREFUGFdjYJh39z8ABJgCe/ZvAS4AAAAASUVORK5CYII=`
+     * @returns Color object
+     */
+    static async fromImage(image) {
+        return Color.fromHex(`#009edd`);
+    }
+    /**
+     * Creates a new Color instance from color in hex format
+     *
+     * @param color in hex for example `#009edd`, `009edd`, `#555`,...
+     * @returns Color object
+     */
+    static fromHex(hex) {
+        const hexOriginal = hex;
+        if (hex.startsWith('#')) {
+            hex = hex.substring(1);
+        }
+        if (hex.length === 3) {
+            return Color.fromHex3(hex);
+        }
+        if (hex.length === 6) {
+            return Color.fromHex6(hex);
+        }
+        if (hex.length === 8) {
+            return Color.fromHex8(hex);
+        }
+        throw new Error(`Can not parse color from hex string "${hexOriginal}"`);
+    }
+    /**
+     * Creates a new Color instance from color in hex format with 3 color digits (without alpha channel)
+     *
+     * @param color in hex for example `09d`
+     * @returns Color object
+     */
+    static fromHex3(hex) {
+        const r = parseInt(hex.substr(0, 1), 16) * 16;
+        const g = parseInt(hex.substr(1, 1), 16) * 16;
+        const b = parseInt(hex.substr(2, 1), 16) * 16;
+        return take(new Color(r, g, b));
+    }
+    /**
+     * Creates a new Color instance from color in hex format with 6 color digits (without alpha channel)
+     *
+     * @param color in hex for example `009edd`
+     * @returns Color object
+     */
+    static fromHex6(hex) {
+        const r = parseInt(hex.substr(0, 2), 16);
+        const g = parseInt(hex.substr(2, 2), 16);
+        const b = parseInt(hex.substr(4, 2), 16);
+        return take(new Color(r, g, b));
+    }
+    /**
+     * Creates a new Color instance from color in hex format with 8 color digits (with alpha channel)
+     *
+     * @param color in hex for example `009edd`
+     * @returns Color object
+     */
+    static fromHex8(hex) {
+        const r = parseInt(hex.substr(0, 2), 16);
+        const g = parseInt(hex.substr(2, 2), 16);
+        const b = parseInt(hex.substr(4, 2), 16);
+        const a = parseInt(hex.substr(6, 2), 16);
+        return take(new Color(r, g, b, a));
+    }
+    /**
+     * Creates a new Color instance from color in hsl format
+     *
+     * @param color as a hsl for example `hsl(197.1,100%,43.3%)`
+     * @returns Color object
+     */
+    static fromHsl(hsl) {
+        const match = hsl.match(/^hsl\(\s*([0-9.]+)\s*,\s*([0-9.]+)%\s*,\s*([0-9.]+)%\s*\)$/);
+        if (!match) {
+            throw new Error(`Invalid hsl string format: "${hsl}"`);
+        }
+        const h = parseFloat(match[1]);
+        const s = parseFloat(match[2]) / 100;
+        const l = parseFloat(match[3]) / 100;
+        // HSL to RGB conversion
+        const c = (1 - Math.abs(2 * l - 1)) * s;
+        const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+        const m = l - c / 2;
+        let r1 = 0, g1 = 0, b1 = 0;
+        if (h >= 0 && h < 60) {
+            r1 = c;
+            g1 = x;
+            b1 = 0;
+        }
+        else if (h >= 60 && h < 120) {
+            r1 = x;
+            g1 = c;
+            b1 = 0;
+        }
+        else if (h >= 120 && h < 180) {
+            r1 = 0;
+            g1 = c;
+            b1 = x;
+        }
+        else if (h >= 180 && h < 240) {
+            r1 = 0;
+            g1 = x;
+            b1 = c;
+        }
+        else if (h >= 240 && h < 300) {
+            r1 = x;
+            g1 = 0;
+            b1 = c;
+        }
+        else if (h >= 300 && h < 360) {
+            r1 = c;
+            g1 = 0;
+            b1 = x;
+        }
+        const r = Math.round((r1 + m) * 255);
+        const g = Math.round((g1 + m) * 255);
+        const b = Math.round((b1 + m) * 255);
+        return take(new Color(r, g, b));
+    }
+    /**
+     * Creates a new Color instance from color in rgb format
+     *
+     * @param color as a rgb for example `rgb(0,158,221)`, `rgb(0%,62%,86.7%)`
+     * @returns Color object
+     */
+    static fromRgbString(rgb) {
+        const match = rgb.match(/^rgb\(\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*\)$/);
+        if (!match) {
+            throw new Error(`Invalid rgb string format: "${rgb}"`);
+        }
+        const parseChannel = (value) => {
+            if (value.endsWith('%')) {
+                // Percentage value
+                const percent = parseFloat(value);
+                return Math.round((percent / 100) * 255);
+            }
+            else {
+                // Numeric value
+                return Math.round(parseFloat(value));
+            }
+        };
+        const r = parseChannel(match[1]);
+        const g = parseChannel(match[2]);
+        const b = parseChannel(match[3]);
+        return take(new Color(r, g, b));
+    }
+    /**
+     * Creates a new Color instance from color in rbga format
+     *
+     * @param color as a rgba for example `rgba(0,158,221,0.5)`, `rgb(0%,62%,86.7%,50%)`
+     * @returns Color object
+     */
+    static fromRgbaString(rgba) {
+        const match = rgba.match(/^rgba\(\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*\)$/);
+        if (!match) {
+            throw new Error(`Invalid rgba string format: "${rgba}"`);
+        }
+        const parseChannel = (value) => {
+            if (value.endsWith('%')) {
+                const percent = parseFloat(value);
+                return Math.round((percent / 100) * 255);
+            }
+            else {
+                return Math.round(parseFloat(value));
+            }
+        };
+        const parseAlpha = (value) => {
+            if (value.endsWith('%')) {
+                const percent = parseFloat(value);
+                return Math.round((percent / 100) * 255);
+            }
+            else {
+                const alphaFloat = parseFloat(value);
+                // If alpha is between 0 and 1, treat as float
+                if (alphaFloat <= 1) {
+                    return Math.round(alphaFloat * 255);
+                }
+                // Otherwise, treat as 0-255
+                return Math.round(alphaFloat);
+            }
+        };
+        const r = parseChannel(match[1]);
+        const g = parseChannel(match[2]);
+        const b = parseChannel(match[3]);
+        const a = parseAlpha(match[4]);
+        return take(new Color(r, g, b, a));
+    }
+    /**
+     * Creates a new Color for color channels values
+     *
+     * @param red number from 0 to 255
+     * @param green number from 0 to 255
+     * @param blue number from 0 to 255
+     * @param alpha number from 0 (transparent) to 255 (opaque = default)
+     * @returns Color object
+     */
+    static fromValues(red, green, blue, alpha = 255) {
+        return take(new Color(red, green, blue, alpha));
+    }
+    /**
+     * Checks if the given value is a valid Color object.
+     *
+     * @param {unknown} value - The value to check.
+     * @return {value is WithTake<Color>} Returns true if the value is a valid Color object, false otherwise.
+     */
+    static isColor(value) {
+        if (typeof value !== 'object') {
+            return false;
+        }
+        if (value === null) {
+            return false;
+        }
+        if (typeof value.red !== 'number' ||
+            typeof value.green !== 'number' ||
+            typeof value.blue !== 'number' ||
+            typeof value.alpha !== 'number') {
+            return false;
+        }
+        if (typeof value.then !== 'function') {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Checks if the given value is a valid hex color string
+     *
+     * @param value - value to check
+     * @returns true if the value is a valid hex color string (e.g., `#009edd`, `#fff`, etc.)
+     */
+    static isHexColorString(value) {
+        return typeof value === 'string' && /^#(?:[0-9a-fA-F]{3}){1,2}$/.test(value);
+    }
+    /**
+     * Creates new Color object
+     *
+     * Note: Consider using one of static methods like `from` or `fromString`
+     *
+     * @param red number from 0 to 255
+     * @param green number from 0 to 255
+     * @param blue number from 0 to 255
+     * @param alpha number from 0 (transparent) to 255 (opaque)
+     */
+    constructor(red, green, blue, alpha = 255) {
+        this.red = red;
+        this.green = green;
+        this.blue = blue;
+        this.alpha = alpha;
+        checkChannelValue('Red', red);
+        checkChannelValue('Green', green);
+        checkChannelValue('Blue', blue);
+        checkChannelValue('Alpha', alpha);
+    }
+    /**
+     * Shortcut for `red` property
+     * Number from 0 to 255
+     * @alias red
+     */
+    get r() {
+        return this.red;
+    }
+    /**
+     * Shortcut for `green` property
+     * Number from 0 to 255
+     * @alias green
+     */
+    get g() {
+        return this.green;
+    }
+    /**
+     * Shortcut for `blue` property
+     * Number from 0 to 255
+     * @alias blue
+     */
+    get b() {
+        return this.blue;
+    }
+    /**
+     * Shortcut for `alpha` property
+     * Number from 0 (transparent) to 255 (opaque)
+     * @alias alpha
+     */
+    get a() {
+        return this.alpha;
+    }
+    /**
+     * Shortcut for `alpha` property
+     * Number from 0 (transparent) to 255 (opaque)
+     * @alias alpha
+     */
+    get opacity() {
+        return this.alpha;
+    }
+    /**
+     * Shortcut for 1-`alpha` property
+     */
+    get transparency() {
+        return 255 - this.alpha;
+    }
+    clone() {
+        return take(new Color(this.red, this.green, this.blue, this.alpha));
+    }
+    toString() {
+        return this.toHex();
+    }
+    toHex() {
+        if (this.alpha === 255) {
+            return `#${this.red.toString(16).padStart(2, '0')}${this.green.toString(16).padStart(2, '0')}${this.blue
+                .toString(16)
+                .padStart(2, '0')}`;
+        }
+        else {
+            return `#${this.red.toString(16).padStart(2, '0')}${this.green.toString(16).padStart(2, '0')}${this.blue
+                .toString(16)
+                .padStart(2, '0')}${this.alpha.toString(16).padStart(2, '0')}`;
+        }
+    }
+    toRgb() {
+        if (this.alpha === 255) {
+            return `rgb(${this.red}, ${this.green}, ${this.blue})`;
+        }
+        else {
+            return `rgba(${this.red}, ${this.green}, ${this.blue}, ${Math.round((this.alpha / 255) * 100)}%)`;
+        }
+    }
+    toHsl() {
+        throw new Error(`Getting HSL is not implemented`);
+    }
+}
+/**
+ * TODO: [🥻] Split Color class and color type
+ * TODO: For each method a corresponding static method should be created
+ *       Like clone can be done by color.clone() OR Color.clone(color)
+ * TODO: Probably as an independent LIB OR add to LIB xyzt (ask @roseckyj)
+ * TODO: !! Transfer back to Collboard (whole directory)
+ * TODO: Maybe [🏌️‍♂️] change ACRY toString => (toHex) toRgb when there will be toRgb and toRgba united
+ * TODO: Convert getters to methods - getters only for values
+ * TODO: Write tests
+ * TODO: Getters for alpha, opacity, transparency, r, b, g, h, s, l, a,...
+ * TODO: [0] Should be fromRgbString and fromRgbaString one or two functions + one or two regex
+ * TODO: Use rgb, rgba, hsl for testing and parsing with the same regex
+ * TODO: Regex for rgb, rgba, hsl does not support all options like deg, rad, turn,...
+ * TODO: Convolution matrix
+ * TODO: Maybe connect with textures
+ */
+
+/**
+ * Converts HSL values to RGB values
+ *
+ * @param hue [0-1]
+ * @param saturation [0-1]
+ * @param lightness [0-1]
+ * @returns [red, green, blue] [0-255]
+ *
+ * @private util of `@promptbook/color`
+ */
+function hslToRgb(hue, saturation, lightness) {
+    let red;
+    let green;
+    let blue;
+    if (saturation === 0) {
+        // achromatic
+        red = lightness;
+        green = lightness;
+        blue = lightness;
+    }
+    else {
+        // TODO: Extract to separate function
+        const hue2rgb = (p, q, t) => {
+            if (t < 0)
+                t += 1;
+            if (t > 1)
+                t -= 1;
+            if (t < 1 / 6)
+                return p + (q - p) * 6 * t;
+            if (t < 1 / 2)
+                return q;
+            if (t < 2 / 3)
+                return p + (q - p) * (2 / 3 - t) * 6;
+            return p;
+        };
+        const q = lightness < 0.5 ? lightness * (1 + saturation) : lightness + saturation - lightness * saturation;
+        const p = 2 * lightness - q;
+        red = hue2rgb(p, q, hue + 1 / 3);
+        green = hue2rgb(p, q, hue);
+        blue = hue2rgb(p, q, hue - 1 / 3);
+    }
+    return [Math.round(red * 255), Math.round(green * 255), Math.round(blue * 255)];
+}
+/**
+ * TODO: Properly name all used internal variables
+ */
+
+/**
+ * Converts RGB values to HSL values
+ *
+ * @param red [0-255]
+ * @param green [0-255]
+ * @param blue [0-255]
+ * @returns [hue, saturation, lightness] [0-1]
+ *
+ * @private util of `@promptbook/color`
+ */
+function rgbToHsl(red, green, blue) {
+    red /= 255;
+    green /= 255;
+    blue /= 255;
+    const max = Math.max(red, green, blue);
+    const min = Math.min(red, green, blue);
+    let hue;
+    let saturation;
+    const lightness = (max + min) / 2;
+    if (max === min) {
+        // achromatic
+        hue = 0;
+        saturation = 0;
+    }
+    else {
+        const d = max - min;
+        saturation = lightness > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch (max) {
+            case red:
+                hue = (green - blue) / d + (green < blue ? 6 : 0);
+                break;
+            case green:
+                hue = (blue - red) / d + 2;
+                break;
+            case blue:
+                hue = (red - green) / d + 4;
+                break;
+            default:
+                hue = 0;
+        }
+        hue /= 6;
+    }
+    return [hue, saturation, lightness];
+}
+/**
+ * TODO: Properly name all used internal variables
+ */
+
+/**
+ * Makes color transformer which lighten the given color
+ *
+ * @param amount from 0 to 1
+ *
+ * @public exported from `@promptbook/color`
+ */
+function lighten(amount) {
+    return ({ red, green, blue, alpha }) => {
+        const [h, s, lInitial] = rgbToHsl(red, green, blue);
+        let l = lInitial + amount;
+        l = Math.max(0, Math.min(l, 1)); // Replace lodash clamp with Math.max and Math.min
+        const [r, g, b] = hslToRgb(h, s, l);
+        return Color.fromValues(r, g, b, alpha);
+    };
+}
+/**
+ * TODO: Maybe implement by mix+hsl
+ */
+
+/**
+ * Calculates distance between two colors
+ *
+ * @param color1 first color
+ * @param color2 second color
+ *
+ * Note: This function is inefficient. Use colorDistanceSquared instead if possible.
+ *
+ * @public exported from `@promptbook/color`
+ */
+/**
+ * Calculates distance between two colors without square root
+ *
+ * @param color1 first color
+ * @param color2 second color
+ *
+ * @public exported from `@promptbook/color`
+ */
+function colorDistanceSquared(color1, color2) {
+    const rmean = (color1.red + color2.red) / 2;
+    const r = color1.red - color2.red;
+    const g = color1.green - color2.green;
+    const b = color1.blue - color2.blue;
+    const weightR = 2 + rmean / 256;
+    const weightG = 4.0;
+    const weightB = 2 + (255 - rmean) / 256;
+    const distance = weightR * r * r + weightG * g * g + weightB * b * b;
+    return distance;
+}
+
+/**
+ * Makes color transformer which finds the nearest color from the given list
+ *
+ * @param colors array of colors to choose from
+ *
+ * @public exported from `@promptbook/color`
+ */
+function nearest(...colors) {
+    return (color) => {
+        const distances = colors.map((c) => colorDistanceSquared(c, color));
+        const minDistance = Math.min(...distances);
+        const minIndex = distances.indexOf(minDistance);
+        const nearestColor = colors[minIndex];
+        return nearestColor;
+    };
+}
+
+/**
+ * Color transformer which returns the negative color
+ *
+ * @public exported from `@promptbook/color`
+ */
+function negative(color) {
+    const r = 255 - color.red;
+    const g = 255 - color.green;
+    const b = 255 - color.blue;
+    return Color.fromValues(r, g, b, color.alpha);
+}
+
+/**
+ * Makes color transformer which finds the furthest color from the given list
+ *
+ * @param colors array of colors to choose from
+ *
+ * @public exported from `@promptbook/color`
+ */
+function furthest(...colors) {
+    return (color) => {
+        const furthestColor = negative(nearest(...colors.map(negative))(color));
+        return furthestColor;
+    };
+}
+/**
+ * Makes color transformer which finds the best text color (black or white) for the given background color
+ *
+ * @public exported from `@promptbook/color`
+ */
+furthest(Color.get('white'), Color.from('black'));
+
+/**
+ * Makes color transformer which returns a grayscale version of the color
+ *
+ * @param amount from 0 to 1
+ *
+ * @public exported from `@promptbook/color`
+ */
+function grayscale(amount) {
+    return ({ red, green, blue, alpha }) => {
+        const average = (red + green + blue) / 3;
+        red = Math.round(average * amount + red * (1 - amount));
+        green = Math.round(average * amount + green * (1 - amount));
+        blue = Math.round(average * amount + blue * (1 - amount));
+        return Color.fromValues(red, green, blue, alpha);
+    };
+}
+
+/**
+ * Makes color transformer which saturate the given color
+ *
+ * @param amount from -1 to 1
+ *
+ * @public exported from `@promptbook/color`
+ */
+function saturate(amount) {
+    return ({ red, green, blue, alpha }) => {
+        const [h, sInitial, l] = rgbToHsl(red, green, blue);
+        let s = sInitial + amount;
+        s = Math.max(0, Math.min(s, 1));
+        const [r, g, b] = hslToRgb(h, s, l);
+        return Color.fromValues(r, g, b, alpha);
+    };
+}
+/**
+ * TODO: Maybe implement by mix+hsl
+ */
+
 /**
  * Name for the Promptbook
  *
@@ -87,6 +976,32 @@ const ADMIN_EMAIL = 'pavol@ptbk.io';
  * @public exported from `@promptbook/core`
  */
 const ADMIN_GITHUB_NAME = 'hejny';
+//            <- TODO: [🐊] Pick the best claim
+/**
+ * Color of the Promptbook
+ *
+ * TODO: [🗽] Unite branding and make single place for it
+ *
+ * @public exported from `@promptbook/core`
+ */
+const PROMPTBOOK_COLOR = Color.fromHex('#79EAFD');
+// <- TODO: [🧠] Using `Color` here increases the package size approx 3kb, maybe remove it
+/**
+ * Dark color of the Promptbook
+ *
+ * TODO: [🗽] Unite branding and make single place for it
+ *
+ * @public exported from `@promptbook/core`
+ */
+PROMPTBOOK_COLOR.then(lighten(0.1)).then(saturate(0.9)).then(grayscale(0.9));
+/**
+ * Color of the user (in chat)
+ *
+ * TODO: [🗽] Unite branding and make single place for it
+ *
+ * @public exported from `@promptbook/core`
+ */
+Color.fromHex('#1D4ED8');
 // <- TODO: [🧠] Better system for generator warnings - not always "code" and "by `@promptbook/cli`"
 /**
  * The maximum number of iterations for a loops
@@ -1521,19 +2436,28 @@ class AnthropicClaudeExecutionTools {
         }
         const modelName = modelRequirements.modelName || this.getDefaultChatModel().modelName;
         const rawPromptContent = templateParameters(content, { ...parameters, modelName });
+        // Support chat thread if provided, otherwise fallback to single message
+        let messages;
+        if ('thread' in prompt && Array.isArray(prompt.thread)) {
+            messages = prompt.thread.map((msg) => ({
+                role: msg.role === 'assistant' ? 'assistant' : 'user',
+                content: msg.content,
+            }));
+        }
+        else {
+            messages = [
+                {
+                    role: 'user',
+                    content: rawPromptContent,
+                },
+            ];
+        }
         const rawRequest = {
             model: modelRequirements.modelName || this.getDefaultChatModel().modelName,
             max_tokens: modelRequirements.maxTokens || 8192,
             temperature: modelRequirements.temperature,
             system: modelRequirements.systemMessage,
-            messages: [
-                {
-                    role: 'user',
-                    content: rawPromptContent,
-                    // <- TODO: [🧠][♏] Maybe if expecting JSON and its not specified in prompt content, append the instructions
-                    //    @see https://docs.anthropic.com/en/docs/test-and-evaluate/strengthen-guardrails/increase-consistency#specify-the-desired-output-format
-                },
-            ],
+            messages,
         };
         const start = $getCurrentDate();
         if (this.options.isVerbose) {