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

package/ui/styling/style-properties.js

@@ -50,13 +50,15 @@ function convertToStringCommon(length) {
     if (typeof length === 'number') {
         return length.toString();
     }
-    let val = length.value;
+    var val = length.value;
     if (length.unit === '%') {
         val *= 100;
     }
     return val + length.unit;
 }
-function toDevicePixelsCommon(length, auto = Number.NaN, parentAvailableWidth = Number.NaN) {
+function toDevicePixelsCommon(length, auto, parentAvailableWidth) {
+    if (auto === void 0) { auto = Number.NaN; }
+    if (parentAvailableWidth === void 0) { parentAvailableWidth = Number.NaN; }
     if (length == 'auto') {
         // tslint:disable-line
         return auto;
@@ -85,10 +87,10 @@ export var PercentLength;
             return 'auto';
         }
         if (typeof fromValue === 'string') {
-            let stringValue = fromValue.trim();
-            const percentIndex = stringValue.indexOf('%');
+            var stringValue = fromValue.trim();
+            var percentIndex = stringValue.indexOf('%');
             if (percentIndex !== -1) {
-                let value;
+                var value = void 0;
                 // if only % or % is not last we treat it as invalid value.
                 if (percentIndex !== stringValue.length - 1 || percentIndex === 0) {
                     value = Number.NaN;
@@ -98,22 +100,22 @@ export var PercentLength;
                     value = parseFloat(stringValue.substring(0, stringValue.length - 1).trim()) / 100;
                 }
                 if (isNaN(value) || !isFinite(value)) {
-                    throw new Error(`Invalid value: ${fromValue}`);
+                    throw new Error("Invalid value: ".concat(fromValue));
                 }
-                return { unit: '%', value };
+                return { unit: '%', value: value };
             }
             else if (stringValue.indexOf('px') !== -1) {
                 stringValue = stringValue.replace('px', '').trim();
-                const value = parseFloat(stringValue);
+                var value = parseFloat(stringValue);
                 if (isNaN(value) || !isFinite(value)) {
-                    throw new Error(`Invalid value: ${fromValue}`);
+                    throw new Error("Invalid value: ".concat(fromValue));
                 }
-                return { unit: 'px', value };
+                return { unit: 'px', value: value };
             }
             else {
-                const value = parseFloat(stringValue);
+                var value = parseFloat(stringValue);
                 if (isNaN(value) || !isFinite(value)) {
-                    throw new Error(`Invalid value: ${fromValue}`);
+                    throw new Error("Invalid value: ".concat(fromValue));
                 }
                 return value;
             }
@@ -135,19 +137,19 @@ export var Length;
             return 'auto';
         }
         if (typeof fromValue === 'string') {
-            let stringValue = fromValue.trim();
+            var stringValue = fromValue.trim();
             if (stringValue.indexOf('px') !== -1) {
                 stringValue = stringValue.replace('px', '').trim();
-                const value = parseFloat(stringValue);
+                var value = parseFloat(stringValue);
                 if (isNaN(value) || !isFinite(value)) {
-                    throw new Error(`Invalid value: ${stringValue}`);
+                    throw new Error("Invalid value: ".concat(stringValue));
                 }
-                return { unit: 'px', value };
+                return { unit: 'px', value: value };
             }
             else {
-                const value = parseFloat(stringValue);
+                var value = parseFloat(stringValue);
                 if (isNaN(value) || !isFinite(value)) {
-                    throw new Error(`Invalid value: ${stringValue}`);
+                    throw new Error("Invalid value: ".concat(stringValue));
                 }
                 return value;
             }
@@ -161,52 +163,52 @@ export var Length;
     Length.toDevicePixels = toDevicePixelsCommon;
     Length.convertToString = convertToStringCommon;
 })(Length || (Length = {}));
-export const minWidthProperty = new CssProperty({
+export var minWidthProperty = new CssProperty({
     name: 'minWidth',
     cssName: 'min-width',
     defaultValue: CoreTypes.zeroLength,
     affectsLayout: global.isIOS,
     equalityComparer: Length.equals,
-    valueChanged: (target, oldValue, newValue) => {
-        const view = target.viewRef.get();
+    valueChanged: function (target, oldValue, newValue) {
+        var view = target.viewRef.get();
         if (view) {
             view.effectiveMinWidth = Length.toDevicePixels(newValue, 0);
         }
         else {
-            Trace.write(`${newValue} not set to view's property because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
+            Trace.write("".concat(newValue, " not set to view's property because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
         }
     },
     valueConverter: Length.parse,
 });
 minWidthProperty.register(Style);
-export const minHeightProperty = new CssProperty({
+export var minHeightProperty = new CssProperty({
     name: 'minHeight',
     cssName: 'min-height',
     defaultValue: CoreTypes.zeroLength,
     affectsLayout: global.isIOS,
     equalityComparer: Length.equals,
-    valueChanged: (target, oldValue, newValue) => {
-        const view = target.viewRef.get();
+    valueChanged: function (target, oldValue, newValue) {
+        var view = target.viewRef.get();
         if (view) {
             view.effectiveMinHeight = Length.toDevicePixels(newValue, 0);
         }
         else {
-            Trace.write(`${newValue} not set to view's property because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
+            Trace.write("".concat(newValue, " not set to view's property because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
         }
     },
     valueConverter: Length.parse,
 });
 minHeightProperty.register(Style);
-export const widthProperty = new CssAnimationProperty({
+export var widthProperty = new CssAnimationProperty({
     name: 'width',
     cssName: 'width',
     defaultValue: 'auto',
     equalityComparer: Length.equals,
     // TODO: CSSAnimationProperty was needed for keyframe (copying other impls), but `affectsLayout` does not exist
     //       on the animation property, so fake it here. x_x
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         if (global.isIOS) {
-            const view = target.viewRef.get();
+            var view = target.viewRef.get();
             if (view) {
                 view.requestLayout();
             }
@@ -215,16 +217,16 @@ export const widthProperty = new CssAnimationProperty({
     valueConverter: PercentLength.parse,
 });
 widthProperty.register(Style);
-export const heightProperty = new CssAnimationProperty({
+export var heightProperty = new CssAnimationProperty({
     name: 'height',
     cssName: 'height',
     defaultValue: 'auto',
     equalityComparer: Length.equals,
     // TODO: CSSAnimationProperty was needed for keyframe (copying other impls), but `affectsLayout` does not exist
     //       on the animation property, so fake it here. -_-
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         if (global.isIOS) {
-            const view = target.viewRef.get();
+            var view = target.viewRef.get();
             if (view) {
                 view.requestLayout();
             }
@@ -233,19 +235,19 @@ export const heightProperty = new CssAnimationProperty({
     valueConverter: PercentLength.parse,
 });
 heightProperty.register(Style);
-const marginProperty = new ShorthandProperty({
+var marginProperty = new ShorthandProperty({
     name: 'margin',
     cssName: 'margin',
     getter: function () {
         if (PercentLength.equals(this.marginTop, this.marginRight) && PercentLength.equals(this.marginTop, this.marginBottom) && PercentLength.equals(this.marginTop, this.marginLeft)) {
             return this.marginTop;
         }
-        return `${PercentLength.convertToString(this.marginTop)} ${PercentLength.convertToString(this.marginRight)} ${PercentLength.convertToString(this.marginBottom)} ${PercentLength.convertToString(this.marginLeft)}`;
+        return "".concat(PercentLength.convertToString(this.marginTop), " ").concat(PercentLength.convertToString(this.marginRight), " ").concat(PercentLength.convertToString(this.marginBottom), " ").concat(PercentLength.convertToString(this.marginLeft));
     },
     converter: convertToMargins,
 });
 marginProperty.register(Style);
-export const marginLeftProperty = new CssProperty({
+export var marginLeftProperty = new CssProperty({
     name: 'marginLeft',
     cssName: 'margin-left',
     defaultValue: CoreTypes.zeroLength,
@@ -254,7 +256,7 @@ export const marginLeftProperty = new CssProperty({
     valueConverter: PercentLength.parse,
 });
 marginLeftProperty.register(Style);
-export const marginRightProperty = new CssProperty({
+export var marginRightProperty = new CssProperty({
     name: 'marginRight',
     cssName: 'margin-right',
     defaultValue: CoreTypes.zeroLength,
@@ -263,7 +265,7 @@ export const marginRightProperty = new CssProperty({
     valueConverter: PercentLength.parse,
 });
 marginRightProperty.register(Style);
-export const marginTopProperty = new CssProperty({
+export var marginTopProperty = new CssProperty({
     name: 'marginTop',
     cssName: 'margin-top',
     defaultValue: CoreTypes.zeroLength,
@@ -272,7 +274,7 @@ export const marginTopProperty = new CssProperty({
     valueConverter: PercentLength.parse,
 });
 marginTopProperty.register(Style);
-export const marginBottomProperty = new CssProperty({
+export var marginBottomProperty = new CssProperty({
     name: 'marginBottom',
     cssName: 'margin-bottom',
     defaultValue: CoreTypes.zeroLength,
@@ -281,91 +283,91 @@ export const marginBottomProperty = new CssProperty({
     valueConverter: PercentLength.parse,
 });
 marginBottomProperty.register(Style);
-const paddingProperty = new ShorthandProperty({
+var paddingProperty = new ShorthandProperty({
     name: 'padding',
     cssName: 'padding',
     getter: function () {
         if (Length.equals(this.paddingTop, this.paddingRight) && Length.equals(this.paddingTop, this.paddingBottom) && Length.equals(this.paddingTop, this.paddingLeft)) {
             return this.paddingTop;
         }
-        return `${Length.convertToString(this.paddingTop)} ${Length.convertToString(this.paddingRight)} ${Length.convertToString(this.paddingBottom)} ${Length.convertToString(this.paddingLeft)}`;
+        return "".concat(Length.convertToString(this.paddingTop), " ").concat(Length.convertToString(this.paddingRight), " ").concat(Length.convertToString(this.paddingBottom), " ").concat(Length.convertToString(this.paddingLeft));
     },
     converter: convertToPaddings,
 });
 paddingProperty.register(Style);
-export const paddingLeftProperty = new CssProperty({
+export var paddingLeftProperty = new CssProperty({
     name: 'paddingLeft',
     cssName: 'padding-left',
     defaultValue: CoreTypes.zeroLength,
     affectsLayout: global.isIOS,
     equalityComparer: Length.equals,
-    valueChanged: (target, oldValue, newValue) => {
-        const view = target.viewRef.get();
+    valueChanged: function (target, oldValue, newValue) {
+        var view = target.viewRef.get();
         if (view) {
             view.effectivePaddingLeft = Length.toDevicePixels(newValue, 0);
         }
         else {
-            Trace.write(`${newValue} not set to view's property because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
+            Trace.write("".concat(newValue, " not set to view's property because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
         }
     },
     valueConverter: Length.parse,
 });
 paddingLeftProperty.register(Style);
-export const paddingRightProperty = new CssProperty({
+export var paddingRightProperty = new CssProperty({
     name: 'paddingRight',
     cssName: 'padding-right',
     defaultValue: CoreTypes.zeroLength,
     affectsLayout: global.isIOS,
     equalityComparer: Length.equals,
-    valueChanged: (target, oldValue, newValue) => {
-        const view = target.viewRef.get();
+    valueChanged: function (target, oldValue, newValue) {
+        var view = target.viewRef.get();
         if (view) {
             view.effectivePaddingRight = Length.toDevicePixels(newValue, 0);
         }
         else {
-            Trace.write(`${newValue} not set to view's property because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
+            Trace.write("".concat(newValue, " not set to view's property because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
         }
     },
     valueConverter: Length.parse,
 });
 paddingRightProperty.register(Style);
-export const paddingTopProperty = new CssProperty({
+export var paddingTopProperty = new CssProperty({
     name: 'paddingTop',
     cssName: 'padding-top',
     defaultValue: CoreTypes.zeroLength,
     affectsLayout: global.isIOS,
     equalityComparer: Length.equals,
-    valueChanged: (target, oldValue, newValue) => {
-        const view = target.viewRef.get();
+    valueChanged: function (target, oldValue, newValue) {
+        var view = target.viewRef.get();
         if (view) {
             view.effectivePaddingTop = Length.toDevicePixels(newValue, 0);
         }
         else {
-            Trace.write(`${newValue} not set to view's property because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
+            Trace.write("".concat(newValue, " not set to view's property because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
         }
     },
     valueConverter: Length.parse,
 });
 paddingTopProperty.register(Style);
-export const paddingBottomProperty = new CssProperty({
+export var paddingBottomProperty = new CssProperty({
     name: 'paddingBottom',
     cssName: 'padding-bottom',
     defaultValue: CoreTypes.zeroLength,
     affectsLayout: global.isIOS,
     equalityComparer: Length.equals,
-    valueChanged: (target, oldValue, newValue) => {
-        const view = target.viewRef.get();
+    valueChanged: function (target, oldValue, newValue) {
+        var view = target.viewRef.get();
         if (view) {
             view.effectivePaddingBottom = Length.toDevicePixels(newValue, 0);
         }
         else {
-            Trace.write(`${newValue} not set to view's property because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
+            Trace.write("".concat(newValue, " not set to view's property because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
         }
     },
     valueConverter: Length.parse,
 });
 paddingBottomProperty.register(Style);
-export const horizontalAlignmentProperty = new CssProperty({
+export var horizontalAlignmentProperty = new CssProperty({
     name: 'horizontalAlignment',
     cssName: 'horizontal-align',
     defaultValue: CoreTypes.HorizontalAlignment.stretch,
@@ -373,7 +375,7 @@ export const horizontalAlignmentProperty = new CssProperty({
     valueConverter: CoreTypes.HorizontalAlignment.parse,
 });
 horizontalAlignmentProperty.register(Style);
-export const verticalAlignmentProperty = new CssProperty({
+export var verticalAlignmentProperty = new CssProperty({
     name: 'verticalAlignment',
     cssName: 'vertical-align',
     defaultValue: CoreTypes.VerticalAlignmentText.stretch,
@@ -383,31 +385,31 @@ export const verticalAlignmentProperty = new CssProperty({
 verticalAlignmentProperty.register(Style);
 function parseThickness(value) {
     if (typeof value === 'string') {
-        const arr = value.split(/[ ,]+/);
-        let top;
-        let right;
-        let bottom;
-        let left;
+        var arr = value.split(/[ ,]+/);
+        var top_1;
+        var right = void 0;
+        var bottom = void 0;
+        var left = void 0;
         if (arr.length === 1) {
-            top = arr[0];
+            top_1 = arr[0];
             right = arr[0];
             bottom = arr[0];
             left = arr[0];
         }
         else if (arr.length === 2) {
-            top = arr[0];
+            top_1 = arr[0];
             bottom = arr[0];
             right = arr[1];
             left = arr[1];
         }
         else if (arr.length === 3) {
-            top = arr[0];
+            top_1 = arr[0];
             right = arr[1];
             left = arr[1];
             bottom = arr[2];
         }
         else if (arr.length === 4) {
-            top = arr[0];
+            top_1 = arr[0];
             right = arr[1];
             bottom = arr[2];
             left = arr[3];
@@ -416,7 +418,7 @@ function parseThickness(value) {
             throw new Error('Expected 1, 2, 3 or 4 parameters. Actual: ' + value);
         }
         return {
-            top: top,
+            top: top_1,
             right: right,
             bottom: bottom,
             left: left,
@@ -428,7 +430,7 @@ function parseThickness(value) {
 }
 function convertToMargins(value) {
     if (typeof value === 'string' && value !== 'auto') {
-        const thickness = parseThickness(value);
+        var thickness = parseThickness(value);
         return [
             [marginTopProperty, PercentLength.parse(thickness.top)],
             [marginRightProperty, PercentLength.parse(thickness.right)],
@@ -447,7 +449,7 @@ function convertToMargins(value) {
 }
 function convertToPaddings(value) {
     if (typeof value === 'string' && value !== 'auto') {
-        const thickness = parseThickness(value);
+        var thickness = parseThickness(value);
         return [
             [paddingTopProperty, Length.parse(thickness.top)],
             [paddingRightProperty, Length.parse(thickness.right)],
@@ -464,42 +466,42 @@ function convertToPaddings(value) {
         ];
     }
 }
-export const rotateProperty = new CssAnimationProperty({
+export var rotateProperty = new CssAnimationProperty({
     name: 'rotate',
     cssName: 'rotate',
     defaultValue: 0,
     valueConverter: parseFloat,
 });
 rotateProperty.register(Style);
-export const rotateXProperty = new CssAnimationProperty({
+export var rotateXProperty = new CssAnimationProperty({
     name: 'rotateX',
     cssName: 'rotatex',
     defaultValue: 0,
     valueConverter: parseFloat,
 });
 rotateXProperty.register(Style);
-export const rotateYProperty = new CssAnimationProperty({
+export var rotateYProperty = new CssAnimationProperty({
     name: 'rotateY',
     cssName: 'rotatey',
     defaultValue: 0,
     valueConverter: parseFloat,
 });
 rotateYProperty.register(Style);
-export const perspectiveProperty = new CssAnimationProperty({
+export var perspectiveProperty = new CssAnimationProperty({
     name: 'perspective',
     cssName: 'perspective',
     defaultValue: 1000,
     valueConverter: parseFloat,
 });
 perspectiveProperty.register(Style);
-export const scaleXProperty = new CssAnimationProperty({
+export var scaleXProperty = new CssAnimationProperty({
     name: 'scaleX',
     cssName: 'scaleX',
     defaultValue: 1,
     valueConverter: parseFloat,
 });
 scaleXProperty.register(Style);
-export const scaleYProperty = new CssAnimationProperty({
+export var scaleYProperty = new CssAnimationProperty({
     name: 'scaleY',
     cssName: 'scaleY',
     defaultValue: 1,
@@ -514,106 +516,118 @@ function parseDIPs(value) {
         return parseFloat(value.replace('dip', '').trim());
     }
 }
-export const translateXProperty = new CssAnimationProperty({
+export var translateXProperty = new CssAnimationProperty({
     name: 'translateX',
     cssName: 'translateX',
     defaultValue: 0,
     valueConverter: parseDIPs,
 });
 translateXProperty.register(Style);
-export const translateYProperty = new CssAnimationProperty({
+export var translateYProperty = new CssAnimationProperty({
     name: 'translateY',
     cssName: 'translateY',
     defaultValue: 0,
     valueConverter: parseDIPs,
 });
 translateYProperty.register(Style);
-const transformProperty = new ShorthandProperty({
+var transformProperty = new ShorthandProperty({
     name: 'transform',
     cssName: 'transform',
     getter: function () {
-        const scaleX = this.scaleX;
-        const scaleY = this.scaleY;
-        const translateX = this.translateX;
-        const translateY = this.translateY;
-        const rotate = this.rotate;
-        const rotateX = this.rotateX;
-        const rotateY = this.rotateY;
-        let result = '';
+        var scaleX = this.scaleX;
+        var scaleY = this.scaleY;
+        var translateX = this.translateX;
+        var translateY = this.translateY;
+        var rotate = this.rotate;
+        var rotateX = this.rotateX;
+        var rotateY = this.rotateY;
+        var result = '';
         if (translateX !== 0 || translateY !== 0) {
-            result += `translate(${translateX}, ${translateY}) `;
+            result += "translate(".concat(translateX, ", ").concat(translateY, ") ");
         }
         if (scaleX !== 1 || scaleY !== 1) {
-            result += `scale(${scaleX}, ${scaleY}) `;
+            result += "scale(".concat(scaleX, ", ").concat(scaleY, ") ");
         }
         if (rotateX !== 0 || rotateY !== 0 || rotate !== 0) {
-            result += `rotate(${rotateX}, ${rotateY}, ${rotate}) `;
-            result += `rotate (${rotate})`;
+            result += "rotate(".concat(rotateX, ", ").concat(rotateY, ", ").concat(rotate, ") ");
+            result += "rotate (".concat(rotate, ")");
         }
         return result.trim();
     },
     converter: convertToTransform,
 });
 transformProperty.register(Style);
-const IDENTITY_TRANSFORMATION = {
+var IDENTITY_TRANSFORMATION = {
     translate: { x: 0, y: 0 },
     rotate: { x: 0, y: 0, z: 0 },
     scale: { x: 1, y: 1 },
 };
-const TRANSFORM_SPLITTER = new RegExp(/\s*(.+?)\((.*?)\)/g);
-const TRANSFORMATIONS = Object.freeze(['rotate', 'rotateX', 'rotateY', 'rotate3d', 'translate', 'translate3d', 'translateX', 'translateY', 'scale', 'scale3d', 'scaleX', 'scaleY']);
-const STYLE_TRANSFORMATION_MAP = Object.freeze({
-    scale: (value) => ({ property: 'scale', value }),
-    scale3d: (value) => ({ property: 'scale', value }),
-    scaleX: ({ x }) => ({
-        property: 'scale',
-        value: { x, y: IDENTITY_TRANSFORMATION.scale.y },
-    }),
-    scaleY: ({ y }) => ({
-        property: 'scale',
-        value: { y, x: IDENTITY_TRANSFORMATION.scale.x },
-    }),
-    translate: (value) => ({ property: 'translate', value }),
-    translate3d: (value) => ({ property: 'translate', value }),
-    translateX: ({ x }) => ({
-        property: 'translate',
-        value: { x, y: IDENTITY_TRANSFORMATION.translate.y },
-    }),
-    translateY: ({ y }) => ({
-        property: 'translate',
-        value: { y, x: IDENTITY_TRANSFORMATION.translate.x },
-    }),
-    rotate3d: (value) => ({ property: 'rotate', value }),
-    rotateX: (x) => ({
+var TRANSFORM_SPLITTER = new RegExp(/\s*(.+?)\((.*?)\)/g);
+var TRANSFORMATIONS = Object.freeze(['rotate', 'rotateX', 'rotateY', 'rotate3d', 'translate', 'translate3d', 'translateX', 'translateY', 'scale', 'scale3d', 'scaleX', 'scaleY']);
+var STYLE_TRANSFORMATION_MAP = Object.freeze({
+    scale: function (value) { return ({ property: 'scale', value: value }); },
+    scale3d: function (value) { return ({ property: 'scale', value: value }); },
+    scaleX: function (_a) {
+        var x = _a.x;
+        return ({
+            property: 'scale',
+            value: { x: x, y: IDENTITY_TRANSFORMATION.scale.y },
+        });
+    },
+    scaleY: function (_a) {
+        var y = _a.y;
+        return ({
+            property: 'scale',
+            value: { y: y, x: IDENTITY_TRANSFORMATION.scale.x },
+        });
+    },
+    translate: function (value) { return ({ property: 'translate', value: value }); },
+    translate3d: function (value) { return ({ property: 'translate', value: value }); },
+    translateX: function (_a) {
+        var x = _a.x;
+        return ({
+            property: 'translate',
+            value: { x: x, y: IDENTITY_TRANSFORMATION.translate.y },
+        });
+    },
+    translateY: function (_a) {
+        var y = _a.y;
+        return ({
+            property: 'translate',
+            value: { y: y, x: IDENTITY_TRANSFORMATION.translate.x },
+        });
+    },
+    rotate3d: function (value) { return ({ property: 'rotate', value: value }); },
+    rotateX: function (x) { return ({
         property: 'rotate',
         value: {
-            x,
+            x: x,
             y: IDENTITY_TRANSFORMATION.rotate.y,
             z: IDENTITY_TRANSFORMATION.rotate.z,
         },
-    }),
-    rotateY: (y) => ({
+    }); },
+    rotateY: function (y) { return ({
         property: 'rotate',
         value: {
             x: IDENTITY_TRANSFORMATION.rotate.x,
-            y,
+            y: y,
             z: IDENTITY_TRANSFORMATION.rotate.z,
         },
-    }),
-    rotate: (z) => ({
+    }); },
+    rotate: function (z) { return ({
         property: 'rotate',
         value: {
             x: IDENTITY_TRANSFORMATION.rotate.x,
             y: IDENTITY_TRANSFORMATION.rotate.y,
-            z,
+            z: z,
         },
-    }),
+    }); },
 });
 function convertToTransform(value) {
     if (value === unsetValue) {
         value = 'none';
     }
-    const { translate, rotate, scale } = transformConverter(value);
+    var _a = transformConverter(value), translate = _a.translate, rotate = _a.rotate, scale = _a.scale;
     return [
         [translateXProperty, translate.x],
         [translateYProperty, translate.y],
@@ -625,79 +639,80 @@ function convertToTransform(value) {
     ];
 }
 export function transformConverter(text) {
-    const transformations = parseTransformString(text);
+    var transformations = parseTransformString(text);
     if (text === 'none' || text === '' || !transformations.length) {
         return IDENTITY_TRANSFORMATION;
     }
-    const usedTransforms = transformations.map((t) => t.property);
+    var usedTransforms = transformations.map(function (t) { return t.property; });
     if (!hasDuplicates(usedTransforms)) {
-        const fullTransformations = { ...IDENTITY_TRANSFORMATION };
-        transformations.forEach((transform) => {
-            fullTransformations[transform.property] = transform.value;
+        var fullTransformations_1 = __assign({}, IDENTITY_TRANSFORMATION);
+        transformations.forEach(function (transform) {
+            fullTransformations_1[transform.property] = transform.value;
         });
-        return fullTransformations;
+        return fullTransformations_1;
     }
-    const affineMatrix = transformations.map(getTransformMatrix).reduce(multiplyAffine2d);
-    const cssMatrix = matrixArrayToCssMatrix(affineMatrix);
+    var affineMatrix = transformations.map(getTransformMatrix).reduce(multiplyAffine2d);
+    var cssMatrix = matrixArrayToCssMatrix(affineMatrix);
     return decompose2DTransformMatrix(cssMatrix);
 }
 // using general regex and manually checking the matched
 // properties is faster than using more specific regex
 // https://jsperf.com/cssparse
 function parseTransformString(text) {
-    const matches = [];
-    let match;
+    var matches = [];
+    var match;
     while ((match = TRANSFORM_SPLITTER.exec(text)) !== null) {
-        const property = match[1];
-        const value = convertTransformValue(property, match[2]);
+        var property = match[1];
+        var value = convertTransformValue(property, match[2]);
         if (TRANSFORMATIONS.indexOf(property) !== -1) {
-            matches.push(normalizeTransformation({ property, value }));
+            matches.push(normalizeTransformation({ property: property, value: value }));
         }
     }
     return matches;
 }
-function normalizeTransformation({ property, value }) {
+function normalizeTransformation(_a) {
+    var property = _a.property, value = _a.value;
     return STYLE_TRANSFORMATION_MAP[property](value);
 }
 function convertTransformValue(property, stringValue) {
     // eslint-disable-next-line prefer-const
-    let [x, y, z] = stringValue.split(',').map(parseFloat);
+    var _a = stringValue.split(',').map(parseFloat), x = _a[0], y = _a[1], z = _a[2];
     if (property === 'translate') {
-        y ?? (y = IDENTITY_TRANSFORMATION.translate.y);
+        y !== null && y !== void 0 ? y : (y = IDENTITY_TRANSFORMATION.translate.y);
     }
     else {
-        y ?? (y = x);
-        z ?? (z = y);
+        y !== null && y !== void 0 ? y : (y = x);
+        z !== null && z !== void 0 ? z : (z = y);
     }
     if (property === 'rotate' || property === 'rotateX' || property === 'rotateY') {
         return stringValue.slice(-3) === 'rad' ? radiansToDegrees(x) : x;
     }
-    return { x, y, z };
+    return { x: x, y: y, z: z };
 }
 // Background properties.
-const backgroundProperty = new ShorthandProperty({
+var backgroundProperty = new ShorthandProperty({
     name: 'background',
     cssName: 'background',
     getter: function () {
-        return `${this.backgroundColor} ${this.backgroundImage} ${this.backgroundRepeat} ${this.backgroundPosition}`;
+        return "".concat(this.backgroundColor, " ").concat(this.backgroundImage, " ").concat(this.backgroundRepeat, " ").concat(this.backgroundPosition);
     },
     converter: convertToBackgrounds,
 });
 backgroundProperty.register(Style);
-export const backgroundInternalProperty = new CssProperty({
+export var backgroundInternalProperty = new CssProperty({
     name: 'backgroundInternal',
     cssName: '_backgroundInternal',
     defaultValue: Background.default,
 });
 backgroundInternalProperty.register(Style);
 // const pattern: RegExp = /url\(('|")(.*?)\1\)/;
-export const backgroundImageProperty = new CssProperty({
+export var backgroundImageProperty = new CssProperty({
     name: 'backgroundImage',
     cssName: 'background-image',
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         target.backgroundInternal = target.backgroundInternal.withImage(newValue);
     },
-    equalityComparer: (value1, value2) => {
+    equalityComparer: function (value1, value2) {
         if (value1 instanceof LinearGradient && value2 instanceof LinearGradient) {
             return LinearGradient.equals(value1, value2);
         }
@@ -705,9 +720,9 @@ export const backgroundImageProperty = new CssProperty({
             return value1 === value2;
         }
     },
-    valueConverter: (value) => {
+    valueConverter: function (value) {
         if (typeof value === 'string') {
-            const parsed = parseBackground(value);
+            var parsed = parseBackground(value);
             if (parsed) {
                 value = typeof parsed.value.image === 'object' ? LinearGradient.parse(parsed.value.image) : value;
             }
@@ -716,57 +731,57 @@ export const backgroundImageProperty = new CssProperty({
     },
 });
 backgroundImageProperty.register(Style);
-export const backgroundColorProperty = new CssAnimationProperty({
+export var backgroundColorProperty = new CssAnimationProperty({
     name: 'backgroundColor',
     cssName: 'background-color',
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         target.backgroundInternal = target.backgroundInternal.withColor(newValue);
     },
     equalityComparer: Color.equals,
-    valueConverter: (value) => new Color(value),
+    valueConverter: function (value) { return new Color(value); },
 });
 backgroundColorProperty.register(Style);
-export const backgroundRepeatProperty = new CssProperty({
+export var backgroundRepeatProperty = new CssProperty({
     name: 'backgroundRepeat',
     cssName: 'background-repeat',
     valueConverter: CoreTypes.BackgroundRepeat.parse,
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         target.backgroundInternal = target.backgroundInternal.withRepeat(newValue);
     },
 });
 backgroundRepeatProperty.register(Style);
-export const backgroundSizeProperty = new CssProperty({
+export var backgroundSizeProperty = new CssProperty({
     name: 'backgroundSize',
     cssName: 'background-size',
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         target.backgroundInternal = target.backgroundInternal.withSize(newValue);
     },
 });
 backgroundSizeProperty.register(Style);
-export const backgroundPositionProperty = new CssProperty({
+export var backgroundPositionProperty = new CssProperty({
     name: 'backgroundPosition',
     cssName: 'background-position',
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         target.backgroundInternal = target.backgroundInternal.withPosition(newValue);
     },
 });
 backgroundPositionProperty.register(Style);
 function convertToBackgrounds(value) {
     if (typeof value === 'string') {
-        const backgrounds = parseBackground(value).value;
-        let backgroundColor = unsetValue;
+        var backgrounds = parseBackground(value).value;
+        var backgroundColor = unsetValue;
         if (backgrounds.color) {
             backgroundColor = backgrounds.color instanceof Color ? backgrounds.color : new Color(backgrounds.color);
         }
-        let backgroundImage;
+        var backgroundImage = void 0;
         if (typeof backgrounds.image === 'object' && backgrounds.image) {
             backgroundImage = LinearGradient.parse(backgrounds.image);
         }
         else {
             backgroundImage = backgrounds.image || unsetValue;
         }
-        const backgroundRepeat = backgrounds.repeat || unsetValue;
-        const backgroundPosition = backgrounds.position ? backgrounds.position.text : unsetValue;
+        var backgroundRepeat = backgrounds.repeat || unsetValue;
+        var backgroundPosition = backgrounds.position ? backgrounds.position.text : unsetValue;
         return [
             [backgroundColorProperty, backgroundColor],
             [backgroundImageProperty, backgroundImage],
@@ -784,7 +799,7 @@ function convertToBackgrounds(value) {
     }
 }
 function parseBorderColor(value) {
-    const result = {
+    var result = {
         top: undefined,
         right: undefined,
         bottom: undefined,
@@ -794,48 +809,48 @@ function parseBorderColor(value) {
         result.top = result.right = result.bottom = result.left = new Color(value);
         return result;
     }
-    const arr = value.split(/[ ,]+/);
+    var arr = value.split(/[ ,]+/);
     if (arr.length === 1) {
-        const arr0 = new Color(arr[0]);
+        var arr0 = new Color(arr[0]);
         result.top = arr0;
         result.right = arr0;
         result.bottom = arr0;
         result.left = arr0;
     }
     else if (arr.length === 2) {
-        const arr0 = new Color(arr[0]);
-        const arr1 = new Color(arr[1]);
+        var arr0 = new Color(arr[0]);
+        var arr1 = new Color(arr[1]);
         result.top = arr0;
         result.right = arr1;
         result.bottom = arr0;
         result.left = arr1;
     }
     else if (arr.length === 3) {
-        const arr0 = new Color(arr[0]);
-        const arr1 = new Color(arr[1]);
-        const arr2 = new Color(arr[2]);
+        var arr0 = new Color(arr[0]);
+        var arr1 = new Color(arr[1]);
+        var arr2 = new Color(arr[2]);
         result.top = arr0;
         result.right = arr1;
         result.bottom = arr2;
         result.left = arr1;
     }
     else if (arr.length === 4) {
-        const arr0 = new Color(arr[0]);
-        const arr1 = new Color(arr[1]);
-        const arr2 = new Color(arr[2]);
-        const arr3 = new Color(arr[3]);
+        var arr0 = new Color(arr[0]);
+        var arr1 = new Color(arr[1]);
+        var arr2 = new Color(arr[2]);
+        var arr3 = new Color(arr[3]);
         result.top = arr0;
         result.right = arr1;
         result.bottom = arr2;
         result.left = arr3;
     }
     else {
-        throw new Error(`Expected 1, 2, 3 or 4 parameters. Actual: ${value}`);
+        throw new Error("Expected 1, 2, 3 or 4 parameters. Actual: ".concat(value));
     }
     return result;
 }
 // Border Color properties.
-const borderColorProperty = new ShorthandProperty({
+var borderColorProperty = new ShorthandProperty({
     name: 'borderColor',
     cssName: 'border-color',
     getter: function () {
@@ -843,12 +858,12 @@ const borderColorProperty = new ShorthandProperty({
             return this.borderTopColor;
         }
         else {
-            return `${this.borderTopColor} ${this.borderRightColor} ${this.borderBottomColor} ${this.borderLeftColor}`;
+            return "".concat(this.borderTopColor, " ").concat(this.borderRightColor, " ").concat(this.borderBottomColor, " ").concat(this.borderLeftColor);
         }
     },
     converter: function (value) {
         if (typeof value === 'string') {
-            const fourColors = parseBorderColor(value);
+            var fourColors = parseBorderColor(value);
             return [
                 [borderTopColorProperty, fourColors.top],
                 [borderRightColorProperty, fourColors.right],
@@ -867,48 +882,48 @@ const borderColorProperty = new ShorthandProperty({
     },
 });
 borderColorProperty.register(Style);
-export const borderTopColorProperty = new CssProperty({
+export var borderTopColorProperty = new CssProperty({
     name: 'borderTopColor',
     cssName: 'border-top-color',
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         target.backgroundInternal = target.backgroundInternal.withBorderTopColor(newValue);
     },
     equalityComparer: Color.equals,
-    valueConverter: (value) => new Color(value),
+    valueConverter: function (value) { return new Color(value); },
 });
 borderTopColorProperty.register(Style);
-export const borderRightColorProperty = new CssProperty({
+export var borderRightColorProperty = new CssProperty({
     name: 'borderRightColor',
     cssName: 'border-right-color',
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         target.backgroundInternal = target.backgroundInternal.withBorderRightColor(newValue);
     },
     equalityComparer: Color.equals,
-    valueConverter: (value) => new Color(value),
+    valueConverter: function (value) { return new Color(value); },
 });
 borderRightColorProperty.register(Style);
-export const borderBottomColorProperty = new CssProperty({
+export var borderBottomColorProperty = new CssProperty({
     name: 'borderBottomColor',
     cssName: 'border-bottom-color',
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         target.backgroundInternal = target.backgroundInternal.withBorderBottomColor(newValue);
     },
     equalityComparer: Color.equals,
-    valueConverter: (value) => new Color(value),
+    valueConverter: function (value) { return new Color(value); },
 });
 borderBottomColorProperty.register(Style);
-export const borderLeftColorProperty = new CssProperty({
+export var borderLeftColorProperty = new CssProperty({
     name: 'borderLeftColor',
     cssName: 'border-left-color',
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         target.backgroundInternal = target.backgroundInternal.withBorderLeftColor(newValue);
     },
     equalityComparer: Color.equals,
-    valueConverter: (value) => new Color(value),
+    valueConverter: function (value) { return new Color(value); },
 });
 borderLeftColorProperty.register(Style);
 // Border Width properties.
-const borderWidthProperty = new ShorthandProperty({
+var borderWidthProperty = new ShorthandProperty({
     name: 'borderWidth',
     cssName: 'border-width',
     getter: function () {
@@ -916,12 +931,12 @@ const borderWidthProperty = new ShorthandProperty({
             return this.borderTopWidth;
         }
         else {
-            return `${Length.convertToString(this.borderTopWidth)} ${Length.convertToString(this.borderRightWidth)} ${Length.convertToString(this.borderBottomWidth)} ${Length.convertToString(this.borderLeftWidth)}`;
+            return "".concat(Length.convertToString(this.borderTopWidth), " ").concat(Length.convertToString(this.borderRightWidth), " ").concat(Length.convertToString(this.borderBottomWidth), " ").concat(Length.convertToString(this.borderLeftWidth));
         }
     },
     converter: function (value) {
         if (typeof value === 'string' && value !== 'auto') {
-            const borderWidths = parseThickness(value);
+            var borderWidths = parseThickness(value);
             return [
                 [borderTopWidthProperty, borderWidths.top],
                 [borderRightWidthProperty, borderWidths.right],
@@ -940,92 +955,92 @@ const borderWidthProperty = new ShorthandProperty({
     },
 });
 borderWidthProperty.register(Style);
-export const borderTopWidthProperty = new CssProperty({
+export var borderTopWidthProperty = new CssProperty({
     name: 'borderTopWidth',
     cssName: 'border-top-width',
     defaultValue: CoreTypes.zeroLength,
     affectsLayout: global.isIOS,
     equalityComparer: Length.equals,
-    valueChanged: (target, oldValue, newValue) => {
-        const value = Length.toDevicePixels(newValue, 0);
+    valueChanged: function (target, oldValue, newValue) {
+        var value = Length.toDevicePixels(newValue, 0);
         if (!isNonNegativeFiniteNumber(value)) {
-            throw new Error(`border-top-width should be Non-Negative Finite number. Value: ${value}`);
+            throw new Error("border-top-width should be Non-Negative Finite number. Value: ".concat(value));
         }
-        const view = target.viewRef.get();
+        var view = target.viewRef.get();
         if (view) {
             view.effectiveBorderTopWidth = value;
         }
         else {
-            Trace.write(`${newValue} not set to view's property because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
+            Trace.write("".concat(newValue, " not set to view's property because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
         }
         target.backgroundInternal = target.backgroundInternal.withBorderTopWidth(value);
     },
     valueConverter: Length.parse,
 });
 borderTopWidthProperty.register(Style);
-export const borderRightWidthProperty = new CssProperty({
+export var borderRightWidthProperty = new CssProperty({
     name: 'borderRightWidth',
     cssName: 'border-right-width',
     defaultValue: CoreTypes.zeroLength,
     affectsLayout: global.isIOS,
     equalityComparer: Length.equals,
-    valueChanged: (target, oldValue, newValue) => {
-        const value = Length.toDevicePixels(newValue, 0);
+    valueChanged: function (target, oldValue, newValue) {
+        var value = Length.toDevicePixels(newValue, 0);
         if (!isNonNegativeFiniteNumber(value)) {
-            throw new Error(`border-right-width should be Non-Negative Finite number. Value: ${value}`);
+            throw new Error("border-right-width should be Non-Negative Finite number. Value: ".concat(value));
         }
-        const view = target.viewRef.get();
+        var view = target.viewRef.get();
         if (view) {
             view.effectiveBorderRightWidth = value;
         }
         else {
-            Trace.write(`${newValue} not set to view's property because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
+            Trace.write("".concat(newValue, " not set to view's property because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
         }
         target.backgroundInternal = target.backgroundInternal.withBorderRightWidth(value);
     },
     valueConverter: Length.parse,
 });
 borderRightWidthProperty.register(Style);
-export const borderBottomWidthProperty = new CssProperty({
+export var borderBottomWidthProperty = new CssProperty({
     name: 'borderBottomWidth',
     cssName: 'border-bottom-width',
     defaultValue: CoreTypes.zeroLength,
     affectsLayout: global.isIOS,
     equalityComparer: Length.equals,
-    valueChanged: (target, oldValue, newValue) => {
-        const value = Length.toDevicePixels(newValue, 0);
+    valueChanged: function (target, oldValue, newValue) {
+        var value = Length.toDevicePixels(newValue, 0);
         if (!isNonNegativeFiniteNumber(value)) {
-            throw new Error(`border-bottom-width should be Non-Negative Finite number. Value: ${value}`);
+            throw new Error("border-bottom-width should be Non-Negative Finite number. Value: ".concat(value));
         }
-        const view = target.viewRef.get();
+        var view = target.viewRef.get();
         if (view) {
             view.effectiveBorderBottomWidth = value;
         }
         else {
-            Trace.write(`${newValue} not set to view's property because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
+            Trace.write("".concat(newValue, " not set to view's property because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
         }
         target.backgroundInternal = target.backgroundInternal.withBorderBottomWidth(value);
     },
     valueConverter: Length.parse,
 });
 borderBottomWidthProperty.register(Style);
-export const borderLeftWidthProperty = new CssProperty({
+export var borderLeftWidthProperty = new CssProperty({
     name: 'borderLeftWidth',
     cssName: 'border-left-width',
     defaultValue: CoreTypes.zeroLength,
     affectsLayout: global.isIOS,
     equalityComparer: Length.equals,
-    valueChanged: (target, oldValue, newValue) => {
-        const value = Length.toDevicePixels(newValue, 0);
+    valueChanged: function (target, oldValue, newValue) {
+        var value = Length.toDevicePixels(newValue, 0);
         if (!isNonNegativeFiniteNumber(value)) {
-            throw new Error(`border-left-width should be Non-Negative Finite number. Value: ${value}`);
+            throw new Error("border-left-width should be Non-Negative Finite number. Value: ".concat(value));
         }
-        const view = target.viewRef.get();
+        var view = target.viewRef.get();
         if (view) {
             view.effectiveBorderLeftWidth = value;
         }
         else {
-            Trace.write(`${newValue} not set to view's property because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
+            Trace.write("".concat(newValue, " not set to view's property because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
         }
         target.backgroundInternal = target.backgroundInternal.withBorderLeftWidth(value);
     },
@@ -1033,18 +1048,18 @@ export const borderLeftWidthProperty = new CssProperty({
 });
 borderLeftWidthProperty.register(Style);
 // Border Radius properties.
-const borderRadiusProperty = new ShorthandProperty({
+var borderRadiusProperty = new ShorthandProperty({
     name: 'borderRadius',
     cssName: 'border-radius',
     getter: function () {
         if (Length.equals(this.borderTopLeftRadius, this.borderTopRightRadius) && Length.equals(this.borderTopLeftRadius, this.borderBottomRightRadius) && Length.equals(this.borderTopLeftRadius, this.borderBottomLeftRadius)) {
             return this.borderTopLeftRadius;
         }
-        return `${Length.convertToString(this.borderTopLeftRadius)} ${Length.convertToString(this.borderTopRightRadius)} ${Length.convertToString(this.borderBottomRightRadius)} ${Length.convertToString(this.borderBottomLeftRadius)}`;
+        return "".concat(Length.convertToString(this.borderTopLeftRadius), " ").concat(Length.convertToString(this.borderTopRightRadius), " ").concat(Length.convertToString(this.borderBottomRightRadius), " ").concat(Length.convertToString(this.borderBottomLeftRadius));
     },
     converter: function (value) {
         if (typeof value === 'string') {
-            const borderRadius = parseThickness(value);
+            var borderRadius = parseThickness(value);
             return [
                 [borderTopLeftRadiusProperty, borderRadius.top],
                 [borderTopRightRadiusProperty, borderRadius.right],
@@ -1063,15 +1078,15 @@ const borderRadiusProperty = new ShorthandProperty({
     },
 });
 borderRadiusProperty.register(Style);
-export const borderTopLeftRadiusProperty = new CssProperty({
+export var borderTopLeftRadiusProperty = new CssProperty({
     name: 'borderTopLeftRadius',
     cssName: 'border-top-left-radius',
     defaultValue: 0,
     affectsLayout: global.isIOS,
-    valueChanged: (target, oldValue, newValue) => {
-        const value = Length.toDevicePixels(newValue, 0);
+    valueChanged: function (target, oldValue, newValue) {
+        var value = Length.toDevicePixels(newValue, 0);
         if (!isNonNegativeFiniteNumber(value)) {
-            throw new Error(`border-top-left-radius should be Non-Negative Finite number. Value: ${value}`);
+            throw new Error("border-top-left-radius should be Non-Negative Finite number. Value: ".concat(value));
         }
         target.backgroundInternal = target.backgroundInternal.withBorderTopLeftRadius(value);
     },
@@ -1079,15 +1094,15 @@ export const borderTopLeftRadiusProperty = new CssProperty({
     equalityComparer: Length.equals,
 });
 borderTopLeftRadiusProperty.register(Style);
-export const borderTopRightRadiusProperty = new CssProperty({
+export var borderTopRightRadiusProperty = new CssProperty({
     name: 'borderTopRightRadius',
     cssName: 'border-top-right-radius',
     defaultValue: 0,
     affectsLayout: global.isIOS,
-    valueChanged: (target, oldValue, newValue) => {
-        const value = Length.toDevicePixels(newValue, 0);
+    valueChanged: function (target, oldValue, newValue) {
+        var value = Length.toDevicePixels(newValue, 0);
         if (!isNonNegativeFiniteNumber(value)) {
-            throw new Error(`border-top-right-radius should be Non-Negative Finite number. Value: ${value}`);
+            throw new Error("border-top-right-radius should be Non-Negative Finite number. Value: ".concat(value));
         }
         target.backgroundInternal = target.backgroundInternal.withBorderTopRightRadius(value);
     },
@@ -1095,15 +1110,15 @@ export const borderTopRightRadiusProperty = new CssProperty({
     equalityComparer: Length.equals,
 });
 borderTopRightRadiusProperty.register(Style);
-export const borderBottomRightRadiusProperty = new CssProperty({
+export var borderBottomRightRadiusProperty = new CssProperty({
     name: 'borderBottomRightRadius',
     cssName: 'border-bottom-right-radius',
     defaultValue: 0,
     affectsLayout: global.isIOS,
-    valueChanged: (target, oldValue, newValue) => {
-        const value = Length.toDevicePixels(newValue, 0);
+    valueChanged: function (target, oldValue, newValue) {
+        var value = Length.toDevicePixels(newValue, 0);
         if (!isNonNegativeFiniteNumber(value)) {
-            throw new Error(`border-bottom-right-radius should be Non-Negative Finite number. Value: ${value}`);
+            throw new Error("border-bottom-right-radius should be Non-Negative Finite number. Value: ".concat(value));
         }
         target.backgroundInternal = target.backgroundInternal.withBorderBottomRightRadius(value);
     },
@@ -1111,15 +1126,15 @@ export const borderBottomRightRadiusProperty = new CssProperty({
     equalityComparer: Length.equals,
 });
 borderBottomRightRadiusProperty.register(Style);
-export const borderBottomLeftRadiusProperty = new CssProperty({
+export var borderBottomLeftRadiusProperty = new CssProperty({
     name: 'borderBottomLeftRadius',
     cssName: 'border-bottom-left-radius',
     defaultValue: 0,
     affectsLayout: global.isIOS,
-    valueChanged: (target, oldValue, newValue) => {
-        const value = Length.toDevicePixels(newValue, 0);
+    valueChanged: function (target, oldValue, newValue) {
+        var value = Length.toDevicePixels(newValue, 0);
         if (!isNonNegativeFiniteNumber(value)) {
-            throw new Error(`border-bottom-left-radius should be Non-Negative Finite number. Value: ${value}`);
+            throw new Error("border-bottom-left-radius should be Non-Negative Finite number. Value: ".concat(value));
         }
         target.backgroundInternal = target.backgroundInternal.withBorderBottomLeftRadius(value);
     },
@@ -1127,10 +1142,10 @@ export const borderBottomLeftRadiusProperty = new CssProperty({
     equalityComparer: Length.equals,
 });
 borderBottomLeftRadiusProperty.register(Style);
-const boxShadowProperty = new CssProperty({
+var boxShadowProperty = new CssProperty({
     name: 'boxShadow',
     cssName: 'box-shadow',
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         target.backgroundInternal = target.backgroundInternal.withBoxShadow(newValue
             ? {
                 inset: newValue.inset,
@@ -1142,7 +1157,7 @@ const boxShadowProperty = new CssProperty({
             }
             : null);
     },
-    valueConverter: (value) => {
+    valueConverter: function (value) {
         return parseCSSShadow(value);
     },
 });
@@ -1150,18 +1165,18 @@ boxShadowProperty.register(Style);
 function isNonNegativeFiniteNumber(value) {
     return isFinite(value) && !isNaN(value) && value >= 0;
 }
-const supportedPaths = ['rect', 'circle', 'ellipse', 'polygon', 'inset'];
+var supportedPaths = ['rect', 'circle', 'ellipse', 'polygon', 'inset'];
 function isClipPathValid(value) {
     if (!value) {
         return true;
     }
-    const functionName = value.substring(0, value.indexOf('(')).trim();
+    var functionName = value.substring(0, value.indexOf('(')).trim();
     return supportedPaths.indexOf(functionName) !== -1;
 }
-export const clipPathProperty = new CssProperty({
+export var clipPathProperty = new CssProperty({
     name: 'clipPath',
     cssName: 'clip-path',
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         if (!isClipPathValid(newValue)) {
             throw new Error('clip-path is not valid.');
         }
@@ -1170,116 +1185,116 @@ export const clipPathProperty = new CssProperty({
 });
 clipPathProperty.register(Style);
 function isFloatValueConverter(value) {
-    const newValue = parseFloat(value);
+    var newValue = parseFloat(value);
     if (isNaN(newValue)) {
-        throw new Error(`Invalid value: ${newValue}`);
+        throw new Error("Invalid value: ".concat(newValue));
     }
     return newValue;
 }
-export const zIndexProperty = new CssProperty({
+export var zIndexProperty = new CssProperty({
     name: 'zIndex',
     cssName: 'z-index',
     valueConverter: isFloatValueConverter,
 });
 zIndexProperty.register(Style);
 function opacityConverter(value) {
-    const newValue = parseFloat(value);
+    var newValue = parseFloat(value);
     if (!isNaN(newValue) && 0 <= newValue && newValue <= 1) {
         return newValue;
     }
-    throw new Error(`Opacity should be between [0, 1]. Value: ${newValue}`);
+    throw new Error("Opacity should be between [0, 1]. Value: ".concat(newValue));
 }
-export const opacityProperty = new CssAnimationProperty({
+export var opacityProperty = new CssAnimationProperty({
     name: 'opacity',
     cssName: 'opacity',
     defaultValue: 1,
     valueConverter: opacityConverter,
 });
 opacityProperty.register(Style);
-export const colorProperty = new InheritedCssProperty({
+export var colorProperty = new InheritedCssProperty({
     name: 'color',
     cssName: 'color',
     equalityComparer: Color.equals,
-    valueConverter: (v) => new Color(v),
+    valueConverter: function (v) { return new Color(v); },
 });
 colorProperty.register(Style);
-export const fontInternalProperty = new CssProperty({
+export var fontInternalProperty = new CssProperty({
     name: 'fontInternal',
     cssName: '_fontInternal',
 });
 fontInternalProperty.register(Style);
-export const fontFamilyProperty = new InheritedCssProperty({
+export var fontFamilyProperty = new InheritedCssProperty({
     name: 'fontFamily',
     cssName: 'font-family',
     affectsLayout: global.isIOS,
-    valueChanged: (target, oldValue, newValue) => {
-        const currentFont = target.fontInternal || Font.default;
+    valueChanged: function (target, oldValue, newValue) {
+        var currentFont = target.fontInternal || Font.default;
         if (currentFont.fontFamily !== newValue) {
-            const newFont = currentFont.withFontFamily(newValue);
+            var newFont = currentFont.withFontFamily(newValue);
             target.fontInternal = Font.equals(Font.default, newFont) ? unsetValue : newFont;
         }
     },
 });
 fontFamilyProperty.register(Style);
-export const fontScaleInternalProperty = new InheritedCssProperty({
+export var fontScaleInternalProperty = new InheritedCssProperty({
     name: 'fontScaleInternal',
     cssName: '_fontScaleInternal',
     defaultValue: 1.0,
-    valueConverter: (v) => parseFloat(v),
+    valueConverter: function (v) { return parseFloat(v); },
 });
 fontScaleInternalProperty.register(Style);
-export const fontSizeProperty = new InheritedCssProperty({
+export var fontSizeProperty = new InheritedCssProperty({
     name: 'fontSize',
     cssName: 'font-size',
     affectsLayout: global.isIOS,
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         if (target.viewRef['handleFontSize'] === true) {
             return;
         }
-        const currentFont = target.fontInternal || Font.default;
+        var currentFont = target.fontInternal || Font.default;
         if (currentFont.fontSize !== newValue) {
-            const newFont = currentFont.withFontSize(newValue);
+            var newFont = currentFont.withFontSize(newValue);
             target.fontInternal = Font.equals(Font.default, newFont) ? unsetValue : newFont;
         }
     },
-    valueConverter: (v) => parseFloat(v),
+    valueConverter: function (v) { return parseFloat(v); },
 });
 fontSizeProperty.register(Style);
-export const fontStyleProperty = new InheritedCssProperty({
+export var fontStyleProperty = new InheritedCssProperty({
     name: 'fontStyle',
     cssName: 'font-style',
     affectsLayout: global.isIOS,
     defaultValue: FontStyle.NORMAL,
     valueConverter: FontStyle.parse,
-    valueChanged: (target, oldValue, newValue) => {
-        const currentFont = target.fontInternal || Font.default;
+    valueChanged: function (target, oldValue, newValue) {
+        var currentFont = target.fontInternal || Font.default;
         if (currentFont.fontStyle !== newValue) {
-            const newFont = currentFont.withFontStyle(newValue);
+            var newFont = currentFont.withFontStyle(newValue);
             target.fontInternal = Font.equals(Font.default, newFont) ? unsetValue : newFont;
         }
     },
 });
 fontStyleProperty.register(Style);
-export const fontWeightProperty = new InheritedCssProperty({
+export var fontWeightProperty = new InheritedCssProperty({
     name: 'fontWeight',
     cssName: 'font-weight',
     affectsLayout: global.isIOS,
     defaultValue: FontWeight.NORMAL,
     valueConverter: FontWeight.parse,
-    valueChanged: (target, oldValue, newValue) => {
-        const currentFont = target.fontInternal || Font.default;
+    valueChanged: function (target, oldValue, newValue) {
+        var currentFont = target.fontInternal || Font.default;
         if (currentFont.fontWeight !== newValue) {
-            const newFont = currentFont.withFontWeight(newValue);
+            var newFont = currentFont.withFontWeight(newValue);
             target.fontInternal = Font.equals(Font.default, newFont) ? unsetValue : newFont;
         }
     },
 });
 fontWeightProperty.register(Style);
-const fontProperty = new ShorthandProperty({
+var fontProperty = new ShorthandProperty({
     name: 'font',
     cssName: 'font',
     getter: function () {
-        return `${this.fontStyle} ${this.fontWeight} ${this.fontSize} ${this.fontFamily}`;
+        return "".concat(this.fontStyle, " ").concat(this.fontWeight, " ").concat(this.fontSize, " ").concat(this.fontFamily);
     },
     converter: function (value) {
         if (value === unsetValue) {
@@ -1291,8 +1306,8 @@ const fontProperty = new ShorthandProperty({
             ];
         }
         else {
-            const font = parseFont(value);
-            const fontSize = parseFloat(font.fontSize);
+            var font = parseFont(value);
+            var fontSize = parseFloat(font.fontSize);
             return [
                 [fontStyleProperty, font.fontStyle],
                 [fontWeightProperty, font.fontWeight],
@@ -1303,46 +1318,46 @@ const fontProperty = new ShorthandProperty({
     },
 });
 fontProperty.register(Style);
-export const fontVariationSettingsProperty = new InheritedCssProperty({
+export var fontVariationSettingsProperty = new InheritedCssProperty({
     name: 'fontVariationSettings',
     cssName: 'font-variation-settings',
     affectsLayout: global.isIOS,
-    valueChanged: (target, oldValue, newValue) => {
-        const currentFont = target.fontInternal || Font.default;
+    valueChanged: function (target, oldValue, newValue) {
+        var currentFont = target.fontInternal || Font.default;
         if (currentFont.fontVariationSettings !== newValue) {
-            const newFont = currentFont.withFontVariationSettings(newValue);
+            var newFont = currentFont.withFontVariationSettings(newValue);
             target.fontInternal = Font.equals(Font.default, newFont) ? unsetValue : newFont;
         }
     },
-    valueConverter: (value) => {
+    valueConverter: function (value) {
         return FontVariationSettings.parse(value);
     },
 });
 fontVariationSettingsProperty.register(Style);
-export const visibilityProperty = new CssProperty({
+export var visibilityProperty = new CssProperty({
     name: 'visibility',
     cssName: 'visibility',
     defaultValue: CoreTypes.Visibility.visible,
     affectsLayout: global.isIOS,
     valueConverter: CoreTypes.Visibility.parse,
-    valueChanged: (target, oldValue, newValue) => {
-        const view = target.viewRef.get();
+    valueChanged: function (target, oldValue, newValue) {
+        var view = target.viewRef.get();
         if (view) {
             view.isCollapsed = newValue === CoreTypes.Visibility.collapse;
         }
         else {
-            Trace.write(`${newValue} not set to view's property because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
+            Trace.write("".concat(newValue, " not set to view's property because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
         }
     },
 });
 visibilityProperty.register(Style);
-export const androidElevationProperty = new CssProperty({
+export var androidElevationProperty = new CssProperty({
     name: 'androidElevation',
     cssName: 'android-elevation',
     valueConverter: parseFloat,
 });
 androidElevationProperty.register(Style);
-export const androidDynamicElevationOffsetProperty = new CssProperty({
+export var androidDynamicElevationOffsetProperty = new CssProperty({
     name: 'androidDynamicElevationOffset',
     cssName: 'android-dynamic-elevation-offset',
     valueConverter: parseFloat,