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

package/ui/styling/background.ios.js

@@ -3,11 +3,11 @@ import { Screen } from '../../platform';
 import { isDataURI, isFileOrResourcePath, layout } from '../../utils';
 import { ios as iosViewUtils } from '../utils';
 import { ImageSource } from '../../image-source';
-import { parse as cssParse } from '../../css-value';
+import { parse as cssParse } from '../../css-value/reworkcss-value.js';
 export * from './background-common';
-const clearCGColor = UIColor.clearColor.CGColor;
-const uriPattern = /url\(('|")(.*?)\1\)/;
-const symbolUrl = Symbol('backgroundImageUrl');
+var clearCGColor = UIColor.clearColor.CGColor;
+var uriPattern = /url\(('|")(.*?)\1\)/;
+var symbolUrl = Symbol('backgroundImageUrl');
 export var CacheMode;
 (function (CacheMode) {
     CacheMode[CacheMode["none"] = 0] = "none";
@@ -15,8 +15,9 @@ export var CacheMode;
 export var ios;
 (function (ios) {
     function createBackgroundUIColor(view, callback, flip) {
-        const background = view.style.backgroundInternal;
-        const nativeView = view.nativeViewProtected;
+        var _a;
+        var background = view.style.backgroundInternal;
+        var nativeView = view.nativeViewProtected;
         if (!nativeView) {
             return;
         }
@@ -27,20 +28,24 @@ export var ios;
         // Borders, shadows, etc
         drawBackgroundVisualEffects(view);
         if (!background.image) {
-            callback(background?.color?.ios);
+            callback((_a = background === null || background === void 0 ? void 0 : background.color) === null || _a === void 0 ? void 0 : _a.ios);
         }
         else {
             if (!(background.image instanceof LinearGradient)) {
-                setUIColorFromImage(view, nativeView, callback, flip);
+                createUIImageFromURI(view, background.image, flip, function (image) {
+                    var _a;
+                    callback(image ? UIColor.alloc().initWithPatternImage(image) : (_a = background === null || background === void 0 ? void 0 : background.color) === null || _a === void 0 ? void 0 : _a.ios);
+                });
             }
         }
     }
     ios.createBackgroundUIColor = createBackgroundUIColor;
     function drawBackgroundVisualEffects(view) {
-        const background = view.style.backgroundInternal;
-        const nativeView = view.nativeViewProtected;
-        const layer = nativeView.layer;
-        let needsLayerAdjustmentOnScroll = false;
+        var _a;
+        var background = view.style.backgroundInternal;
+        var nativeView = view.nativeViewProtected;
+        var layer = nativeView.layer;
+        var needsLayerAdjustmentOnScroll = false;
         // Add new gradient layer or update existing one
         if (background.image instanceof LinearGradient) {
             if (!nativeView.gradientLayer) {
@@ -53,8 +58,8 @@ export var ios;
         // Initialize clipping mask (usually for clip-path and non-uniform rounded borders)
         maskLayerIfNeeded(nativeView, background);
         if (background.hasUniformBorder()) {
-            const borderColor = background.getUniformBorderColor();
-            layer.borderColor = borderColor?.ios?.CGColor;
+            var borderColor = background.getUniformBorderColor();
+            layer.borderColor = (_a = borderColor === null || borderColor === void 0 ? void 0 : borderColor.ios) === null || _a === void 0 ? void 0 : _a.CGColor;
             layer.borderWidth = layout.toDeviceIndependentPixels(background.getUniformBorderWidth());
             layer.cornerRadius = getUniformBorderRadius(view, layer.bounds);
         }
@@ -76,14 +81,14 @@ export var ios;
     }
     ios.drawBackgroundVisualEffects = drawBackgroundVisualEffects;
     function clearBackgroundVisualEffects(view) {
-        const nativeView = view.nativeViewProtected;
+        var nativeView = view.nativeViewProtected;
         if (!nativeView) {
             return;
         }
-        const background = view.style.backgroundInternal;
-        const hasGradientBackground = background.image && background.image instanceof LinearGradient;
+        var background = view.style.backgroundInternal;
+        var hasGradientBackground = background.image && background.image instanceof LinearGradient;
         // Remove mask if there is no clip path or non-uniform border with radius
-        let needsMask;
+        var needsMask;
         switch (nativeView.maskType) {
             case iosViewUtils.LayerMask.BORDER:
                 needsMask = !background.hasUniformBorder() && background.hasBorderRadius();
@@ -121,26 +126,69 @@ export var ios;
         background.clearFlags = 0 /* BackgroundClearFlags.NONE */;
     }
     ios.clearBackgroundVisualEffects = clearBackgroundVisualEffects;
+    function createUIImageFromURI(view, imageURI, flip, callback) {
+        var nativeView = view.nativeViewProtected;
+        if (!nativeView) {
+            return;
+        }
+        var frame = nativeView.frame;
+        var boundsWidth = view.scaleX ? frame.size.width / view.scaleX : frame.size.width;
+        var boundsHeight = view.scaleY ? frame.size.height / view.scaleY : frame.size.height;
+        if (!boundsWidth || !boundsHeight) {
+            return undefined;
+        }
+        var style = view.style;
+        if (imageURI) {
+            var match = imageURI.match(uriPattern);
+            if (match && match[2]) {
+                imageURI = match[2];
+            }
+        }
+        var bitmap;
+        if (isDataURI(imageURI)) {
+            var base64Data = imageURI.split(',')[1];
+            if (base64Data !== undefined) {
+                var imageSource = ImageSource.fromBase64Sync(base64Data);
+                bitmap = imageSource && imageSource.ios;
+            }
+        }
+        else if (isFileOrResourcePath(imageURI)) {
+            var imageSource = ImageSource.fromFileOrResourceSync(imageURI);
+            bitmap = imageSource && imageSource.ios;
+        }
+        else if (imageURI.indexOf('http') !== -1) {
+            style[symbolUrl] = imageURI;
+            ImageSource.fromUrl(imageURI)
+                .then(function (r) {
+                if (style && style[symbolUrl] === imageURI) {
+                    callback(generatePatternImage(r.ios, view, flip));
+                }
+            })
+                .catch(function () { });
+        }
+        callback(generatePatternImage(bitmap, view, flip));
+    }
+    ios.createUIImageFromURI = createUIImageFromURI;
     function generateShadowLayerPaths(view, bounds) {
-        const background = view.style.backgroundInternal;
-        const nativeView = view.nativeViewProtected;
-        const layer = nativeView.layer;
-        const boxShadow = background.getBoxShadow();
-        const spreadRadius = layout.toDeviceIndependentPixels(boxShadow.spreadRadius);
-        const { width, height } = bounds.size;
-        let innerPath, shadowPath;
+        var background = view.style.backgroundInternal;
+        var nativeView = view.nativeViewProtected;
+        var layer = nativeView.layer;
+        var boxShadow = background.getBoxShadow();
+        var spreadRadius = layout.toDeviceIndependentPixels(boxShadow.spreadRadius);
+        var _a = bounds.size, width = _a.width, height = _a.height;
+        var innerPath, shadowPath;
         // Generate more detailed paths if view has border radius
         if (background.hasBorderRadius()) {
             if (background.hasUniformBorder()) {
-                const cornerRadius = layer.cornerRadius;
-                const cappedRadius = getBorderCapRadius(cornerRadius, width / 2, height / 2);
-                const cappedOuterRadii = {
+                var cornerRadius = layer.cornerRadius;
+                var cappedRadius = getBorderCapRadius(cornerRadius, width / 2, height / 2);
+                var cappedOuterRadii = {
                     topLeft: cappedRadius,
                     topRight: cappedRadius,
                     bottomLeft: cappedRadius,
                     bottomRight: cappedRadius,
                 };
-                const cappedOuterRadiiWithSpread = {
+                var cappedOuterRadiiWithSpread = {
                     topLeft: cappedRadius + spreadRadius,
                     topRight: cappedRadius + spreadRadius,
                     bottomLeft: cappedRadius + spreadRadius,
@@ -150,15 +198,15 @@ export var ios;
                 shadowPath = generateNonUniformBorderOuterClipPath(bounds, cappedOuterRadiiWithSpread, spreadRadius);
             }
             else {
-                const outerTopLeftRadius = layout.toDeviceIndependentPixels(background.borderTopLeftRadius);
-                const outerTopRightRadius = layout.toDeviceIndependentPixels(background.borderTopRightRadius);
-                const outerBottomRightRadius = layout.toDeviceIndependentPixels(background.borderBottomRightRadius);
-                const outerBottomLeftRadius = layout.toDeviceIndependentPixels(background.borderBottomLeftRadius);
-                const topRadii = outerTopLeftRadius + outerTopRightRadius;
-                const rightRadii = outerTopRightRadius + outerBottomRightRadius;
-                const bottomRadii = outerBottomRightRadius + outerBottomLeftRadius;
-                const leftRadii = outerBottomLeftRadius + outerTopLeftRadius;
-                const cappedOuterRadii = {
+                var outerTopLeftRadius = layout.toDeviceIndependentPixels(background.borderTopLeftRadius);
+                var outerTopRightRadius = layout.toDeviceIndependentPixels(background.borderTopRightRadius);
+                var outerBottomRightRadius = layout.toDeviceIndependentPixels(background.borderBottomRightRadius);
+                var outerBottomLeftRadius = layout.toDeviceIndependentPixels(background.borderBottomLeftRadius);
+                var topRadii = outerTopLeftRadius + outerTopRightRadius;
+                var rightRadii = outerTopRightRadius + outerBottomRightRadius;
+                var bottomRadii = outerBottomRightRadius + outerBottomLeftRadius;
+                var leftRadii = outerBottomLeftRadius + outerTopLeftRadius;
+                var cappedOuterRadii = {
                     topLeft: getBorderCapRadius(outerTopLeftRadius, (outerTopLeftRadius / topRadii) * width, (outerTopLeftRadius / leftRadii) * height),
                     topRight: getBorderCapRadius(outerTopRightRadius, (outerTopRightRadius / topRadii) * width, (outerTopRightRadius / rightRadii) * height),
                     bottomLeft: getBorderCapRadius(outerBottomLeftRadius, (outerBottomLeftRadius / bottomRadii) * width, (outerBottomLeftRadius / leftRadii) * height),
@@ -166,7 +214,7 @@ export var ios;
                 };
                 // Add spread radius to corners that actually have radius as shadow has grown larger
                 // than view itself and needs to be rounded accordingly
-                const cappedOuterRadiiWithSpread = {
+                var cappedOuterRadiiWithSpread = {
                     topLeft: cappedOuterRadii.topLeft > 0 ? cappedOuterRadii.topLeft + spreadRadius : cappedOuterRadii.topLeft,
                     topRight: cappedOuterRadii.topRight > 0 ? cappedOuterRadii.topRight + spreadRadius : cappedOuterRadii.topRight,
                     bottomLeft: cappedOuterRadii.bottomLeft > 0 ? cappedOuterRadii.bottomLeft + spreadRadius : cappedOuterRadii.bottomLeft,
@@ -182,14 +230,14 @@ export var ios;
         }
         return {
             maskPath: generateShadowMaskPath(bounds, boxShadow, innerPath),
-            shadowPath,
+            shadowPath: shadowPath,
         };
     }
     ios.generateShadowLayerPaths = generateShadowLayerPaths;
     function generateClipPath(view, bounds) {
-        const background = view.style.backgroundInternal;
-        const { origin, size } = bounds;
-        const position = {
+        var background = view.style.backgroundInternal;
+        var origin = bounds.origin, size = bounds.size;
+        var position = {
             left: origin.x,
             top: origin.y,
             bottom: size.height,
@@ -198,10 +246,10 @@ export var ios;
         if (position.right === 0 || position.bottom === 0) {
             return;
         }
-        let path;
-        const clipPath = background.clipPath;
-        const functionName = clipPath.substring(0, clipPath.indexOf('('));
-        const value = clipPath.replace(`${functionName}(`, '').replace(')', '');
+        var path;
+        var clipPath = background.clipPath;
+        var functionName = clipPath.substring(0, clipPath.indexOf('('));
+        var value = clipPath.replace("".concat(functionName, "("), '').replace(')', '');
         switch (functionName) {
             case 'rect':
                 path = rectPath(value, position);
@@ -223,32 +271,32 @@ export var ios;
     }
     ios.generateClipPath = generateClipPath;
     function getUniformBorderRadius(view, bounds) {
-        const background = view.style.backgroundInternal;
-        const { width, height } = bounds.size;
-        const cornerRadius = layout.toDeviceIndependentPixels(background.getUniformBorderRadius());
+        var background = view.style.backgroundInternal;
+        var _a = bounds.size, width = _a.width, height = _a.height;
+        var cornerRadius = layout.toDeviceIndependentPixels(background.getUniformBorderRadius());
         return Math.min(Math.min(width / 2, height / 2), cornerRadius);
     }
     ios.getUniformBorderRadius = getUniformBorderRadius;
     function generateNonUniformBorderInnerClipRoundedPath(view, bounds) {
-        const background = view.style.backgroundInternal;
-        const cappedOuterRadii = calculateNonUniformBorderCappedRadii(bounds, background);
+        var background = view.style.backgroundInternal;
+        var cappedOuterRadii = calculateNonUniformBorderCappedRadii(bounds, background);
         return generateNonUniformBorderInnerClipPath(bounds, background, cappedOuterRadii);
     }
     ios.generateNonUniformBorderInnerClipRoundedPath = generateNonUniformBorderInnerClipRoundedPath;
     function generateNonUniformBorderOuterClipRoundedPath(view, bounds) {
-        const background = view.style.backgroundInternal;
-        const cappedOuterRadii = calculateNonUniformBorderCappedRadii(bounds, background);
+        var background = view.style.backgroundInternal;
+        var cappedOuterRadii = calculateNonUniformBorderCappedRadii(bounds, background);
         return generateNonUniformBorderOuterClipPath(bounds, cappedOuterRadii);
     }
     ios.generateNonUniformBorderOuterClipRoundedPath = generateNonUniformBorderOuterClipRoundedPath;
     function generateNonUniformMultiColorBorderRoundedPaths(view, bounds) {
-        const background = view.style.backgroundInternal;
+        var background = view.style.backgroundInternal;
         return generateNonUniformMultiColorBorderPaths(bounds, background);
     }
     ios.generateNonUniformMultiColorBorderRoundedPaths = generateNonUniformMultiColorBorderRoundedPaths;
 })(ios || (ios = {}));
 function maskLayerIfNeeded(nativeView, background) {
-    const layer = nativeView.layer;
+    var layer = nativeView.layer;
     // Check if layer should be masked
     if (!(layer.mask instanceof CAShapeLayer)) {
         // Since layers can only accept up to a single mask at a time, clip path is given more priority
@@ -276,8 +324,8 @@ function clearLayerMask(nativeView) {
     nativeView.maskType = null;
 }
 function onBackgroundViewScroll(args) {
-    const view = args.object;
-    const nativeView = view.nativeViewProtected;
+    var view = args.object;
+    var nativeView = view.nativeViewProtected;
     if (nativeView instanceof UIScrollView) {
         adjustLayersForScrollView(nativeView);
     }
@@ -286,8 +334,8 @@ function adjustLayersForScrollView(nativeView) {
     // Compensates with transition for the background layers for scrolling in ScrollView based controls.
     CATransaction.begin();
     CATransaction.setDisableActions(true);
-    const offset = nativeView.contentOffset;
-    const transform = {
+    var offset = nativeView.contentOffset;
+    var transform = {
         a: 1,
         b: 0,
         c: 0,
@@ -339,55 +387,15 @@ function clearNonUniformBorders(nativeView) {
     }
     nativeView.hasNonUniformBorder = false;
 }
-function setUIColorFromImage(view, nativeView, callback, flip) {
-    const frame = nativeView.frame;
-    const boundsWidth = view.scaleX ? frame.size.width / view.scaleX : frame.size.width;
-    const boundsHeight = view.scaleY ? frame.size.height / view.scaleY : frame.size.height;
-    if (!boundsWidth || !boundsHeight) {
-        return undefined;
-    }
-    const style = view.style;
-    const background = style.backgroundInternal;
-    let imageUri = background.image;
-    if (imageUri) {
-        const match = imageUri.match(uriPattern);
-        if (match && match[2]) {
-            imageUri = match[2];
-        }
-    }
-    let bitmap;
-    if (isDataURI(imageUri)) {
-        const base64Data = imageUri.split(',')[1];
-        if (base64Data !== undefined) {
-            const imageSource = ImageSource.fromBase64Sync(base64Data);
-            bitmap = imageSource && imageSource.ios;
-        }
-    }
-    else if (isFileOrResourcePath(imageUri)) {
-        const imageSource = ImageSource.fromFileOrResourceSync(imageUri);
-        bitmap = imageSource && imageSource.ios;
-    }
-    else if (imageUri.indexOf('http') !== -1) {
-        style[symbolUrl] = imageUri;
-        ImageSource.fromUrl(imageUri)
-            .then((r) => {
-            if (style && style[symbolUrl] === imageUri) {
-                uiColorFromImage(r.ios, view, callback, flip);
-            }
-        })
-            .catch(() => { });
-    }
-    uiColorFromImage(bitmap, view, callback, flip);
-}
 function parsePosition(pos) {
-    const values = cssParse(pos);
+    var values = cssParse(pos);
     if (values.length === 2) {
         return { x: values[0], y: values[1] };
     }
     if (values.length === 1) {
-        const center = { type: 'ident', string: 'center' };
+        var center = { type: 'ident', string: 'center' };
         if (values[0].type === 'ident') {
-            const val = values[0].string.toLocaleLowerCase();
+            var val = values[0].string.toLocaleLowerCase();
             // If you only one keyword is specified, the other value is "center"
             if (val === 'left' || val === 'right') {
                 return { x: values[0], y: center };
@@ -409,7 +417,7 @@ function getDrawParams(image, background, width, height) {
     if (!image) {
         return null;
     }
-    const res = {
+    var res = {
         repeatX: true,
         repeatY: true,
         posX: 0,
@@ -430,16 +438,16 @@ function getDrawParams(image, background, width, height) {
                 break;
         }
     }
-    const imageSize = image.size;
-    let imageWidth = imageSize.width;
-    let imageHeight = imageSize.height;
+    var imageSize = image.size;
+    var imageWidth = imageSize.width;
+    var imageHeight = imageSize.height;
     // size
-    const size = background.size;
+    var size = background.size;
     if (size) {
-        const values = cssParse(size);
+        var values = cssParse(size);
         if (values.length === 2) {
-            const vx = values[0];
-            const vy = values[1];
+            var vx = values[0];
+            var vy = values[1];
             if (vx.unit === '%' && vy.unit === '%') {
                 imageWidth = (width * vx.value) / 100;
                 imageHeight = (height * vy.value) / 100;
@@ -454,7 +462,7 @@ function getDrawParams(image, background, width, height) {
             }
         }
         else if (values.length === 1 && values[0].type === 'ident') {
-            let scale = 0;
+            var scale = 0;
             if (values[0].string === 'cover') {
                 scale = Math.max(width / imageWidth, height / imageHeight);
             }
@@ -470,12 +478,12 @@ function getDrawParams(image, background, width, height) {
         }
     }
     // position
-    const position = background.position;
+    var position = background.position;
     if (position) {
-        const v = parsePosition(position);
+        var v = parsePosition(position);
         if (v) {
-            const spaceX = width - imageWidth;
-            const spaceY = height - imageHeight;
+            var spaceX = width - imageWidth;
+            var spaceY = height - imageHeight;
             if (v.x.unit === '%' && v.y.unit === '%') {
                 res.posX = (spaceX * v.x.value) / 100;
                 res.posY = (spaceY * v.y.value) / 100;
@@ -516,26 +524,25 @@ function getDrawParams(image, background, width, height) {
     }
     return res;
 }
-function uiColorFromImage(img, view, callback, flip) {
-    const background = view.style.backgroundInternal;
-    const nativeView = view.nativeViewProtected;
+function generatePatternImage(img, view, flip) {
+    var background = view.style.backgroundInternal;
+    var nativeView = view.nativeViewProtected;
     if (!img || !nativeView) {
-        callback(background.color && background.color.ios);
-        return;
+        return null;
     }
-    const frame = nativeView.frame;
-    const boundsWidth = view.scaleX ? frame.size.width / view.scaleX : frame.size.width;
-    const boundsHeight = view.scaleY ? frame.size.height / view.scaleY : frame.size.height;
-    const params = getDrawParams(img, background, boundsWidth, boundsHeight);
+    var frame = nativeView.frame;
+    var boundsWidth = view.scaleX ? frame.size.width / view.scaleX : frame.size.width;
+    var boundsHeight = view.scaleY ? frame.size.height / view.scaleY : frame.size.height;
+    var params = getDrawParams(img, background, boundsWidth, boundsHeight);
     if (params.sizeX > 0 && params.sizeY > 0) {
-        const resizeRect = CGRectMake(0, 0, params.sizeX, params.sizeY);
+        var resizeRect = CGRectMake(0, 0, params.sizeX, params.sizeY);
         UIGraphicsBeginImageContextWithOptions(resizeRect.size, false, 0.0);
         img.drawInRect(resizeRect);
         img = UIGraphicsGetImageFromCurrentImageContext();
         UIGraphicsEndImageContext();
     }
-    UIGraphicsBeginImageContextWithOptions(CGSizeFromString(`{${boundsWidth},${boundsHeight}}`), false, 0.0);
-    const context = UIGraphicsGetCurrentContext();
+    UIGraphicsBeginImageContextWithOptions(CGSizeFromString("{".concat(boundsWidth, ",").concat(boundsHeight, "}")), false, 0.0);
+    var context = UIGraphicsGetCurrentContext();
     if (background.color && background.color.ios) {
         CGContextSetFillColorWithColor(context, background.color.ios.CGColor);
         CGContextFillRect(context, CGRectMake(0, 0, boundsWidth, boundsHeight));
@@ -544,35 +551,29 @@ function uiColorFromImage(img, view, callback, flip) {
         img.drawAtPoint(CGPointMake(params.posX, params.posY));
     }
     else {
-        const w = params.repeatX ? boundsWidth : img.size.width;
-        const h = params.repeatY ? boundsHeight : img.size.height;
+        var w = params.repeatX ? boundsWidth : img.size.width;
+        var h = params.repeatY ? boundsHeight : img.size.height;
         CGContextSetPatternPhase(context, CGSizeMake(params.posX, params.posY));
         params.posX = params.repeatX ? 0 : params.posX;
         params.posY = params.repeatY ? 0 : params.posY;
-        const patternRect = CGRectMake(params.posX, params.posY, w, h);
+        var patternRect = CGRectMake(params.posX, params.posY, w, h);
         img.drawAsPatternInRect(patternRect);
     }
-    const bkgImage = UIGraphicsGetImageFromCurrentImageContext();
+    var bgImage = UIGraphicsGetImageFromCurrentImageContext();
     UIGraphicsEndImageContext();
-    if (flip) {
-        const flippedImage = _flipImage(bkgImage);
-        callback(UIColor.alloc().initWithPatternImage(flippedImage));
-    }
-    else {
-        callback(UIColor.alloc().initWithPatternImage(bkgImage));
-    }
+    return flip ? _flipImage(bgImage) : bgImage;
 }
 // Flipping the default coordinate system
 // https://developer.apple.com/library/ios/documentation/2DDrawing/Conceptual/DrawingPrintingiOS/GraphicsDrawingOverview/GraphicsDrawingOverview.html
 function _flipImage(originalImage) {
     UIGraphicsBeginImageContextWithOptions(originalImage.size, false, 0.0);
-    const context = UIGraphicsGetCurrentContext();
+    var context = UIGraphicsGetCurrentContext();
     CGContextSaveGState(context);
     CGContextTranslateCTM(context, 0.0, originalImage.size.height);
     CGContextScaleCTM(context, 1.0, -1.0);
     originalImage.drawInRect(CGRectMake(0, 0, originalImage.size.width, originalImage.size.height));
     CGContextRestoreGState(context);
-    const flippedImage = UIGraphicsGetImageFromCurrentImageContext();
+    var flippedImage = UIGraphicsGetImageFromCurrentImageContext();
     UIGraphicsEndImageContext();
     return flippedImage;
 }
@@ -592,17 +593,17 @@ function getBorderCapRadius(a, b, c) {
     return a && Math.min(a, Math.min(b, c));
 }
 function calculateNonUniformBorderCappedRadii(bounds, background) {
-    const { width, height } = bounds.size;
-    const { x, y } = bounds.origin;
-    const outerTopLeftRadius = layout.toDeviceIndependentPixels(background.borderTopLeftRadius);
-    const outerTopRightRadius = layout.toDeviceIndependentPixels(background.borderTopRightRadius);
-    const outerBottomRightRadius = layout.toDeviceIndependentPixels(background.borderBottomRightRadius);
-    const outerBottomLeftRadius = layout.toDeviceIndependentPixels(background.borderBottomLeftRadius);
-    const topRadii = outerTopLeftRadius + outerTopRightRadius;
-    const rightRadii = outerTopRightRadius + outerBottomRightRadius;
-    const bottomRadii = outerBottomRightRadius + outerBottomLeftRadius;
-    const leftRadii = outerBottomLeftRadius + outerTopLeftRadius;
-    const cappedOuterRadii = {
+    var _a = bounds.size, width = _a.width, height = _a.height;
+    var _b = bounds.origin, x = _b.x, y = _b.y;
+    var outerTopLeftRadius = layout.toDeviceIndependentPixels(background.borderTopLeftRadius);
+    var outerTopRightRadius = layout.toDeviceIndependentPixels(background.borderTopRightRadius);
+    var outerBottomRightRadius = layout.toDeviceIndependentPixels(background.borderBottomRightRadius);
+    var outerBottomLeftRadius = layout.toDeviceIndependentPixels(background.borderBottomLeftRadius);
+    var topRadii = outerTopLeftRadius + outerTopRightRadius;
+    var rightRadii = outerTopRightRadius + outerBottomRightRadius;
+    var bottomRadii = outerBottomRightRadius + outerBottomLeftRadius;
+    var leftRadii = outerBottomLeftRadius + outerTopLeftRadius;
+    var cappedOuterRadii = {
         topLeft: getBorderCapRadius(outerTopLeftRadius, (outerTopLeftRadius / topRadii) * width, (outerTopLeftRadius / leftRadii) * height),
         topRight: getBorderCapRadius(outerTopRightRadius, (outerTopRightRadius / topRadii) * width, (outerTopRightRadius / rightRadii) * height),
         bottomLeft: getBorderCapRadius(outerBottomLeftRadius, (outerBottomLeftRadius / bottomRadii) * width, (outerBottomLeftRadius / leftRadii) * height),
@@ -611,12 +612,13 @@ function calculateNonUniformBorderCappedRadii(bounds, background) {
     return cappedOuterRadii;
 }
 function drawNonUniformBorders(nativeView, background) {
-    const layer = nativeView.layer;
-    const layerBounds = layer.bounds;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    var layer = nativeView.layer;
+    var layerBounds = layer.bounds;
     layer.borderColor = null;
     layer.borderWidth = 0;
     layer.cornerRadius = 0;
-    const cappedOuterRadii = calculateNonUniformBorderCappedRadii(layerBounds, background);
+    var cappedOuterRadii = calculateNonUniformBorderCappedRadii(layerBounds, background);
     if (nativeView.maskType === iosViewUtils.LayerMask.BORDER && layer.mask instanceof CAShapeLayer) {
         layer.mask.path = generateNonUniformBorderOuterClipPath(layerBounds, cappedOuterRadii);
     }
@@ -631,14 +633,14 @@ function drawNonUniformBorders(nativeView, background) {
             // Use anti-aliasing or borders will draw incorrectly at times
             nativeView.borderLayer.shouldRasterize = true;
             nativeView.borderLayer.rasterizationScale = Screen.mainScreen.scale;
-            nativeView.borderLayer.fillColor = background.borderTopColor?.ios?.CGColor || UIColor.blackColor.CGColor;
+            nativeView.borderLayer.fillColor = ((_b = (_a = background.borderTopColor) === null || _a === void 0 ? void 0 : _a.ios) === null || _b === void 0 ? void 0 : _b.CGColor) || UIColor.blackColor.CGColor;
             nativeView.borderLayer.path = generateNonUniformBorderInnerClipPath(layerBounds, background, cappedOuterRadii);
         }
         else {
             // Non-uniform borders need more layers in order to display multiple colors at the same time
-            let borderTopLayer, borderRightLayer, borderBottomLayer, borderLeftLayer;
+            var borderTopLayer = void 0, borderRightLayer = void 0, borderBottomLayer = void 0, borderLeftLayer = void 0;
             if (!nativeView.hasNonUniformBorderColor) {
-                const maskLayer = CAShapeLayer.new();
+                var maskLayer = CAShapeLayer.new();
                 maskLayer.fillRule = kCAFillRuleEvenOdd;
                 // Use anti-aliasing or borders will draw incorrectly at times
                 maskLayer.shouldRasterize = true;
@@ -660,14 +662,14 @@ function drawNonUniformBorders(nativeView, background) {
                 borderBottomLayer = nativeView.borderLayer.sublayers[2];
                 borderLeftLayer = nativeView.borderLayer.sublayers[3];
             }
-            const paths = generateNonUniformMultiColorBorderPaths(layerBounds, background);
-            borderTopLayer.fillColor = background.borderTopColor?.ios?.CGColor || UIColor.blackColor.CGColor;
+            var paths = generateNonUniformMultiColorBorderPaths(layerBounds, background);
+            borderTopLayer.fillColor = ((_d = (_c = background.borderTopColor) === null || _c === void 0 ? void 0 : _c.ios) === null || _d === void 0 ? void 0 : _d.CGColor) || UIColor.blackColor.CGColor;
             borderTopLayer.path = paths[0];
-            borderRightLayer.fillColor = background.borderRightColor?.ios?.CGColor || UIColor.blackColor.CGColor;
+            borderRightLayer.fillColor = ((_f = (_e = background.borderRightColor) === null || _e === void 0 ? void 0 : _e.ios) === null || _f === void 0 ? void 0 : _f.CGColor) || UIColor.blackColor.CGColor;
             borderRightLayer.path = paths[1];
-            borderBottomLayer.fillColor = background.borderBottomColor?.ios?.CGColor || UIColor.blackColor.CGColor;
+            borderBottomLayer.fillColor = ((_h = (_g = background.borderBottomColor) === null || _g === void 0 ? void 0 : _g.ios) === null || _h === void 0 ? void 0 : _h.CGColor) || UIColor.blackColor.CGColor;
             borderBottomLayer.path = paths[2];
-            borderLeftLayer.fillColor = background.borderLeftColor?.ios?.CGColor || UIColor.blackColor.CGColor;
+            borderLeftLayer.fillColor = ((_k = (_j = background.borderLeftColor) === null || _j === void 0 ? void 0 : _j.ios) === null || _k === void 0 ? void 0 : _k.CGColor) || UIColor.blackColor.CGColor;
             borderLeftLayer.path = paths[3];
             // Clip inner area to create borders
             if (nativeView.borderLayer.mask instanceof CAShapeLayer) {
@@ -677,9 +679,9 @@ function drawNonUniformBorders(nativeView, background) {
     }
 }
 function calculateInnerBorderClipRadius(radius, insetX, insetY) {
-    const innerXRadius = Math.max(0, radius - insetX);
-    const innerYRadius = Math.max(0, radius - insetY);
-    const innerMaxRadius = Math.max(innerXRadius, innerYRadius);
+    var innerXRadius = Math.max(0, radius - insetX);
+    var innerYRadius = Math.max(0, radius - insetY);
+    var innerMaxRadius = Math.max(innerXRadius, innerYRadius);
     return {
         xRadius: innerXRadius,
         yRadius: innerYRadius,
@@ -694,14 +696,15 @@ function calculateInnerBorderClipRadius(radius, insetX, insetY) {
  * @param offset
  * @returns
  */
-export function generateNonUniformBorderOuterClipPath(bounds, cappedRadii, offset = 0) {
-    const { width, height } = bounds.size;
-    const { x, y } = bounds.origin;
-    const left = x - offset;
-    const top = y - offset;
-    const right = x + width + offset;
-    const bottom = y + height + offset;
-    const clipPath = CGPathCreateMutable();
+function generateNonUniformBorderOuterClipPath(bounds, cappedRadii, offset) {
+    if (offset === void 0) { offset = 0; }
+    var _a = bounds.size, width = _a.width, height = _a.height;
+    var _b = bounds.origin, x = _b.x, y = _b.y;
+    var left = x - offset;
+    var top = y - offset;
+    var right = x + width + offset;
+    var bottom = y + height + offset;
+    var clipPath = CGPathCreateMutable();
     CGPathMoveToPoint(clipPath, null, left + cappedRadii.topLeft, top);
     CGPathAddArcToPoint(clipPath, null, right, top, right, top + cappedRadii.topRight, cappedRadii.topRight);
     CGPathAddArcToPoint(clipPath, null, right, bottom, right - cappedRadii.bottomRight, bottom, cappedRadii.bottomRight);
@@ -719,25 +722,25 @@ export function generateNonUniformBorderOuterClipPath(bounds, cappedRadii, offse
  * @returns
  */
 function generateNonUniformBorderInnerClipPath(bounds, background, cappedOuterRadii) {
-    const { width, height } = bounds.size;
-    const { x, y } = bounds.origin;
-    const position = {
+    var _a = bounds.size, width = _a.width, height = _a.height;
+    var _b = bounds.origin, x = _b.x, y = _b.y;
+    var position = {
         left: x,
         top: y,
         bottom: y + height,
         right: x + width,
     };
-    const borderTopWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderTopWidth));
-    const borderRightWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderRightWidth));
-    const borderBottomWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderBottomWidth));
-    const borderLeftWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderLeftWidth));
-    const borderVWidth = borderTopWidth + borderBottomWidth;
-    const borderHWidth = borderLeftWidth + borderRightWidth;
-    const cappedBorderTopWidth = borderTopWidth && borderTopWidth * Math.min(1, height / borderVWidth);
-    const cappedBorderRightWidth = borderRightWidth && borderRightWidth * Math.min(1, width / borderHWidth);
-    const cappedBorderBottomWidth = borderBottomWidth && borderBottomWidth * Math.min(1, height / borderVWidth);
-    const cappedBorderLeftWidth = borderLeftWidth && borderLeftWidth * Math.min(1, width / borderHWidth);
-    const clipPath = CGPathCreateMutable();
+    var borderTopWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderTopWidth));
+    var borderRightWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderRightWidth));
+    var borderBottomWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderBottomWidth));
+    var borderLeftWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderLeftWidth));
+    var borderVWidth = borderTopWidth + borderBottomWidth;
+    var borderHWidth = borderLeftWidth + borderRightWidth;
+    var cappedBorderTopWidth = borderTopWidth && borderTopWidth * Math.min(1, height / borderVWidth);
+    var cappedBorderRightWidth = borderRightWidth && borderRightWidth * Math.min(1, width / borderHWidth);
+    var cappedBorderBottomWidth = borderBottomWidth && borderBottomWidth * Math.min(1, height / borderVWidth);
+    var cappedBorderLeftWidth = borderLeftWidth && borderLeftWidth * Math.min(1, width / borderHWidth);
+    var clipPath = CGPathCreateMutable();
     CGPathAddRect(clipPath, null, CGRectMake(x, y, width, height));
     // Inner clip paths
     if (cappedBorderTopWidth > 0 || cappedBorderLeftWidth > 0) {
@@ -747,32 +750,32 @@ function generateNonUniformBorderInnerClipPath(bounds, background, cappedOuterRa
         CGPathMoveToPoint(clipPath, null, position.left, position.top);
     }
     if (cappedBorderTopWidth > 0 || cappedBorderRightWidth > 0) {
-        const { xRadius, yRadius, maxRadius } = calculateInnerBorderClipRadius(cappedOuterRadii.topRight, cappedBorderRightWidth, cappedBorderTopWidth);
-        const innerTopRightTransform = CGAffineTransformMake(maxRadius && xRadius / maxRadius, 0, 0, maxRadius && yRadius / maxRadius, position.right - cappedBorderRightWidth - xRadius, position.top + cappedBorderTopWidth + yRadius);
+        var _c = calculateInnerBorderClipRadius(cappedOuterRadii.topRight, cappedBorderRightWidth, cappedBorderTopWidth), xRadius = _c.xRadius, yRadius = _c.yRadius, maxRadius = _c.maxRadius;
+        var innerTopRightTransform = CGAffineTransformMake(maxRadius && xRadius / maxRadius, 0, 0, maxRadius && yRadius / maxRadius, position.right - cappedBorderRightWidth - xRadius, position.top + cappedBorderTopWidth + yRadius);
         CGPathAddArc(clipPath, innerTopRightTransform, 0, 0, maxRadius, (Math.PI * 3) / 2, 0, false);
     }
     else {
         CGPathAddLineToPoint(clipPath, null, position.right, position.top);
     }
     if (cappedBorderBottomWidth > 0 || cappedBorderRightWidth > 0) {
-        const { xRadius, yRadius, maxRadius } = calculateInnerBorderClipRadius(cappedOuterRadii.bottomRight, cappedBorderRightWidth, cappedBorderBottomWidth);
-        const innerBottomRightTransform = CGAffineTransformMake(maxRadius && xRadius / maxRadius, 0, 0, maxRadius && yRadius / maxRadius, position.right - cappedBorderRightWidth - xRadius, position.bottom - cappedBorderBottomWidth - yRadius);
+        var _d = calculateInnerBorderClipRadius(cappedOuterRadii.bottomRight, cappedBorderRightWidth, cappedBorderBottomWidth), xRadius = _d.xRadius, yRadius = _d.yRadius, maxRadius = _d.maxRadius;
+        var innerBottomRightTransform = CGAffineTransformMake(maxRadius && xRadius / maxRadius, 0, 0, maxRadius && yRadius / maxRadius, position.right - cappedBorderRightWidth - xRadius, position.bottom - cappedBorderBottomWidth - yRadius);
         CGPathAddArc(clipPath, innerBottomRightTransform, 0, 0, maxRadius, 0, Math.PI / 2, false);
     }
     else {
         CGPathAddLineToPoint(clipPath, null, position.right, position.bottom);
     }
     if (cappedBorderBottomWidth > 0 || cappedBorderLeftWidth > 0) {
-        const { xRadius, yRadius, maxRadius } = calculateInnerBorderClipRadius(cappedOuterRadii.bottomLeft, cappedBorderLeftWidth, cappedBorderBottomWidth);
-        const innerBottomLeftTransform = CGAffineTransformMake(maxRadius && xRadius / maxRadius, 0, 0, maxRadius && yRadius / maxRadius, position.left + cappedBorderLeftWidth + xRadius, position.bottom - cappedBorderBottomWidth - yRadius);
+        var _e = calculateInnerBorderClipRadius(cappedOuterRadii.bottomLeft, cappedBorderLeftWidth, cappedBorderBottomWidth), xRadius = _e.xRadius, yRadius = _e.yRadius, maxRadius = _e.maxRadius;
+        var innerBottomLeftTransform = CGAffineTransformMake(maxRadius && xRadius / maxRadius, 0, 0, maxRadius && yRadius / maxRadius, position.left + cappedBorderLeftWidth + xRadius, position.bottom - cappedBorderBottomWidth - yRadius);
         CGPathAddArc(clipPath, innerBottomLeftTransform, 0, 0, maxRadius, Math.PI / 2, Math.PI, false);
     }
     else {
         CGPathAddLineToPoint(clipPath, null, position.left, position.bottom);
     }
     if (cappedBorderTopWidth > 0 || cappedBorderLeftWidth > 0) {
-        const { xRadius, yRadius, maxRadius } = calculateInnerBorderClipRadius(cappedOuterRadii.topLeft, cappedBorderLeftWidth, cappedBorderTopWidth);
-        const innerTopLeftTransform = CGAffineTransformMake(maxRadius && xRadius / maxRadius, 0, 0, maxRadius && yRadius / maxRadius, position.left + cappedBorderLeftWidth + xRadius, position.top + cappedBorderTopWidth + yRadius);
+        var _f = calculateInnerBorderClipRadius(cappedOuterRadii.topLeft, cappedBorderLeftWidth, cappedBorderTopWidth), xRadius = _f.xRadius, yRadius = _f.yRadius, maxRadius = _f.maxRadius;
+        var innerTopLeftTransform = CGAffineTransformMake(maxRadius && xRadius / maxRadius, 0, 0, maxRadius && yRadius / maxRadius, position.left + cappedBorderLeftWidth + xRadius, position.top + cappedBorderTopWidth + yRadius);
         CGPathAddArc(clipPath, innerTopLeftTransform, 0, 0, maxRadius, Math.PI, (Math.PI * 3) / 2, false);
     }
     else {
@@ -790,16 +793,16 @@ function generateNonUniformBorderInnerClipPath(bounds, background, cappedOuterRa
  * @returns
  */
 function getBorderTriangleWidths(bounds, background) {
-    const width = bounds.origin.x + bounds.size.width;
-    const height = bounds.origin.y + bounds.size.height;
-    const borderTopWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderTopWidth));
-    const borderRightWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderRightWidth));
-    const borderBottomWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderBottomWidth));
-    const borderLeftWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderLeftWidth));
-    const verticalBorderWidth = borderTopWidth + borderBottomWidth;
-    const horizontalBorderWidth = borderLeftWidth + borderRightWidth;
-    let verticalBorderMultiplier = verticalBorderWidth > 0 ? height / verticalBorderWidth : 0;
-    let horizontalBorderMultiplier = horizontalBorderWidth > 0 ? width / horizontalBorderWidth : 0;
+    var width = bounds.origin.x + bounds.size.width;
+    var height = bounds.origin.y + bounds.size.height;
+    var borderTopWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderTopWidth));
+    var borderRightWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderRightWidth));
+    var borderBottomWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderBottomWidth));
+    var borderLeftWidth = Math.max(0, layout.toDeviceIndependentPixels(background.borderLeftWidth));
+    var verticalBorderWidth = borderTopWidth + borderBottomWidth;
+    var horizontalBorderWidth = borderLeftWidth + borderRightWidth;
+    var verticalBorderMultiplier = verticalBorderWidth > 0 ? height / verticalBorderWidth : 0;
+    var horizontalBorderMultiplier = horizontalBorderWidth > 0 ? width / horizontalBorderWidth : 0;
     // Both directions should consider each other in order to scale widths properly, as a view might have different width and height
     if (verticalBorderMultiplier > 0 && verticalBorderMultiplier < horizontalBorderMultiplier) {
         horizontalBorderMultiplier -= horizontalBorderMultiplier - verticalBorderMultiplier;
@@ -824,54 +827,54 @@ function getBorderTriangleWidths(bounds, background) {
  * @returns
  */
 function generateNonUniformMultiColorBorderPaths(bounds, background) {
-    const { width, height } = bounds.size;
-    const { x, y } = bounds.origin;
-    const position = {
+    var _a = bounds.size, width = _a.width, height = _a.height;
+    var _b = bounds.origin, x = _b.x, y = _b.y;
+    var position = {
         left: x,
         top: y,
         bottom: y + height,
         right: x + width,
     };
-    const borderWidths = getBorderTriangleWidths(bounds, background);
-    const paths = new Array(4);
-    const lto = {
+    var borderWidths = getBorderTriangleWidths(bounds, background);
+    var paths = new Array(4);
+    var lto = {
         x: position.left,
         y: position.top,
     }; // left-top-outside
-    const lti = {
+    var lti = {
         x: position.left + borderWidths.left,
         y: position.top + borderWidths.top,
     }; // left-top-inside
-    const rto = {
+    var rto = {
         x: position.right,
         y: position.top,
     }; // right-top-outside
-    const rti = {
+    var rti = {
         x: position.right - borderWidths.right,
         y: position.top + borderWidths.top,
     }; // right-top-inside
-    const rbo = {
+    var rbo = {
         x: position.right,
         y: position.bottom,
     }; // right-bottom-outside
-    const rbi = {
+    var rbi = {
         x: position.right - borderWidths.right,
         y: position.bottom - borderWidths.bottom,
     }; // right-bottom-inside
-    const lbo = {
+    var lbo = {
         x: position.left,
         y: position.bottom,
     }; // left-bottom-outside
-    const lbi = {
+    var lbi = {
         x: position.left + borderWidths.left,
         y: position.bottom - borderWidths.bottom,
     }; // left-bottom-inside
-    const borderTopColor = background.borderTopColor;
-    const borderRightColor = background.borderRightColor;
-    const borderBottomColor = background.borderBottomColor;
-    const borderLeftColor = background.borderLeftColor;
-    if (borderWidths.top > 0 && borderTopColor?.ios) {
-        const topBorderPath = CGPathCreateMutable();
+    var borderTopColor = background.borderTopColor;
+    var borderRightColor = background.borderRightColor;
+    var borderBottomColor = background.borderBottomColor;
+    var borderLeftColor = background.borderLeftColor;
+    if (borderWidths.top > 0 && (borderTopColor === null || borderTopColor === void 0 ? void 0 : borderTopColor.ios)) {
+        var topBorderPath = CGPathCreateMutable();
         CGPathMoveToPoint(topBorderPath, null, lto.x, lto.y);
         CGPathAddLineToPoint(topBorderPath, null, rto.x, rto.y);
         CGPathAddLineToPoint(topBorderPath, null, rti.x, rti.y);
@@ -881,8 +884,8 @@ function generateNonUniformMultiColorBorderPaths(bounds, background) {
         CGPathAddLineToPoint(topBorderPath, null, lto.x, lto.y);
         paths[0] = topBorderPath;
     }
-    if (borderWidths.right > 0 && borderRightColor?.ios) {
-        const rightBorderPath = CGPathCreateMutable();
+    if (borderWidths.right > 0 && (borderRightColor === null || borderRightColor === void 0 ? void 0 : borderRightColor.ios)) {
+        var rightBorderPath = CGPathCreateMutable();
         CGPathMoveToPoint(rightBorderPath, null, rto.x, rto.y);
         CGPathAddLineToPoint(rightBorderPath, null, rbo.x, rbo.y);
         CGPathAddLineToPoint(rightBorderPath, null, rbi.x, rbi.y);
@@ -892,8 +895,8 @@ function generateNonUniformMultiColorBorderPaths(bounds, background) {
         CGPathAddLineToPoint(rightBorderPath, null, rto.x, rto.y);
         paths[1] = rightBorderPath;
     }
-    if (borderWidths.bottom > 0 && borderBottomColor?.ios) {
-        const bottomBorderPath = CGPathCreateMutable();
+    if (borderWidths.bottom > 0 && (borderBottomColor === null || borderBottomColor === void 0 ? void 0 : borderBottomColor.ios)) {
+        var bottomBorderPath = CGPathCreateMutable();
         CGPathMoveToPoint(bottomBorderPath, null, rbo.x, rbo.y);
         CGPathAddLineToPoint(bottomBorderPath, null, lbo.x, lbo.y);
         CGPathAddLineToPoint(bottomBorderPath, null, lbi.x, lbi.y);
@@ -903,8 +906,8 @@ function generateNonUniformMultiColorBorderPaths(bounds, background) {
         CGPathAddLineToPoint(bottomBorderPath, null, rbo.x, rbo.y);
         paths[2] = bottomBorderPath;
     }
-    if (borderWidths.left > 0 && borderLeftColor?.ios) {
-        const leftBorderPath = CGPathCreateMutable();
+    if (borderWidths.left > 0 && (borderLeftColor === null || borderLeftColor === void 0 ? void 0 : borderLeftColor.ios)) {
+        var leftBorderPath = CGPathCreateMutable();
         CGPathMoveToPoint(leftBorderPath, null, lbo.x, lbo.y);
         CGPathAddLineToPoint(leftBorderPath, null, lto.x, lto.y);
         CGPathAddLineToPoint(leftBorderPath, null, lti.x, lti.y);
@@ -917,26 +920,27 @@ function generateNonUniformMultiColorBorderPaths(bounds, background) {
     return paths;
 }
 function drawBoxShadow(view) {
-    const background = view.style.backgroundInternal;
-    const nativeView = view.nativeViewProtected;
-    const layer = nativeView.layer;
+    var _a, _b, _c;
+    var background = view.style.backgroundInternal;
+    var nativeView = view.nativeViewProtected;
+    var layer = nativeView.layer;
     // There is no parent to add shadow to
     if (!layer.superlayer) {
         return;
     }
-    const bounds = nativeView.bounds;
-    const boxShadow = background.getBoxShadow();
+    var bounds = nativeView.bounds;
+    var boxShadow = background.getBoxShadow();
     // Initialize outer shadows
-    let outerShadowContainerLayer;
+    var outerShadowContainerLayer;
     if (nativeView.outerShadowContainerLayer) {
         outerShadowContainerLayer = nativeView.outerShadowContainerLayer;
     }
     else {
         outerShadowContainerLayer = CALayer.new();
         // TODO: Make this dynamic when views get support for multiple shadows
-        const shadowLayer = CALayer.new();
+        var shadowLayer = CALayer.new();
         // This mask is necessary to maintain transparent background
-        const maskLayer = CAShapeLayer.new();
+        var maskLayer = CAShapeLayer.new();
         maskLayer.fillRule = kCAFillRuleEvenOdd;
         shadowLayer.mask = maskLayer;
         outerShadowContainerLayer.addSublayer(shadowLayer);
@@ -960,21 +964,21 @@ function drawBoxShadow(view) {
     // Inherit view visibility values
     outerShadowContainerLayer.opacity = layer.opacity;
     outerShadowContainerLayer.hidden = layer.hidden;
-    const outerShadowLayers = outerShadowContainerLayer.sublayers;
-    if (outerShadowLayers?.count) {
-        for (let i = 0, count = outerShadowLayers.count; i < count; i++) {
-            const shadowLayer = outerShadowLayers[i];
-            const shadowRadius = layout.toDeviceIndependentPixels(boxShadow.blurRadius);
-            const spreadRadius = layout.toDeviceIndependentPixels(boxShadow.spreadRadius);
-            const offsetX = layout.toDeviceIndependentPixels(boxShadow.offsetX);
-            const offsetY = layout.toDeviceIndependentPixels(boxShadow.offsetY);
-            const { maskPath, shadowPath } = ios.generateShadowLayerPaths(view, bounds);
+    var outerShadowLayers = outerShadowContainerLayer.sublayers;
+    if (outerShadowLayers === null || outerShadowLayers === void 0 ? void 0 : outerShadowLayers.count) {
+        for (var i = 0, count = outerShadowLayers.count; i < count; i++) {
+            var shadowLayer = outerShadowLayers[i];
+            var shadowRadius = layout.toDeviceIndependentPixels(boxShadow.blurRadius);
+            var spreadRadius = layout.toDeviceIndependentPixels(boxShadow.spreadRadius);
+            var offsetX = layout.toDeviceIndependentPixels(boxShadow.offsetX);
+            var offsetY = layout.toDeviceIndependentPixels(boxShadow.offsetY);
+            var _d = ios.generateShadowLayerPaths(view, bounds), maskPath = _d.maskPath, shadowPath = _d.shadowPath;
             shadowLayer.allowsEdgeAntialiasing = true;
             shadowLayer.contentsScale = Screen.mainScreen.scale;
             // Shadow opacity is handled on the shadow's color instance
-            shadowLayer.shadowOpacity = boxShadow.color?.a ? boxShadow.color.a / 255 : 1;
+            shadowLayer.shadowOpacity = ((_a = boxShadow.color) === null || _a === void 0 ? void 0 : _a.a) ? boxShadow.color.a / 255 : 1;
             shadowLayer.shadowRadius = shadowRadius;
-            shadowLayer.shadowColor = boxShadow.color?.ios?.CGColor;
+            shadowLayer.shadowColor = (_c = (_b = boxShadow.color) === null || _b === void 0 ? void 0 : _b.ios) === null || _c === void 0 ? void 0 : _c.CGColor;
             shadowLayer.shadowOffset = CGSizeMake(offsetX, offsetY);
             // Apply spread radius by expanding shadow layer bounds (this has a nice glow with radii set to 0)
             shadowLayer.shadowPath = shadowPath;
@@ -1000,33 +1004,33 @@ function clearBoxShadow(nativeView) {
  * @returns
  */
 function generateShadowMaskPath(bounds, boxShadow, innerClipPath) {
-    const shadowRadius = layout.toDeviceIndependentPixels(boxShadow.blurRadius);
-    const spreadRadius = layout.toDeviceIndependentPixels(boxShadow.spreadRadius);
-    const offsetX = layout.toDeviceIndependentPixels(boxShadow.offsetX);
-    const offsetY = layout.toDeviceIndependentPixels(boxShadow.offsetY);
+    var shadowRadius = layout.toDeviceIndependentPixels(boxShadow.blurRadius);
+    var spreadRadius = layout.toDeviceIndependentPixels(boxShadow.spreadRadius);
+    var offsetX = layout.toDeviceIndependentPixels(boxShadow.offsetX);
+    var offsetY = layout.toDeviceIndependentPixels(boxShadow.offsetY);
     // This value has to be large enough to avoid clipping shadow halo effect
-    const outerRectRadius = shadowRadius * 3 + spreadRadius;
-    const maskPath = CGPathCreateMutable();
+    var outerRectRadius = shadowRadius * 3 + spreadRadius;
+    var maskPath = CGPathCreateMutable();
     // Proper clip position and size
-    const outerRect = CGRectOffset(CGRectInset(bounds, -outerRectRadius, -outerRectRadius), offsetX, offsetY);
+    var outerRect = CGRectOffset(CGRectInset(bounds, -outerRectRadius, -outerRectRadius), offsetX, offsetY);
     CGPathAddPath(maskPath, null, innerClipPath);
     CGPathAddRect(maskPath, null, outerRect);
     return maskPath;
 }
 function rectPath(value, position) {
-    const arr = value.split(/[\s]+/);
-    const top = cssValueToDeviceIndependentPixels(arr[0], position.top);
-    const right = cssValueToDeviceIndependentPixels(arr[1], position.right);
-    const bottom = cssValueToDeviceIndependentPixels(arr[2], position.bottom);
-    const left = cssValueToDeviceIndependentPixels(arr[3], position.left);
+    var arr = value.split(/[\s]+/);
+    var top = cssValueToDeviceIndependentPixels(arr[0], position.top);
+    var right = cssValueToDeviceIndependentPixels(arr[1], position.right);
+    var bottom = cssValueToDeviceIndependentPixels(arr[2], position.bottom);
+    var left = cssValueToDeviceIndependentPixels(arr[3], position.left);
     return UIBezierPath.bezierPathWithRect(CGRectMake(left, top, right - left, bottom - top)).CGPath;
 }
 function insetPath(value, position) {
-    const arr = value.split(/[\s]+/);
-    let topString;
-    let rightString;
-    let bottomString;
-    let leftString;
+    var arr = value.split(/[\s]+/);
+    var topString;
+    var rightString;
+    var bottomString;
+    var leftString;
     if (arr.length === 1) {
         topString = rightString = bottomString = leftString = arr[0];
     }
@@ -1045,38 +1049,38 @@ function insetPath(value, position) {
         bottomString = arr[2];
         leftString = arr[3];
     }
-    const top = cssValueToDeviceIndependentPixels(topString, position.bottom);
-    const right = cssValueToDeviceIndependentPixels('100%', position.right) - cssValueToDeviceIndependentPixels(rightString, position.right);
-    const bottom = cssValueToDeviceIndependentPixels('100%', position.bottom) - cssValueToDeviceIndependentPixels(bottomString, position.bottom);
-    const left = cssValueToDeviceIndependentPixels(leftString, position.right);
+    var top = cssValueToDeviceIndependentPixels(topString, position.bottom);
+    var right = cssValueToDeviceIndependentPixels('100%', position.right) - cssValueToDeviceIndependentPixels(rightString, position.right);
+    var bottom = cssValueToDeviceIndependentPixels('100%', position.bottom) - cssValueToDeviceIndependentPixels(bottomString, position.bottom);
+    var left = cssValueToDeviceIndependentPixels(leftString, position.right);
     return UIBezierPath.bezierPathWithRect(CGRectMake(left, top, right - left, bottom - top)).CGPath;
 }
 function circlePath(value, position) {
-    const arr = value.split(/[\s]+/);
-    const radius = cssValueToDeviceIndependentPixels(arr[0], (position.right > position.bottom ? position.bottom : position.right) / 2);
-    const y = cssValueToDeviceIndependentPixels(arr[2], position.bottom);
-    const x = cssValueToDeviceIndependentPixels(arr[3], position.right);
+    var arr = value.split(/[\s]+/);
+    var radius = cssValueToDeviceIndependentPixels(arr[0], (position.right > position.bottom ? position.bottom : position.right) / 2);
+    var y = cssValueToDeviceIndependentPixels(arr[2], position.bottom);
+    var x = cssValueToDeviceIndependentPixels(arr[3], position.right);
     return UIBezierPath.bezierPathWithArcCenterRadiusStartAngleEndAngleClockwise(CGPointMake(x, y), radius, 0, 360, true).CGPath;
 }
 function ellipsePath(value, position) {
-    const arr = value.split(/[\s]+/);
-    const rX = cssValueToDeviceIndependentPixels(arr[0], position.right);
-    const rY = cssValueToDeviceIndependentPixels(arr[1], position.bottom);
-    const cX = cssValueToDeviceIndependentPixels(arr[3], position.right);
-    const cY = cssValueToDeviceIndependentPixels(arr[4], position.bottom);
-    const left = cX - rX;
-    const top = cY - rY;
-    const width = rX * 2;
-    const height = rY * 2;
+    var arr = value.split(/[\s]+/);
+    var rX = cssValueToDeviceIndependentPixels(arr[0], position.right);
+    var rY = cssValueToDeviceIndependentPixels(arr[1], position.bottom);
+    var cX = cssValueToDeviceIndependentPixels(arr[3], position.right);
+    var cY = cssValueToDeviceIndependentPixels(arr[4], position.bottom);
+    var left = cX - rX;
+    var top = cY - rY;
+    var width = rX * 2;
+    var height = rY * 2;
     return UIBezierPath.bezierPathWithOvalInRect(CGRectMake(left, top, width, height)).CGPath;
 }
 function polygonPath(value, position) {
-    const path = CGPathCreateMutable();
-    let firstPoint;
-    const arr = value.split(/[,]+/);
-    for (let i = 0; i < arr.length; i++) {
-        const xy = arr[i].trim().split(/[\s]+/);
-        const point = {
+    var path = CGPathCreateMutable();
+    var firstPoint;
+    var arr = value.split(/[,]+/);
+    for (var i = 0; i < arr.length; i++) {
+        var xy = arr[i].trim().split(/[\s]+/);
+        var point = {
             x: cssValueToDeviceIndependentPixels(xy[0], position.right),
             y: cssValueToDeviceIndependentPixels(xy[1], position.bottom),
         };