@nativescript/core 8.9.0-alpha.3 → 8.9.0-napi-es5.0

package/css/parser.js

@@ -1,38 +1,42 @@
 import { Color } from '../color';
 import { getKnownColor } from '../color/known-colors';
-const urlRegEx = /\s*url\((?:(['"])([^\1]*)\1|([^)]*))\)\s*/gy;
-export function parseURL(text, start = 0) {
+var urlRegEx = /\s*url\((?:(['"])(.*?)\1|([^)]*))\)\s*/gy;
+// const urlRegEx = /(?:^|\s*#[a-fA-F0-9]{3,6}\s*|^\s*)url\((['"]?)(.*?)\1\)\s*/gi;
+export function parseURL(text, start) {
+    if (start === void 0) { start = 0; }
     urlRegEx.lastIndex = start;
-    const result = urlRegEx.exec(text);
+    var result = urlRegEx.exec(text);
     if (!result) {
         return null;
     }
-    const end = urlRegEx.lastIndex;
-    const value = result[2] || result[3];
-    return { start, end, value };
+    var end = urlRegEx.lastIndex;
+    var value = result[2] || result[3];
+    return { start: start, end: end, value: value };
 }
-const hexColorRegEx = /\s*#((?:[0-9A-F]{8})|(?:[0-9A-F]{6})|(?:[0-9A-F]{4})|(?:[0-9A-F]{3}))\s*/giy;
-export function parseHexColor(text, start = 0) {
+var hexColorRegEx = /\s*#((?:[0-9A-F]{8})|(?:[0-9A-F]{6})|(?:[0-9A-F]{4})|(?:[0-9A-F]{3}))\s*/giy;
+export function parseHexColor(text, start) {
+    if (start === void 0) { start = 0; }
     hexColorRegEx.lastIndex = start;
-    const result = hexColorRegEx.exec(text);
+    var result = hexColorRegEx.exec(text);
     if (!result) {
         return null;
     }
-    const end = hexColorRegEx.lastIndex;
-    return { start, end, value: new Color('#' + result[1]) };
+    var end = hexColorRegEx.lastIndex;
+    return { start: start, end: end, value: new Color('#' + result[1]) };
 }
-const cssColorRegEx = /\s*((?:rgb|rgba|hsl|hsla|hsv|hsva)\([^\(\)]*\))/gy;
-export function parseCssColor(text, start = 0) {
+var cssColorRegEx = /\s*((?:rgb|rgba|hsl|hsla|hsv|hsva)\([^\(\)]*\))/gy;
+export function parseCssColor(text, start) {
+    if (start === void 0) { start = 0; }
     cssColorRegEx.lastIndex = start;
-    const result = cssColorRegEx.exec(text);
+    var result = cssColorRegEx.exec(text);
     if (!result) {
         return null;
     }
-    const end = cssColorRegEx.lastIndex;
+    var end = cssColorRegEx.lastIndex;
     try {
-        return { start, end, value: new Color(result[1]) };
+        return { start: start, end: end, value: new Color(result[1]) };
     }
-    catch {
+    catch (_a) {
         return null;
     }
 }
@@ -41,9 +45,9 @@ export function convertHSLToRGBColor(hue, saturation, lightness) {
     // https://en.wikipedia.org/wiki/HSL_and_HSV#HSL_to_RGB
     hue /= 60;
     lightness /= 100;
-    const chroma = ((1 - Math.abs(2 * lightness - 1)) * saturation) / 100, X = chroma * (1 - Math.abs((hue % 2) - 1));
+    var 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 };
+    var _a = { m: lightness - chroma / 2 }, r = _a.m, g = _a.m, b = _a.m;
     if (0 <= hue && hue < 1) {
         r += chroma;
         g += X;
@@ -74,54 +78,62 @@ export function convertHSLToRGBColor(hue, saturation, lightness) {
         b: Math.round(b * 0xff),
     };
 }
-export function parseColorKeyword(value, start, keyword = parseKeyword(value, start)) {
-    const parseColor = keyword && getKnownColor(keyword.value);
+export function parseColorKeyword(value, start, keyword) {
+    if (keyword === void 0) { keyword = parseKeyword(value, start); }
+    var parseColor = keyword && getKnownColor(keyword.value);
     if (parseColor != null) {
-        const end = keyword.end;
-        return { start, end, value: new Color(parseColor) };
+        var end = keyword.end;
+        return { start: start, end: end, value: new Color(parseColor) };
     }
     return null;
 }
-export function parseColor(value, start = 0, keyword = parseKeyword(value, start)) {
+export function parseColor(value, start, keyword) {
+    if (start === void 0) { start = 0; }
+    if (keyword === void 0) { keyword = parseKeyword(value, start); }
     return parseHexColor(value, start) || parseColorKeyword(value, start, keyword) || parseCssColor(value, start);
 }
-const keywordRegEx = /\s*([a-z][\w\-]*)\s*/giy;
-function parseKeyword(text, start = 0) {
+var keywordRegEx = /\s*([a-z][\w\-]*)\s*/giy;
+function parseKeyword(text, start) {
+    if (start === void 0) { start = 0; }
     keywordRegEx.lastIndex = start;
-    const result = keywordRegEx.exec(text);
+    var result = keywordRegEx.exec(text);
     if (!result) {
         return null;
     }
-    const end = keywordRegEx.lastIndex;
-    const value = result[1];
-    return { start, end, value };
+    var end = keywordRegEx.lastIndex;
+    var value = result[1];
+    return { start: start, end: end, value: value };
 }
-const backgroundRepeatKeywords = new Set(['repeat', 'repeat-x', 'repeat-y', 'no-repeat']);
-export function parseRepeat(value, start = 0, keyword = parseKeyword(value, start)) {
+var backgroundRepeatKeywords = new Set(['repeat', 'repeat-x', 'repeat-y', 'no-repeat']);
+export function parseRepeat(value, start, keyword) {
+    if (start === void 0) { start = 0; }
+    if (keyword === void 0) { keyword = parseKeyword(value, start); }
     if (keyword && backgroundRepeatKeywords.has(keyword.value)) {
-        const end = keyword.end;
-        const value = keyword.value;
-        return { start, end, value };
+        var end = keyword.end;
+        var value_1 = keyword.value;
+        return { start: start, end: end, value: value_1 };
     }
     return null;
 }
-const unitRegEx = /\s*([+\-]?(?:\d+\.\d+|\d+|\.\d+)(?:[eE][+\-]?\d+)?)([a-zA-Z]+|%)?\s*/gy;
-export function parseUnit(text, start = 0) {
+var unitRegEx = /\s*([+\-]?(?:\d+\.\d+|\d+|\.\d+)(?:[eE][+\-]?\d+)?)([a-zA-Z]+|%)?\s*/gy;
+export function parseUnit(text, start) {
+    if (start === void 0) { start = 0; }
     unitRegEx.lastIndex = start;
-    const result = unitRegEx.exec(text);
+    var result = unitRegEx.exec(text);
     if (!result) {
         return null;
     }
-    const end = unitRegEx.lastIndex;
-    const value = parseFloat(result[1]);
-    const unit = result[2] || 'dip';
-    return { start, end, value: { value, unit } };
+    var end = unitRegEx.lastIndex;
+    var value = parseFloat(result[1]);
+    var unit = result[2] || 'dip';
+    return { start: start, end: end, value: { value: value, unit: unit } };
 }
-export function parsePercentageOrLength(text, start = 0) {
-    const unitResult = parseUnit(text, start);
+export function parsePercentageOrLength(text, start) {
+    if (start === void 0) { start = 0; }
+    var unitResult = parseUnit(text, start);
     if (unitResult) {
-        const { start, end } = unitResult;
-        const value = unitResult.value;
+        var start_1 = unitResult.start, end = unitResult.end;
+        var value = unitResult.value;
         if (value.unit === '%') {
             value.value /= 100;
         }
@@ -134,76 +146,81 @@ export function parsePercentageOrLength(text, start = 0) {
         else {
             return null;
         }
-        return { start, end, value };
+        return { start: start_1, end: end, value: value };
     }
     return null;
 }
-const angleUnitsToRadMap = {
-    deg: (start, end, deg) => ({
-        start,
-        end,
+var angleUnitsToRadMap = {
+    deg: function (start, end, deg) { return ({
+        start: start,
+        end: end,
         value: (deg / 180) * Math.PI,
-    }),
-    rad: (start, end, rad) => ({
-        start,
-        end,
+    }); },
+    rad: function (start, end, rad) { return ({
+        start: start,
+        end: end,
         value: rad,
-    }),
-    grad: (start, end, grad) => ({
-        start,
-        end,
+    }); },
+    grad: function (start, end, grad) { return ({
+        start: start,
+        end: end,
         value: (grad / 200) * Math.PI,
-    }),
-    turn: (start, end, turn) => ({
-        start,
-        end,
+    }); },
+    turn: function (start, end, turn) { return ({
+        start: start,
+        end: end,
         value: turn * Math.PI * 2,
-    }),
+    }); },
 };
-export function parseAngle(value, start = 0) {
-    const angleResult = parseUnit(value, start);
+export function parseAngle(value, start) {
+    if (start === void 0) { start = 0; }
+    var angleResult = parseUnit(value, start);
     if (angleResult) {
-        const { start, end, value } = angleResult;
-        return (angleUnitsToRadMap[value.unit] || ((_, __, ___) => null))(start, end, value.value);
+        var start_2 = angleResult.start, end = angleResult.end, value_2 = angleResult.value;
+        return (angleUnitsToRadMap[value_2.unit] || (function (_, __, ___) { return null; }))(start_2, end, value_2.value);
     }
     return null;
 }
-const backgroundSizeKeywords = new Set(['auto', 'contain', 'cover']);
-export function parseBackgroundSize(value, start = 0, keyword = parseKeyword(value, start)) {
-    let end = start;
+var backgroundSizeKeywords = new Set(['auto', 'contain', 'cover']);
+export function parseBackgroundSize(value, start, keyword) {
+    if (start === void 0) { start = 0; }
+    if (keyword === void 0) { keyword = parseKeyword(value, start); }
+    var end = start;
     if (keyword && backgroundSizeKeywords.has(keyword.value)) {
         end = keyword.end;
-        const value = keyword.value;
-        return { start, end, value };
+        var value_3 = keyword.value;
+        return { start: start, end: end, value: value_3 };
     }
     // Parse one or two lengths... the other will be "auto"
-    const firstLength = parsePercentageOrLength(value, end);
+    var firstLength = parsePercentageOrLength(value, end);
     if (firstLength) {
         end = firstLength.end;
-        const secondLength = parsePercentageOrLength(value, firstLength.end);
+        var secondLength = parsePercentageOrLength(value, firstLength.end);
         if (secondLength) {
             end = secondLength.end;
             return {
-                start,
-                end,
+                start: start,
+                end: end,
                 value: { x: firstLength.value, y: secondLength.value },
             };
         }
         else {
-            return { start, end, value: { x: firstLength.value, y: 'auto' } };
+            return { start: start, end: end, value: { x: firstLength.value, y: 'auto' } };
         }
     }
     return null;
 }
-const backgroundPositionKeywords = Object.freeze(new Set(['left', 'right', 'top', 'bottom', 'center']));
-const backgroundPositionKeywordsDirection = {
+var backgroundPositionKeywords = Object.freeze(new Set(['left', 'right', 'top', 'bottom', 'center']));
+var backgroundPositionKeywordsDirection = {
     left: 'x',
     right: 'x',
     center: 'center',
     top: 'y',
     bottom: 'y',
 };
-export function parseBackgroundPosition(text, start = 0, keyword = parseKeyword(text, start)) {
+export function parseBackgroundPosition(text, start, keyword) {
+    if (start === void 0) { start = 0; }
+    if (keyword === void 0) { keyword = parseKeyword(text, start); }
     function formatH(align, offset) {
         if (align.value === 'center') {
             return 'center';
@@ -222,29 +239,29 @@ export function parseBackgroundPosition(text, start = 0, keyword = parseKeyword(
         }
         return align.value;
     }
-    let end = start;
+    var end = start;
     if (keyword && backgroundPositionKeywords.has(keyword.value)) {
         end = keyword.end;
-        const firstDirection = backgroundPositionKeywordsDirection[keyword.value];
-        const firstLength = firstDirection !== 'center' && parsePercentageOrLength(text, end);
+        var firstDirection = backgroundPositionKeywordsDirection[keyword.value];
+        var firstLength = firstDirection !== 'center' && parsePercentageOrLength(text, end);
         if (firstLength) {
             end = firstLength.end;
         }
-        const secondKeyword = parseKeyword(text, end);
+        var secondKeyword = parseKeyword(text, end);
         if (secondKeyword && backgroundPositionKeywords.has(secondKeyword.value)) {
             end = secondKeyword.end;
-            const secondDirection = backgroundPositionKeywordsDirection[secondKeyword.end];
+            var secondDirection = backgroundPositionKeywordsDirection[secondKeyword.end];
             if (firstDirection === secondDirection && firstDirection !== 'center') {
                 return null; // Reject pair of both horizontal or both vertical alignments.
             }
-            const secondLength = secondDirection !== 'center' && parsePercentageOrLength(text, end);
+            var secondLength = secondDirection !== 'center' && parsePercentageOrLength(text, end);
             if (secondLength) {
                 end = secondLength.end;
             }
             if ((firstDirection === secondDirection && secondDirection === 'center') || firstDirection === 'x' || secondDirection === 'y') {
                 return {
-                    start,
-                    end,
+                    start: start,
+                    end: end,
                     value: {
                         x: formatH(keyword, firstLength),
                         y: formatV(secondKeyword, secondLength),
@@ -253,8 +270,8 @@ export function parseBackgroundPosition(text, start = 0, keyword = parseKeyword(
             }
             else {
                 return {
-                    start,
-                    end,
+                    start: start,
+                    end: end,
                     value: {
                         x: formatH(secondKeyword, secondLength),
                         y: formatV(keyword, firstLength),
@@ -264,12 +281,12 @@ export function parseBackgroundPosition(text, start = 0, keyword = parseKeyword(
         }
         else {
             if (firstDirection === 'center') {
-                return { start, end, value: { x: 'center', y: 'center' } };
+                return { start: start, end: end, value: { x: 'center', y: 'center' } };
             }
             else if (firstDirection === 'x') {
                 return {
-                    start,
-                    end,
+                    start: start,
+                    end: end,
                     value: {
                         x: formatH(keyword, firstLength),
                         y: 'center',
@@ -278,8 +295,8 @@ export function parseBackgroundPosition(text, start = 0, keyword = parseKeyword(
             }
             else {
                 return {
-                    start,
-                    end,
+                    start: start,
+                    end: end,
                     value: {
                         x: 'center',
                         y: formatV(keyword, firstLength),
@@ -289,15 +306,15 @@ export function parseBackgroundPosition(text, start = 0, keyword = parseKeyword(
         }
     }
     else {
-        const firstLength = parsePercentageOrLength(text, end);
+        var firstLength = parsePercentageOrLength(text, end);
         if (firstLength) {
             end = firstLength.end;
-            const secondLength = parsePercentageOrLength(text, end);
+            var secondLength = parsePercentageOrLength(text, end);
             if (secondLength) {
                 end = secondLength.end;
                 return {
-                    start,
-                    end,
+                    start: start,
+                    end: end,
                     value: {
                         x: { align: 'left', offset: firstLength.value },
                         y: { align: 'top', offset: secondLength.value },
@@ -306,8 +323,8 @@ export function parseBackgroundPosition(text, start = 0, keyword = parseKeyword(
             }
             else {
                 return {
-                    start,
-                    end,
+                    start: start,
+                    end: end,
                     value: {
                         x: { align: 'left', offset: firstLength.value },
                         y: 'center',
@@ -320,14 +337,14 @@ export function parseBackgroundPosition(text, start = 0, keyword = parseKeyword(
         }
     }
 }
-const directionRegEx = /\s*to\s*(left|right|top|bottom)\s*(left|right|top|bottom)?\s*/gy;
-const sideDirections = {
+var directionRegEx = /\s*to\s*(left|right|top|bottom)\s*(left|right|top|bottom)?\s*/gy;
+var sideDirections = {
     top: (Math.PI * 0) / 2,
     right: (Math.PI * 1) / 2,
     bottom: (Math.PI * 2) / 2,
     left: (Math.PI * 3) / 2,
 };
-const cornerDirections = {
+var cornerDirections = {
     top: {
         right: (Math.PI * 1) / 4,
         left: (Math.PI * 7) / 4,
@@ -345,49 +362,50 @@ const cornerDirections = {
         bottom: (Math.PI * 5) / 4,
     },
 };
-function parseDirection(text, start = 0) {
+function parseDirection(text, start) {
+    if (start === void 0) { start = 0; }
     directionRegEx.lastIndex = start;
-    const result = directionRegEx.exec(text);
+    var result = directionRegEx.exec(text);
     if (!result) {
         return null;
     }
-    const end = directionRegEx.lastIndex;
-    const firstDirection = result[1];
+    var end = directionRegEx.lastIndex;
+    var firstDirection = result[1];
     if (result[2]) {
-        const secondDirection = result[2];
-        const value = cornerDirections[firstDirection][secondDirection];
-        return value === undefined ? null : { start, end, value };
+        var secondDirection = result[2];
+        var value = cornerDirections[firstDirection][secondDirection];
+        return value === undefined ? null : { start: start, end: end, value: value };
     }
     else {
-        return { start, end, value: sideDirections[firstDirection] };
+        return { start: start, end: end, value: sideDirections[firstDirection] };
     }
 }
-const openingBracketRegEx = /\s*\(\s*/gy;
-const closingBracketRegEx = /\s*\)\s*/gy;
-const closingBracketOrCommaRegEx = /\s*([),])\s*/gy;
+var openingBracketRegEx = /\s*\(\s*/gy;
+var closingBracketRegEx = /\s*\)\s*/gy;
+var closingBracketOrCommaRegEx = /\s*([),])\s*/gy;
 function parseArgumentsList(text, start, argument) {
     openingBracketRegEx.lastIndex = start;
-    const openingBracket = openingBracketRegEx.exec(text);
+    var openingBracket = openingBracketRegEx.exec(text);
     if (!openingBracket) {
         return null;
     }
-    let end = openingBracketRegEx.lastIndex;
-    const value = [];
+    var end = openingBracketRegEx.lastIndex;
+    var value = [];
     closingBracketRegEx.lastIndex = end;
-    const closingBracket = closingBracketRegEx.exec(text);
+    var closingBracket = closingBracketRegEx.exec(text);
     if (closingBracket) {
-        return { start, end, value };
+        return { start: start, end: end, value: value };
     }
     // eslint-disable-next-line no-constant-condition
-    for (let index = 0; true; index++) {
-        const arg = argument(text, end, index);
+    for (var index = 0; true; index++) {
+        var arg = argument(text, end, index);
         if (!arg) {
             return null;
         }
         end = arg.end;
         value.push(arg);
         closingBracketOrCommaRegEx.lastIndex = end;
-        const closingBracketOrComma = closingBracketOrCommaRegEx.exec(text);
+        var closingBracketOrComma = closingBracketOrCommaRegEx.exec(text);
         if (closingBracketOrComma) {
             end = closingBracketOrCommaRegEx.lastIndex;
             if (closingBracketOrComma[1] === ',') {
@@ -395,7 +413,7 @@ function parseArgumentsList(text, start, argument) {
                 continue;
             }
             else if (closingBracketOrComma[1] === ')') {
-                return { start, end, value };
+                return { start: start, end: end, value: value };
             }
         }
         else {
@@ -403,43 +421,45 @@ function parseArgumentsList(text, start, argument) {
         }
     }
 }
-export function parseColorStop(text, start = 0) {
-    const color = parseColor(text, start);
+export function parseColorStop(text, start) {
+    if (start === void 0) { start = 0; }
+    var color = parseColor(text, start);
     if (!color) {
         return null;
     }
-    let end = color.end;
-    const offset = parsePercentageOrLength(text, end);
+    var end = color.end;
+    var offset = parsePercentageOrLength(text, end);
     if (offset) {
         end = offset.end;
         return {
-            start,
-            end,
+            start: start,
+            end: end,
             value: { color: color.value, offset: offset.value },
         };
     }
-    return { start, end, value: { color: color.value } };
+    return { start: start, end: end, value: { color: color.value } };
 }
-const linearGradientStartRegEx = /\s*linear-gradient\s*/gy;
-export function parseLinearGradient(text, start = 0) {
+var linearGradientStartRegEx = /\s*linear-gradient\s*/gy;
+export function parseLinearGradient(text, start) {
+    if (start === void 0) { start = 0; }
     linearGradientStartRegEx.lastIndex = start;
-    const lgs = linearGradientStartRegEx.exec(text);
+    var lgs = linearGradientStartRegEx.exec(text);
     if (!lgs) {
         return null;
     }
-    let end = linearGradientStartRegEx.lastIndex;
-    let angle = Math.PI;
-    const colors = [];
-    const parsedArgs = parseArgumentsList(text, end, (text, start, index) => {
+    var end = linearGradientStartRegEx.lastIndex;
+    var angle = Math.PI;
+    var colors = [];
+    var parsedArgs = parseArgumentsList(text, end, function (text, start, index) {
         if (index === 0) {
             // First arg can be gradient direction
-            const angleArg = parseAngle(text, start) || parseDirection(text, start);
+            var angleArg = parseAngle(text, start) || parseDirection(text, start);
             if (angleArg) {
                 angle = angleArg.value;
                 return angleArg;
             }
         }
-        const colorStop = parseColorStop(text, start);
+        var colorStop = parseColorStop(text, start);
         if (colorStop) {
             colors.push(colorStop.value);
             return colorStop;
@@ -450,44 +470,45 @@ export function parseLinearGradient(text, start = 0) {
         return null;
     }
     end = parsedArgs.end;
-    return { start, end, value: { angle, colors } };
+    return { start: start, end: end, value: { angle: angle, colors: colors } };
 }
-const slashRegEx = /\s*(\/)\s*/gy;
+var slashRegEx = /\s*(\/)\s*/gy;
 function parseSlash(text, start) {
     slashRegEx.lastIndex = start;
-    const slash = slashRegEx.exec(text);
+    var slash = slashRegEx.exec(text);
     if (!slash) {
         return null;
     }
-    const end = slashRegEx.lastIndex;
-    return { start, end, value: '/' };
+    var end = slashRegEx.lastIndex;
+    return { start: start, end: end, value: '/' };
 }
-export function parseBackground(text, start = 0) {
-    const value = {};
-    let end = start;
+export function parseBackground(text, start) {
+    if (start === void 0) { start = 0; }
+    var value = {};
+    var end = start;
     while (end < text.length) {
-        const keyword = parseKeyword(text, end);
-        const color = parseColor(text, end, keyword);
+        var keyword = parseKeyword(text, end);
+        var color = parseColor(text, end, keyword);
         if (color) {
             value.color = color.value;
             end = color.end;
             continue;
         }
-        const repeat = parseRepeat(text, end, keyword);
+        var repeat = parseRepeat(text, end, keyword);
         if (repeat) {
             value.repeat = repeat.value;
             end = repeat.end;
             continue;
         }
-        const position = parseBackgroundPosition(text, end, keyword);
+        var position = parseBackgroundPosition(text, end, keyword);
         if (position) {
             position.value.text = text.substring(position.start, position.end);
             value.position = position.value;
             end = position.end;
-            const slash = parseSlash(text, end);
+            var slash = parseSlash(text, end);
             if (slash) {
                 end = slash.end;
-                const size = parseBackgroundSize(text, end);
+                var size = parseBackgroundSize(text, end);
                 if (!size) {
                     // Found / but no proper size following
                     return null;
@@ -497,13 +518,13 @@ export function parseBackground(text, start = 0) {
             }
             continue;
         }
-        const url = parseURL(text, end);
+        var url = parseURL(text, end);
         if (url) {
             value.image = url.value;
             end = url.end;
             continue;
         }
-        const gradient = parseLinearGradient(text, end);
+        var gradient = parseLinearGradient(text, end);
         if (gradient) {
             value.image = gradient.value;
             end = gradient.end;
@@ -511,6 +532,6 @@ export function parseBackground(text, start = 0) {
         }
         return null;
     }
-    return { start, end, value };
+    return { start: start, end: end, value: value };
 }
 //# sourceMappingURL=parser.js.map