@voryx/color 1.0.0

package/dist/Color.d.ts

@@ -0,0 +1,47 @@
+import type { ColorSpace } from './spaces/types';
+import { type SRGBComponents } from './spaces/SRGB';
+import { type HSLComponents } from './spaces/HSL';
+import { type RGBComponents } from './spaces/RGB';
+import { type P3Components } from './spaces/P3';
+import { type OKLCHComponents } from './spaces/OKLCH';
+import { type OKLABComponents } from './spaces/OKLAB';
+import { type LMSComponents } from './spaces/LMS';
+export type ColorComponents<S extends ColorSpace = ColorSpace> = S extends 'srgb' ? SRGBComponents : S extends 'hsl' ? HSLComponents : S extends 'rgb' ? RGBComponents : S extends 'p3' ? P3Components : S extends 'oklch' ? OKLCHComponents : S extends 'oklab' ? OKLABComponents : S extends 'lms' ? LMSComponents : never;
+export declare class Color {
+    #private;
+    static fromSRGB(components: SRGBComponents): Color;
+    static fromHSL(components: HSLComponents): Color;
+    static fromRGB(components: RGBComponents): Color;
+    static fromP3(components: P3Components): Color;
+    static fromOKLCH(components: OKLCHComponents): Color;
+    static fromOKLAB(components: OKLABComponents): Color;
+    static fromLMS(components: LMSComponents): Color;
+    static fromColorCode(code: string): Color;
+    static from(item: Color | ColorComponents | string): Color;
+    constructor(view: [number, number, number, number]);
+    rotate(degrees: number, space?: 'oklch' | 'hsl'): Color;
+    to<S extends ColorSpace>(space: S): ColorComponents<S>;
+    get srgb(): SRGBComponents;
+    get hsl(): HSLComponents;
+    get rgb(): RGBComponents;
+    get p3(): P3Components;
+    get oklch(): OKLCHComponents;
+    get oklab(): OKLABComponents;
+    get lms(): LMSComponents;
+    get long(): number;
+    get medium(): number;
+    get short(): number;
+    get alpha(): number;
+    get luminance(): number;
+    get foregroundColor(): Color;
+    withAlpha(alpha: number): Color;
+    contrastRatio(other: Color): number;
+    inGamut(gamut: 'srgb' | 'p3', epsilon?: number): boolean;
+    toGamut(gamut: 'srgb' | 'p3', epsilon?: number): Color;
+    toCSS<S extends ColorSpace>({ space, precision }?: {
+        space?: S;
+        precision?: number;
+    }): string;
+    toColorCode(): string;
+}
+//# sourceMappingURL=Color.d.ts.map

package/dist/Color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Color.d.ts","sourceRoot":"","sources":["../src/Color.ts"],"names":[],"mappings":"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"}

package/dist/Color.js

@@ -0,0 +1,551 @@
+import { SRGB } from "./spaces/SRGB.js";
+import { HSL } from "./spaces/HSL.js";
+import { RGB } from "./spaces/RGB.js";
+import { P3 } from "./spaces/P3.js";
+import { OKLCH } from "./spaces/OKLCH.js";
+import { OKLAB } from "./spaces/OKLAB.js";
+import { inGamut } from "./gamut/inGamut.js";
+import { mapToGamut } from "./gamut/map.js";
+import { normalizeAngle, roundToPrecision } from "./misc.js";
+import { ObjectCache } from "@voryx/object-cache";
+import { decodeColorCode, encodeColorCode } from "./encode.js";
+class Color {
+    static fromSRGB(components) {
+        const lms = SRGB.toLMS([
+            components.sRed,
+            components.green,
+            components.blue,
+            components.alpha
+        ]);
+        return new Color(lms);
+    }
+    static fromHSL(components) {
+        const lms = HSL.toLMS([
+            components.hue,
+            components.saturation,
+            components.lightness,
+            components.alpha
+        ]);
+        return new Color(lms);
+    }
+    static fromRGB(components) {
+        const lms = RGB.toLMS([
+            components.red,
+            components.green,
+            components.blue,
+            components.alpha
+        ]);
+        return new Color(lms);
+    }
+    static fromP3(components) {
+        const lms = P3.toLMS([
+            components.p3Red,
+            components.green,
+            components.blue,
+            components.alpha
+        ]);
+        return new Color(lms);
+    }
+    static fromOKLCH(components) {
+        const lms = OKLCH.toLMS([
+            components.lightness,
+            components.chroma,
+            components.hue,
+            components.alpha
+        ]);
+        return new Color(lms);
+    }
+    static fromOKLAB(components) {
+        const lms = OKLAB.toLMS([
+            components.lightness,
+            components.a,
+            components.b,
+            components.alpha
+        ]);
+        return new Color(lms);
+    }
+    static fromLMS(components) {
+        return new Color([
+            components.long,
+            components.medium,
+            components.short,
+            components.alpha
+        ]);
+    }
+    static fromColorCode(code) {
+        const decoded = decodeColorCode(code);
+        return new Color([
+            decoded.l,
+            decoded.m,
+            decoded.s,
+            decoded.alpha
+        ]);
+    }
+    static from(item) {
+        let components;
+        if (item instanceof Color) return new Color([
+            item.lms.long,
+            item.lms.medium,
+            item.lms.short,
+            item.lms.alpha
+        ]);
+        if ('string' == typeof item) {
+            const comp = parseColorString(item);
+            if (!comp) throw new Error(`Invalid color string: ${item}`);
+            components = comp;
+        } else components = item;
+        if ('sRed' in components) {
+            const lms = SRGB.toLMS([
+                components.sRed,
+                components.green,
+                components.blue,
+                components.alpha
+            ]);
+            return new Color(lms);
+        }
+        if ('p3Red' in components) {
+            const lms = P3.toLMS([
+                components.p3Red,
+                components.green,
+                components.blue,
+                components.alpha
+            ]);
+            return new Color(lms);
+        }
+        if ('chroma' in components) {
+            const lms = OKLCH.toLMS([
+                components.lightness,
+                components.chroma,
+                components.hue,
+                components.alpha
+            ]);
+            return new Color(lms);
+        }
+        if ('a' in components) {
+            const lms = OKLAB.toLMS([
+                components.lightness,
+                components.a,
+                components.b,
+                components.alpha
+            ]);
+            return new Color(lms);
+        }
+        if ('hue' in components) {
+            const lms = HSL.toLMS([
+                components.hue,
+                components.saturation,
+                components.lightness,
+                components.alpha
+            ]);
+            return new Color(lms);
+        }
+        if ('red' in components) {
+            const lms = RGB.toLMS([
+                components.red,
+                components.green,
+                components.blue,
+                components.alpha
+            ]);
+            return new Color(lms);
+        }
+        if ('long' in components) return new Color([
+            components.long,
+            components.medium,
+            components.short,
+            components.alpha
+        ]);
+        throw new Error('Invalid color components');
+    }
+    #view;
+    constructor(view){
+        this.#view = view;
+    }
+    rotate(degrees, space = 'oklch') {
+        if ('oklch' === space) {
+            const oklch = OKLCH.fromLMS([
+                this.#view[0],
+                this.#view[1],
+                this.#view[2],
+                this.#view[3]
+            ]);
+            const newHue = normalizeAngle(oklch[2] + degrees);
+            const newOklch = [
+                oklch[0],
+                oklch[1],
+                newHue,
+                oklch[3]
+            ];
+            const newLMS = OKLCH.toLMS(newOklch);
+            return new Color(newLMS);
+        }
+        if ('hsl' === space) {
+            const hsl = HSL.fromLMS([
+                this.#view[0],
+                this.#view[1],
+                this.#view[2],
+                this.#view[3]
+            ]);
+            const newHue = normalizeAngle(hsl[0] + degrees);
+            const newHsl = [
+                newHue,
+                hsl[1],
+                hsl[2],
+                hsl[3]
+            ];
+            const newLMS = HSL.toLMS(newHsl);
+            return new Color(newLMS);
+        }
+        throw new Error('Invalid rotation space');
+    }
+    to(space) {
+        return ObjectCache.getOrSet(this, `to-${space}`, ()=>{
+            switch(space){
+                case 'srgb':
+                    const srgb = SRGB.fromLMS([
+                        this.#view[0],
+                        this.#view[1],
+                        this.#view[2],
+                        this.#view[3]
+                    ]);
+                    return {
+                        sRed: srgb[0],
+                        green: srgb[1],
+                        blue: srgb[2],
+                        alpha: srgb[3]
+                    };
+                case 'hsl':
+                    const hsl = HSL.fromLMS([
+                        this.#view[0],
+                        this.#view[1],
+                        this.#view[2],
+                        this.#view[3]
+                    ]);
+                    return {
+                        hue: hsl[0],
+                        saturation: hsl[1],
+                        lightness: hsl[2],
+                        alpha: hsl[3]
+                    };
+                case 'rgb':
+                    const rgb = RGB.fromLMS([
+                        this.#view[0],
+                        this.#view[1],
+                        this.#view[2],
+                        this.#view[3]
+                    ]);
+                    return {
+                        red: rgb[0],
+                        green: rgb[1],
+                        blue: rgb[2],
+                        alpha: rgb[3]
+                    };
+                case 'p3':
+                    const p3 = P3.fromLMS([
+                        this.#view[0],
+                        this.#view[1],
+                        this.#view[2],
+                        this.#view[3]
+                    ]);
+                    return {
+                        p3Red: p3[0],
+                        green: p3[1],
+                        blue: p3[2],
+                        alpha: p3[3]
+                    };
+                case 'oklch':
+                    const oklch = OKLCH.fromLMS([
+                        this.#view[0],
+                        this.#view[1],
+                        this.#view[2],
+                        this.#view[3]
+                    ]);
+                    return {
+                        lightness: oklch[0],
+                        chroma: oklch[1],
+                        hue: oklch[2],
+                        alpha: oklch[3]
+                    };
+                case 'oklab':
+                    const oklab = OKLAB.fromLMS([
+                        this.#view[0],
+                        this.#view[1],
+                        this.#view[2],
+                        this.#view[3]
+                    ]);
+                    return {
+                        lightness: oklab[0],
+                        a: oklab[1],
+                        b: oklab[2],
+                        alpha: oklab[3]
+                    };
+                case 'lms':
+                    return {
+                        long: this.#view[0],
+                        medium: this.#view[1],
+                        short: this.#view[2],
+                        alpha: this.#view[3]
+                    };
+                default:
+                    throw new Error(`Unsupported color space: ${space}`);
+            }
+        });
+    }
+    get srgb() {
+        return this.to('srgb');
+    }
+    get hsl() {
+        return this.to('hsl');
+    }
+    get rgb() {
+        return this.to('rgb');
+    }
+    get p3() {
+        return this.to('p3');
+    }
+    get oklch() {
+        return this.to('oklch');
+    }
+    get oklab() {
+        return this.to('oklab');
+    }
+    get lms() {
+        return this.to('lms');
+    }
+    get long() {
+        return this.#view[0];
+    }
+    get medium() {
+        return this.#view[1];
+    }
+    get short() {
+        return this.#view[2];
+    }
+    get alpha() {
+        return this.#view[3];
+    }
+    get luminance() {
+        return 0.15514 * this.long + 0.53121 * this.medium + 0.04618 * this.short;
+    }
+    get foregroundColor() {
+        const contrastWithBlack = this.contrastRatio(Color.fromSRGB({
+            sRed: 0,
+            green: 0,
+            blue: 0,
+            alpha: 1
+        }));
+        const contrastWithWhite = this.contrastRatio(Color.fromSRGB({
+            sRed: 1,
+            green: 1,
+            blue: 1,
+            alpha: 1
+        }));
+        return contrastWithBlack > contrastWithWhite ? Color.fromSRGB({
+            sRed: 0,
+            green: 0,
+            blue: 0,
+            alpha: 1
+        }) : Color.fromSRGB({
+            sRed: 1,
+            green: 1,
+            blue: 1,
+            alpha: 1
+        });
+    }
+    withAlpha(alpha) {
+        return new Color([
+            this.#view[0],
+            this.#view[1],
+            this.#view[2],
+            alpha
+        ]);
+    }
+    contrastRatio(other) {
+        const lum1 = this.luminance;
+        const lum2 = other.luminance;
+        const brightest = Math.max(lum1, lum2);
+        const darkest = Math.min(lum1, lum2);
+        return (brightest + 0.05) / (darkest + 0.05);
+    }
+    inGamut(gamut, epsilon) {
+        return inGamut([
+            this.#view[0],
+            this.#view[1],
+            this.#view[2],
+            this.#view[3]
+        ], gamut, epsilon);
+    }
+    toGamut(gamut, epsilon) {
+        const mapped = mapToGamut([
+            this.#view[0],
+            this.#view[1],
+            this.#view[2],
+            this.#view[3]
+        ], gamut, {
+            epsilon
+        });
+        return new Color(mapped);
+    }
+    toCSS({ space, precision = 3 } = {}) {
+        return ObjectCache.getOrSet(this, `toCSS-${space}-${precision}`, ()=>{
+            if (!space) space = 'rgb';
+            const components = this.to(space);
+            switch(space){
+                case 'srgb':
+                    return `color(srgb ${roundToPrecision(components.sRed, precision)} ${roundToPrecision(components.green, precision)} ${roundToPrecision(components.blue, precision)} / ${roundToPrecision(components.alpha, 2)})`;
+                case 'hsl':
+                    return `hsla(${roundToPrecision(components.hue, precision)}, ${roundToPrecision(components.saturation, precision)}%, ${roundToPrecision(components.lightness, precision)}%, ${roundToPrecision(components.alpha, 2)})`;
+                case 'rgb':
+                    return `rgba(${roundToPrecision(components.red, precision)}, ${roundToPrecision(components.green, precision)}, ${roundToPrecision(components.blue, precision)}, ${roundToPrecision(components.alpha, 2)})`;
+                case 'p3':
+                    return `color(display-p3 ${roundToPrecision(components.p3Red, precision)} ${roundToPrecision(components.green, precision)} ${roundToPrecision(components.blue, precision)} / ${roundToPrecision(components.alpha, 2)})`;
+                case 'oklch':
+                    return `oklch(${roundToPrecision(components.lightness, precision)} ${roundToPrecision(components.chroma, precision)} ${roundToPrecision(components.hue, precision)} / ${roundToPrecision(components.alpha, 2)})`;
+                case 'oklab':
+                    return `oklab(${roundToPrecision(components.lightness, precision)} ${roundToPrecision(components.a, precision)} ${roundToPrecision(components.b, precision)} / ${roundToPrecision(components.alpha, 2)})`;
+                case 'lms':
+                    return `lms(${roundToPrecision(components.long, precision)} ${roundToPrecision(components.medium, precision)} ${roundToPrecision(components.short, precision)} / ${roundToPrecision(components.alpha, 2)})`;
+                default:
+                    throw new Error(`Unsupported color space: ${space}`);
+            }
+        });
+    }
+    toColorCode() {
+        return encodeColorCode({
+            l: this.#view[0],
+            m: this.#view[1],
+            s: this.#view[2],
+            alpha: this.#view[3]
+        });
+    }
+}
+function parseColorString(colorString) {
+    const trimmed = colorString.trim().toLowerCase();
+    if (trimmed.startsWith('rgba')) {
+        const match = trimmed.match(/rgba\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*\)/);
+        if (match) return {
+            red: parseFloat(match[1]),
+            green: parseFloat(match[2]),
+            blue: parseFloat(match[3]),
+            alpha: parseFloat(match[4])
+        };
+    }
+    if (trimmed.startsWith('rgb')) {
+        const match = trimmed.match(/rgb\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*\)/);
+        if (match) return {
+            red: parseFloat(match[1]),
+            green: parseFloat(match[2]),
+            blue: parseFloat(match[3]),
+            alpha: 1
+        };
+    }
+    if (trimmed.startsWith('hsla')) {
+        const match = trimmed.match(/hsla\(\s*([\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%\s*,\s*([\d.]+)\s*\)/);
+        if (match) return {
+            hue: parseFloat(match[1]),
+            saturation: parseFloat(match[2]),
+            lightness: parseFloat(match[3]),
+            alpha: parseFloat(match[4])
+        };
+    }
+    if (trimmed.startsWith('hsl')) {
+        const match = trimmed.match(/hsl\(\s*([\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%\s*\)/);
+        if (match) return {
+            hue: parseFloat(match[1]),
+            saturation: parseFloat(match[2]),
+            lightness: parseFloat(match[3]),
+            alpha: 1
+        };
+    }
+    if (trimmed.startsWith('color(')) {
+        const match = trimmed.match(/color\(\s*([\w-]+)\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)(?:\s*\/\s*([\d.]+))?\s*\)/);
+        if (match) {
+            const space = match[1];
+            const c1 = parseFloat(match[2]);
+            const c2 = parseFloat(match[3]);
+            const c3 = parseFloat(match[4]);
+            const alpha = match[5] ? parseFloat(match[5]) : 1;
+            switch(space){
+                case 'srgb':
+                    return {
+                        sRed: c1,
+                        green: c2,
+                        blue: c3,
+                        alpha
+                    };
+                case 'display-p3':
+                    return {
+                        p3Red: c1,
+                        green: c2,
+                        blue: c3,
+                        alpha
+                    };
+                default:
+                    return null;
+            }
+        }
+    }
+    if (trimmed.startsWith('oklch')) {
+        const match = trimmed.match(/oklch\(\s*([\d.]+)\s+([\d.]+)\s+([\d.]+)(?:\s*\/\s*([\d.]+))?\s*\)/);
+        if (match) return {
+            lightness: parseFloat(match[1]),
+            chroma: parseFloat(match[2]),
+            hue: parseFloat(match[3]),
+            alpha: match[4] ? parseFloat(match[4]) : 1
+        };
+    }
+    if (trimmed.startsWith('oklab')) {
+        const match = trimmed.match(/oklab\(\s*([\d.]+)\s+([\d.]+)\s+([\d.]+)(?:\s*\/\s*([\d.]+))?\s*\)/);
+        if (match) return {
+            lightness: parseFloat(match[1]),
+            a: parseFloat(match[2]),
+            b: parseFloat(match[3]),
+            alpha: match[4] ? parseFloat(match[4]) : 1
+        };
+    }
+    if (trimmed.startsWith('lms')) {
+        const match = trimmed.match(/lms\(\s*([\d.]+)\s+([\d.]+)\s+([\d.]+)(?:\s*\/\s*([\d.]+))?\s*\)/);
+        if (match) return {
+            long: parseFloat(match[1]),
+            medium: parseFloat(match[2]),
+            short: parseFloat(match[3]),
+            alpha: match[4] ? parseFloat(match[4]) : 1
+        };
+    }
+    if (trimmed.startsWith('#')) {
+        const hex = trimmed.slice(1);
+        if (6 === hex.length) {
+            const r = parseInt(hex.slice(0, 2), 16) / 255;
+            const g = parseInt(hex.slice(2, 4), 16) / 255;
+            const b = parseInt(hex.slice(4, 6), 16) / 255;
+            return {
+                sRed: r,
+                green: g,
+                blue: b,
+                alpha: 1
+            };
+        }
+        if (8 === hex.length) {
+            const r = parseInt(hex.slice(0, 2), 16) / 255;
+            const g = parseInt(hex.slice(2, 4), 16) / 255;
+            const b = parseInt(hex.slice(4, 6), 16) / 255;
+            const a = parseInt(hex.slice(6, 8), 16) / 255;
+            return {
+                sRed: r,
+                green: g,
+                blue: b,
+                alpha: a
+            };
+        }
+    }
+    if (trimmed.startsWith('L')) {
+        const decoded = decodeColorCode(trimmed);
+        return {
+            long: decoded.l,
+            medium: decoded.m,
+            short: decoded.s,
+            alpha: decoded.alpha
+        };
+    }
+    return null;
+}
+export { Color };

package/dist/encode.d.ts

@@ -0,0 +1,9 @@
+export interface LMSA {
+    l: number;
+    m: number;
+    s: number;
+    alpha: number;
+}
+export declare function encodeColorCode(color: LMSA): string;
+export declare function decodeColorCode(code: string): LMSA;
+//# sourceMappingURL=encode.d.ts.map

package/dist/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../src/encode.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,IAAI;IACnB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;CACd;AAoGD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,IAAI,GACV,MAAM,CASR;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,GACX,IAAI,CAsBN"}

package/dist/encode.js

@@ -0,0 +1,60 @@
+const LMS_MIN = -2;
+const LMS_MAX = 2;
+const LMS_BITS = 16;
+const LMS_INT_MAX = 2 ** LMS_BITS - 1;
+const ALPHA_BITS = 8;
+const ALPHA_INT_MAX = 2 ** ALPHA_BITS - 1;
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function encodeLMSChannel(value) {
+    const normalized = (clamp(value, LMS_MIN, LMS_MAX) - LMS_MIN) / (LMS_MAX - LMS_MIN);
+    return Math.round(normalized * LMS_INT_MAX);
+}
+function decodeLMSChannel(value) {
+    const normalized = value / LMS_INT_MAX;
+    return LMS_MIN + normalized * (LMS_MAX - LMS_MIN);
+}
+function encodeAlpha(alpha) {
+    return Math.round(clamp(alpha, 0, 1) * ALPHA_INT_MAX);
+}
+function decodeAlpha(alpha) {
+    return alpha / ALPHA_INT_MAX;
+}
+function encodeLMSA({ l, m, s, alpha }) {
+    const L = BigInt(encodeLMSChannel(l));
+    const M = BigInt(encodeLMSChannel(m));
+    const S = BigInt(encodeLMSChannel(s));
+    const A = BigInt(encodeAlpha(alpha));
+    return L << 40n | M << 24n | S << 8n | A;
+}
+function decodeLMSA(value) {
+    const L = Number(value >> 40n & 0xffffn);
+    const M = Number(value >> 24n & 0xffffn);
+    const S = Number(value >> 8n & 0xffffn);
+    const A = Number(0xffn & value);
+    return {
+        l: decodeLMSChannel(L),
+        m: decodeLMSChannel(M),
+        s: decodeLMSChannel(S),
+        alpha: decodeAlpha(A)
+    };
+}
+const VERSION = '1';
+function encodeColorCode(color) {
+    const encoded = encodeLMSA(color);
+    const hex = encoded.toString(16).padStart(14, '0').toUpperCase();
+    return `L${VERSION}${hex}`;
+}
+function decodeColorCode(code) {
+    const match = /^L(\d)([0-9A-Fa-f]{14})$/.exec(code);
+    if (!match) throw new Error(`Invalid color code: ${code}`);
+    const [, version, hex] = match;
+    switch(version){
+        case '1':
+            return decodeLMSA(BigInt(`0x${hex}`));
+        default:
+            throw new Error(`Unsupported color code version: ${version}`);
+    }
+}
+export { decodeColorCode, encodeColorCode };

package/dist/gamut/inGamut.d.ts

@@ -0,0 +1,6 @@
+import type { RGBGamut } from './types';
+export declare function isRGBInGamut(rgb: [number, number, number, number], epsilon?: number): boolean;
+export declare function lmsToGamutRGB(lms: [number, number, number, number], gamut: RGBGamut): [number, number, number, number];
+export declare function gamutRGBToLMS(rgb: [number, number, number, number], gamut: RGBGamut): [number, number, number, number];
+export declare function inGamut(lms: [number, number, number, number], gamut: RGBGamut, epsilon?: number): boolean;
+//# sourceMappingURL=inGamut.d.ts.map

package/dist/gamut/inGamut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inGamut.d.ts","sourceRoot":"","sources":["../../src/gamut/inGamut.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAKvC,wBAAgB,YAAY,CAC1B,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACrC,OAAO,SAAO,GACb,OAAO,CAST;AAED,wBAAgB,aAAa,CAC3B,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACrC,KAAK,EAAE,QAAQ,GACd,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAQlC;AAED,wBAAgB,aAAa,CAC3B,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACrC,KAAK,EAAE,QAAQ,GACd,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAQlC;AAED,wBAAgB,OAAO,CACrB,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACrC,KAAK,EAAE,QAAQ,EACf,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAKT"}