@opensumi/ide-theme 2.12.1-next-079c1930

package/lib/common/color.d.ts

@@ -0,0 +1,163 @@
+export declare class RGBA {
+    _rgbaBrand: void;
+    /**
+     * Red: integer in [0-255]
+     */
+    readonly r: number;
+    /**
+     * Green: integer in [0-255]
+     */
+    readonly g: number;
+    /**
+     * Blue: integer in [0-255]
+     */
+    readonly b: number;
+    /**
+     * Alpha: float in [0-1]
+     */
+    readonly a: number;
+    constructor(r: number, g: number, b: number, a?: number);
+    static equals(a: RGBA, b: RGBA): boolean;
+}
+export declare class HSLA {
+    _hslaBrand: void;
+    /**
+     * Hue: integer in [0, 360]
+     */
+    readonly h: number;
+    /**
+     * Saturation: float in [0, 1]
+     */
+    readonly s: number;
+    /**
+     * Luminosity: float in [0, 1]
+     */
+    readonly l: number;
+    /**
+     * Alpha: float in [0, 1]
+     */
+    readonly a: number;
+    constructor(h: number, s: number, l: number, a: number);
+    static equals(a: HSLA, b: HSLA): boolean;
+    /**
+     * Converts an RGB color value to HSL. Conversion formula
+     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+     * Assumes r, g, and b are contained in the set [0, 255] and
+     * returns h in the set [0, 360], s, and l in the set [0, 1].
+     */
+    static fromRGBA(rgba: RGBA): HSLA;
+    private static _hue2rgb;
+    /**
+     * Converts an HSL color value to RGB. Conversion formula
+     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+     * Assumes h in the set [0, 360] s, and l are contained in the set [0, 1] and
+     * returns r, g, and b in the set [0, 255].
+     */
+    static toRGBA(hsla: HSLA): RGBA;
+}
+export declare class HSVA {
+    _hsvaBrand: void;
+    /**
+     * Hue: integer in [0, 360]
+     */
+    readonly h: number;
+    /**
+     * Saturation: float in [0, 1]
+     */
+    readonly s: number;
+    /**
+     * Value: float in [0, 1]
+     */
+    readonly v: number;
+    /**
+     * Alpha: float in [0, 1]
+     */
+    readonly a: number;
+    constructor(h: number, s: number, v: number, a: number);
+    static equals(a: HSVA, b: HSVA): boolean;
+    static fromRGBA(rgba: RGBA): HSVA;
+    static toRGBA(hsva: HSVA): RGBA;
+}
+export declare class Color {
+    static fromHex(hex: string): Color;
+    readonly rgba: RGBA;
+    private _hsla?;
+    get hsla(): HSLA;
+    private _hsva?;
+    get hsva(): HSVA;
+    constructor(arg: RGBA | HSLA | HSVA);
+    equals(other: Color): boolean;
+    /**
+     * http://www.w3.org/TR/WCAG20/#relativeluminancedef
+     * Returns the number in the set [0, 1]. O => Darkest Black. 1 => Lightest white.
+     */
+    getRelativeLuminance(): number;
+    private static _relativeLuminanceForComponent;
+    /**
+     * http://www.w3.org/TR/WCAG20/#contrast-ratiodef
+     * Returns the contrast ration number in the set [1, 21].
+     */
+    getContrastRatio(another: Color): number;
+    /**
+     *	http://24ways.org/2010/calculating-color-contrast
+     *  Return 'true' if darker color otherwise 'false'
+     */
+    isDarker(): boolean;
+    /**
+     *	http://24ways.org/2010/calculating-color-contrast
+     *  Return 'true' if lighter color otherwise 'false'
+     */
+    isLighter(): boolean;
+    isLighterThan(another: Color): boolean;
+    isDarkerThan(another: Color): boolean;
+    lighten(factor: number): Color;
+    darken(factor: number): Color;
+    transparent(factor: number): Color;
+    isTransparent(): boolean;
+    isOpaque(): boolean;
+    opposite(): Color;
+    blend(c: Color): Color;
+    flatten(...backgrounds: Color[]): Color;
+    private static _flatten;
+    toString(): string;
+    static getLighterColor(of: Color, relative: Color, factor?: number): Color;
+    static getDarkerColor(of: Color, relative: Color, factor?: number): Color;
+    static readonly white: Color;
+    static readonly black: Color;
+    static readonly red: Color;
+    static readonly blue: Color;
+    static readonly green: Color;
+    static readonly cyan: Color;
+    static readonly lightgrey: Color;
+    static readonly transparent: Color;
+}
+export declare namespace Color {
+    namespace Format {
+        namespace CSS {
+            function formatRGB(color: Color): string;
+            function formatRGBA(color: Color): string;
+            function formatHSL(color: Color): string;
+            function formatHSLA(color: Color): string;
+            /**
+             * Formats the color as #RRGGBB
+             */
+            function formatHex(color: Color): string;
+            /**
+             * Formats the color as #RRGGBBAA
+             * If 'compact' is set, colors without transparancy will be printed as #RRGGBB
+             */
+            function formatHexA(color: Color, compact?: boolean): string;
+            /**
+             * The default format will use HEX if opaque and RGBA otherwise.
+             */
+            function format(color: Color): string | null;
+            /**
+             * Converts an Hex color value to a Color.
+             * returns r, g, and b are contained in the set [0, 255]
+             * @param hex string (#RGB, #RGBA, #RRGGBB or #RRGGBBAA).
+             */
+            function parseHex(hex: string): Color | null;
+        }
+    }
+}
+//# sourceMappingURL=color.d.ts.map

package/lib/common/color.d.ts.map

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

package/lib/common/color.js

@@ -0,0 +1,497 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// Some code copued and modified from https://github.com/microsoft/vscode/blob/1.44.0/src/vs/base/common/color.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color = exports.HSVA = exports.HSLA = exports.RGBA = void 0;
+function roundFloat(num, decimalPoints) {
+    const decimal = Math.pow(10, decimalPoints);
+    return Math.round(num * decimal) / decimal;
+}
+class RGBA {
+    constructor(r, g, b, a = 1) {
+        this.r = Math.min(255, Math.max(0, r)) | 0;
+        this.g = Math.min(255, Math.max(0, g)) | 0;
+        this.b = Math.min(255, Math.max(0, b)) | 0;
+        this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);
+    }
+    static equals(a, b) {
+        return a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a;
+    }
+}
+exports.RGBA = RGBA;
+class HSLA {
+    constructor(h, s, l, a) {
+        this.h = Math.max(Math.min(360, h), 0) | 0;
+        this.s = roundFloat(Math.max(Math.min(1, s), 0), 3);
+        this.l = roundFloat(Math.max(Math.min(1, l), 0), 3);
+        this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);
+    }
+    static equals(a, b) {
+        return a.h === b.h && a.s === b.s && a.l === b.l && a.a === b.a;
+    }
+    /**
+     * Converts an RGB color value to HSL. Conversion formula
+     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+     * Assumes r, g, and b are contained in the set [0, 255] and
+     * returns h in the set [0, 360], s, and l in the set [0, 1].
+     */
+    static fromRGBA(rgba) {
+        const r = rgba.r / 255;
+        const g = rgba.g / 255;
+        const b = rgba.b / 255;
+        const a = rgba.a;
+        const max = Math.max(r, g, b);
+        const min = Math.min(r, g, b);
+        let h = 0;
+        let s = 0;
+        const l = (min + max) / 2;
+        const chroma = max - min;
+        if (chroma > 0) {
+            s = Math.min((l <= 0.5 ? chroma / (2 * l) : chroma / (2 - (2 * l))), 1);
+            switch (max) {
+                case r:
+                    h = (g - b) / chroma + (g < b ? 6 : 0);
+                    break;
+                case g:
+                    h = (b - r) / chroma + 2;
+                    break;
+                case b:
+                    h = (r - g) / chroma + 4;
+                    break;
+            }
+            h *= 60;
+            h = Math.round(h);
+        }
+        return new HSLA(h, s, l, a);
+    }
+    static _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;
+    }
+    /**
+     * Converts an HSL color value to RGB. Conversion formula
+     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+     * Assumes h in the set [0, 360] s, and l are contained in the set [0, 1] and
+     * returns r, g, and b in the set [0, 255].
+     */
+    static toRGBA(hsla) {
+        const h = hsla.h / 360;
+        const { s, l, a } = hsla;
+        let r;
+        let g;
+        let b;
+        if (s === 0) {
+            r = g = b = l; // achromatic
+        }
+        else {
+            const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+            const p = 2 * l - q;
+            r = HSLA._hue2rgb(p, q, h + 1 / 3);
+            g = HSLA._hue2rgb(p, q, h);
+            b = HSLA._hue2rgb(p, q, h - 1 / 3);
+        }
+        return new RGBA(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a);
+    }
+}
+exports.HSLA = HSLA;
+class HSVA {
+    constructor(h, s, v, a) {
+        this.h = Math.max(Math.min(360, h), 0) | 0;
+        this.s = roundFloat(Math.max(Math.min(1, s), 0), 3);
+        this.v = roundFloat(Math.max(Math.min(1, v), 0), 3);
+        this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);
+    }
+    static equals(a, b) {
+        return a.h === b.h && a.s === b.s && a.v === b.v && a.a === b.a;
+    }
+    // from http://www.rapidtables.com/convert/color/rgb-to-hsv.htm
+    static fromRGBA(rgba) {
+        const r = rgba.r / 255;
+        const g = rgba.g / 255;
+        const b = rgba.b / 255;
+        const cmax = Math.max(r, g, b);
+        const cmin = Math.min(r, g, b);
+        const delta = cmax - cmin;
+        const s = cmax === 0 ? 0 : (delta / cmax);
+        let m;
+        if (delta === 0) {
+            m = 0;
+        }
+        else if (cmax === r) {
+            m = ((((g - b) / delta) % 6) + 6) % 6;
+        }
+        else if (cmax === g) {
+            m = ((b - r) / delta) + 2;
+        }
+        else {
+            m = ((r - g) / delta) + 4;
+        }
+        return new HSVA(Math.round(m * 60), s, cmax, rgba.a);
+    }
+    // from http://www.rapidtables.com/convert/color/hsv-to-rgb.htm
+    static toRGBA(hsva) {
+        const { h, s, v, a } = hsva;
+        const c = v * s;
+        const x = c * (1 - Math.abs((h / 60) % 2 - 1));
+        const m = v - c;
+        let [r, g, b] = [0, 0, 0];
+        if (h < 60) {
+            r = c;
+            g = x;
+        }
+        else if (h < 120) {
+            r = x;
+            g = c;
+        }
+        else if (h < 180) {
+            g = c;
+            b = x;
+        }
+        else if (h < 240) {
+            g = x;
+            b = c;
+        }
+        else if (h < 300) {
+            r = x;
+            b = c;
+        }
+        else if (h < 360) {
+            r = c;
+            b = x;
+        }
+        r = Math.round((r + m) * 255);
+        g = Math.round((g + m) * 255);
+        b = Math.round((b + m) * 255);
+        return new RGBA(r, g, b, a);
+    }
+}
+exports.HSVA = HSVA;
+class Color {
+    constructor(arg) {
+        if (!arg) {
+            throw new Error('Color needs a value');
+        }
+        else if (arg instanceof RGBA) {
+            this.rgba = arg;
+        }
+        else if (arg instanceof HSLA) {
+            this._hsla = arg;
+            this.rgba = HSLA.toRGBA(arg);
+        }
+        else if (arg instanceof HSVA) {
+            this._hsva = arg;
+            this.rgba = HSVA.toRGBA(arg);
+        }
+        else {
+            throw new Error('Invalid color ctor argument');
+        }
+    }
+    static fromHex(hex) {
+        return Color.Format.CSS.parseHex(hex) || Color.red;
+    }
+    get hsla() {
+        if (this._hsla) {
+            return this._hsla;
+        }
+        else {
+            return HSLA.fromRGBA(this.rgba);
+        }
+    }
+    get hsva() {
+        if (this._hsva) {
+            return this._hsva;
+        }
+        return HSVA.fromRGBA(this.rgba);
+    }
+    equals(other) {
+        return !!other && RGBA.equals(this.rgba, other.rgba) && HSLA.equals(this.hsla, other.hsla) && HSVA.equals(this.hsva, other.hsva);
+    }
+    /**
+     * http://www.w3.org/TR/WCAG20/#relativeluminancedef
+     * Returns the number in the set [0, 1]. O => Darkest Black. 1 => Lightest white.
+     */
+    getRelativeLuminance() {
+        const R = Color._relativeLuminanceForComponent(this.rgba.r);
+        const G = Color._relativeLuminanceForComponent(this.rgba.g);
+        const B = Color._relativeLuminanceForComponent(this.rgba.b);
+        const luminance = 0.2126 * R + 0.7152 * G + 0.0722 * B;
+        return roundFloat(luminance, 4);
+    }
+    static _relativeLuminanceForComponent(color) {
+        const c = color / 255;
+        return (c <= 0.03928) ? c / 12.92 : Math.pow(((c + 0.055) / 1.055), 2.4);
+    }
+    /**
+     * http://www.w3.org/TR/WCAG20/#contrast-ratiodef
+     * Returns the contrast ration number in the set [1, 21].
+     */
+    getContrastRatio(another) {
+        const lum1 = this.getRelativeLuminance();
+        const lum2 = another.getRelativeLuminance();
+        return lum1 > lum2 ? (lum1 + 0.05) / (lum2 + 0.05) : (lum2 + 0.05) / (lum1 + 0.05);
+    }
+    /**
+     *	http://24ways.org/2010/calculating-color-contrast
+     *  Return 'true' if darker color otherwise 'false'
+     */
+    isDarker() {
+        const yiq = (this.rgba.r * 299 + this.rgba.g * 587 + this.rgba.b * 114) / 1000;
+        return yiq < 128;
+    }
+    /**
+     *	http://24ways.org/2010/calculating-color-contrast
+     *  Return 'true' if lighter color otherwise 'false'
+     */
+    isLighter() {
+        const yiq = (this.rgba.r * 299 + this.rgba.g * 587 + this.rgba.b * 114) / 1000;
+        return yiq >= 128;
+    }
+    isLighterThan(another) {
+        const lum1 = this.getRelativeLuminance();
+        const lum2 = another.getRelativeLuminance();
+        return lum1 > lum2;
+    }
+    isDarkerThan(another) {
+        const lum1 = this.getRelativeLuminance();
+        const lum2 = another.getRelativeLuminance();
+        return lum1 < lum2;
+    }
+    lighten(factor) {
+        return new Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l + this.hsla.l * factor, this.hsla.a));
+    }
+    darken(factor) {
+        return new Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l - this.hsla.l * factor, this.hsla.a));
+    }
+    transparent(factor) {
+        const { r, g, b, a } = this.rgba;
+        return new Color(new RGBA(r, g, b, a * factor));
+    }
+    isTransparent() {
+        return this.rgba.a === 0;
+    }
+    isOpaque() {
+        return this.rgba.a === 1;
+    }
+    opposite() {
+        return new Color(new RGBA(255 - this.rgba.r, 255 - this.rgba.g, 255 - this.rgba.b, this.rgba.a));
+    }
+    blend(c) {
+        const rgba = c.rgba;
+        // Convert to 0..1 opacity
+        const thisA = this.rgba.a;
+        const colorA = rgba.a;
+        const a = thisA + colorA * (1 - thisA);
+        if (a < 1e-6) {
+            return Color.transparent;
+        }
+        const r = this.rgba.r * thisA / a + rgba.r * colorA * (1 - thisA) / a;
+        const g = this.rgba.g * thisA / a + rgba.g * colorA * (1 - thisA) / a;
+        const b = this.rgba.b * thisA / a + rgba.b * colorA * (1 - thisA) / a;
+        return new Color(new RGBA(r, g, b, a));
+    }
+    flatten(...backgrounds) {
+        const background = backgrounds.reduceRight((accumulator, color) => {
+            return Color._flatten(color, accumulator);
+        });
+        return Color._flatten(this, background);
+    }
+    static _flatten(foreground, background) {
+        const backgroundAlpha = 1 - foreground.rgba.a;
+        return new Color(new RGBA(backgroundAlpha * background.rgba.r + foreground.rgba.a * foreground.rgba.r, backgroundAlpha * background.rgba.g + foreground.rgba.a * foreground.rgba.g, backgroundAlpha * background.rgba.b + foreground.rgba.a * foreground.rgba.b));
+    }
+    toString() {
+        return '' + Color.Format.CSS.format(this);
+    }
+    static getLighterColor(of, relative, factor) {
+        if (of.isLighterThan(relative)) {
+            return of;
+        }
+        factor = factor ? factor : 0.5;
+        const lum1 = of.getRelativeLuminance();
+        const lum2 = relative.getRelativeLuminance();
+        factor = factor * (lum2 - lum1) / lum2;
+        return of.lighten(factor);
+    }
+    static getDarkerColor(of, relative, factor) {
+        if (of.isDarkerThan(relative)) {
+            return of;
+        }
+        factor = factor ? factor : 0.5;
+        const lum1 = of.getRelativeLuminance();
+        const lum2 = relative.getRelativeLuminance();
+        factor = factor * (lum1 - lum2) / lum1;
+        return of.darken(factor);
+    }
+}
+exports.Color = Color;
+Color.white = new Color(new RGBA(255, 255, 255, 1));
+Color.black = new Color(new RGBA(0, 0, 0, 1));
+Color.red = new Color(new RGBA(255, 0, 0, 1));
+Color.blue = new Color(new RGBA(0, 0, 255, 1));
+Color.green = new Color(new RGBA(0, 255, 0, 1));
+Color.cyan = new Color(new RGBA(0, 255, 255, 1));
+Color.lightgrey = new Color(new RGBA(211, 211, 211, 1));
+Color.transparent = new Color(new RGBA(0, 0, 0, 0));
+(function (Color) {
+    let Format;
+    (function (Format) {
+        let CSS;
+        (function (CSS) {
+            function formatRGB(color) {
+                if (color.rgba.a === 1) {
+                    return `rgb(${color.rgba.r}, ${color.rgba.g}, ${color.rgba.b})`;
+                }
+                return Color.Format.CSS.formatRGBA(color);
+            }
+            CSS.formatRGB = formatRGB;
+            function formatRGBA(color) {
+                return `rgba(${color.rgba.r}, ${color.rgba.g}, ${color.rgba.b}, ${+(color.rgba.a).toFixed(2)})`;
+            }
+            CSS.formatRGBA = formatRGBA;
+            function formatHSL(color) {
+                if (color.hsla.a === 1) {
+                    return `hsl(${color.hsla.h}, ${(color.hsla.s * 100).toFixed(2)}%, ${(color.hsla.l * 100).toFixed(2)}%)`;
+                }
+                return Color.Format.CSS.formatHSLA(color);
+            }
+            CSS.formatHSL = formatHSL;
+            function formatHSLA(color) {
+                return `hsla(${color.hsla.h}, ${(color.hsla.s * 100).toFixed(2)}%, ${(color.hsla.l * 100).toFixed(2)}%, ${color.hsla.a.toFixed(2)})`;
+            }
+            CSS.formatHSLA = formatHSLA;
+            function _toTwoDigitHex(n) {
+                const r = n.toString(16);
+                return r.length !== 2 ? '0' + r : r;
+            }
+            /**
+             * Formats the color as #RRGGBB
+             */
+            function formatHex(color) {
+                return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}`;
+            }
+            CSS.formatHex = formatHex;
+            /**
+             * Formats the color as #RRGGBBAA
+             * If 'compact' is set, colors without transparancy will be printed as #RRGGBB
+             */
+            function formatHexA(color, compact = false) {
+                if (compact && color.rgba.a === 1) {
+                    return Color.Format.CSS.formatHex(color);
+                }
+                return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}${_toTwoDigitHex(Math.round(color.rgba.a * 255))}`;
+            }
+            CSS.formatHexA = formatHexA;
+            /**
+             * The default format will use HEX if opaque and RGBA otherwise.
+             */
+            function format(color) {
+                if (!color) {
+                    return null;
+                }
+                if (color.isOpaque()) {
+                    return Color.Format.CSS.formatHex(color);
+                }
+                return Color.Format.CSS.formatRGBA(color);
+            }
+            CSS.format = format;
+            /**
+             * Converts an Hex color value to a Color.
+             * returns r, g, and b are contained in the set [0, 255]
+             * @param hex string (#RGB, #RGBA, #RRGGBB or #RRGGBBAA).
+             */
+            function parseHex(hex) {
+                if (!hex) {
+                    // Invalid color
+                    return null;
+                }
+                const length = hex.length;
+                if (length === 0) {
+                    // Invalid color
+                    return null;
+                }
+                if (hex.charCodeAt(0) !== 35 /* Hash */) {
+                    // Does not begin with a #
+                    return null;
+                }
+                if (length === 7) {
+                    // #RRGGBB format
+                    const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));
+                    const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));
+                    const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));
+                    return new Color(new RGBA(r, g, b, 1));
+                }
+                if (length === 9) {
+                    // #RRGGBBAA format
+                    const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));
+                    const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));
+                    const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));
+                    const a = 16 * _parseHexDigit(hex.charCodeAt(7)) + _parseHexDigit(hex.charCodeAt(8));
+                    return new Color(new RGBA(r, g, b, a / 255));
+                }
+                if (length === 4) {
+                    // #RGB format
+                    const r = _parseHexDigit(hex.charCodeAt(1));
+                    const g = _parseHexDigit(hex.charCodeAt(2));
+                    const b = _parseHexDigit(hex.charCodeAt(3));
+                    return new Color(new RGBA(16 * r + r, 16 * g + g, 16 * b + b));
+                }
+                if (length === 5) {
+                    // #RGBA format
+                    const r = _parseHexDigit(hex.charCodeAt(1));
+                    const g = _parseHexDigit(hex.charCodeAt(2));
+                    const b = _parseHexDigit(hex.charCodeAt(3));
+                    const a = _parseHexDigit(hex.charCodeAt(4));
+                    return new Color(new RGBA(16 * r + r, 16 * g + g, 16 * b + b, (16 * a + a) / 255));
+                }
+                // Invalid color
+                return null;
+            }
+            CSS.parseHex = parseHex;
+            function _parseHexDigit(charCode) {
+                switch (charCode) {
+                    case 48 /* Digit0 */: return 0;
+                    case 49 /* Digit1 */: return 1;
+                    case 50 /* Digit2 */: return 2;
+                    case 51 /* Digit3 */: return 3;
+                    case 52 /* Digit4 */: return 4;
+                    case 53 /* Digit5 */: return 5;
+                    case 54 /* Digit6 */: return 6;
+                    case 55 /* Digit7 */: return 7;
+                    case 56 /* Digit8 */: return 8;
+                    case 57 /* Digit9 */: return 9;
+                    case 97 /* a */: return 10;
+                    case 65 /* A */: return 10;
+                    case 98 /* b */: return 11;
+                    case 66 /* B */: return 11;
+                    case 99 /* c */: return 12;
+                    case 67 /* C */: return 12;
+                    case 100 /* d */: return 13;
+                    case 68 /* D */: return 13;
+                    case 101 /* e */: return 14;
+                    case 69 /* E */: return 14;
+                    case 102 /* f */: return 15;
+                    case 70 /* F */: return 15;
+                }
+                return 0;
+            }
+        })(CSS = Format.CSS || (Format.CSS = {}));
+    })(Format = Color.Format || (Color.Format = {}));
+})(Color = exports.Color || (exports.Color = {}));
+//# sourceMappingURL=color.js.map