javascript/NativeScript
1
0
Fork 0
mirror of https://github.com/NativeScript/NativeScript.git synced 2025-08-15 11:01:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

perf: faster color parsing (#9001)

Browse Source
This commit is contained in:
Martin Guillon
2020-11-10 02:00:22 +01:00
committed by GitHub
parent d30b22c9a3
commit c569236357
3 changed files with 196 additions and 341 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
packages/core/color/color-common.ts
View File

@ -23,9 +23,9 @@ export class Color implements definition.Color {
this._argb = argbFromHslOrHsla(arg); this._argb = argbFromHslOrHsla(arg);
} else if (knownColors.isKnownName(arg)) { } else if (knownColors.isKnownName(arg)) {
// The parameter is a known color name // The parameter is a known color name
const hex = knownColors.getKnownColor(arg); const argb = knownColors.getKnownColor(arg);
this._name = arg; this._name = arg;
this._argb = this._argbFromString(hex); this._argb = argb;
} else if (HEX_REGEX.test(arg)) { } else if (HEX_REGEX.test(arg)) {
// The parameter is a "#AARRGGBB" formatted string // The parameter is a "#AARRGGBB" formatted string
const hex = this._normalizeHex(arg); const hex = this._normalizeHex(arg);

296
packages/core/color/known-colors.ts
View File

@ -1,6 +1,10 @@
const _allColors = {}; const _allColors:{[k:string]:number} = {};
function registerColor(name, value): string { function registerColor(name: string | string[], value: number): number {
_allColors[name.toLowerCase()] = value; if (Array.isArray(name)) {
name.forEach(n=>_allColors[n.toLowerCase()] = value)
} else {
_allColors[name.toLowerCase()] = value;
}
return value; return value;
} }
@ -13,7 +17,7 @@ export function isKnownName(name: string) {
return name.toLowerCase() in _allColors; return name.toLowerCase() in _allColors;
} }
export function getKnownColor(name: string): string { export function getKnownColor(name: string): number {
if (!name) { if (!name) {
return undefined; return undefined;
} }
@ -21,145 +25,145 @@ export function getKnownColor(name: string): string {
return _allColors[name.toLowerCase()]; return _allColors[name.toLowerCase()];
} }
export const Transparent = registerColor('Transparent', '#00000000'); export const Transparent = registerColor('Transparent', 0x00000000);
export const AliceBlue = registerColor('AliceBlue', '#F0F8FF'); export const AliceBlue = registerColor('AliceBlue', 0xffF0F8FF);
export const AntiqueWhite = registerColor('AntiqueWhite', '#FAEBD7'); export const AntiqueWhite = registerColor('AntiqueWhite', 0xffFAEBD7);
export const Aqua = registerColor('Aqua', '#00FFFF'); export const Aqua = registerColor('Aqua', 0xff00FFFF);
export const Aquamarine = registerColor('Aquamarine', '#7FFFD4'); export const Aquamarine = registerColor('Aquamarine', 0xff7FFFD4);
export const Azure = registerColor('Azure', '#F0FFFF'); export const Azure = registerColor('Azure', 0xffF0FFFF);
export const Beige = registerColor('Beige', '#F5F5DC'); export const Beige = registerColor('Beige', 0xffF5F5DC);
export const Bisque = registerColor('Bisque', '#FFE4C4'); export const Bisque = registerColor('Bisque', 0xffFFE4C4);
export const Black = registerColor('Black', '#000000'); export const Black = registerColor('Black', 0xff000000);
export const BlanchedAlmond = registerColor('BlanchedAlmond', '#FFEBCD'); export const BlanchedAlmond = registerColor('BlanchedAlmond', 0xffFFEBCD);
export const Blue = registerColor('Blue', '#0000FF'); export const Blue = registerColor('Blue', 0xff0000FF);
export const BlueViolet = registerColor('BlueViolet', '#8A2BE2'); export const BlueViolet = registerColor('BlueViolet', 0xff8A2BE2);
export const Brown = registerColor('Brown', '#A52A2A'); export const Brown = registerColor('Brown', 0xffA52A2A);
export const BurlyWood = registerColor('BurlyWood', '#DEB887'); export const BurlyWood = registerColor('BurlyWood', 0xffDEB887);
export const CadetBlue = registerColor('CadetBlue', '#5F9EA0'); export const CadetBlue = registerColor('CadetBlue', 0xff5F9EA0);
export const Chartreuse = registerColor('Chartreuse', '#7FFF00'); export const Chartreuse = registerColor('Chartreuse', 0xff7FFF00);
export const Chocolate = registerColor('Chocolate', '#D2691E'); export const Chocolate = registerColor('Chocolate', 0xffD2691E);
export const Coral = registerColor('Coral', '#FF7F50'); export const Coral = registerColor('Coral', 0xffFF7F50);
export const CornflowerBlue = registerColor('CornflowerBlue', '#6495ED'); export const CornflowerBlue = registerColor('CornflowerBlue', 0xff6495ED);
export const Cornsilk = registerColor('Cornsilk', '#FFF8DC'); export const Cornsilk = registerColor('Cornsilk', 0xffFFF8DC);
export const Crimson = registerColor('Crimson', '#DC143C'); export const Crimson = registerColor('Crimson', 0xffDC143C);
export const Cyan = registerColor('Cyan', '#00FFFF'); export const Cyan = registerColor('Cyan', 0xff00FFFF);
export const DarkBlue = registerColor('DarkBlue', '#00008B'); export const DarkBlue = registerColor('DarkBlue', 0xff00008B);
export const DarkCyan = registerColor('DarkCyan', '#008B8B'); export const DarkCyan = registerColor('DarkCyan', 0xff008B8B);
export const DarkGoldenRod = registerColor('DarkGoldenRod', '#B8860B'); export const DarkGoldenRod = registerColor('DarkGoldenRod', 0xffB8860B);
export const DarkGray = registerColor('DarkGray', '#A9A9A9'); export const DarkGray = registerColor(['DarkGray', 'DarkGrey'], 0xffA9A9A9);
export const DarkGreen = registerColor('DarkGreen', '#006400'); export const DarkGreen = registerColor('DarkGreen', 0xff006400);
export const DarkKhaki = registerColor('DarkKhaki', '#BDB76B'); export const DarkKhaki = registerColor('DarkKhaki', 0xffBDB76B);
export const DarkMagenta = registerColor('DarkMagenta', '#8B008B'); export const DarkMagenta = registerColor('DarkMagenta', 0xff8B008B);
export const DarkOliveGreen = registerColor('DarkOliveGreen', '#556B2F'); export const DarkOliveGreen = registerColor('DarkOliveGreen', 0xff556B2F);
export const DarkOrange = registerColor('DarkOrange', '#FF8C00'); export const DarkOrange = registerColor('DarkOrange', 0xffFF8C00);
export const DarkOrchid = registerColor('DarkOrchid', '#9932CC'); export const DarkOrchid = registerColor('DarkOrchid', 0xff9932CC);
export const DarkRed = registerColor('DarkRed', '#8B0000'); export const DarkRed = registerColor('DarkRed', 0xff8B0000);
export const DarkSalmon = registerColor('DarkSalmon', '#E9967A'); export const DarkSalmon = registerColor('DarkSalmon', 0xffE9967A);
export const DarkSeaGreen = registerColor('DarkSeaGreen', '#8FBC8F'); export const DarkSeaGreen = registerColor('DarkSeaGreen', 0xff8FBC8F);
export const DarkSlateBlue = registerColor('DarkSlateBlue', '#483D8B'); export const DarkSlateBlue = registerColor('DarkSlateBlue', 0xff483D8B);
export const DarkSlateGray = registerColor('DarkSlateGray', '#2F4F4F'); export const DarkSlateGray = registerColor(['DarkSlateGray', 'DarkSlateGrey'], 0xff2F4F4F);
export const DarkTurquoise = registerColor('DarkTurquoise', '#00CED1'); export const DarkTurquoise = registerColor('DarkTurquoise', 0xff00CED1);
export const DarkViolet = registerColor('DarkViolet', '#9400D3'); export const DarkViolet = registerColor('DarkViolet', 0xff9400D3);
export const DeepPink = registerColor('DeepPink', '#FF1493'); export const DeepPink = registerColor('DeepPink', 0xffFF1493);
export const DeepSkyBlue = registerColor('DeepSkyBlue', '#00BFFF'); export const DeepSkyBlue = registerColor('DeepSkyBlue', 0xff00BFFF);
export const DimGray = registerColor('DimGray', '#696969'); export const DimGray = registerColor(['DimGray', 'DimGrey'], 0xff696969);
export const DodgerBlue = registerColor('DodgerBlue', '#1E90FF'); export const DodgerBlue = registerColor('DodgerBlue', 0xff1E90FF);
export const FireBrick = registerColor('FireBrick', '#B22222'); export const FireBrick = registerColor('FireBrick', 0xffB22222);
export const FloralWhite = registerColor('FloralWhite', '#FFFAF0'); export const FloralWhite = registerColor('FloralWhite', 0xffFFFAF0);
export const ForestGreen = registerColor('ForestGreen', '#228B22'); export const ForestGreen = registerColor('ForestGreen', 0xff228B22);
export const Fuchsia = registerColor('Fuchsia', '#FF00FF'); export const Fuchsia = registerColor('Fuchsia', 0xffFF00FF);
export const Gainsboro = registerColor('Gainsboro', '#DCDCDC'); export const Gainsboro = registerColor('Gainsboro', 0xffDCDCDC);
export const GhostWhite = registerColor('GhostWhite', '#F8F8FF'); export const GhostWhite = registerColor('GhostWhite', 0xffF8F8FF);
export const Gold = registerColor('Gold', '#FFD700'); export const Gold = registerColor('Gold', 0xffFFD700);
export const GoldenRod = registerColor('GoldenRod', '#DAA520'); export const GoldenRod = registerColor('GoldenRod', 0xffDAA520);
export const Gray = registerColor('Gray', '#808080'); export const Gray = registerColor(['Gray', 'Grey'], 0xff808080);
export const Green = registerColor('Green', '#008000'); export const Green = registerColor('Green', 0xff008000);
export const GreenYellow = registerColor('GreenYellow', '#ADFF2F'); export const GreenYellow = registerColor('GreenYellow', 0xffADFF2F);
export const HoneyDew = registerColor('HoneyDew', '#F0FFF0'); export const HoneyDew = registerColor('HoneyDew', 0xffF0FFF0);
export const HotPink = registerColor('HotPink', '#FF69B4'); export const HotPink = registerColor('HotPink', 0xffFF69B4);
export const IndianRed = registerColor('IndianRed', '#CD5C5C'); export const IndianRed = registerColor('IndianRed', 0xffCD5C5C);
export const Indigo = registerColor('Indigo', '#4B0082'); export const Indigo = registerColor('Indigo', 0xff4B0082);
export const Ivory = registerColor('Ivory', '#FFFFF0'); export const Ivory = registerColor('Ivory', 0xffFFFFF0);
export const Khaki = registerColor('Khaki', '#F0E68C'); export const Khaki = registerColor('Khaki', 0xffF0E68C);
export const Lavender = registerColor('Lavender', '#E6E6FA'); export const Lavender = registerColor('Lavender', 0xffE6E6FA);
export const LavenderBlush = registerColor('LavenderBlush', '#FFF0F5'); export const LavenderBlush = registerColor('LavenderBlush', 0xffFFF0F5);
export const LawnGreen = registerColor('LawnGreen', '#7CFC00'); export const LawnGreen = registerColor('LawnGreen', 0xff7CFC00);
export const LemonChiffon = registerColor('LemonChiffon', '#FFFACD'); export const LemonChiffon = registerColor('LemonChiffon', 0xffFFFACD);
export const LightBlue = registerColor('LightBlue', '#ADD8E6'); export const LightBlue = registerColor('LightBlue', 0xffADD8E6);
export const LightCoral = registerColor('LightCoral', '#F08080'); export const LightCoral = registerColor('LightCoral', 0xffF08080);
export const LightCyan = registerColor('LightCyan', '#E0FFFF'); export const LightCyan = registerColor('LightCyan', 0xffE0FFFF);
export const LightGoldenRodYellow = registerColor('LightGoldenRodYellow', '#FAFAD2'); export const LightGoldenRodYellow = registerColor('LightGoldenRodYellow', 0xffFAFAD2);
export const LightGray = registerColor('LightGray', '#D3D3D3'); export const LightGray = registerColor(['LightGray', 'LightGrey'], 0xffD3D3D3);
export const LightGreen = registerColor('LightGreen', '#90EE90'); export const LightGreen = registerColor('LightGreen', 0xff90EE90);
export const LightPink = registerColor('LightPink', '#FFB6C1'); export const LightPink = registerColor('LightPink', 0xffFFB6C1);
export const LightSalmon = registerColor('LightSalmon', '#FFA07A'); export const LightSalmon = registerColor('LightSalmon', 0xffFFA07A);
export const LightSeaGreen = registerColor('LightSeaGreen', '#20B2AA'); export const LightSeaGreen = registerColor('LightSeaGreen', 0xff20B2AA);
export const LightSkyBlue = registerColor('LightSkyBlue', '#87CEFA'); export const LightSkyBlue = registerColor('LightSkyBlue', 0xff87CEFA);
export const LightSlateGray = registerColor('LightSlateGray', '#778899'); export const LightSlateGray = registerColor(['LightSlateGray', 'LightSlateGrey'], 0xff778899);
export const LightSteelBlue = registerColor('LightSteelBlue', '#B0C4DE'); export const LightSteelBlue = registerColor('LightSteelBlue', 0xffB0C4DE);
export const LightYellow = registerColor('LightYellow', '#FFFFE0'); export const LightYellow = registerColor('LightYellow', 0xffFFFFE0);
export const Lime = registerColor('Lime', '#00FF00'); export const Lime = registerColor('Lime', 0xff00FF00);
export const LimeGreen = registerColor('LimeGreen', '#32CD32'); export const LimeGreen = registerColor('LimeGreen', 0xff32CD32);
export const Linen = registerColor('Linen', '#FAF0E6'); export const Linen = registerColor('Linen', 0xffFAF0E6);
export const Magenta = registerColor('Magenta', '#FF00FF'); export const Magenta = registerColor('Magenta', 0xffFF00FF);
export const Maroon = registerColor('Maroon', '#800000'); export const Maroon = registerColor('Maroon', 0xff800000);
export const MediumAquaMarine = registerColor('MediumAquaMarine', '#66CDAA'); export const MediumAquaMarine = registerColor('MediumAquaMarine', 0xff66CDAA);
export const MediumBlue = registerColor('MediumBlue', '#0000CD'); export const MediumBlue = registerColor('MediumBlue', 0xff0000CD);
export const MediumOrchid = registerColor('MediumOrchid', '#BA55D3'); export const MediumOrchid = registerColor('MediumOrchid', 0xffBA55D3);
export const MediumPurple = registerColor('MediumPurple', '#9370DB'); export const MediumPurple = registerColor('MediumPurple', 0xff9370DB);
export const MediumSeaGreen = registerColor('MediumSeaGreen', '#3CB371'); export const MediumSeaGreen = registerColor('MediumSeaGreen', 0xff3CB371);
export const MediumSlateBlue = registerColor('MediumSlateBlue', '#7B68EE'); export const MediumSlateBlue = registerColor('MediumSlateBlue', 0xff7B68EE);
export const MediumSpringGreen = registerColor('MediumSpringGreen', '#00FA9A'); export const MediumSpringGreen = registerColor('MediumSpringGreen', 0xff00FA9A);
export const MediumTurquoise = registerColor('MediumTurquoise', '#48D1CC'); export const MediumTurquoise = registerColor('MediumTurquoise', 0xff48D1CC);
export const MediumVioletRed = registerColor('MediumVioletRed', '#C71585'); export const MediumVioletRed = registerColor('MediumVioletRed', 0xffC71585);
export const MidnightBlue = registerColor('MidnightBlue', '#191970'); export const MidnightBlue = registerColor('MidnightBlue', 0xff191970);
export const MintCream = registerColor('MintCream', '#F5FFFA'); export const MintCream = registerColor('MintCream', 0xffF5FFFA);
export const MistyRose = registerColor('MistyRose', '#FFE4E1'); export const MistyRose = registerColor('MistyRose', 0xffFFE4E1);
export const Moccasin = registerColor('Moccasin', '#FFE4B5'); export const Moccasin = registerColor('Moccasin', 0xffFFE4B5);
export const NavajoWhite = registerColor('NavajoWhite', '#FFDEAD'); export const NavajoWhite = registerColor('NavajoWhite', 0xffFFDEAD);
export const Navy = registerColor('Navy', '#000080'); export const Navy = registerColor('Navy', 0xff000080);
export const OldLace = registerColor('OldLace', '#FDF5E6'); export const OldLace = registerColor('OldLace', 0xffFDF5E6);
export const Olive = registerColor('Olive', '#808000'); export const Olive = registerColor('Olive', 0xff808000);
export const OliveDrab = registerColor('OliveDrab', '#6B8E23'); export const OliveDrab = registerColor('OliveDrab', 0xff6B8E23);
export const Orange = registerColor('Orange', '#FFA500'); export const Orange = registerColor('Orange', 0xffFFA500);
export const OrangeRed = registerColor('OrangeRed', '#FF4500'); export const OrangeRed = registerColor('OrangeRed', 0xffFF4500);
export const Orchid = registerColor('Orchid', '#DA70D6'); export const Orchid = registerColor('Orchid', 0xffDA70D6);
export const PaleGoldenRod = registerColor('PaleGoldenRod', '#EEE8AA'); export const PaleGoldenRod = registerColor('PaleGoldenRod', 0xffEEE8AA);
export const PaleGreen = registerColor('PaleGreen', '#98FB98'); export const PaleGreen = registerColor('PaleGreen', 0xff98FB98);
export const PaleTurquoise = registerColor('PaleTurquoise', '#AFEEEE'); export const PaleTurquoise = registerColor('PaleTurquoise', 0xffAFEEEE);
export const PaleVioletRed = registerColor('PaleVioletRed', '#DB7093'); export const PaleVioletRed = registerColor('PaleVioletRed', 0xffDB7093);
export const PapayaWhip = registerColor('PapayaWhip', '#FFEFD5'); export const PapayaWhip = registerColor('PapayaWhip', 0xffFFEFD5);
export const PeachPuff = registerColor('PeachPuff', '#FFDAB9'); export const PeachPuff = registerColor('PeachPuff', 0xffFFDAB9);
export const Peru = registerColor('Peru', '#CD853F'); export const Peru = registerColor('Peru', 0xffCD853F);
export const Pink = registerColor('Pink', '#FFC0CB'); export const Pink = registerColor('Pink', 0xffFFC0CB);
export const Plum = registerColor('Plum', '#DDA0DD'); export const Plum = registerColor('Plum', 0xffDDA0DD);
export const PowderBlue = registerColor('PowderBlue', '#B0E0E6'); export const PowderBlue = registerColor('PowderBlue', 0xffB0E0E6);
export const Purple = registerColor('Purple', '#800080'); export const Purple = registerColor('Purple', 0xff800080);
export const RebeccaPurple = registerColor('RebeccaPurple', '#663399'); export const RebeccaPurple = registerColor('RebeccaPurple', 0xff663399);
export const Red = registerColor('Red', '#FF0000'); export const Red = registerColor('Red', 0xffFF0000);
export const RosyBrown = registerColor('RosyBrown', '#BC8F8F'); export const RosyBrown = registerColor('RosyBrown', 0xffBC8F8F);
export const RoyalBlue = registerColor('RoyalBlue', '#4169E1'); export const RoyalBlue = registerColor('RoyalBlue', 0xff4169E1);
export const SaddleBrown = registerColor('SaddleBrown', '#8B4513'); export const SaddleBrown = registerColor('SaddleBrown', 0xff8B4513);
export const Salmon = registerColor('Salmon', '#FA8072'); export const Salmon = registerColor('Salmon', 0xffFA8072);
export const SandyBrown = registerColor('SandyBrown', '#F4A460'); export const SandyBrown = registerColor('SandyBrown', 0xffF4A460);
export const SeaGreen = registerColor('SeaGreen', '#2E8B57'); export const SeaGreen = registerColor('SeaGreen', 0xff2E8B57);
export const SeaShell = registerColor('SeaShell', '#FFF5EE'); export const SeaShell = registerColor('SeaShell', 0xffFFF5EE);
export const Sienna = registerColor('Sienna', '#A0522D'); export const Sienna = registerColor('Sienna', 0xffA0522D);
export const Silver = registerColor('Silver', '#C0C0C0'); export const Silver = registerColor('Silver', 0xffC0C0C0);
export const SkyBlue = registerColor('SkyBlue', '#87CEEB'); export const SkyBlue = registerColor('SkyBlue', 0xff87CEEB);
export const SlateBlue = registerColor('SlateBlue', '#6A5ACD'); export const SlateBlue = registerColor('SlateBlue', 0xff6A5ACD);
export const SlateGray = registerColor('SlateGray', '#708090'); export const SlateGray = registerColor(['SlateGray', 'SlateGrey'], 0xff708090);
export const Snow = registerColor('Snow', '#FFFAFA'); export const Snow = registerColor('Snow', 0xffFFFAFA);
export const SpringGreen = registerColor('SpringGreen', '#00FF7F'); export const SpringGreen = registerColor('SpringGreen', 0xff00FF7F);
export const SteelBlue = registerColor('SteelBlue', '#4682B4'); export const SteelBlue = registerColor('SteelBlue', 0xff4682B4);
export const Tan = registerColor('Tan', '#D2B48C'); export const Tan = registerColor('Tan', 0xffD2B48C);
export const Teal = registerColor('Teal', '#008080'); export const Teal = registerColor('Teal', 0xff008080);
export const Thistle = registerColor('Thistle', '#D8BFD8'); export const Thistle = registerColor('Thistle', 0xffD8BFD8);
export const Tomato = registerColor('Tomato', '#FF6347'); export const Tomato = registerColor('Tomato', 0xffFF6347);
export const Turquoise = registerColor('Turquoise', '#40E0D0'); export const Turquoise = registerColor('Turquoise', 0xff40E0D0);
export const Violet = registerColor('Violet', '#EE82EE'); export const Violet = registerColor('Violet', 0xffEE82EE);
export const Wheat = registerColor('Wheat', '#F5DEB3'); export const Wheat = registerColor('Wheat', 0xffF5DEB3);
export const White = registerColor('White', '#FFFFFF'); export const White = registerColor('White', 0xffFFFFFF);
export const WhiteSmoke = registerColor('WhiteSmoke', '#F5F5F5'); export const WhiteSmoke = registerColor('WhiteSmoke', 0xffF5F5F5);
export const Yellow = registerColor('Yellow', '#FFFF00'); export const Yellow = registerColor('Yellow', 0xffFFFF00);
export const YellowGreen = registerColor('YellowGreen', '#9ACD32'); export const YellowGreen = registerColor('YellowGreen', 0xff9ACD32);

237
packages/core/css/parser.ts
View File

@ -1,3 +1,5 @@
import { getKnownColor } from "../color/known-colors";
export type Parsed<V> = { start: number; end: number; value: V }; export type Parsed<V> = { start: number; end: number; value: V };
// Values // Values
@ -53,7 +55,7 @@ export interface BackgroundPosition {
} }
const urlRegEx = /\s*url\((?:('|")([^\1]*)\1|([^\)]*))\)\s*/gy; const urlRegEx = /\s*url\((?:('|")([^\1]*)\1|([^\)]*))\)\s*/gy;
export function parseURL(text: string, start: number = 0): Parsed<URL> { export function parseURL(text: string, start = 0): Parsed<URL> {
urlRegEx.lastIndex = start; urlRegEx.lastIndex = start;
const result = urlRegEx.exec(text); const result = urlRegEx.exec(text);
if (!result) { if (!result) {
@ -66,14 +68,14 @@ export function parseURL(text: string, start: number = 0): Parsed<URL> {
} }
const hexColorRegEx = /\s*#((?:[0-9A-F]{8})|(?:[0-9A-F]{6})|(?:[0-9A-F]{3}))\s*/giy; const hexColorRegEx = /\s*#((?:[0-9A-F]{8})|(?:[0-9A-F]{6})|(?:[0-9A-F]{3}))\s*/giy;
export function parseHexColor(text: string, start: number = 0): Parsed<ARGB> { export function parseHexColor(text: string, start = 0): Parsed<ARGB> {
hexColorRegEx.lastIndex = start; hexColorRegEx.lastIndex = start;
const result = hexColorRegEx.exec(text); const result = hexColorRegEx.exec(text);
if (!result) { if (!result) {
return null; return null;
} }
const end = hexColorRegEx.lastIndex; const end = hexColorRegEx.lastIndex;
let hex = result[1]; const hex = result[1];
let argb; let argb;
if (hex.length === 8) { if (hex.length === 8) {
argb = parseInt('0x' + hex); argb = parseInt('0x' + hex);
@ -86,7 +88,7 @@ export function parseHexColor(text: string, start: number = 0): Parsed<ARGB> {
return { start, end, value: argb }; return { start, end, value: argb };
} }
function rgbaToArgbNumber(r: number, g: number, b: number, a: number = 1): number | undefined { function rgbaToArgbNumber(r: number, g: number, b: number, a = 1): number | undefined {
if (r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255 && a >= 0 && a <= 1) { if (r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255 && a >= 0 && a <= 1) {
return Math.round(a * 0xff) * 0x01000000 + r * 0x010000 + g * 0x000100 + b; return Math.round(a * 0xff) * 0x01000000 + r * 0x010000 + g * 0x000100 + b;
} else { } else {
@ -95,7 +97,7 @@ function rgbaToArgbNumber(r: number, g: number, b: number, a: number = 1): numbe
} }
const rgbColorRegEx = /\s*(rgb\(\s*(\d*)\s*,\s*(\d*)\s*,\s*(\d*)\s*\))/gy; const rgbColorRegEx = /\s*(rgb\(\s*(\d*)\s*,\s*(\d*)\s*,\s*(\d*)\s*\))/gy;
export function parseRGBColor(text: string, start: number = 0): Parsed<ARGB> { export function parseRGBColor(text: string, start = 0): Parsed<ARGB> {
rgbColorRegEx.lastIndex = start; rgbColorRegEx.lastIndex = start;
const result = rgbColorRegEx.exec(text); const result = rgbColorRegEx.exec(text);
if (!result) { if (!result) {
@ -108,7 +110,7 @@ export function parseRGBColor(text: string, start: number = 0): Parsed<ARGB> {
} }
const rgbaColorRegEx = /\s*(rgba\(\s*(\d*)\s*,\s*(\d*)\s*,\s*(\d*)\s*,\s*([01]?\.?\d*)\s*\))/gy; const rgbaColorRegEx = /\s*(rgba\(\s*(\d*)\s*,\s*(\d*)\s*,\s*(\d*)\s*,\s*([01]?\.?\d*)\s*\))/gy;
export function parseRGBAColor(text: string, start: number = 0): Parsed<ARGB> { export function parseRGBAColor(text: string, start = 0): Parsed<ARGB> {
rgbaColorRegEx.lastIndex = start; rgbaColorRegEx.lastIndex = start;
const result = rgbaColorRegEx.exec(text); const result = rgbaColorRegEx.exec(text);
if (!result) { if (!result) {
@ -158,8 +160,8 @@ export function convertHSLToRGBColor(hue: number, saturation: number, lightness:
}; };
} }
function hslaToArgbNumber(h: number, s: number, l: number, a: number = 1): number | undefined { function hslaToArgbNumber(h: number, s: number, l: number, a = 1): number | undefined {
let { r, g, b } = convertHSLToRGBColor(h, s, l); const { r, g, b } = convertHSLToRGBColor(h, s, l);
if (r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255 && a >= 0 && a <= 1) { if (r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255 && a >= 0 && a <= 1) {
return Math.round(a * 0xff) * 0x01000000 + r * 0x010000 + g * 0x000100 + b; return Math.round(a * 0xff) * 0x01000000 + r * 0x010000 + g * 0x000100 + b;
@ -169,7 +171,7 @@ function hslaToArgbNumber(h: number, s: number, l: number, a: number = 1): numbe
} }
const hslColorRegEx = /\s*(hsl\(\s*([\d.]*)\s*,\s*([\d.]*)%\s*,\s*([\d.]*)%\s*\))/gy; const hslColorRegEx = /\s*(hsl\(\s*([\d.]*)\s*,\s*([\d.]*)%\s*,\s*([\d.]*)%\s*\))/gy;
export function parseHSLColor(text: string, start: number = 0): Parsed<ARGB> { export function parseHSLColor(text: string, start = 0): Parsed<ARGB> {
hslColorRegEx.lastIndex = start; hslColorRegEx.lastIndex = start;
const result = hslColorRegEx.exec(text); const result = hslColorRegEx.exec(text);
if (!result) { if (!result) {
@ -182,7 +184,7 @@ export function parseHSLColor(text: string, start: number = 0): Parsed<ARGB> {
} }
const hslaColorRegEx = /\s*(hsla\(\s*([\d.]*)\s*,\s*([\d.]*)%\s*,\s*([\d.]*)%\s*,\s*([01]?\.?\d*)\s*\))/gy; const hslaColorRegEx = /\s*(hsla\(\s*([\d.]*)\s*,\s*([\d.]*)%\s*,\s*([\d.]*)%\s*,\s*([01]?\.?\d*)\s*\))/gy;
export function parseHSLAColor(text: string, start: number = 0): Parsed<ARGB> { export function parseHSLAColor(text: string, start = 0): Parsed<ARGB> {
hslaColorRegEx.lastIndex = start; hslaColorRegEx.lastIndex = start;
const result = hslaColorRegEx.exec(text); const result = hslaColorRegEx.exec(text);
if (!result) { if (!result) {
@ -194,175 +196,24 @@ export function parseHSLAColor(text: string, start: number = 0): Parsed<ARGB> {
return { start, end, value }; return { start, end, value };
} }
export enum colors {
transparent = 0x00000000,
aliceblue = 0xfff0f8ff,
antiquewhite = 0xfffaebd7,
aqua = 0xff00ffff,
aquamarine = 0xff7fffd4,
azure = 0xfff0ffff,
beige = 0xfff5f5dc,
bisque = 0xffffe4c4,
black = 0xff000000,
blanchedalmond = 0xffffebcd,
blue = 0xff0000ff,
blueviolet = 0xff8a2be2,
brown = 0xffa52a2a,
burlywood = 0xffdeb887,
cadetblue = 0xff5f9ea0,
chartreuse = 0xff7fff00,
chocolate = 0xffd2691e,
coral = 0xffff7f50,
cornflowerblue = 0xff6495ed,
cornsilk = 0xfffff8dc,
crimson = 0xffdc143c,
cyan = 0xff00ffff,
darkblue = 0xff00008b,
darkcyan = 0xff008b8b,
darkgoldenrod = 0xffb8860b,
darkgray = 0xffa9a9a9,
darkgreen = 0xff006400,
darkgrey = 0xffa9a9a9,
darkkhaki = 0xffbdb76b,
darkmagenta = 0xff8b008b,
darkolivegreen = 0xff556b2f,
darkorange = 0xffff8c00,
darkorchid = 0xff9932cc,
darkred = 0xff8b0000,
darksalmon = 0xffe9967a,
darkseagreen = 0xff8fbc8f,
darkslateblue = 0xff483d8b,
darkslategray = 0xff2f4f4f,
darkslategrey = 0xff2f4f4f,
darkturquoise = 0xff00ced1,
darkviolet = 0xff9400d3,
deeppink = 0xffff1493,
deepskyblue = 0xff00bfff,
dimgray = 0xff696969,
dimgrey = 0xff696969,
dodgerblue = 0xff1e90ff,
firebrick = 0xffb22222,
floralwhite = 0xfffffaf0,
forestgreen = 0xff228b22,
fuchsia = 0xffff00ff,
gainsboro = 0xffdcdcdc,
ghostwhite = 0xfff8f8ff,
gold = 0xffffd700,
goldenrod = 0xffdaa520,
gray = 0xff808080,
green = 0xff008000,
greenyellow = 0xffadff2f,
grey = 0xff808080,
honeydew = 0xfff0fff0,
hotpink = 0xffff69b4,
indianred = 0xffcd5c5c,
indigo = 0xff4b0082,
ivory = 0xfffffff0,
khaki = 0xfff0e68c,
lavender = 0xffe6e6fa,
lavenderblush = 0xfffff0f5,
lawngreen = 0xff7cfc00,
lemonchiffon = 0xfffffacd,
lightblue = 0xffadd8e6,
lightcoral = 0xfff08080,
lightcyan = 0xffe0ffff,
lightgoldenrodyellow = 0xfffafad2,
lightgray = 0xffd3d3d3,
lightgreen = 0xff90ee90,
lightgrey = 0xffd3d3d3,
lightpink = 0xffffb6c1,
lightsalmon = 0xffffa07a,
lightseagreen = 0xff20b2aa,
lightskyblue = 0xff87cefa,
lightslategray = 0xff778899,
lightslategrey = 0xff778899,
lightsteelblue = 0xffb0c4de,
lightyellow = 0xffffffe0,
lime = 0xff00ff00,
limegreen = 0xff32cd32,
linen = 0xfffaf0e6,
magenta = 0xffff00ff,
maroon = 0xff800000,
mediumaquamarine = 0xff66cdaa,
mediumblue = 0xff0000cd,
mediumorchid = 0xffba55d3,
mediumpurple = 0xff9370db,
mediumseagreen = 0xff3cb371,
mediumslateblue = 0xff7b68ee,
mediumspringgreen = 0xff00fa9a,
mediumturquoise = 0xff48d1cc,
mediumvioletred = 0xffc71585,
midnightblue = 0xff191970,
mintcream = 0xfff5fffa,
mistyrose = 0xffffe4e1,
moccasin = 0xffffe4b5,
navajowhite = 0xffffdead,
navy = 0xff000080,
oldlace = 0xfffdf5e6,
olive = 0xff808000,
olivedrab = 0xff6b8e23,
orange = 0xffffa500,
orangered = 0xffff4500,
orchid = 0xffda70d6,
palegoldenrod = 0xffeee8aa,
palegreen = 0xff98fb98,
paleturquoise = 0xffafeeee,
palevioletred = 0xffdb7093,
papayawhip = 0xffffefd5,
peachpuff = 0xffffdab9,
peru = 0xffcd853f,
pink = 0xffffc0cb,
plum = 0xffdda0dd,
powderblue = 0xffb0e0e6,
purple = 0xff800080,
rebeccapurple = 0xff663399,
red = 0xffff0000,
rosybrown = 0xffbc8f8f,
royalblue = 0xff4169e1,
saddlebrown = 0xff8b4513,
salmon = 0xfffa8072,
sandybrown = 0xfff4a460,
seagreen = 0xff2e8b57,
seashell = 0xfffff5ee,
sienna = 0xffa0522d,
silver = 0xffc0c0c0,
skyblue = 0xff87ceeb,
slateblue = 0xff6a5acd,
slategray = 0xff708090,
slategrey = 0xff708090,
snow = 0xfffffafa,
springgreen = 0xff00ff7f,
steelblue = 0xff4682b4,
tan = 0xffd2b48c,
teal = 0xff008080,
thistle = 0xffd8bfd8,
tomato = 0xffff6347,
turquoise = 0xff40e0d0,
violet = 0xffee82ee,
wheat = 0xfff5deb3,
white = 0xffffffff,
whitesmoke = 0xfff5f5f5,
yellow = 0xffffff00,
yellowgreen = 0xff9acd32,
}
export function parseColorKeyword(value, start: number, keyword = parseKeyword(value, start)): Parsed<ARGB> { export function parseColorKeyword(value, start: number, keyword = parseKeyword(value, start)): Parsed<ARGB> {
if (keyword && keyword.value in colors) { const parseColor = keyword && getKnownColor(keyword.value);
if (parseColor !== undefined) {
const end = keyword.end; const end = keyword.end;
const value = colors[keyword.value]; const value = parseColor;
return { start, end, value }; return { start, end, value };
} }
return null; return null;
} }
export function parseColor(value: string, start: number = 0, keyword = parseKeyword(value, start)): Parsed<ARGB> { export function parseColor(value: string, start = 0, keyword = parseKeyword(value, start)): Parsed<ARGB> {
return parseHexColor(value, start) || parseColorKeyword(value, start, keyword) || parseRGBColor(value, start) || parseRGBAColor(value, start) || parseHSLColor(value, start) || parseHSLAColor(value, start); return parseHexColor(value, start) || parseColorKeyword(value, start, keyword) || parseRGBColor(value, start) || parseRGBAColor(value, start) || parseHSLColor(value, start) || parseHSLAColor(value, start);
} }
const keywordRegEx = /\s*([a-z][\w\-]*)\s*/giy; const keywordRegEx = /\s*([a-z][\w\-]*)\s*/giy;
function parseKeyword(text: string, start: number = 0): Parsed<Keyword> { function parseKeyword(text: string, start = 0): Parsed<Keyword> {
keywordRegEx.lastIndex = start; keywordRegEx.lastIndex = start;
const result = keywordRegEx.exec(text); const result = keywordRegEx.exec(text);
if (!result) { if (!result) {
@ -375,7 +226,7 @@ function parseKeyword(text: string, start: number = 0): Parsed<Keyword> {
} }
const backgroundRepeatKeywords = new Set(['repeat', 'repeat-x', 'repeat-y', 'no-repeat']); const backgroundRepeatKeywords = new Set(['repeat', 'repeat-x', 'repeat-y', 'no-repeat']);
export function parseRepeat(value: string, start: number = 0, keyword = parseKeyword(value, start)): Parsed<BackgroundRepeat> { export function parseRepeat(value: string, start = 0, keyword = parseKeyword(value, start)): Parsed<BackgroundRepeat> {
if (keyword && backgroundRepeatKeywords.has(keyword.value)) { if (keyword && backgroundRepeatKeywords.has(keyword.value)) {
const end = keyword.end; const end = keyword.end;
const value = <BackgroundRepeat>keyword.value; const value = <BackgroundRepeat>keyword.value;
@ -387,7 +238,7 @@ export function parseRepeat(value: string, start: number = 0, keyword = parseKey
} }
const unitRegEx = /\s*([\+\-]?(?:\d+\.\d+|\d+|\.\d+)(?:[eE][\+\-]?\d+)?)([a-zA-Z]+|%)?\s*/gy; const unitRegEx = /\s*([\+\-]?(?:\d+\.\d+|\d+|\.\d+)(?:[eE][\+\-]?\d+)?)([a-zA-Z]+|%)?\s*/gy;
export function parseUnit(text: string, start: number = 0): Parsed<Unit<string>> { export function parseUnit(text: string, start = 0): Parsed<Unit<string>> {
unitRegEx.lastIndex = start; unitRegEx.lastIndex = start;
const result = unitRegEx.exec(text); const result = unitRegEx.exec(text);
if (!result) { if (!result) {
@ -400,7 +251,7 @@ export function parseUnit(text: string, start: number = 0): Parsed<Unit<string>>
return { start, end, value: { value, unit } }; return { start, end, value: { value, unit } };
} }
export function parsePercentageOrLength(text: string, start: number = 0): Parsed<LengthPercentage> { export function parsePercentageOrLength(text: string, start = 0): Parsed<LengthPercentage> {
const unitResult = parseUnit(text, start); const unitResult = parseUnit(text, start);
if (unitResult) { if (unitResult) {
const { start, end } = unitResult; const { start, end } = unitResult;
@ -445,7 +296,7 @@ const angleUnitsToRadMap: {
value: turn * Math.PI * 2, value: turn * Math.PI * 2,
}), }),
}; };
export function parseAngle(value: string, start: number = 0): Parsed<Angle> { export function parseAngle(value: string, start = 0): Parsed<Angle> {
const angleResult = parseUnit(value, start); const angleResult = parseUnit(value, start);
if (angleResult) { if (angleResult) {
const { start, end, value } = angleResult; const { start, end, value } = angleResult;
@ -457,7 +308,7 @@ export function parseAngle(value: string, start: number = 0): Parsed<Angle> {
} }
const backgroundSizeKeywords = new Set(['auto', 'contain', 'cover']); const backgroundSizeKeywords = new Set(['auto', 'contain', 'cover']);
export function parseBackgroundSize(value: string, start: number = 0, keyword = parseKeyword(value, start)): Parsed<BackgroundSize> { export function parseBackgroundSize(value: string, start = 0, keyword = parseKeyword(value, start)): Parsed<BackgroundSize> {
let end = start; let end = start;
if (keyword && backgroundSizeKeywords.has(keyword.value)) { if (keyword && backgroundSizeKeywords.has(keyword.value)) {
end = keyword.end; end = keyword.end;
@ -497,7 +348,7 @@ const backgroundPositionKeywordsDirection: {
top: 'y', top: 'y',
bottom: 'y', bottom: 'y',
}; };
export function parseBackgroundPosition(text: string, start: number = 0, keyword = parseKeyword(text, start)): Parsed<BackgroundPosition> { export function parseBackgroundPosition(text: string, start = 0, keyword = parseKeyword(text, start)): Parsed<BackgroundPosition> {
function formatH(align: Parsed<HorizontalAlign>, offset: Parsed<LengthPercentage>) { function formatH(align: Parsed<HorizontalAlign>, offset: Parsed<LengthPercentage>) {
if (align.value === 'center') { if (align.value === 'center') {
return 'center'; return 'center';
@ -521,7 +372,7 @@ export function parseBackgroundPosition(text: string, start: number = 0, keyword
let end = start; let end = start;
if (keyword && backgroundPositionKeywords.has(keyword.value)) { if (keyword && backgroundPositionKeywords.has(keyword.value)) {
end = keyword.end; end = keyword.end;
let firstDirection = backgroundPositionKeywordsDirection[keyword.value]; const firstDirection = backgroundPositionKeywordsDirection[keyword.value];
const firstLength = firstDirection !== 'center' && parsePercentageOrLength(text, end); const firstLength = firstDirection !== 'center' && parsePercentageOrLength(text, end);
if (firstLength) { if (firstLength) {
@ -531,7 +382,7 @@ export function parseBackgroundPosition(text: string, start: number = 0, keyword
const secondKeyword = parseKeyword(text, end); const secondKeyword = parseKeyword(text, end);
if (secondKeyword && backgroundPositionKeywords.has(secondKeyword.value)) { if (secondKeyword && backgroundPositionKeywords.has(secondKeyword.value)) {
end = secondKeyword.end; end = secondKeyword.end;
let secondDirection = backgroundPositionKeywordsDirection[secondKeyword.end]; const secondDirection = backgroundPositionKeywordsDirection[secondKeyword.end];
if (firstDirection === secondDirection && firstDirection !== 'center') { if (firstDirection === secondDirection && firstDirection !== 'center') {
return null; // Reject pair of both horizontal or both vertical alignments. return null; // Reject pair of both horizontal or both vertical alignments.
@ -641,7 +492,7 @@ const cornerDirections = {
bottom: (Math.PI * 5) / 4, bottom: (Math.PI * 5) / 4,
}, },
}; };
function parseDirection(text: string, start: number = 0): Parsed<Angle> { function parseDirection(text: string, start = 0): Parsed<Angle> {
directionRegEx.lastIndex = start; directionRegEx.lastIndex = start;
const result = directionRegEx.exec(text); const result = directionRegEx.exec(text);
if (!result) { if (!result) {
@ -700,7 +551,7 @@ function parseArgumentsList<T>(text: string, start: number, argument: (value: st
} }
} }
export function parseColorStop(text: string, start: number = 0): Parsed<ColorStop> { export function parseColorStop(text: string, start = 0): Parsed<ColorStop> {
const color = parseColor(text, start); const color = parseColor(text, start);
if (!color) { if (!color) {
return null; return null;
@ -721,7 +572,7 @@ export function parseColorStop(text: string, start: number = 0): Parsed<ColorSto
} }
const linearGradientStartRegEx = /\s*linear-gradient\s*/gy; const linearGradientStartRegEx = /\s*linear-gradient\s*/gy;
export function parseLinearGradient(text: string, start: number = 0): Parsed<LinearGradient> { export function parseLinearGradient(text: string, start = 0): Parsed<LinearGradient> {
linearGradientStartRegEx.lastIndex = start; linearGradientStartRegEx.lastIndex = start;
const lgs = linearGradientStartRegEx.exec(text); const lgs = linearGradientStartRegEx.exec(text);
if (!lgs) { if (!lgs) {
@ -772,7 +623,7 @@ function parseSlash(text: string, start: number): Parsed<'/'> {
return { start, end, value: '/' }; return { start, end, value: '/' };
} }
export function parseBackground(text: string, start: number = 0): Parsed<Background> { export function parseBackground(text: string, start = 0): Parsed<Background> {
const value: any = {}; const value: any = {};
let end = start; let end = start;
while (end < text.length) { while (end < text.length) {
@ -865,7 +716,7 @@ export type SelectorCombinatorPair = [SimpleSelectorSequence, Combinator];
export type Selector = SelectorCombinatorPair[]; export type Selector = SelectorCombinatorPair[];
const universalSelectorRegEx = /\*/gy; const universalSelectorRegEx = /\*/gy;
export function parseUniversalSelector(text: string, start: number = 0): Parsed<UniversalSelector> { export function parseUniversalSelector(text: string, start = 0): Parsed<UniversalSelector> {
universalSelectorRegEx.lastIndex = start; universalSelectorRegEx.lastIndex = start;
const result = universalSelectorRegEx.exec(text); const result = universalSelectorRegEx.exec(text);
if (!result) { if (!result) {
@ -878,7 +729,7 @@ export function parseUniversalSelector(text: string, start: number = 0): Parsed<
const simpleIdentifierSelectorRegEx = /(#|\.|:|\b)((?:[\w_-]|\\.)(?:[\w\d_-]|\\.)*)/guy; const simpleIdentifierSelectorRegEx = /(#|\.|:|\b)((?:[\w_-]|\\.)(?:[\w\d_-]|\\.)*)/guy;
const unicodeEscapeRegEx = /\\([0-9a-fA-F]{1,5}\s|[0-9a-fA-F]{6})/g; const unicodeEscapeRegEx = /\\([0-9a-fA-F]{1,5}\s|[0-9a-fA-F]{6})/g;
export function parseSimpleIdentifierSelector(text: string, start: number = 0): Parsed<TypeSelector | ClassSelector | IdSelector | PseudoClassSelector> { export function parseSimpleIdentifierSelector(text: string, start = 0): Parsed<TypeSelector | ClassSelector | IdSelector | PseudoClassSelector> {
simpleIdentifierSelectorRegEx.lastIndex = start; simpleIdentifierSelectorRegEx.lastIndex = start;
const result = simpleIdentifierSelectorRegEx.exec(text.replace(unicodeEscapeRegEx, (_, c) => '\\' + String.fromCodePoint(parseInt(c.trim(), 16)))); const result = simpleIdentifierSelectorRegEx.exec(text.replace(unicodeEscapeRegEx, (_, c) => '\\' + String.fromCodePoint(parseInt(c.trim(), 16))));
if (!result) { if (!result) {
@ -911,7 +762,7 @@ export function parseAttributeSelector(text: string, start: number): Parsed<Attr
return { start, end, value: { type: '[]', property } }; return { start, end, value: { type: '[]', property } };
} }
export function parseSimpleSelector(text: string, start: number = 0): Parsed<SimpleSelector> { export function parseSimpleSelector(text: string, start = 0): Parsed<SimpleSelector> {
return parseUniversalSelector(text, start) || parseSimpleIdentifierSelector(text, start) || parseAttributeSelector(text, start); return parseUniversalSelector(text, start) || parseSimpleIdentifierSelector(text, start) || parseAttributeSelector(text, start);
} }
@ -921,7 +772,7 @@ export function parseSimpleSelectorSequence(text: string, start: number): Parsed
return null; return null;
} }
let end = simpleSelector.end; let end = simpleSelector.end;
let value = <SimpleSelectorSequence>[]; const value = <SimpleSelectorSequence>[];
while (simpleSelector) { while (simpleSelector) {
value.push(simpleSelector.value); value.push(simpleSelector.value);
end = simpleSelector.end; end = simpleSelector.end;
@ -932,7 +783,7 @@ export function parseSimpleSelectorSequence(text: string, start: number): Parsed
} }
const combinatorRegEx = /\s*(\+|~|>)?\s*/gy; const combinatorRegEx = /\s*(\+|~|>)?\s*/gy;
export function parseCombinator(text: string, start: number = 0): Parsed<Combinator> { export function parseCombinator(text: string, start = 0): Parsed<Combinator> {
combinatorRegEx.lastIndex = start; combinatorRegEx.lastIndex = start;
const result = combinatorRegEx.exec(text); const result = combinatorRegEx.exec(text);
if (!result) { if (!result) {
@ -945,14 +796,14 @@ export function parseCombinator(text: string, start: number = 0): Parsed<Combina
} }
const whiteSpaceRegEx = /\s*/gy; const whiteSpaceRegEx = /\s*/gy;
export function parseSelector(text: string, start: number = 0): Parsed<Selector> { export function parseSelector(text: string, start = 0): Parsed<Selector> {
let end = start; let end = start;
whiteSpaceRegEx.lastIndex = end; whiteSpaceRegEx.lastIndex = end;
const leadingWhiteSpace = whiteSpaceRegEx.exec(text); const leadingWhiteSpace = whiteSpaceRegEx.exec(text);
if (leadingWhiteSpace) { if (leadingWhiteSpace) {
end = whiteSpaceRegEx.lastIndex; end = whiteSpaceRegEx.lastIndex;
} }
let value = <Selector>[]; const value = <Selector>[];
let combinator: Parsed<Combinator>; let combinator: Parsed<Combinator>;
let expectSimpleSelector = true; // Must have at least one let expectSimpleSelector = true; // Must have at least one
let pair: SelectorCombinatorPair; let pair: SelectorCombinatorPair;
@ -1092,7 +943,7 @@ interface SimpleBlock extends InputTokenObject {
values: InputToken[]; values: InputToken[];
} }
interface AtKeywordToken extends InputTokenObject {} type AtKeywordToken = InputTokenObject
/** /**
* CSS parser following relatively close: * CSS parser following relatively close:
@ -1111,7 +962,7 @@ export class CSS3Parser {
* This method allows us to run and assert the proper working of the tokenizer. * This method allows us to run and assert the proper working of the tokenizer.
*/ */
tokenize(): InputToken[] { tokenize(): InputToken[] {
let tokens: InputToken[] = []; const tokens: InputToken[] = [];
let inputToken: InputToken; let inputToken: InputToken;
do { do {
inputToken = this.consumeAToken(); inputToken = this.consumeAToken();
@ -1127,7 +978,7 @@ export class CSS3Parser {
*/ */
private consumeAToken(): InputToken { private consumeAToken(): InputToken {
if (this.reconsumedInputToken) { if (this.reconsumedInputToken) {
let result = this.reconsumedInputToken; const result = this.reconsumedInputToken;
this.reconsumedInputToken = null; this.reconsumedInputToken = null;
return result; return result;
@ -1224,7 +1075,7 @@ export class CSS3Parser {
private consumeAHashToken(): InputTokenObject { private consumeAHashToken(): InputTokenObject {
this.nextInputCodePointIndex++; this.nextInputCodePointIndex++;
let hashName = this.consumeAName(); const hashName = this.consumeAName();
if (hashName) { if (hashName) {
return { type: TokenObjectType.hash, text: '#' + hashName.text }; return { type: TokenObjectType.hash, text: '#' + hashName.text };
} }
@ -1429,7 +1280,7 @@ export class CSS3Parser {
private consumeAtKeyword(): InputTokenObject { private consumeAtKeyword(): InputTokenObject {
this.nextInputCodePointIndex++; this.nextInputCodePointIndex++;
let name = this.consumeAName(); const name = this.consumeAName();
if (name) { if (name) {
return { type: TokenObjectType.atKeyword, text: name.text }; return { type: TokenObjectType.atKeyword, text: name.text };
} }
@ -1559,7 +1410,7 @@ export class CSS3Parser {
let inputToken: InputToken; let inputToken: InputToken;
while ((inputToken = this.consumeAToken())) { while ((inputToken = this.consumeAToken())) {
if (inputToken === '{') { if (inputToken === '{') {
let block = this.consumeASimpleBlock(inputToken); const block = this.consumeASimpleBlock(inputToken);
qualifiedRule.block = block; qualifiedRule.block = block;
return qualifiedRule; return qualifiedRule;
@ -1739,7 +1590,7 @@ export class CSSNativeScript {
let reading: 'property' | 'value' = 'property'; let reading: 'property' | 'value' = 'property';
for (let i = 0; i < declarationsInputTokens.length; i++) { for (let i = 0; i < declarationsInputTokens.length; i++) {
let inputToken = declarationsInputTokens[i]; const inputToken = declarationsInputTokens[i];
if (reading === 'property') { if (reading === 'property') {
if (inputToken === ':') { if (inputToken === ':') {
reading = 'value'; reading = 'value';
@ -1773,7 +1624,7 @@ export class CSSNativeScript {
} }
private preludeToSelectorsStringArray(prelude: InputToken[]): string[] { private preludeToSelectorsStringArray(prelude: InputToken[]): string[] {
let selectors = []; const selectors = [];
let selector = ''; let selector = '';
prelude.forEach((inputToken) => { prelude.forEach((inputToken) => {
if (typeof inputToken === 'string') { if (typeof inputToken === 'string') {