@nativescript/core 7.3.0-rc.0 → 7.3.0

package/css/parser.js

@@ -1,30 +1,25 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CSSNativeScript = exports.CSS3Parser = exports.parseSelector = exports.parseCombinator = exports.parseSimpleSelectorSequence = exports.parseSimpleSelector = exports.parseAttributeSelector = exports.parseSimpleIdentifierSelector = exports.parseUniversalSelector = exports.parseBackground = exports.parseLinearGradient = exports.parseColorStop = exports.parseBackgroundPosition = exports.parseBackgroundSize = exports.parseAngle = exports.parsePercentageOrLength = exports.parseUnit = exports.parseRepeat = exports.parseColor = exports.parseColorKeyword = exports.parseHSLAColor = exports.parseHSLColor = exports.convertHSLToRGBColor = exports.parseRGBAColor = exports.parseRGBColor = exports.parseHexColor = exports.parseURL = void 0;
-var known_colors_1 = require("../color/known-colors");
-var urlRegEx = /\s*url\((?:(['"])([^\1]*)\1|([^)]*))\)\s*/gy;
-function parseURL(text, start) {
-    if (start === void 0) { start = 0; }
+import { getKnownColor } from '../color/known-colors';
+const urlRegEx = /\s*url\((?:(['"])([^\1]*)\1|([^)]*))\)\s*/gy;
+export function parseURL(text, start = 0) {
     urlRegEx.lastIndex = start;
-    var result = urlRegEx.exec(text);
+    const result = urlRegEx.exec(text);
     if (!result) {
         return null;
     }
-    var end = urlRegEx.lastIndex;
-    var value = result[2] || result[3];
-    return { start: start, end: end, value: value };
+    const end = urlRegEx.lastIndex;
+    const value = result[2] || result[3];
+    return { start, end, value };
 }
-exports.parseURL = parseURL;
-var hexColorRegEx = /\s*#((?:[0-9A-F]{8})|(?:[0-9A-F]{6})|(?:[0-9A-F]{3}))\s*/giy;
-function parseHexColor(text, start) {
-    if (start === void 0) { start = 0; }
+const hexColorRegEx = /\s*#((?:[0-9A-F]{8})|(?:[0-9A-F]{6})|(?:[0-9A-F]{3}))\s*/giy;
+export function parseHexColor(text, start = 0) {
     hexColorRegEx.lastIndex = start;
-    var result = hexColorRegEx.exec(text);
+    const result = hexColorRegEx.exec(text);
     if (!result) {
         return null;
     }
-    var end = hexColorRegEx.lastIndex;
-    var hex = result[1];
-    var argb;
+    const end = hexColorRegEx.lastIndex;
+    const hex = result[1];
+    let argb;
     if (hex.length === 8) {
         argb = parseInt('0x' + hex);
     }
@@ -34,11 +29,9 @@ function parseHexColor(text, start) {
     else if (hex.length === 3) {
         argb = parseInt('0xFF' + hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2]);
     }
-    return { start: start, end: end, value: argb };
+    return { start, end, value: argb };
 }
-exports.parseHexColor = parseHexColor;
-function rgbaToArgbNumber(r, g, b, a) {
-    if (a === void 0) { a = 1; }
+function rgbaToArgbNumber(r, g, b, 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;
     }
@@ -46,37 +39,36 @@ function rgbaToArgbNumber(r, g, b, a) {
         return null;
     }
 }
-var rgbColorRegEx = /\s*(rgb\(\s*(\d*)\s*,\s*(\d*)\s*,\s*(\d*)\s*\))/gy;
-function parseRGBColor(text, start) {
-    if (start === void 0) { start = 0; }
+const rgbColorRegEx = /\s*(rgb\(\s*(\d*)\s*,\s*(\d*)\s*,\s*(\d*)\s*\))/gy;
+export function parseRGBColor(text, start = 0) {
     rgbColorRegEx.lastIndex = start;
-    var result = rgbColorRegEx.exec(text);
+    const result = rgbColorRegEx.exec(text);
     if (!result) {
         return null;
     }
-    var end = rgbColorRegEx.lastIndex;
-    var value = result[1] && rgbaToArgbNumber(parseInt(result[2]), parseInt(result[3]), parseInt(result[4]));
-    return { start: start, end: end, value: value };
+    const end = rgbColorRegEx.lastIndex;
+    const value = result[1] && rgbaToArgbNumber(parseInt(result[2]), parseInt(result[3]), parseInt(result[4]));
+    return { start, end, value };
 }
-exports.parseRGBColor = parseRGBColor;
-var rgbaColorRegEx = /\s*(rgba\(\s*(\d*)\s*,\s*(\d*)\s*,\s*(\d*)\s*,\s*([01]?\.?\d*)\s*\))/gy;
-function parseRGBAColor(text, start) {
-    if (start === void 0) { start = 0; }
+const rgbaColorRegEx = /\s*(rgba\(\s*(\d*)\s*,\s*(\d*)\s*,\s*(\d*)\s*,\s*([01]?\.?\d*)\s*\))/gy;
+export function parseRGBAColor(text, start = 0) {
     rgbaColorRegEx.lastIndex = start;
-    var result = rgbaColorRegEx.exec(text);
+    const result = rgbaColorRegEx.exec(text);
     if (!result) {
         return null;
     }
-    var end = rgbaColorRegEx.lastIndex;
-    var value = rgbaToArgbNumber(parseInt(result[2]), parseInt(result[3]), parseInt(result[4]), parseFloat(result[5]));
-    return { start: start, end: end, value: value };
+    const end = rgbaColorRegEx.lastIndex;
+    const value = rgbaToArgbNumber(parseInt(result[2]), parseInt(result[3]), parseInt(result[4]), parseFloat(result[5]));
+    return { start, end, value };
 }
-exports.parseRGBAColor = parseRGBAColor;
-function convertHSLToRGBColor(hue, saturation, lightness) {
+export function convertHSLToRGBColor(hue, saturation, lightness) {
+    // Per formula it will be easier if hue is divided to 60° and saturation to 100 beforehand
+    // https://en.wikipedia.org/wiki/HSL_and_HSV#HSL_to_RGB
     hue /= 60;
     lightness /= 100;
-    var chroma = ((1 - Math.abs(2 * lightness - 1)) * saturation) / 100, X = chroma * (1 - Math.abs((hue % 2) - 1));
-    var _a = { m: lightness - chroma / 2 }, r = _a.m, g = _a.m, b = _a.m;
+    const chroma = ((1 - Math.abs(2 * lightness - 1)) * saturation) / 100, X = chroma * (1 - Math.abs((hue % 2) - 1));
+    // Add lightness match to all RGB components beforehand
+    let { m: r, m: g, m: b } = { m: lightness - chroma / 2 };
     if (0 <= hue && hue < 1) {
         r += chroma;
         g += X;
@@ -107,99 +99,81 @@ function convertHSLToRGBColor(hue, saturation, lightness) {
         b: Math.round(b * 0xff),
     };
 }
-exports.convertHSLToRGBColor = convertHSLToRGBColor;
-function hslaToArgbNumber(h, s, l, a) {
-    if (a === void 0) { a = 1; }
-    var _a = convertHSLToRGBColor(h, s, l), r = _a.r, g = _a.g, b = _a.b;
+function hslaToArgbNumber(h, s, l, a = 1) {
+    const { r, g, b } = convertHSLToRGBColor(h, s, l);
     return rgbaToArgbNumber(r, g, b, a);
 }
-var hslColorRegEx = /\s*(hsl\(\s*([\d.]*)\s*,\s*([\d.]*)%\s*,\s*([\d.]*)%\s*\))/gy;
-function parseHSLColor(text, start) {
-    if (start === void 0) { start = 0; }
+const hslColorRegEx = /\s*(hsl\(\s*([\d.]*)\s*,\s*([\d.]*)%\s*,\s*([\d.]*)%\s*\))/gy;
+export function parseHSLColor(text, start = 0) {
     hslColorRegEx.lastIndex = start;
-    var result = hslColorRegEx.exec(text);
+    const result = hslColorRegEx.exec(text);
     if (!result) {
         return null;
     }
-    var end = hslColorRegEx.lastIndex;
-    var value = result[1] && hslaToArgbNumber(parseFloat(result[2]), parseFloat(result[3]), parseFloat(result[4]));
-    return { start: start, end: end, value: value };
+    const end = hslColorRegEx.lastIndex;
+    const value = result[1] && hslaToArgbNumber(parseFloat(result[2]), parseFloat(result[3]), parseFloat(result[4]));
+    return { start, end, value };
 }
-exports.parseHSLColor = parseHSLColor;
-var hslaColorRegEx = /\s*(hsla\(\s*([\d.]*)\s*,\s*([\d.]*)%\s*,\s*([\d.]*)%\s*,\s*([01]?\.?\d*)\s*\))/gy;
-function parseHSLAColor(text, start) {
-    if (start === void 0) { start = 0; }
+const hslaColorRegEx = /\s*(hsla\(\s*([\d.]*)\s*,\s*([\d.]*)%\s*,\s*([\d.]*)%\s*,\s*([01]?\.?\d*)\s*\))/gy;
+export function parseHSLAColor(text, start = 0) {
     hslaColorRegEx.lastIndex = start;
-    var result = hslaColorRegEx.exec(text);
+    const result = hslaColorRegEx.exec(text);
     if (!result) {
         return null;
     }
-    var end = hslaColorRegEx.lastIndex;
-    var value = hslaToArgbNumber(parseFloat(result[2]), parseFloat(result[3]), parseFloat(result[4]), parseFloat(result[5]));
-    return { start: start, end: end, value: value };
+    const end = hslaColorRegEx.lastIndex;
+    const value = hslaToArgbNumber(parseFloat(result[2]), parseFloat(result[3]), parseFloat(result[4]), parseFloat(result[5]));
+    return { start, end, value };
 }
-exports.parseHSLAColor = parseHSLAColor;
-function parseColorKeyword(value, start, keyword) {
-    if (keyword === void 0) { keyword = parseKeyword(value, start); }
-    var parseColor = keyword && known_colors_1.getKnownColor(keyword.value);
+export function parseColorKeyword(value, start, keyword = parseKeyword(value, start)) {
+    const parseColor = keyword && getKnownColor(keyword.value);
     if (parseColor != null) {
-        var end = keyword.end;
-        var value_1 = parseColor;
-        return { start: start, end: end, value: value_1 };
+        const end = keyword.end;
+        const value = parseColor;
+        return { start, end, value };
     }
     return null;
 }
-exports.parseColorKeyword = parseColorKeyword;
-function parseColor(value, start, keyword) {
-    if (start === void 0) { start = 0; }
-    if (keyword === void 0) { keyword = parseKeyword(value, start); }
+export function parseColor(value, start = 0, keyword = parseKeyword(value, start)) {
     return parseHexColor(value, start) || parseColorKeyword(value, start, keyword) || parseRGBColor(value, start) || parseRGBAColor(value, start) || parseHSLColor(value, start) || parseHSLAColor(value, start);
 }
-exports.parseColor = parseColor;
-var keywordRegEx = /\s*([a-z][\w\-]*)\s*/giy;
-function parseKeyword(text, start) {
-    if (start === void 0) { start = 0; }
+const keywordRegEx = /\s*([a-z][\w\-]*)\s*/giy;
+function parseKeyword(text, start = 0) {
     keywordRegEx.lastIndex = start;
-    var result = keywordRegEx.exec(text);
+    const result = keywordRegEx.exec(text);
     if (!result) {
         return null;
     }
-    var end = keywordRegEx.lastIndex;
-    var value = result[1];
-    return { start: start, end: end, value: value };
+    const end = keywordRegEx.lastIndex;
+    const value = result[1];
+    return { start, end, value };
 }
-var backgroundRepeatKeywords = new Set(['repeat', 'repeat-x', 'repeat-y', 'no-repeat']);
-function parseRepeat(value, start, keyword) {
-    if (start === void 0) { start = 0; }
-    if (keyword === void 0) { keyword = parseKeyword(value, start); }
+const backgroundRepeatKeywords = new Set(['repeat', 'repeat-x', 'repeat-y', 'no-repeat']);
+export function parseRepeat(value, start = 0, keyword = parseKeyword(value, start)) {
     if (keyword && backgroundRepeatKeywords.has(keyword.value)) {
-        var end = keyword.end;
-        var value_2 = keyword.value;
-        return { start: start, end: end, value: value_2 };
+        const end = keyword.end;
+        const value = keyword.value;
+        return { start, end, value };
     }
     return null;
 }
-exports.parseRepeat = parseRepeat;
-var unitRegEx = /\s*([+\-]?(?:\d+\.\d+|\d+|\.\d+)(?:[eE][+\-]?\d+)?)([a-zA-Z]+|%)?\s*/gy;
-function parseUnit(text, start) {
-    if (start === void 0) { start = 0; }
+const unitRegEx = /\s*([+\-]?(?:\d+\.\d+|\d+|\.\d+)(?:[eE][+\-]?\d+)?)([a-zA-Z]+|%)?\s*/gy;
+export function parseUnit(text, start = 0) {
     unitRegEx.lastIndex = start;
-    var result = unitRegEx.exec(text);
+    const result = unitRegEx.exec(text);
     if (!result) {
         return null;
     }
-    var end = unitRegEx.lastIndex;
-    var value = parseFloat(result[1]);
-    var unit = result[2] || 'dip';
-    return { start: start, end: end, value: { value: value, unit: unit } };
+    const end = unitRegEx.lastIndex;
+    const value = parseFloat(result[1]);
+    const unit = result[2] || 'dip';
+    return { start, end, value: { value, unit } };
 }
-exports.parseUnit = parseUnit;
-function parsePercentageOrLength(text, start) {
-    if (start === void 0) { start = 0; }
-    var unitResult = parseUnit(text, start);
+export function parsePercentageOrLength(text, start = 0) {
+    const unitResult = parseUnit(text, start);
     if (unitResult) {
-        var start_1 = unitResult.start, end = unitResult.end;
-        var value = unitResult.value;
+        const { start, end } = unitResult;
+        const value = unitResult.value;
         if (value.unit === '%') {
             value.value /= 100;
         }
@@ -207,87 +181,81 @@ function parsePercentageOrLength(text, start) {
             value.unit = 'dip';
         }
         else if (value.unit === 'px' || value.unit === 'dip') {
+            // same
         }
         else {
             return null;
         }
-        return { start: start_1, end: end, value: value };
+        return { start, end, value };
     }
     return null;
 }
-exports.parsePercentageOrLength = parsePercentageOrLength;
-var angleUnitsToRadMap = {
-    deg: function (start, end, deg) { return ({
-        start: start,
-        end: end,
+const angleUnitsToRadMap = {
+    deg: (start, end, deg) => ({
+        start,
+        end,
         value: (deg / 180) * Math.PI,
-    }); },
-    rad: function (start, end, rad) { return ({
-        start: start,
-        end: end,
+    }),
+    rad: (start, end, rad) => ({
+        start,
+        end,
         value: rad,
-    }); },
-    grad: function (start, end, grad) { return ({
-        start: start,
-        end: end,
+    }),
+    grad: (start, end, grad) => ({
+        start,
+        end,
         value: (grad / 200) * Math.PI,
-    }); },
-    turn: function (start, end, turn) { return ({
-        start: start,
-        end: end,
+    }),
+    turn: (start, end, turn) => ({
+        start,
+        end,
         value: turn * Math.PI * 2,
-    }); },
+    }),
 };
-function parseAngle(value, start) {
-    if (start === void 0) { start = 0; }
-    var angleResult = parseUnit(value, start);
+export function parseAngle(value, start = 0) {
+    const angleResult = parseUnit(value, start);
     if (angleResult) {
-        var start_2 = angleResult.start, end = angleResult.end, value_3 = angleResult.value;
-        return (angleUnitsToRadMap[value_3.unit] || (function (_, __, ___) { return null; }))(start_2, end, value_3.value);
+        const { start, end, value } = angleResult;
+        return (angleUnitsToRadMap[value.unit] || ((_, __, ___) => null))(start, end, value.value);
     }
     return null;
 }
-exports.parseAngle = parseAngle;
-var backgroundSizeKeywords = new Set(['auto', 'contain', 'cover']);
-function parseBackgroundSize(value, start, keyword) {
-    if (start === void 0) { start = 0; }
-    if (keyword === void 0) { keyword = parseKeyword(value, start); }
-    var end = start;
+const backgroundSizeKeywords = new Set(['auto', 'contain', 'cover']);
+export function parseBackgroundSize(value, start = 0, keyword = parseKeyword(value, start)) {
+    let end = start;
     if (keyword && backgroundSizeKeywords.has(keyword.value)) {
         end = keyword.end;
-        var value_4 = keyword.value;
-        return { start: start, end: end, value: value_4 };
+        const value = keyword.value;
+        return { start, end, value };
     }
-    var firstLength = parsePercentageOrLength(value, end);
+    // Parse one or two lengths... the other will be "auto"
+    const firstLength = parsePercentageOrLength(value, end);
     if (firstLength) {
         end = firstLength.end;
-        var secondLength = parsePercentageOrLength(value, firstLength.end);
+        const secondLength = parsePercentageOrLength(value, firstLength.end);
         if (secondLength) {
             end = secondLength.end;
             return {
-                start: start,
-                end: end,
+                start,
+                end,
                 value: { x: firstLength.value, y: secondLength.value },
             };
         }
         else {
-            return { start: start, end: end, value: { x: firstLength.value, y: 'auto' } };
+            return { start, end, value: { x: firstLength.value, y: 'auto' } };
         }
     }
     return null;
 }
-exports.parseBackgroundSize = parseBackgroundSize;
-var backgroundPositionKeywords = Object.freeze(new Set(['left', 'right', 'top', 'bottom', 'center']));
-var backgroundPositionKeywordsDirection = {
+const backgroundPositionKeywords = Object.freeze(new Set(['left', 'right', 'top', 'bottom', 'center']));
+const backgroundPositionKeywordsDirection = {
     left: 'x',
     right: 'x',
     center: 'center',
     top: 'y',
     bottom: 'y',
 };
-function parseBackgroundPosition(text, start, keyword) {
-    if (start === void 0) { start = 0; }
-    if (keyword === void 0) { keyword = parseKeyword(text, start); }
+export function parseBackgroundPosition(text, start = 0, keyword = parseKeyword(text, start)) {
     function formatH(align, offset) {
         if (align.value === 'center') {
             return 'center';
@@ -306,29 +274,29 @@ function parseBackgroundPosition(text, start, keyword) {
         }
         return align.value;
     }
-    var end = start;
+    let end = start;
     if (keyword && backgroundPositionKeywords.has(keyword.value)) {
         end = keyword.end;
-        var firstDirection = backgroundPositionKeywordsDirection[keyword.value];
-        var firstLength = firstDirection !== 'center' && parsePercentageOrLength(text, end);
+        const firstDirection = backgroundPositionKeywordsDirection[keyword.value];
+        const firstLength = firstDirection !== 'center' && parsePercentageOrLength(text, end);
         if (firstLength) {
             end = firstLength.end;
         }
-        var secondKeyword = parseKeyword(text, end);
+        const secondKeyword = parseKeyword(text, end);
         if (secondKeyword && backgroundPositionKeywords.has(secondKeyword.value)) {
             end = secondKeyword.end;
-            var secondDirection = backgroundPositionKeywordsDirection[secondKeyword.end];
+            const secondDirection = backgroundPositionKeywordsDirection[secondKeyword.end];
             if (firstDirection === secondDirection && firstDirection !== 'center') {
-                return null;
+                return null; // Reject pair of both horizontal or both vertical alignments.
             }
-            var secondLength = secondDirection !== 'center' && parsePercentageOrLength(text, end);
+            const secondLength = secondDirection !== 'center' && parsePercentageOrLength(text, end);
             if (secondLength) {
                 end = secondLength.end;
             }
             if ((firstDirection === secondDirection && secondDirection === 'center') || firstDirection === 'x' || secondDirection === 'y') {
                 return {
-                    start: start,
-                    end: end,
+                    start,
+                    end,
                     value: {
                         x: formatH(keyword, firstLength),
                         y: formatV(secondKeyword, secondLength),
@@ -337,8 +305,8 @@ function parseBackgroundPosition(text, start, keyword) {
             }
             else {
                 return {
-                    start: start,
-                    end: end,
+                    start,
+                    end,
                     value: {
                         x: formatH(secondKeyword, secondLength),
                         y: formatV(keyword, firstLength),
@@ -348,12 +316,12 @@ function parseBackgroundPosition(text, start, keyword) {
         }
         else {
             if (firstDirection === 'center') {
-                return { start: start, end: end, value: { x: 'center', y: 'center' } };
+                return { start, end, value: { x: 'center', y: 'center' } };
             }
             else if (firstDirection === 'x') {
                 return {
-                    start: start,
-                    end: end,
+                    start,
+                    end,
                     value: {
                         x: formatH(keyword, firstLength),
                         y: 'center',
@@ -362,8 +330,8 @@ function parseBackgroundPosition(text, start, keyword) {
             }
             else {
                 return {
-                    start: start,
-                    end: end,
+                    start,
+                    end,
                     value: {
                         x: 'center',
                         y: formatV(keyword, firstLength),
@@ -373,15 +341,15 @@ function parseBackgroundPosition(text, start, keyword) {
         }
     }
     else {
-        var firstLength = parsePercentageOrLength(text, end);
+        const firstLength = parsePercentageOrLength(text, end);
         if (firstLength) {
             end = firstLength.end;
-            var secondLength = parsePercentageOrLength(text, end);
+            const secondLength = parsePercentageOrLength(text, end);
             if (secondLength) {
                 end = secondLength.end;
                 return {
-                    start: start,
-                    end: end,
+                    start,
+                    end,
                     value: {
                         x: { align: 'left', offset: firstLength.value },
                         y: { align: 'top', offset: secondLength.value },
@@ -390,8 +358,8 @@ function parseBackgroundPosition(text, start, keyword) {
             }
             else {
                 return {
-                    start: start,
-                    end: end,
+                    start,
+                    end,
                     value: {
                         x: { align: 'left', offset: firstLength.value },
                         y: 'center',
@@ -404,15 +372,14 @@ function parseBackgroundPosition(text, start, keyword) {
         }
     }
 }
-exports.parseBackgroundPosition = parseBackgroundPosition;
-var directionRegEx = /\s*to\s*(left|right|top|bottom)\s*(left|right|top|bottom)?\s*/gy;
-var sideDirections = {
+const directionRegEx = /\s*to\s*(left|right|top|bottom)\s*(left|right|top|bottom)?\s*/gy;
+const sideDirections = {
     top: (Math.PI * 0) / 2,
     right: (Math.PI * 1) / 2,
     bottom: (Math.PI * 2) / 2,
     left: (Math.PI * 3) / 2,
 };
-var cornerDirections = {
+const cornerDirections = {
     top: {
         right: (Math.PI * 1) / 4,
         left: (Math.PI * 7) / 4,
@@ -430,56 +397,56 @@ var cornerDirections = {
         bottom: (Math.PI * 5) / 4,
     },
 };
-function parseDirection(text, start) {
-    if (start === void 0) { start = 0; }
+function parseDirection(text, start = 0) {
     directionRegEx.lastIndex = start;
-    var result = directionRegEx.exec(text);
+    const result = directionRegEx.exec(text);
     if (!result) {
         return null;
     }
-    var end = directionRegEx.lastIndex;
-    var firstDirection = result[1];
+    const end = directionRegEx.lastIndex;
+    const firstDirection = result[1];
     if (result[2]) {
-        var secondDirection = result[2];
-        var value = cornerDirections[firstDirection][secondDirection];
-        return value === undefined ? null : { start: start, end: end, value: value };
+        const secondDirection = result[2];
+        const value = cornerDirections[firstDirection][secondDirection];
+        return value === undefined ? null : { start, end, value };
     }
     else {
-        return { start: start, end: end, value: sideDirections[firstDirection] };
+        return { start, end, value: sideDirections[firstDirection] };
     }
 }
-var openingBracketRegEx = /\s*\(\s*/gy;
-var closingBracketRegEx = /\s*\)\s*/gy;
-var closingBracketOrCommaRegEx = /\s*([),])\s*/gy;
+const openingBracketRegEx = /\s*\(\s*/gy;
+const closingBracketRegEx = /\s*\)\s*/gy;
+const closingBracketOrCommaRegEx = /\s*([),])\s*/gy;
 function parseArgumentsList(text, start, argument) {
     openingBracketRegEx.lastIndex = start;
-    var openingBracket = openingBracketRegEx.exec(text);
+    const openingBracket = openingBracketRegEx.exec(text);
     if (!openingBracket) {
         return null;
     }
-    var end = openingBracketRegEx.lastIndex;
-    var value = [];
+    let end = openingBracketRegEx.lastIndex;
+    const value = [];
     closingBracketRegEx.lastIndex = end;
-    var closingBracket = closingBracketRegEx.exec(text);
+    const closingBracket = closingBracketRegEx.exec(text);
     if (closingBracket) {
-        return { start: start, end: end, value: value };
+        return { start, end, value };
     }
-    for (var index = 0; true; index++) {
-        var arg = argument(text, end, index);
+    for (let index = 0; true; index++) {
+        const arg = argument(text, end, index);
         if (!arg) {
             return null;
         }
         end = arg.end;
         value.push(arg);
         closingBracketOrCommaRegEx.lastIndex = end;
-        var closingBracketOrComma = closingBracketOrCommaRegEx.exec(text);
+        const closingBracketOrComma = closingBracketOrCommaRegEx.exec(text);
         if (closingBracketOrComma) {
             end = closingBracketOrCommaRegEx.lastIndex;
             if (closingBracketOrComma[1] === ',') {
+                // noinspection UnnecessaryContinueJS
                 continue;
             }
             else if (closingBracketOrComma[1] === ')') {
-                return { start: start, end: end, value: value };
+                return { start, end, value };
             }
         }
         else {
@@ -487,45 +454,43 @@ function parseArgumentsList(text, start, argument) {
         }
     }
 }
-function parseColorStop(text, start) {
-    if (start === void 0) { start = 0; }
-    var color = parseColor(text, start);
+export function parseColorStop(text, start = 0) {
+    const color = parseColor(text, start);
     if (!color) {
         return null;
     }
-    var end = color.end;
-    var offset = parsePercentageOrLength(text, end);
+    let end = color.end;
+    const offset = parsePercentageOrLength(text, end);
     if (offset) {
         end = offset.end;
         return {
-            start: start,
-            end: end,
+            start,
+            end,
             value: { argb: color.value, offset: offset.value },
         };
     }
-    return { start: start, end: end, value: { argb: color.value } };
+    return { start, end, value: { argb: color.value } };
 }
-exports.parseColorStop = parseColorStop;
-var linearGradientStartRegEx = /\s*linear-gradient\s*/gy;
-function parseLinearGradient(text, start) {
-    if (start === void 0) { start = 0; }
+const linearGradientStartRegEx = /\s*linear-gradient\s*/gy;
+export function parseLinearGradient(text, start = 0) {
     linearGradientStartRegEx.lastIndex = start;
-    var lgs = linearGradientStartRegEx.exec(text);
+    const lgs = linearGradientStartRegEx.exec(text);
     if (!lgs) {
         return null;
     }
-    var end = linearGradientStartRegEx.lastIndex;
-    var angle = Math.PI;
-    var colors = [];
-    var parsedArgs = parseArgumentsList(text, end, function (text, start, index) {
+    let end = linearGradientStartRegEx.lastIndex;
+    let angle = Math.PI;
+    const colors = [];
+    const parsedArgs = parseArgumentsList(text, end, (text, start, index) => {
         if (index === 0) {
-            var angleArg = parseAngle(text, start) || parseDirection(text, start);
+            // First arg can be gradient direction
+            const angleArg = parseAngle(text, start) || parseDirection(text, start);
             if (angleArg) {
                 angle = angleArg.value;
                 return angleArg;
             }
         }
-        var colorStop = parseColorStop(text, start);
+        const colorStop = parseColorStop(text, start);
         if (colorStop) {
             colors.push(colorStop.value);
             return colorStop;
@@ -536,47 +501,46 @@ function parseLinearGradient(text, start) {
         return null;
     }
     end = parsedArgs.end;
-    return { start: start, end: end, value: { angle: angle, colors: colors } };
+    return { start, end, value: { angle, colors } };
 }
-exports.parseLinearGradient = parseLinearGradient;
-var slashRegEx = /\s*(\/)\s*/gy;
+const slashRegEx = /\s*(\/)\s*/gy;
 function parseSlash(text, start) {
     slashRegEx.lastIndex = start;
-    var slash = slashRegEx.exec(text);
+    const slash = slashRegEx.exec(text);
     if (!slash) {
         return null;
     }
-    var end = slashRegEx.lastIndex;
-    return { start: start, end: end, value: '/' };
+    const end = slashRegEx.lastIndex;
+    return { start, end, value: '/' };
 }
-function parseBackground(text, start) {
-    if (start === void 0) { start = 0; }
-    var value = {};
-    var end = start;
+export function parseBackground(text, start = 0) {
+    const value = {};
+    let end = start;
     while (end < text.length) {
-        var keyword = parseKeyword(text, end);
-        var color = parseColor(text, end, keyword);
+        const keyword = parseKeyword(text, end);
+        const color = parseColor(text, end, keyword);
         if (color) {
             value.color = color.value;
             end = color.end;
             continue;
         }
-        var repeat = parseRepeat(text, end, keyword);
+        const repeat = parseRepeat(text, end, keyword);
         if (repeat) {
             value.repeat = repeat.value;
             end = repeat.end;
             continue;
         }
-        var position = parseBackgroundPosition(text, end, keyword);
+        const position = parseBackgroundPosition(text, end, keyword);
         if (position) {
             position.value.text = text.substring(position.start, position.end);
             value.position = position.value;
             end = position.end;
-            var slash = parseSlash(text, end);
+            const slash = parseSlash(text, end);
             if (slash) {
                 end = slash.end;
-                var size = parseBackgroundSize(text, end);
+                const size = parseBackgroundSize(text, end);
                 if (!size) {
+                    // Found / but no proper size following
                     return null;
                 }
                 value.size = size.value;
@@ -584,13 +548,13 @@ function parseBackground(text, start) {
             }
             continue;
         }
-        var url = parseURL(text, end);
+        const url = parseURL(text, end);
         if (url) {
             value.image = url.value;
             end = url.end;
             continue;
         }
-        var gradient = parseLinearGradient(text, end);
+        const gradient = parseLinearGradient(text, end);
         if (gradient) {
             value.image = gradient.value;
             end = gradient.end;
@@ -598,102 +562,90 @@ function parseBackground(text, start) {
         }
         return null;
     }
-    return { start: start, end: end, value: value };
+    return { start, end, value };
 }
-exports.parseBackground = parseBackground;
-var universalSelectorRegEx = /\*/gy;
-function parseUniversalSelector(text, start) {
-    if (start === void 0) { start = 0; }
+const universalSelectorRegEx = /\*/gy;
+export function parseUniversalSelector(text, start = 0) {
     universalSelectorRegEx.lastIndex = start;
-    var result = universalSelectorRegEx.exec(text);
+    const result = universalSelectorRegEx.exec(text);
     if (!result) {
         return null;
     }
-    var end = universalSelectorRegEx.lastIndex;
-    return { start: start, end: end, value: { type: '*' } };
+    const end = universalSelectorRegEx.lastIndex;
+    return { start, end, value: { type: '*' } };
 }
-exports.parseUniversalSelector = parseUniversalSelector;
-var simpleIdentifierSelectorRegEx = /(#|\.|:|\b)((?:[\w_-]|\\.)(?:[\w\d_-]|\\.)*)/guy;
-var unicodeEscapeRegEx = /\\([0-9a-fA-F]{1,5}\s|[0-9a-fA-F]{6})/g;
-function parseSimpleIdentifierSelector(text, start) {
-    if (start === void 0) { start = 0; }
+const simpleIdentifierSelectorRegEx = /(#|\.|:|\b)((?:[\w_-]|\\.)(?:[\w\d_-]|\\.)*)/guy;
+const unicodeEscapeRegEx = /\\([0-9a-fA-F]{1,5}\s|[0-9a-fA-F]{6})/g;
+export function parseSimpleIdentifierSelector(text, start = 0) {
     simpleIdentifierSelectorRegEx.lastIndex = start;
-    var result = simpleIdentifierSelectorRegEx.exec(text.replace(unicodeEscapeRegEx, function (_, c) { return '\\' + String.fromCodePoint(parseInt(c.trim(), 16)); }));
+    const result = simpleIdentifierSelectorRegEx.exec(text.replace(unicodeEscapeRegEx, (_, c) => '\\' + String.fromCodePoint(parseInt(c.trim(), 16))));
     if (!result) {
         return null;
     }
-    var end = simpleIdentifierSelectorRegEx.lastIndex;
-    var type = result[1];
-    var identifier = result[2].replace(/\\/g, '');
-    var value = { type: type, identifier: identifier };
-    return { start: start, end: end, value: value };
+    const end = simpleIdentifierSelectorRegEx.lastIndex;
+    const type = result[1];
+    const identifier = result[2].replace(/\\/g, '');
+    const value = { type, identifier };
+    return { start, end, value };
 }
-exports.parseSimpleIdentifierSelector = parseSimpleIdentifierSelector;
-var attributeSelectorRegEx = /\[\s*([_\-\w][_\-\w\d]*)\s*(?:(=|\^=|\$=|\*=|\~=|\|=)\s*(?:([_\-\w][_\-\w\d]*)|"((?:[^\\"]|\\(?:"|n|r|f|\\|0-9a-f))*)"|'((?:[^\\']|\\(?:'|n|r|f|\\|0-9a-f))*)')\s*)?\]/gy;
-function parseAttributeSelector(text, start) {
+const attributeSelectorRegEx = /\[\s*([_\-\w][_\-\w\d]*)\s*(?:(=|\^=|\$=|\*=|\~=|\|=)\s*(?:([_\-\w][_\-\w\d]*)|"((?:[^\\"]|\\(?:"|n|r|f|\\|0-9a-f))*)"|'((?:[^\\']|\\(?:'|n|r|f|\\|0-9a-f))*)')\s*)?\]/gy;
+export function parseAttributeSelector(text, start) {
     attributeSelectorRegEx.lastIndex = start;
-    var result = attributeSelectorRegEx.exec(text);
+    const result = attributeSelectorRegEx.exec(text);
     if (!result) {
         return null;
     }
-    var end = attributeSelectorRegEx.lastIndex;
-    var property = result[1];
+    const end = attributeSelectorRegEx.lastIndex;
+    const property = result[1];
     if (result[2]) {
-        var test_1 = result[2];
-        var value = result[3] || result[4] || result[5];
-        return { start: start, end: end, value: { type: '[]', property: property, test: test_1, value: value } };
+        const test = result[2];
+        const value = result[3] || result[4] || result[5];
+        return { start, end, value: { type: '[]', property, test, value } };
     }
-    return { start: start, end: end, value: { type: '[]', property: property } };
+    return { start, end, value: { type: '[]', property } };
 }
-exports.parseAttributeSelector = parseAttributeSelector;
-function parseSimpleSelector(text, start) {
-    if (start === void 0) { start = 0; }
+export function parseSimpleSelector(text, start = 0) {
     return parseUniversalSelector(text, start) || parseSimpleIdentifierSelector(text, start) || parseAttributeSelector(text, start);
 }
-exports.parseSimpleSelector = parseSimpleSelector;
-function parseSimpleSelectorSequence(text, start) {
-    var simpleSelector = parseSimpleSelector(text, start);
+export function parseSimpleSelectorSequence(text, start) {
+    let simpleSelector = parseSimpleSelector(text, start);
     if (!simpleSelector) {
         return null;
     }
-    var end = simpleSelector.end;
-    var value = [];
+    let end = simpleSelector.end;
+    const value = [];
     while (simpleSelector) {
         value.push(simpleSelector.value);
         end = simpleSelector.end;
         simpleSelector = parseSimpleSelector(text, end);
     }
-    return { start: start, end: end, value: value };
+    return { start, end, value };
 }
-exports.parseSimpleSelectorSequence = parseSimpleSelectorSequence;
-var combinatorRegEx = /\s*([+~>])?\s*/gy;
-function parseCombinator(text, start) {
-    if (start === void 0) { start = 0; }
+const combinatorRegEx = /\s*([+~>])?\s*/gy;
+export function parseCombinator(text, start = 0) {
     combinatorRegEx.lastIndex = start;
-    var result = combinatorRegEx.exec(text);
+    const result = combinatorRegEx.exec(text);
     if (!result) {
         return null;
     }
-    var end = combinatorRegEx.lastIndex;
-    var value = result[1] || ' ';
-    return { start: start, end: end, value: value };
+    const end = combinatorRegEx.lastIndex;
+    const value = result[1] || ' ';
+    return { start, end, value };
 }
-exports.parseCombinator = parseCombinator;
-var whiteSpaceRegEx = /\s*/gy;
-function parseSelector(text, start) {
-    if (start === void 0) { start = 0; }
-    var end = start;
+const whiteSpaceRegEx = /\s*/gy;
+export function parseSelector(text, start = 0) {
+    let end = start;
     whiteSpaceRegEx.lastIndex = end;
-    var leadingWhiteSpace = whiteSpaceRegEx.exec(text);
+    const leadingWhiteSpace = whiteSpaceRegEx.exec(text);
     if (leadingWhiteSpace) {
         end = whiteSpaceRegEx.lastIndex;
     }
-    var value = [];
-    var combinator;
-    var expectSimpleSelector = true;
-    var pair;
+    const value = [];
+    let combinator;
+    let expectSimpleSelector = true; // Must have at least one
+    let pair;
     do {
-        var simpleSelectorSequence = parseSimpleSelectorSequence(text, end);
+        const simpleSelectorSequence = parseSimpleSelectorSequence(text, end);
         if (!simpleSelectorSequence) {
             if (expectSimpleSelector) {
                 return null;
@@ -704,6 +656,10 @@ function parseSelector(text, start) {
         }
         end = simpleSelectorSequence.end;
         if (combinator) {
+            // This logic looks weird; this `if` statement would occur on the next LOOP, so it effects the prior `pair`
+            // variable which is already pushed into the `value` array is going to have its `undefined` set to this
+            // value before the following statement creates a new `pair` memory variable.
+            // noinspection JSUnusedAssignment
             pair[1] = combinator.value;
         }
         pair = [simpleSelectorSequence.value, undefined];
@@ -712,38 +668,51 @@ function parseSelector(text, start) {
         if (combinator) {
             end = combinator.end;
         }
-        expectSimpleSelector = combinator && combinator.value !== ' ';
+        expectSimpleSelector = combinator && combinator.value !== ' '; // Simple selector must follow non trailing white space combinator
     } while (combinator);
-    return { start: start, end: end, value: value };
+    return { start, end, value };
 }
-exports.parseSelector = parseSelector;
-var whitespaceRegEx = /[\s\t\n\r\f]*/gmy;
-var singleQuoteStringRegEx = /'((?:[^\n\r\f\']|\\(?:\$|\n|[0-9a-fA-F]{1,6}\s?))*)(:?'|$)/gmy;
-var doubleQuoteStringRegEx = /"((?:[^\n\r\f\"]|\\(?:\$|\n|[0-9a-fA-F]{1,6}\s?))*)(:?"|$)/gmy;
-var commentRegEx = /(\/\*(?:[^\*]|\*[^\/])*\*\/)/gmy;
-var numberRegEx = /[\+\-]?(?:\d+\.\d+|\d+|\.\d+)(?:[eE][\+\-]?\d+)?/gmy;
-var nameRegEx = /-?(?:(?:[a-zA-Z_]|[^\x00-\x7F]|\\(?:\$|\n|[0-9a-fA-F]{1,6}\s?))(?:[a-zA-Z_0-9\-]*|\\(?:\$|\n|[0-9a-fA-F]{1,6}\s?))*)/gmy;
-var CSS3Parser = (function () {
-    function CSS3Parser(text) {
+const whitespaceRegEx = /[\s\t\n\r\f]*/gmy;
+const singleQuoteStringRegEx = /'((?:[^\n\r\f\']|\\(?:\$|\n|[0-9a-fA-F]{1,6}\s?))*)(:?'|$)/gmy; // Besides $n, parse escape
+const doubleQuoteStringRegEx = /"((?:[^\n\r\f\"]|\\(?:\$|\n|[0-9a-fA-F]{1,6}\s?))*)(:?"|$)/gmy; // Besides $n, parse escape
+const commentRegEx = /(\/\*(?:[^\*]|\*[^\/])*\*\/)/gmy;
+const numberRegEx = /[\+\-]?(?:\d+\.\d+|\d+|\.\d+)(?:[eE][\+\-]?\d+)?/gmy;
+// eslint-disable-next-line no-control-regex
+const nameRegEx = /-?(?:(?:[a-zA-Z_]|[^\x00-\x7F]|\\(?:\$|\n|[0-9a-fA-F]{1,6}\s?))(?:[a-zA-Z_0-9\-]*|\\(?:\$|\n|[0-9a-fA-F]{1,6}\s?))*)/gmy;
+/**
+ * CSS parser following relatively close:
+ * CSS Syntax Module Level 3
+ * https://www.w3.org/TR/css-syntax-3/
+ */
+export class CSS3Parser {
+    constructor(text) {
         this.text = text;
         this.nextInputCodePointIndex = 0;
     }
-    CSS3Parser.prototype.tokenize = function () {
-        var tokens = [];
-        var inputToken;
+    /**
+     * For testing purposes.
+     * This method allows us to run and assert the proper working of the tokenizer.
+     */
+    tokenize() {
+        const tokens = [];
+        let inputToken;
         do {
             inputToken = this.consumeAToken();
             tokens.push(inputToken);
         } while (inputToken);
         return tokens;
-    };
-    CSS3Parser.prototype.consumeAToken = function () {
+    }
+    /**
+     * 4.3.1. Consume a token
+     * https://www.w3.org/TR/css-syntax-3/#consume-a-token
+     */
+    consumeAToken() {
         if (this.reconsumedInputToken) {
-            var result = this.reconsumedInputToken;
+            const result = this.reconsumedInputToken;
             this.reconsumedInputToken = null;
             return result;
         }
-        var char = this.text[this.nextInputCodePointIndex];
+        const char = this.text[this.nextInputCodePointIndex];
         switch (char) {
             case '"':
                 return this.consumeAStringToken();
@@ -770,6 +739,7 @@ var CSS3Parser = (function () {
                 return this.consumeAWhitespace();
             case '@':
                 return this.consumeAtKeyword() || this.consumeADelimToken();
+            // TODO: Only if this is valid escape, otherwise it is a parse error
             case '\\':
                 return this.consumeAnIdentLikeToken() || this.consumeADelimToken();
             case '0':
@@ -786,8 +756,9 @@ var CSS3Parser = (function () {
             case 'u':
             case 'U':
                 if (this.text[this.nextInputCodePointIndex + 1] === '+') {
-                    var thirdChar = this.text[this.nextInputCodePointIndex + 2];
+                    const thirdChar = this.text[this.nextInputCodePointIndex + 2];
                     if ((thirdChar >= '0' && thirdChar <= '9') || thirdChar === '?') {
+                        // TODO: Handle unicode stuff such as U+002B
                         throw new Error('Unicode tokens not supported!');
                     }
                 }
@@ -812,71 +783,79 @@ var CSS3Parser = (function () {
             default:
                 return this.consumeAnIdentLikeToken() || this.consumeADelimToken();
         }
-    };
-    CSS3Parser.prototype.consumeADelimToken = function () {
+    }
+    consumeADelimToken() {
         return {
-            type: 2,
+            type: 2 /* delim */,
             text: this.text[this.nextInputCodePointIndex++],
         };
-    };
-    CSS3Parser.prototype.consumeAWhitespace = function () {
+    }
+    consumeAWhitespace() {
         whitespaceRegEx.lastIndex = this.nextInputCodePointIndex;
         whitespaceRegEx.exec(this.text);
         this.nextInputCodePointIndex = whitespaceRegEx.lastIndex;
         return ' ';
-    };
-    CSS3Parser.prototype.consumeAHashToken = function () {
+    }
+    consumeAHashToken() {
         this.nextInputCodePointIndex++;
-        var hashName = this.consumeAName();
+        const hashName = this.consumeAName();
         if (hashName) {
-            return { type: 12, text: '#' + hashName.text };
+            return { type: 12 /* hash */, text: '#' + hashName.text };
         }
         this.nextInputCodePointIndex--;
         return null;
-    };
-    CSS3Parser.prototype.consumeCDO = function () {
+    }
+    consumeCDO() {
         if (this.text.substr(this.nextInputCodePointIndex, 4) === '<!--') {
             this.nextInputCodePointIndex += 4;
             return '<!--';
         }
         return null;
-    };
-    CSS3Parser.prototype.consumeCDC = function () {
+    }
+    consumeCDC() {
         if (this.text.substr(this.nextInputCodePointIndex, 3) === '-->') {
             this.nextInputCodePointIndex += 3;
             return '-->';
         }
         return null;
-    };
-    CSS3Parser.prototype.consumeAMatchToken = function () {
+    }
+    consumeAMatchToken() {
         if (this.text[this.nextInputCodePointIndex + 1] === '=') {
-            var token = this.text.substr(this.nextInputCodePointIndex, 2);
+            const token = this.text.substr(this.nextInputCodePointIndex, 2);
             this.nextInputCodePointIndex += 2;
             return token;
         }
         return null;
-    };
-    CSS3Parser.prototype.consumeANumericToken = function () {
+    }
+    /**
+     * 4.3.2. Consume a numeric token
+     * https://www.w3.org/TR/css-syntax-3/#consume-a-numeric-token
+     */
+    consumeANumericToken() {
         numberRegEx.lastIndex = this.nextInputCodePointIndex;
-        var result = numberRegEx.exec(this.text);
+        const result = numberRegEx.exec(this.text);
         if (!result) {
             return null;
         }
         this.nextInputCodePointIndex = numberRegEx.lastIndex;
         if (this.text[this.nextInputCodePointIndex] === '%') {
-            return { type: 4, text: result[0] };
+            return { type: 4 /* percentage */, text: result[0] }; // TODO: Push the actual number and unit here...
         }
-        var name = this.consumeAName();
+        const name = this.consumeAName();
         if (name) {
             return {
-                type: 5,
+                type: 5 /* dimension */,
                 text: result[0] + name.text,
             };
         }
-        return { type: 3, text: result[0] };
-    };
-    CSS3Parser.prototype.consumeAnIdentLikeToken = function () {
-        var name = this.consumeAName();
+        return { type: 3 /* number */, text: result[0] };
+    }
+    /**
+     * 4.3.3. Consume an ident-like token
+     * https://www.w3.org/TR/css-syntax-3/#consume-an-ident-like-token
+     */
+    consumeAnIdentLikeToken() {
+        const name = this.consumeAName();
         if (!name) {
             return null;
         }
@@ -886,16 +865,20 @@ var CSS3Parser = (function () {
                 return this.consumeAURLToken();
             }
             return {
-                type: 8,
+                type: 8 /* functionToken */,
                 name: name.text,
                 text: name.text + '(',
             };
         }
         return name;
-    };
-    CSS3Parser.prototype.consumeAStringToken = function () {
-        var char = this.text[this.nextInputCodePointIndex];
-        var result;
+    }
+    /**
+     * 4.3.4. Consume a string token
+     * https://www.w3.org/TR/css-syntax-3/#consume-a-string-token
+     */
+    consumeAStringToken() {
+        const char = this.text[this.nextInputCodePointIndex];
+        let result;
         if (char === "'") {
             singleQuoteStringRegEx.lastIndex = this.nextInputCodePointIndex;
             result = singleQuoteStringRegEx.exec(this.text);
@@ -912,35 +895,44 @@ var CSS3Parser = (function () {
             }
             this.nextInputCodePointIndex = doubleQuoteStringRegEx.lastIndex;
         }
-        return { type: 1, text: result[0] };
-    };
-    CSS3Parser.prototype.consumeAURLToken = function () {
-        var start = this.nextInputCodePointIndex - 3 - 1;
-        var urlToken = {
-            type: 7,
+        // TODO: Handle bad-string.
+        // TODO: Perform string escaping.
+        return { type: 1 /* string */, text: result[0] };
+    }
+    /**
+     * 4.3.5. Consume a url token
+     * https://www.w3.org/TR/css-syntax-3/#consume-a-url-token
+     */
+    consumeAURLToken() {
+        const start = this.nextInputCodePointIndex - 3 /* url */ - 1; /* ( */
+        const urlToken = {
+            type: 7 /* url */,
             text: undefined,
         };
         this.consumeAWhitespace();
         if (this.nextInputCodePointIndex >= this.text.length) {
             return urlToken;
         }
-        var nextInputCodePoint = this.text[this.nextInputCodePointIndex];
+        const nextInputCodePoint = this.text[this.nextInputCodePointIndex];
         if (nextInputCodePoint === '"' || nextInputCodePoint === "'") {
-            var stringToken = this.consumeAStringToken();
+            const stringToken = this.consumeAStringToken();
+            // TODO: Handle bad-string.
+            // TODO: Set value instead.
             urlToken.text = stringToken.text;
             this.consumeAWhitespace();
             if (this.text[this.nextInputCodePointIndex] === ')' || this.nextInputCodePointIndex >= this.text.length) {
                 this.nextInputCodePointIndex++;
-                var end = this.nextInputCodePointIndex;
+                const end = this.nextInputCodePointIndex;
                 urlToken.text = this.text.substring(start, end);
                 return urlToken;
             }
             else {
+                // TODO: Handle bad-url.
                 return null;
             }
         }
         while (this.nextInputCodePointIndex < this.text.length) {
-            var char = this.text[this.nextInputCodePointIndex++];
+            const char = this.text[this.nextInputCodePointIndex++];
             switch (char) {
                 case ')':
                     return urlToken;
@@ -955,61 +947,79 @@ var CSS3Parser = (function () {
                         return urlToken;
                     }
                     else {
+                        // TODO: Bar url! Consume remnants.
                         return null;
                     }
                 case '"':
                 case "'":
+                    // TODO: Parse error! Bar url! Consume remnants.
                     return null;
                 case '\\':
+                    // TODO: Escape!
                     throw new Error('Escaping not yet supported!');
                 default:
+                    // TODO: Non-printable chars - error.
                     urlToken.text += char;
             }
         }
         return urlToken;
-    };
-    CSS3Parser.prototype.consumeAName = function () {
+    }
+    /**
+     * 4.3.11. Consume a name
+     * https://www.w3.org/TR/css-syntax-3/#consume-a-name
+     */
+    consumeAName() {
         nameRegEx.lastIndex = this.nextInputCodePointIndex;
-        var result = nameRegEx.exec(this.text);
+        const result = nameRegEx.exec(this.text);
         if (!result) {
             return null;
         }
         this.nextInputCodePointIndex = nameRegEx.lastIndex;
-        return { type: 6, text: result[0] };
-    };
-    CSS3Parser.prototype.consumeAtKeyword = function () {
+        // TODO: Perform string escaping.
+        return { type: 6 /* ident */, text: result[0] };
+    }
+    consumeAtKeyword() {
         this.nextInputCodePointIndex++;
-        var name = this.consumeAName();
+        const name = this.consumeAName();
         if (name) {
-            return { type: 11, text: name.text };
+            return { type: 11 /* atKeyword */, text: name.text };
         }
         this.nextInputCodePointIndex--;
         return null;
-    };
-    CSS3Parser.prototype.consumeAComment = function () {
+    }
+    consumeAComment() {
         if (this.text[this.nextInputCodePointIndex + 1] === '*') {
             commentRegEx.lastIndex = this.nextInputCodePointIndex;
-            var result = commentRegEx.exec(this.text);
+            const result = commentRegEx.exec(this.text);
             if (!result) {
-                return null;
+                return null; // TODO: Handle <bad-comment>
             }
             this.nextInputCodePointIndex = commentRegEx.lastIndex;
+            // The CSS spec tokenizer does not emmit comment tokens
             return this.consumeAToken();
         }
         return null;
-    };
-    CSS3Parser.prototype.reconsumeTheCurrentInputToken = function (currentInputToken) {
+    }
+    reconsumeTheCurrentInputToken(currentInputToken) {
         this.reconsumedInputToken = currentInputToken;
-    };
-    CSS3Parser.prototype.parseAStylesheet = function () {
+    }
+    /**
+     * 5.3.1. Parse a stylesheet
+     * https://www.w3.org/TR/css-syntax-3/#parse-a-stylesheet
+     */
+    parseAStylesheet() {
         this.topLevelFlag = true;
         return {
             rules: this.consumeAListOfRules(),
         };
-    };
-    CSS3Parser.prototype.consumeAListOfRules = function () {
-        var rules = [];
-        var inputToken;
+    }
+    /**
+     * 5.4.1. Consume a list of rules
+     * https://www.w3.org/TR/css-syntax-3/#consume-a-list-of-rules
+     */
+    consumeAListOfRules() {
+        const rules = [];
+        let inputToken;
         while ((inputToken = this.consumeAToken())) {
             switch (inputToken) {
                 case ' ':
@@ -1020,32 +1030,36 @@ var CSS3Parser = (function () {
                         continue;
                     }
                     this.reconsumeTheCurrentInputToken(inputToken);
-                    var atRule = this.consumeAnAtRule();
+                    const atRule = this.consumeAnAtRule();
                     if (atRule) {
                         rules.push(atRule);
                     }
                     continue;
                 }
             }
-            if (inputToken.type === 11) {
+            if (inputToken.type === 11 /* atKeyword */) {
                 this.reconsumeTheCurrentInputToken(inputToken);
-                var atRule = this.consumeAnAtRule();
+                const atRule = this.consumeAnAtRule();
                 if (atRule) {
                     rules.push(atRule);
                 }
                 continue;
             }
             this.reconsumeTheCurrentInputToken(inputToken);
-            var qualifiedRule = this.consumeAQualifiedRule();
+            const qualifiedRule = this.consumeAQualifiedRule();
             if (qualifiedRule) {
                 rules.push(qualifiedRule);
             }
         }
         return rules;
-    };
-    CSS3Parser.prototype.consumeAnAtRule = function () {
-        var inputToken = this.consumeAToken();
-        var atRule = {
+    }
+    /**
+     * 5.4.2. Consume an at-rule
+     * https://www.w3.org/TR/css-syntax-3/#consume-an-at-rule
+     */
+    consumeAnAtRule() {
+        let inputToken = this.consumeAToken();
+        const atRule = {
             type: 'at-rule',
             name: inputToken.text,
             prelude: [],
@@ -1059,47 +1073,57 @@ var CSS3Parser = (function () {
                 atRule.block = this.consumeASimpleBlock(inputToken);
                 return atRule;
             }
-            else if (inputToken.type === 9 && inputToken.associatedToken === '{') {
+            else if (inputToken.type === 9 /* simpleBlock */ && inputToken.associatedToken === '{') {
                 atRule.block = inputToken;
                 return atRule;
             }
             this.reconsumeTheCurrentInputToken(inputToken);
-            var component = this.consumeAComponentValue();
+            const component = this.consumeAComponentValue();
             if (component) {
                 atRule.prelude.push(component);
             }
         }
         return atRule;
-    };
-    CSS3Parser.prototype.consumeAQualifiedRule = function () {
-        var qualifiedRule = {
+    }
+    /**
+     * 5.4.3. Consume a qualified rule
+     * https://www.w3.org/TR/css-syntax-3/#consume-a-qualified-rule
+     */
+    consumeAQualifiedRule() {
+        const qualifiedRule = {
             type: 'qualified-rule',
             prelude: [],
             block: undefined,
         };
-        var inputToken;
+        let inputToken;
         while ((inputToken = this.consumeAToken())) {
             if (inputToken === '{') {
                 qualifiedRule.block = this.consumeASimpleBlock(inputToken);
                 return qualifiedRule;
             }
-            else if (inputToken.type === 9) {
-                var simpleBlock = inputToken;
+            else if (inputToken.type === 9 /* simpleBlock */) {
+                const simpleBlock = inputToken;
                 if (simpleBlock.associatedToken === '{') {
                     qualifiedRule.block = simpleBlock;
                     return qualifiedRule;
                 }
             }
             this.reconsumeTheCurrentInputToken(inputToken);
-            var componentValue = this.consumeAComponentValue();
+            const componentValue = this.consumeAComponentValue();
             if (componentValue) {
                 qualifiedRule.prelude.push(componentValue);
             }
         }
+        // TODO: This is a parse error, log parse errors!
         return null;
-    };
-    CSS3Parser.prototype.consumeAComponentValue = function () {
-        var inputToken = this.consumeAToken();
+    }
+    /**
+     * 5.4.6. Consume a component value
+     * https://www.w3.org/TR/css-syntax-3/#consume-a-component-value
+     */
+    consumeAComponentValue() {
+        // const inputToken = this.consumeAToken();
+        const inputToken = this.consumeAToken();
         switch (inputToken) {
             case '{':
             case '[':
@@ -1107,45 +1131,53 @@ var CSS3Parser = (function () {
                 this.nextInputCodePointIndex++;
                 return this.consumeASimpleBlock(inputToken);
         }
-        if (typeof inputToken === 'object' && inputToken.type === 8) {
+        if (typeof inputToken === 'object' && inputToken.type === 8 /* functionToken */) {
             return this.consumeAFunction(inputToken.name);
         }
         return inputToken;
-    };
-    CSS3Parser.prototype.consumeASimpleBlock = function (associatedToken) {
-        var endianToken = {
+    }
+    /**
+     * 5.4.7. Consume a simple block
+     * https://www.w3.org/TR/css-syntax-3/#consume-a-simple-block
+     */
+    consumeASimpleBlock(associatedToken) {
+        const endianToken = {
             '[': ']',
             '{': '}',
             '(': ')',
         }[associatedToken];
-        var start = this.nextInputCodePointIndex - 1;
-        var block = {
-            type: 9,
+        const start = this.nextInputCodePointIndex - 1;
+        const block = {
+            type: 9 /* simpleBlock */,
             text: undefined,
-            associatedToken: associatedToken,
+            associatedToken,
             values: [],
         };
-        var nextInputToken;
+        let nextInputToken;
         while ((nextInputToken = this.text[this.nextInputCodePointIndex])) {
             if (nextInputToken === endianToken) {
                 this.nextInputCodePointIndex++;
-                var end = this.nextInputCodePointIndex;
+                const end = this.nextInputCodePointIndex;
                 block.text = this.text.substring(start, end);
                 return block;
             }
-            var value = this.consumeAComponentValue();
+            const value = this.consumeAComponentValue();
             if (value) {
                 block.values.push(value);
             }
         }
         block.text = this.text.substring(start);
         return block;
-    };
-    CSS3Parser.prototype.consumeAFunction = function (name) {
-        var start = this.nextInputCodePointIndex;
-        var funcToken = {
-            type: 14,
-            name: name,
+    }
+    /**
+     * 5.4.8. Consume a function
+     * https://www.w3.org/TR/css-syntax-3/#consume-a-function
+     */
+    consumeAFunction(name) {
+        const start = this.nextInputCodePointIndex;
+        const funcToken = {
+            type: 14 /* function */,
+            name,
             text: undefined,
             components: [],
         };
@@ -1154,75 +1186,77 @@ var CSS3Parser = (function () {
                 funcToken.text = name + '(' + this.text.substring(start);
                 return funcToken;
             }
-            var nextInputToken = this.text[this.nextInputCodePointIndex];
+            const nextInputToken = this.text[this.nextInputCodePointIndex];
             switch (nextInputToken) {
                 case ')': {
                     this.nextInputCodePointIndex++;
-                    var end = this.nextInputCodePointIndex;
+                    const end = this.nextInputCodePointIndex;
                     funcToken.text = name + '(' + this.text.substring(start, end);
                     return funcToken;
                 }
                 default: {
-                    var component = this.consumeAComponentValue();
+                    const component = this.consumeAComponentValue();
                     if (component) {
                         funcToken.components.push(component);
                     }
                 }
+                // TODO: Else we won't advance
             }
         } while (true);
-    };
-    return CSS3Parser;
-}());
-exports.CSS3Parser = CSS3Parser;
-var CSSNativeScript = (function () {
-    function CSSNativeScript() {
     }
-    CSSNativeScript.prototype.parseStylesheet = function (stylesheet) {
+}
+/**
+ * Consume a CSS3 parsed stylesheet and convert the rules and selectors to the
+ * NativeScript internal JSON representation.
+ */
+export class CSSNativeScript {
+    parseStylesheet(stylesheet) {
         return {
             type: 'stylesheet',
             stylesheet: {
                 rules: this.parseRules(stylesheet.rules),
             },
         };
-    };
-    CSSNativeScript.prototype.parseRules = function (rules) {
-        var _this = this;
-        return rules.map(function (rule) { return _this.parseRule(rule); });
-    };
-    CSSNativeScript.prototype.parseRule = function (rule) {
+    }
+    parseRules(rules) {
+        return rules.map((rule) => this.parseRule(rule));
+    }
+    parseRule(rule) {
         if (rule.type === 'at-rule') {
             return this.parseAtRule(rule);
         }
         else if (rule.type === 'qualified-rule') {
             return this.parseQualifiedRule(rule);
         }
-    };
-    CSSNativeScript.prototype.parseAtRule = function (rule) {
+    }
+    parseAtRule(rule) {
         if (rule.name === 'import') {
+            // TODO: We have used an "@import { url('path somewhere'); }" at few places.
             return {
                 import: rule.prelude
-                    .map(function (m) { return (typeof m === 'string' ? m : m.text); })
+                    .map((m) => (typeof m === 'string' ? m : m.text))
                     .join('')
                     .trim(),
                 type: 'import',
             };
         }
         return;
-    };
-    CSSNativeScript.prototype.parseQualifiedRule = function (rule) {
+    }
+    parseQualifiedRule(rule) {
         return {
             type: 'rule',
             selectors: this.preludeToSelectorsStringArray(rule.prelude),
             declarations: this.ruleBlockToDeclarations(rule.block.values),
         };
-    };
-    CSSNativeScript.prototype.ruleBlockToDeclarations = function (declarationsInputTokens) {
-        var declarations = [];
-        var property = '';
-        var value = '';
-        var reading = 'property';
-        for (var i = 0; i < declarationsInputTokens.length; i++) {
-            var inputToken = declarationsInputTokens[i];
+    }
+    ruleBlockToDeclarations(declarationsInputTokens) {
+        // return <any>declarationsInputTokens;
+        const declarations = [];
+        let property = '';
+        let value = '';
+        let reading = 'property';
+        for (let i = 0; i < declarationsInputTokens.length; i++) {
+            const inputToken = declarationsInputTokens[i];
             if (reading === 'property') {
                 if (inputToken === ':') {
                     reading = 'value';
@@ -1238,7 +1272,7 @@ var CSSNativeScript = (function () {
                 if (inputToken === ';') {
                     property = property.trim();
                     value = value.trim();
-                    declarations.push({ type: 'declaration', property: property, value: value });
+                    declarations.push({ type: 'declaration', property, value });
                     property = '';
                     value = '';
                     reading = 'property';
@@ -1254,14 +1288,14 @@ var CSSNativeScript = (function () {
         property = property.trim();
         value = value.trim();
         if (property || value) {
-            declarations.push({ type: 'declaration', property: property, value: value });
+            declarations.push({ type: 'declaration', property, value });
         }
         return declarations;
-    };
-    CSSNativeScript.prototype.preludeToSelectorsStringArray = function (prelude) {
-        var selectors = [];
-        var selector = '';
-        prelude.forEach(function (inputToken) {
+    }
+    preludeToSelectorsStringArray(prelude) {
+        const selectors = [];
+        let selector = '';
+        prelude.forEach((inputToken) => {
             if (typeof inputToken === 'string') {
                 if (inputToken === ',') {
                     if (selector) {
@@ -1281,8 +1315,6 @@ var CSSNativeScript = (function () {
             selectors.push(selector.trim());
         }
         return selectors;
-    };
-    return CSSNativeScript;
-}());
-exports.CSSNativeScript = CSSNativeScript;
+    }
+}
 //# sourceMappingURL=parser.js.map