html2canvas-pro 2.1.0 → 2.2.0

package/src/css/types/color.ts

@@ -1,485 +0,0 @@
-import { CSSValue, isIdentToken, isNumberToken, nonFunctionArgSeparator, Parser } from '../syntax/parser';
-import { HashToken, TokenType } from '../syntax/tokenizer';
-import { ITypeDescriptor } from '../type-descriptor';
-import { Context } from '../../core/context';
-import { srgbFromXYZ, srgbLinearFromXYZ } from './color-spaces/srgb';
-import {
-    packSrgbLinear,
-    packSrgb,
-    packHSL,
-    packLch,
-    packOkLch,
-    packOkLab,
-    packLab,
-    isRelativeTransform,
-    pack,
-    getTokenColorValue,
-    convertXyz,
-    convertXyz50,
-    rgbToXyz,
-    hslToXyz,
-    labToXyz,
-    lchToXyz,
-    oklabToXyz,
-    oklchToXyz,
-    xyzFromXYZ,
-    xyz50FromXYZ
-} from './color-utilities';
-import { convertP3, p3FromXYZ } from './color-spaces/p3';
-import { a98FromXYZ, convertA98rgb } from './color-spaces/a98';
-import { convertProPhoto, proPhotoFromXYZ } from './color-spaces/pro-photo';
-import { convertRec2020, rec2020FromXYZ } from './color-spaces/rec2020';
-
-export type Color = number;
-
-export const color: ITypeDescriptor<Color> = {
-    name: 'color',
-    parse: (context: Context, value: CSSValue): Color => {
-        if (value.type === TokenType.FUNCTION) {
-            const colorFunction = SUPPORTED_COLOR_FUNCTIONS[value.name];
-            if (typeof colorFunction === 'undefined') {
-                throw new Error(`Attempting to parse an unsupported color function "${value.name}"`);
-            }
-            return colorFunction(context, value.values);
-        }
-
-        if (value.type === TokenType.HASH_TOKEN) {
-            const [r, g, b, a] = hash2rgb(value);
-            return pack(r, g, b, a);
-        }
-
-        if (value.type === TokenType.IDENT_TOKEN) {
-            const namedColor = COLORS[value.value.toUpperCase()];
-            if (typeof namedColor !== 'undefined') {
-                return namedColor;
-            }
-        }
-
-        return COLORS.TRANSPARENT;
-    }
-};
-
-const hash2rgb = (token: HashToken): [number, number, number, number] => {
-    if (token.value.length === 3) {
-        const r = token.value.substring(0, 1);
-        const g = token.value.substring(1, 2);
-        const b = token.value.substring(2, 3);
-        return [parseInt(r + r, 16), parseInt(g + g, 16), parseInt(b + b, 16), 1];
-    }
-
-    if (token.value.length === 4) {
-        const r = token.value.substring(0, 1);
-        const g = token.value.substring(1, 2);
-        const b = token.value.substring(2, 3);
-        const a = token.value.substring(3, 4);
-        return [parseInt(r + r, 16), parseInt(g + g, 16), parseInt(b + b, 16), parseInt(a + a, 16) / 255];
-    }
-
-    if (token.value.length === 6) {
-        const r = token.value.substring(0, 2);
-        const g = token.value.substring(2, 4);
-        const b = token.value.substring(4, 6);
-        return [parseInt(r, 16), parseInt(g, 16), parseInt(b, 16), 1];
-    }
-
-    if (token.value.length === 8) {
-        const r = token.value.substring(0, 2);
-        const g = token.value.substring(2, 4);
-        const b = token.value.substring(4, 6);
-        const a = token.value.substring(6, 8);
-        return [parseInt(r, 16), parseInt(g, 16), parseInt(b, 16), parseInt(a, 16) / 255];
-    }
-
-    return [0, 0, 0, 1];
-};
-
-const rgb = (_context: Context, args: CSSValue[]): number => {
-    const tokens = args.filter(nonFunctionArgSeparator);
-
-    if (isRelativeTransform(tokens)) {
-        throw new Error('Relative color not supported for rgb()');
-    }
-
-    if (tokens.length === 3) {
-        const [r, g, b] = tokens.map(getTokenColorValue);
-        return pack(r, g, b, 1);
-    }
-
-    if (tokens.length === 4) {
-        const [r, g, b, a] = tokens.map(getTokenColorValue);
-        return pack(r, g, b, a);
-    }
-
-    // Handle modern CSS syntax with / separator: rgb(r g b / alpha)
-    // tokens[0] = r, tokens[1] = g, tokens[2] = b, tokens[3] = '/', tokens[4] = alpha
-    if (tokens.length === 5 && tokens[3].type === TokenType.DELIM_TOKEN && tokens[3].value === '/') {
-        const r = getTokenColorValue(tokens[0], 0);
-        const g = getTokenColorValue(tokens[1], 1);
-        const b = getTokenColorValue(tokens[2], 2);
-        const a = getTokenColorValue(tokens[4], 3);
-        return pack(r, g, b, a);
-    }
-
-    return 0;
-};
-
-/**
- * Handle the CSS color() function
- *
- * @param context
- * @param args
- */
-const _color = (context: Context, args: CSSValue[]) => {
-    const tokens = args.filter(nonFunctionArgSeparator),
-        token_1_value = tokens[0].type === TokenType.IDENT_TOKEN ? tokens[0].value : 'unknown',
-        is_absolute = !isRelativeTransform(tokens);
-
-    if (is_absolute) {
-        const color_space = token_1_value,
-            colorSpaceFunction = SUPPORTED_COLOR_SPACES_ABSOLUTE[color_space];
-        if (typeof colorSpaceFunction === 'undefined') {
-            throw new Error(`Attempting to parse an unsupported color space "${color_space}" for color() function`);
-        }
-        const c1 = isNumberToken(tokens[1]) ? tokens[1].number : 0,
-            c2 = isNumberToken(tokens[2]) ? tokens[2].number : 0,
-            c3 = isNumberToken(tokens[3]) ? tokens[3].number : 0,
-            a =
-                tokens.length > 4 &&
-                tokens[4].type === TokenType.DELIM_TOKEN &&
-                tokens[4].value === '/' &&
-                isNumberToken(tokens[5])
-                    ? tokens[5].number
-                    : 1;
-
-        return colorSpaceFunction([c1, c2, c3, a]);
-    } else {
-        const extractComponent = (color: [number, number, number, number], token: CSSValue) => {
-            if (isNumberToken(token)) {
-                return token.number;
-            }
-
-            const posFromVal = (value: string): number => {
-                return value === 'r' || value === 'x' ? 0 : value === 'g' || value === 'y' ? 1 : 2;
-            };
-
-            if (isIdentToken(token)) {
-                const position = posFromVal(token.value);
-                return color[position];
-            }
-
-            const parseCalc = (args: CSSValue[]): string => {
-                const parts = args.filter(nonFunctionArgSeparator);
-                let expression = '(';
-                for (const part of parts) {
-                    expression +=
-                        part.type === TokenType.FUNCTION && part.name === 'calc'
-                            ? parseCalc(part.values)
-                            : isNumberToken(part)
-                              ? part.number
-                              : part.type === TokenType.DELIM_TOKEN || isIdentToken(part)
-                                ? part.value
-                                : '';
-                }
-                expression += ')';
-                return expression;
-            };
-
-            if (token.type === TokenType.FUNCTION) {
-                const args = token.values.filter(nonFunctionArgSeparator);
-                if (token.name === 'calc') {
-                    const expression = parseCalc(args)
-                        .replace(/r|x/, color[0].toString())
-                        .replace(/g|y/, color[1].toString())
-                        .replace(/b|z/, color[2].toString());
-
-                    return new Function('return ' + expression)();
-                }
-            }
-
-            return null;
-        };
-
-        const from_colorspace =
-                tokens[1].type === TokenType.FUNCTION
-                    ? tokens[1].name
-                    : isIdentToken(tokens[1]) || tokens[1].type === TokenType.HASH_TOKEN
-                      ? 'rgb'
-                      : 'unknown',
-            to_colorspace = isIdentToken(tokens[2]) ? tokens[2].value : 'unknown';
-
-        let from =
-            tokens[1].type === TokenType.FUNCTION ? tokens[1].values : isIdentToken(tokens[1]) ? [tokens[1]] : [];
-
-        if (isIdentToken(tokens[1])) {
-            const named_color = COLORS[tokens[1].value.toUpperCase()];
-            if (typeof named_color === 'undefined') {
-                throw new Error(`Attempting to use unknown color in relative color 'from'`);
-            } else {
-                const _c = parseColor(context, tokens[1].value),
-                    alpha = 0xff & _c,
-                    blue = 0xff & (_c >> 8),
-                    green = 0xff & (_c >> 16),
-                    red = 0xff & (_c >> 24);
-                from = [
-                    { type: TokenType.NUMBER_TOKEN, number: red, flags: 1 },
-                    { type: TokenType.NUMBER_TOKEN, number: green, flags: 1 },
-                    { type: TokenType.NUMBER_TOKEN, number: blue, flags: 1 },
-                    { type: TokenType.NUMBER_TOKEN, number: alpha > 1 ? alpha / 255 : alpha, flags: 1 }
-                ];
-            }
-        } else if (tokens[1].type === TokenType.HASH_TOKEN) {
-            const [red, green, blue, alpha] = hash2rgb(tokens[1]);
-            from = [
-                { type: TokenType.NUMBER_TOKEN, number: red, flags: 1 },
-                { type: TokenType.NUMBER_TOKEN, number: green, flags: 1 },
-                { type: TokenType.NUMBER_TOKEN, number: blue, flags: 1 },
-                { type: TokenType.NUMBER_TOKEN, number: alpha > 1 ? alpha / 255 : alpha, flags: 1 }
-            ];
-        }
-
-        if (from.length === 0) {
-            throw new Error(`Attempting to use unknown color in relative color 'from'`);
-        }
-
-        if (to_colorspace === 'unknown') {
-            throw new Error(`Attempting to use unknown colorspace in relative color 'to'`);
-        }
-
-        const fromColorToXyz = SUPPORTED_COLOR_SPACES_TO_XYZ[from_colorspace],
-            toColorFromXyz = SUPPORTED_COLOR_SPACES_FROM_XYZ[to_colorspace],
-            toColorPack = SUPPORTED_COLOR_SPACES_ABSOLUTE[to_colorspace];
-
-        if (typeof fromColorToXyz === 'undefined') {
-            throw new Error(`Attempting to parse an unsupported color space "${from_colorspace}" for color() function`);
-        }
-        if (typeof toColorFromXyz === 'undefined') {
-            throw new Error(`Attempting to parse an unsupported color space "${to_colorspace}" for color() function`);
-        }
-
-        const from_color: [number, number, number, number] = fromColorToXyz(context, from),
-            from_final_colorspace: [number, number, number, number] = toColorFromXyz(from_color),
-            c1 = extractComponent(from_final_colorspace, tokens[3]),
-            c2 = extractComponent(from_final_colorspace, tokens[4]),
-            c3 = extractComponent(from_final_colorspace, tokens[5]),
-            a =
-                tokens.length > 6 &&
-                tokens[6].type === TokenType.DELIM_TOKEN &&
-                tokens[6].value === '/' &&
-                isNumberToken(tokens[7])
-                    ? tokens[7].number
-                    : 1;
-        if (c1 === null || c2 === null || c3 === null) {
-            throw new Error(`Invalid relative color in color() function`);
-        }
-
-        return toColorPack([c1, c2, c3, a]);
-    }
-};
-
-const SUPPORTED_COLOR_SPACES_ABSOLUTE: {
-    [key: string]: (args: number[]) => number;
-} = {
-    srgb: packSrgb,
-    'srgb-linear': packSrgbLinear,
-    'display-p3': convertP3,
-    'a98-rgb': convertA98rgb,
-    'prophoto-rgb': convertProPhoto,
-    xyz: convertXyz,
-    'xyz-d50': convertXyz50,
-    'xyz-d65': convertXyz,
-    rec2020: convertRec2020
-};
-
-const SUPPORTED_COLOR_SPACES_TO_XYZ: {
-    [key: string]: (context: Context, args: CSSValue[]) => [number, number, number, number];
-} = {
-    rgb: rgbToXyz,
-    hsl: hslToXyz,
-    lab: labToXyz,
-    lch: lchToXyz,
-    oklab: oklabToXyz,
-    oklch: oklchToXyz
-};
-
-const SUPPORTED_COLOR_SPACES_FROM_XYZ: {
-    [key: string]: (args: [number, number, number, number]) => [number, number, number, number];
-} = {
-    srgb: srgbFromXYZ,
-    'srgb-linear': srgbLinearFromXYZ,
-    'display-p3': p3FromXYZ,
-    'a98-rgb': a98FromXYZ,
-    'prophoto-rgb': proPhotoFromXYZ,
-    xyz: xyzFromXYZ,
-    'xyz-d50': xyz50FromXYZ,
-    'xyz-d65': xyzFromXYZ,
-    rec2020: rec2020FromXYZ
-};
-
-const SUPPORTED_COLOR_FUNCTIONS: {
-    [key: string]: (context: Context, args: CSSValue[]) => number;
-} = {
-    hsl: packHSL,
-    hsla: packHSL,
-    rgb: rgb,
-    rgba: rgb,
-    lch: packLch,
-    oklch: packOkLch,
-    oklab: packOkLab,
-    lab: packLab,
-    color: _color
-};
-
-export const parseColor = (context: Context, value: string): Color =>
-    color.parse(context, Parser.create(value).parseComponentValue());
-
-export const COLORS: { [key: string]: Color } = {
-    ALICEBLUE: 0xf0f8ffff,
-    ANTIQUEWHITE: 0xfaebd7ff,
-    AQUA: 0x00ffffff,
-    AQUAMARINE: 0x7fffd4ff,
-    AZURE: 0xf0ffffff,
-    BEIGE: 0xf5f5dcff,
-    BISQUE: 0xffe4c4ff,
-    BLACK: 0x000000ff,
-    BLANCHEDALMOND: 0xffebcdff,
-    BLUE: 0x0000ffff,
-    BLUEVIOLET: 0x8a2be2ff,
-    BROWN: 0xa52a2aff,
-    BURLYWOOD: 0xdeb887ff,
-    CADETBLUE: 0x5f9ea0ff,
-    CHARTREUSE: 0x7fff00ff,
-    CHOCOLATE: 0xd2691eff,
-    CORAL: 0xff7f50ff,
-    CORNFLOWERBLUE: 0x6495edff,
-    CORNSILK: 0xfff8dcff,
-    CRIMSON: 0xdc143cff,
-    CYAN: 0x00ffffff,
-    DARKBLUE: 0x00008bff,
-    DARKCYAN: 0x008b8bff,
-    DARKGOLDENROD: 0xb886bbff,
-    DARKGRAY: 0xa9a9a9ff,
-    DARKGREEN: 0x006400ff,
-    DARKGREY: 0xa9a9a9ff,
-    DARKKHAKI: 0xbdb76bff,
-    DARKMAGENTA: 0x8b008bff,
-    DARKOLIVEGREEN: 0x556b2fff,
-    DARKORANGE: 0xff8c00ff,
-    DARKORCHID: 0x9932ccff,
-    DARKRED: 0x8b0000ff,
-    DARKSALMON: 0xe9967aff,
-    DARKSEAGREEN: 0x8fbc8fff,
-    DARKSLATEBLUE: 0x483d8bff,
-    DARKSLATEGRAY: 0x2f4f4fff,
-    DARKSLATEGREY: 0x2f4f4fff,
-    DARKTURQUOISE: 0x00ced1ff,
-    DARKVIOLET: 0x9400d3ff,
-    DEEPPINK: 0xff1493ff,
-    DEEPSKYBLUE: 0x00bfffff,
-    DIMGRAY: 0x696969ff,
-    DIMGREY: 0x696969ff,
-    DODGERBLUE: 0x1e90ffff,
-    FIREBRICK: 0xb22222ff,
-    FLORALWHITE: 0xfffaf0ff,
-    FORESTGREEN: 0x228b22ff,
-    FUCHSIA: 0xff00ffff,
-    GAINSBORO: 0xdcdcdcff,
-    GHOSTWHITE: 0xf8f8ffff,
-    GOLD: 0xffd700ff,
-    GOLDENROD: 0xdaa520ff,
-    GRAY: 0x808080ff,
-    GREEN: 0x008000ff,
-    GREENYELLOW: 0xadff2fff,
-    GREY: 0x808080ff,
-    HONEYDEW: 0xf0fff0ff,
-    HOTPINK: 0xff69b4ff,
-    INDIANRED: 0xcd5c5cff,
-    INDIGO: 0x4b0082ff,
-    IVORY: 0xfffff0ff,
-    KHAKI: 0xf0e68cff,
-    LAVENDER: 0xe6e6faff,
-    LAVENDERBLUSH: 0xfff0f5ff,
-    LAWNGREEN: 0x7cfc00ff,
-    LEMONCHIFFON: 0xfffacdff,
-    LIGHTBLUE: 0xadd8e6ff,
-    LIGHTCORAL: 0xf08080ff,
-    LIGHTCYAN: 0xe0ffffff,
-    LIGHTGOLDENRODYELLOW: 0xfafad2ff,
-    LIGHTGRAY: 0xd3d3d3ff,
-    LIGHTGREEN: 0x90ee90ff,
-    LIGHTGREY: 0xd3d3d3ff,
-    LIGHTPINK: 0xffb6c1ff,
-    LIGHTSALMON: 0xffa07aff,
-    LIGHTSEAGREEN: 0x20b2aaff,
-    LIGHTSKYBLUE: 0x87cefaff,
-    LIGHTSLATEGRAY: 0x778899ff,
-    LIGHTSLATEGREY: 0x778899ff,
-    LIGHTSTEELBLUE: 0xb0c4deff,
-    LIGHTYELLOW: 0xffffe0ff,
-    LIME: 0x00ff00ff,
-    LIMEGREEN: 0x32cd32ff,
-    LINEN: 0xfaf0e6ff,
-    MAGENTA: 0xff00ffff,
-    MAROON: 0x800000ff,
-    MEDIUMAQUAMARINE: 0x66cdaaff,
-    MEDIUMBLUE: 0x0000cdff,
-    MEDIUMORCHID: 0xba55d3ff,
-    MEDIUMPURPLE: 0x9370dbff,
-    MEDIUMSEAGREEN: 0x3cb371ff,
-    MEDIUMSLATEBLUE: 0x7b68eeff,
-    MEDIUMSPRINGGREEN: 0x00fa9aff,
-    MEDIUMTURQUOISE: 0x48d1ccff,
-    MEDIUMVIOLETRED: 0xc71585ff,
-    MIDNIGHTBLUE: 0x191970ff,
-    MINTCREAM: 0xf5fffaff,
-    MISTYROSE: 0xffe4e1ff,
-    MOCCASIN: 0xffe4b5ff,
-    NAVAJOWHITE: 0xffdeadff,
-    NAVY: 0x000080ff,
-    OLDLACE: 0xfdf5e6ff,
-    OLIVE: 0x808000ff,
-    OLIVEDRAB: 0x6b8e23ff,
-    ORANGE: 0xffa500ff,
-    ORANGERED: 0xff4500ff,
-    ORCHID: 0xda70d6ff,
-    PALEGOLDENROD: 0xeee8aaff,
-    PALEGREEN: 0x98fb98ff,
-    PALETURQUOISE: 0xafeeeeff,
-    PALEVIOLETRED: 0xdb7093ff,
-    PAPAYAWHIP: 0xffefd5ff,
-    PEACHPUFF: 0xffdab9ff,
-    PERU: 0xcd853fff,
-    PINK: 0xffc0cbff,
-    PLUM: 0xdda0ddff,
-    POWDERBLUE: 0xb0e0e6ff,
-    PURPLE: 0x800080ff,
-    REBECCAPURPLE: 0x663399ff,
-    RED: 0xff0000ff,
-    ROSYBROWN: 0xbc8f8fff,
-    ROYALBLUE: 0x4169e1ff,
-    SADDLEBROWN: 0x8b4513ff,
-    SALMON: 0xfa8072ff,
-    SANDYBROWN: 0xf4a460ff,
-    SEAGREEN: 0x2e8b57ff,
-    SEASHELL: 0xfff5eeff,
-    SIENNA: 0xa0522dff,
-    SILVER: 0xc0c0c0ff,
-    SKYBLUE: 0x87ceebff,
-    SLATEBLUE: 0x6a5acdff,
-    SLATEGRAY: 0x708090ff,
-    SLATEGREY: 0x708090ff,
-    SNOW: 0xfffafaff,
-    SPRINGGREEN: 0x00ff7fff,
-    STEELBLUE: 0x4682b4ff,
-    TAN: 0xd2b48cff,
-    TEAL: 0x008080ff,
-    THISTLE: 0xd8bfd8ff,
-    TOMATO: 0xff6347ff,
-    TRANSPARENT: 0x00000000,
-    TURQUOISE: 0x40e0d0ff,
-    VIOLET: 0xee82eeff,
-    WHEAT: 0xf5deb3ff,
-    WHITE: 0xffffffff,
-    WHITESMOKE: 0xf5f5f5ff,
-    YELLOW: 0xffff00ff,
-    YELLOWGREEN: 0x9acd32ff
-};

package/src/css/types/functions/-prefix-linear-gradient.ts

@@ -1,35 +0,0 @@
-import { CSSValue, parseFunctionArgs } from '../../syntax/parser';
-import { CSSImageType, CSSLinearGradientImage, GradientCorner, UnprocessedGradientColorStop } from '../image';
-import { TokenType } from '../../syntax/tokenizer';
-import { isAngle, angle as angleType, parseNamedSide, deg } from '../angle';
-import { parseColorStop } from './gradient';
-import { Context } from '../../../core/context';
-
-export const prefixLinearGradient = (context: Context, tokens: CSSValue[]): CSSLinearGradientImage => {
-    let angle: number | GradientCorner = deg(180);
-    const stops: UnprocessedGradientColorStop[] = [];
-
-    parseFunctionArgs(tokens).forEach((arg, i) => {
-        if (i === 0) {
-            const firstToken = arg[0];
-            if (
-                firstToken.type === TokenType.IDENT_TOKEN &&
-                ['top', 'left', 'right', 'bottom'].indexOf(firstToken.value) !== -1
-            ) {
-                angle = parseNamedSide(arg);
-                return;
-            } else if (isAngle(firstToken)) {
-                angle = (angleType.parse(context, firstToken) + deg(270)) % deg(360);
-                return;
-            }
-        }
-        const colorStop = parseColorStop(context, arg);
-        stops.push(colorStop);
-    });
-
-    return {
-        angle,
-        stops,
-        type: CSSImageType.LINEAR_GRADIENT
-    };
-};

package/src/css/types/functions/-prefix-radial-gradient.ts

@@ -1,106 +0,0 @@
-import { CSSValue, isIdentToken, parseFunctionArgs } from '../../syntax/parser';
-import {
-    CSSImageType,
-    CSSRadialExtent,
-    CSSRadialGradientImage,
-    CSSRadialShape,
-    CSSRadialSize,
-    UnprocessedGradientColorStop
-} from '../image';
-import { parseColorStop } from './gradient';
-import {
-    FIFTY_PERCENT,
-    HUNDRED_PERCENT,
-    isLengthPercentage,
-    LengthPercentage,
-    ZERO_LENGTH
-} from '../length-percentage';
-import { isLength } from '../length';
-import {
-    CIRCLE,
-    CLOSEST_CORNER,
-    CLOSEST_SIDE,
-    CONTAIN,
-    COVER,
-    ELLIPSE,
-    FARTHEST_CORNER,
-    FARTHEST_SIDE
-} from './radial-gradient';
-import { Context } from '../../../core/context';
-
-export const prefixRadialGradient = (context: Context, tokens: CSSValue[]): CSSRadialGradientImage => {
-    let shape: CSSRadialShape = CSSRadialShape.CIRCLE;
-    let size: CSSRadialSize = CSSRadialExtent.FARTHEST_CORNER;
-    const stops: UnprocessedGradientColorStop[] = [];
-    const position: LengthPercentage[] = [];
-
-    parseFunctionArgs(tokens).forEach((arg, i) => {
-        let isColorStop = true;
-        if (i === 0) {
-            isColorStop = arg.reduce((acc, token) => {
-                if (isIdentToken(token)) {
-                    switch (token.value) {
-                        case 'center':
-                            position.push(FIFTY_PERCENT);
-                            return false;
-                        case 'top':
-                        case 'left':
-                            position.push(ZERO_LENGTH);
-                            return false;
-                        case 'right':
-                        case 'bottom':
-                            position.push(HUNDRED_PERCENT);
-                            return false;
-                    }
-                } else if (isLengthPercentage(token) || isLength(token)) {
-                    position.push(token);
-                    return false;
-                }
-
-                return acc;
-            }, isColorStop);
-        } else if (i === 1) {
-            isColorStop = arg.reduce((acc, token) => {
-                if (isIdentToken(token)) {
-                    switch (token.value) {
-                        case CIRCLE:
-                            shape = CSSRadialShape.CIRCLE;
-                            return false;
-                        case ELLIPSE:
-                            shape = CSSRadialShape.ELLIPSE;
-                            return false;
-                        case CONTAIN:
-                        case CLOSEST_SIDE:
-                            size = CSSRadialExtent.CLOSEST_SIDE;
-                            return false;
-                        case FARTHEST_SIDE:
-                            size = CSSRadialExtent.FARTHEST_SIDE;
-                            return false;
-                        case CLOSEST_CORNER:
-                            size = CSSRadialExtent.CLOSEST_CORNER;
-                            return false;
-                        case COVER:
-                        case FARTHEST_CORNER:
-                            size = CSSRadialExtent.FARTHEST_CORNER;
-                            return false;
-                    }
-                } else if (isLength(token) || isLengthPercentage(token)) {
-                    if (!Array.isArray(size)) {
-                        size = [];
-                    }
-                    size.push(token);
-                    return false;
-                }
-
-                return acc;
-            }, isColorStop);
-        }
-
-        if (isColorStop) {
-            const colorStop = parseColorStop(context, arg);
-            stops.push(colorStop);
-        }
-    });
-
-    return { size, shape, stops, position, type: CSSImageType.RADIAL_GRADIENT };
-};

package/src/css/types/functions/-webkit-gradient.ts

@@ -1,69 +0,0 @@
-import { CSSValue, isIdentToken, isNumberToken, nonFunctionArgSeparator, parseFunctionArgs } from '../../syntax/parser';
-import {
-    CSSImageType,
-    CSSLinearGradientImage,
-    CSSRadialExtent,
-    CSSRadialGradientImage,
-    CSSRadialShape,
-    CSSRadialSize,
-    UnprocessedGradientColorStop
-} from '../image';
-import { deg } from '../angle';
-import { TokenType } from '../../syntax/tokenizer';
-import { color as colorType } from '../color';
-import { HUNDRED_PERCENT, LengthPercentage, ZERO_LENGTH } from '../length-percentage';
-import { Context } from '../../../core/context';
-
-export const webkitGradient = (
-    context: Context,
-    tokens: CSSValue[]
-): CSSLinearGradientImage | CSSRadialGradientImage => {
-    const angle = deg(180);
-    const stops: UnprocessedGradientColorStop[] = [];
-    let type = CSSImageType.LINEAR_GRADIENT;
-    const shape: CSSRadialShape = CSSRadialShape.CIRCLE;
-    const size: CSSRadialSize = CSSRadialExtent.FARTHEST_CORNER;
-    const position: LengthPercentage[] = [];
-    parseFunctionArgs(tokens).forEach((arg, i) => {
-        const firstToken = arg[0];
-        if (i === 0) {
-            if (isIdentToken(firstToken) && firstToken.value === 'linear') {
-                type = CSSImageType.LINEAR_GRADIENT;
-                return;
-            } else if (isIdentToken(firstToken) && firstToken.value === 'radial') {
-                type = CSSImageType.RADIAL_GRADIENT;
-                return;
-            }
-        }
-
-        if (firstToken.type === TokenType.FUNCTION) {
-            if (firstToken.name === 'from') {
-                const color = colorType.parse(context, firstToken.values[0]);
-                stops.push({ stop: ZERO_LENGTH, color });
-            } else if (firstToken.name === 'to') {
-                const color = colorType.parse(context, firstToken.values[0]);
-                stops.push({ stop: HUNDRED_PERCENT, color });
-            } else if (firstToken.name === 'color-stop') {
-                const values = firstToken.values.filter(nonFunctionArgSeparator);
-                if (values.length === 2) {
-                    const color = colorType.parse(context, values[1]);
-                    const stop = values[0];
-                    if (isNumberToken(stop)) {
-                        stops.push({
-                            stop: { type: TokenType.PERCENTAGE_TOKEN, number: stop.number * 100, flags: stop.flags },
-                            color
-                        });
-                    }
-                }
-            }
-        }
-    });
-
-    return type === CSSImageType.LINEAR_GRADIENT
-        ? {
-              angle: (angle + deg(180)) % deg(360),
-              stops,
-              type
-          }
-        : { size, shape, stops, position, type };
-};