@nativescript/core 8.9.0-napi-es5.0 → 8.9.0-napi.1

package/ui/styling/background.ios.js

@@ -5,9 +5,9 @@ import { ios as iosViewUtils } from '../utils';
 import { ImageSource } from '../../image-source';
 import { parse as cssParse } from '../../css-value/reworkcss-value.js';
 export * from './background-common';
-var clearCGColor = UIColor.clearColor.CGColor;
-var uriPattern = /url\(('|")(.*?)\1\)/;
-var symbolUrl = Symbol('backgroundImageUrl');
+const clearCGColor = UIColor.clearColor.CGColor;
+const uriPattern = /url\(('|")(.*?)\1\)/;
+const symbolUrl = Symbol('backgroundImageUrl');
 export var CacheMode;
 (function (CacheMode) {
     CacheMode[CacheMode["none"] = 0] = "none";
@@ -15,9 +15,8 @@ export var CacheMode;
 export var ios;
 (function (ios) {
     function createBackgroundUIColor(view, callback, flip) {
-        var _a;
-        var background = view.style.backgroundInternal;
-        var nativeView = view.nativeViewProtected;
+        const background = view.style.backgroundInternal;
+        const nativeView = view.nativeViewProtected;
         if (!nativeView) {
             return;
         }
@@ -28,24 +27,22 @@ export var ios;
         // Borders, shadows, etc
         drawBackgroundVisualEffects(view);
         if (!background.image) {
-            callback((_a = background === null || background === void 0 ? void 0 : background.color) === null || _a === void 0 ? void 0 : _a.ios);
+            callback(background?.color?.ios);
         }
         else {
             if (!(background.image instanceof LinearGradient)) {
-                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);
+                createUIImageFromURI(view, background.image, flip, (image) => {
+                    callback(image ? UIColor.alloc().initWithPatternImage(image) : background?.color?.ios);
                 });
             }
         }
     }
     ios.createBackgroundUIColor = createBackgroundUIColor;
     function drawBackgroundVisualEffects(view) {
-        var _a;
-        var background = view.style.backgroundInternal;
-        var nativeView = view.nativeViewProtected;
-        var layer = nativeView.layer;
-        var needsLayerAdjustmentOnScroll = false;
+        const background = view.style.backgroundInternal;
+        const nativeView = view.nativeViewProtected;
+        const layer = nativeView.layer;
+        let needsLayerAdjustmentOnScroll = false;
         // Add new gradient layer or update existing one
         if (background.image instanceof LinearGradient) {
             if (!nativeView.gradientLayer) {
@@ -58,8 +55,8 @@ export var ios;
         // Initialize clipping mask (usually for clip-path and non-uniform rounded borders)
         maskLayerIfNeeded(nativeView, background);
         if (background.hasUniformBorder()) {
-            var borderColor = background.getUniformBorderColor();
-            layer.borderColor = (_a = borderColor === null || borderColor === void 0 ? void 0 : borderColor.ios) === null || _a === void 0 ? void 0 : _a.CGColor;
+            const borderColor = background.getUniformBorderColor();
+            layer.borderColor = borderColor?.ios?.CGColor;
             layer.borderWidth = layout.toDeviceIndependentPixels(background.getUniformBorderWidth());
             layer.cornerRadius = getUniformBorderRadius(view, layer.bounds);
         }
@@ -81,14 +78,14 @@ export var ios;
     }
     ios.drawBackgroundVisualEffects = drawBackgroundVisualEffects;
     function clearBackgroundVisualEffects(view) {
-        var nativeView = view.nativeViewProtected;
+        const nativeView = view.nativeViewProtected;
         if (!nativeView) {
             return;
         }
-        var background = view.style.backgroundInternal;
-        var hasGradientBackground = background.image && background.image instanceof LinearGradient;
+        const background = view.style.backgroundInternal;
+        const hasGradientBackground = background.image && background.image instanceof LinearGradient;
         // Remove mask if there is no clip path or non-uniform border with radius
-        var needsMask;
+        let needsMask;
         switch (nativeView.maskType) {
             case iosViewUtils.LayerMask.BORDER:
                 needsMask = !background.hasUniformBorder() && background.hasBorderRadius();
@@ -127,68 +124,68 @@ export var ios;
     }
     ios.clearBackgroundVisualEffects = clearBackgroundVisualEffects;
     function createUIImageFromURI(view, imageURI, flip, callback) {
-        var nativeView = view.nativeViewProtected;
+        const 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;
+        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;
         }
-        var style = view.style;
+        const style = view.style;
         if (imageURI) {
-            var match = imageURI.match(uriPattern);
+            const match = imageURI.match(uriPattern);
             if (match && match[2]) {
                 imageURI = match[2];
             }
         }
-        var bitmap;
+        let bitmap;
         if (isDataURI(imageURI)) {
-            var base64Data = imageURI.split(',')[1];
+            const base64Data = imageURI.split(',')[1];
             if (base64Data !== undefined) {
-                var imageSource = ImageSource.fromBase64Sync(base64Data);
+                const imageSource = ImageSource.fromBase64Sync(base64Data);
                 bitmap = imageSource && imageSource.ios;
             }
         }
         else if (isFileOrResourcePath(imageURI)) {
-            var imageSource = ImageSource.fromFileOrResourceSync(imageURI);
+            const imageSource = ImageSource.fromFileOrResourceSync(imageURI);
             bitmap = imageSource && imageSource.ios;
         }
         else if (imageURI.indexOf('http') !== -1) {
             style[symbolUrl] = imageURI;
             ImageSource.fromUrl(imageURI)
-                .then(function (r) {
+                .then((r) => {
                 if (style && style[symbolUrl] === imageURI) {
                     callback(generatePatternImage(r.ios, view, flip));
                 }
             })
-                .catch(function () { });
+                .catch(() => { });
         }
         callback(generatePatternImage(bitmap, view, flip));
     }
     ios.createUIImageFromURI = createUIImageFromURI;
     function generateShadowLayerPaths(view, bounds) {
-        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;
+        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;
         // Generate more detailed paths if view has border radius
         if (background.hasBorderRadius()) {
             if (background.hasUniformBorder()) {
-                var cornerRadius = layer.cornerRadius;
-                var cappedRadius = getBorderCapRadius(cornerRadius, width / 2, height / 2);
-                var cappedOuterRadii = {
+                const cornerRadius = layer.cornerRadius;
+                const cappedRadius = getBorderCapRadius(cornerRadius, width / 2, height / 2);
+                const cappedOuterRadii = {
                     topLeft: cappedRadius,
                     topRight: cappedRadius,
                     bottomLeft: cappedRadius,
                     bottomRight: cappedRadius,
                 };
-                var cappedOuterRadiiWithSpread = {
+                const cappedOuterRadiiWithSpread = {
                     topLeft: cappedRadius + spreadRadius,
                     topRight: cappedRadius + spreadRadius,
                     bottomLeft: cappedRadius + spreadRadius,
@@ -198,15 +195,15 @@ export var ios;
                 shadowPath = generateNonUniformBorderOuterClipPath(bounds, cappedOuterRadiiWithSpread, spreadRadius);
             }
             else {
-                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 = {
+                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 = {
                     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),
@@ -214,7 +211,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
-                var cappedOuterRadiiWithSpread = {
+                const 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,
@@ -230,14 +227,14 @@ export var ios;
         }
         return {
             maskPath: generateShadowMaskPath(bounds, boxShadow, innerPath),
-            shadowPath: shadowPath,
+            shadowPath,
         };
     }
     ios.generateShadowLayerPaths = generateShadowLayerPaths;
     function generateClipPath(view, bounds) {
-        var background = view.style.backgroundInternal;
-        var origin = bounds.origin, size = bounds.size;
-        var position = {
+        const background = view.style.backgroundInternal;
+        const { origin, size } = bounds;
+        const position = {
             left: origin.x,
             top: origin.y,
             bottom: size.height,
@@ -246,10 +243,10 @@ export var ios;
         if (position.right === 0 || position.bottom === 0) {
             return;
         }
-        var path;
-        var clipPath = background.clipPath;
-        var functionName = clipPath.substring(0, clipPath.indexOf('('));
-        var value = clipPath.replace("".concat(functionName, "("), '').replace(')', '');
+        let path;
+        const clipPath = background.clipPath;
+        const functionName = clipPath.substring(0, clipPath.indexOf('('));
+        const value = clipPath.replace(`${functionName}(`, '').replace(')', '');
         switch (functionName) {
             case 'rect':
                 path = rectPath(value, position);
@@ -271,32 +268,32 @@ export var ios;
     }
     ios.generateClipPath = generateClipPath;
     function getUniformBorderRadius(view, bounds) {
-        var background = view.style.backgroundInternal;
-        var _a = bounds.size, width = _a.width, height = _a.height;
-        var cornerRadius = layout.toDeviceIndependentPixels(background.getUniformBorderRadius());
+        const background = view.style.backgroundInternal;
+        const { width, height } = bounds.size;
+        const cornerRadius = layout.toDeviceIndependentPixels(background.getUniformBorderRadius());
         return Math.min(Math.min(width / 2, height / 2), cornerRadius);
     }
     ios.getUniformBorderRadius = getUniformBorderRadius;
     function generateNonUniformBorderInnerClipRoundedPath(view, bounds) {
-        var background = view.style.backgroundInternal;
-        var cappedOuterRadii = calculateNonUniformBorderCappedRadii(bounds, background);
+        const background = view.style.backgroundInternal;
+        const cappedOuterRadii = calculateNonUniformBorderCappedRadii(bounds, background);
         return generateNonUniformBorderInnerClipPath(bounds, background, cappedOuterRadii);
     }
     ios.generateNonUniformBorderInnerClipRoundedPath = generateNonUniformBorderInnerClipRoundedPath;
     function generateNonUniformBorderOuterClipRoundedPath(view, bounds) {
-        var background = view.style.backgroundInternal;
-        var cappedOuterRadii = calculateNonUniformBorderCappedRadii(bounds, background);
+        const background = view.style.backgroundInternal;
+        const cappedOuterRadii = calculateNonUniformBorderCappedRadii(bounds, background);
         return generateNonUniformBorderOuterClipPath(bounds, cappedOuterRadii);
     }
     ios.generateNonUniformBorderOuterClipRoundedPath = generateNonUniformBorderOuterClipRoundedPath;
     function generateNonUniformMultiColorBorderRoundedPaths(view, bounds) {
-        var background = view.style.backgroundInternal;
+        const background = view.style.backgroundInternal;
         return generateNonUniformMultiColorBorderPaths(bounds, background);
     }
     ios.generateNonUniformMultiColorBorderRoundedPaths = generateNonUniformMultiColorBorderRoundedPaths;
 })(ios || (ios = {}));
 function maskLayerIfNeeded(nativeView, background) {
-    var layer = nativeView.layer;
+    const 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
@@ -324,8 +321,8 @@ function clearLayerMask(nativeView) {
     nativeView.maskType = null;
 }
 function onBackgroundViewScroll(args) {
-    var view = args.object;
-    var nativeView = view.nativeViewProtected;
+    const view = args.object;
+    const nativeView = view.nativeViewProtected;
     if (nativeView instanceof UIScrollView) {
         adjustLayersForScrollView(nativeView);
     }
@@ -334,8 +331,8 @@ function adjustLayersForScrollView(nativeView) {
     // Compensates with transition for the background layers for scrolling in ScrollView based controls.
     CATransaction.begin();
     CATransaction.setDisableActions(true);
-    var offset = nativeView.contentOffset;
-    var transform = {
+    const offset = nativeView.contentOffset;
+    const transform = {
         a: 1,
         b: 0,
         c: 0,
@@ -388,14 +385,14 @@ function clearNonUniformBorders(nativeView) {
     nativeView.hasNonUniformBorder = false;
 }
 function parsePosition(pos) {
-    var values = cssParse(pos);
+    const values = cssParse(pos);
     if (values.length === 2) {
         return { x: values[0], y: values[1] };
     }
     if (values.length === 1) {
-        var center = { type: 'ident', string: 'center' };
+        const center = { type: 'ident', string: 'center' };
         if (values[0].type === 'ident') {
-            var val = values[0].string.toLocaleLowerCase();
+            const 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 };
@@ -417,7 +414,7 @@ function getDrawParams(image, background, width, height) {
     if (!image) {
         return null;
     }
-    var res = {
+    const res = {
         repeatX: true,
         repeatY: true,
         posX: 0,
@@ -438,16 +435,16 @@ function getDrawParams(image, background, width, height) {
                 break;
         }
     }
-    var imageSize = image.size;
-    var imageWidth = imageSize.width;
-    var imageHeight = imageSize.height;
+    const imageSize = image.size;
+    let imageWidth = imageSize.width;
+    let imageHeight = imageSize.height;
     // size
-    var size = background.size;
+    const size = background.size;
     if (size) {
-        var values = cssParse(size);
+        const values = cssParse(size);
         if (values.length === 2) {
-            var vx = values[0];
-            var vy = values[1];
+            const vx = values[0];
+            const vy = values[1];
             if (vx.unit === '%' && vy.unit === '%') {
                 imageWidth = (width * vx.value) / 100;
                 imageHeight = (height * vy.value) / 100;
@@ -462,7 +459,7 @@ function getDrawParams(image, background, width, height) {
             }
         }
         else if (values.length === 1 && values[0].type === 'ident') {
-            var scale = 0;
+            let scale = 0;
             if (values[0].string === 'cover') {
                 scale = Math.max(width / imageWidth, height / imageHeight);
             }
@@ -478,12 +475,12 @@ function getDrawParams(image, background, width, height) {
         }
     }
     // position
-    var position = background.position;
+    const position = background.position;
     if (position) {
-        var v = parsePosition(position);
+        const v = parsePosition(position);
         if (v) {
-            var spaceX = width - imageWidth;
-            var spaceY = height - imageHeight;
+            const spaceX = width - imageWidth;
+            const spaceY = height - imageHeight;
             if (v.x.unit === '%' && v.y.unit === '%') {
                 res.posX = (spaceX * v.x.value) / 100;
                 res.posY = (spaceY * v.y.value) / 100;
@@ -525,24 +522,24 @@ function getDrawParams(image, background, width, height) {
     return res;
 }
 function generatePatternImage(img, view, flip) {
-    var background = view.style.backgroundInternal;
-    var nativeView = view.nativeViewProtected;
+    const background = view.style.backgroundInternal;
+    const nativeView = view.nativeViewProtected;
     if (!img || !nativeView) {
         return null;
     }
-    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);
+    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);
     if (params.sizeX > 0 && params.sizeY > 0) {
-        var resizeRect = CGRectMake(0, 0, params.sizeX, params.sizeY);
+        const resizeRect = CGRectMake(0, 0, params.sizeX, params.sizeY);
         UIGraphicsBeginImageContextWithOptions(resizeRect.size, false, 0.0);
         img.drawInRect(resizeRect);
         img = UIGraphicsGetImageFromCurrentImageContext();
         UIGraphicsEndImageContext();
     }
-    UIGraphicsBeginImageContextWithOptions(CGSizeFromString("{".concat(boundsWidth, ",").concat(boundsHeight, "}")), false, 0.0);
-    var context = UIGraphicsGetCurrentContext();
+    UIGraphicsBeginImageContextWithOptions(CGSizeFromString(`{${boundsWidth},${boundsHeight}}`), false, 0.0);
+    const context = UIGraphicsGetCurrentContext();
     if (background.color && background.color.ios) {
         CGContextSetFillColorWithColor(context, background.color.ios.CGColor);
         CGContextFillRect(context, CGRectMake(0, 0, boundsWidth, boundsHeight));
@@ -551,15 +548,15 @@ function generatePatternImage(img, view, flip) {
         img.drawAtPoint(CGPointMake(params.posX, params.posY));
     }
     else {
-        var w = params.repeatX ? boundsWidth : img.size.width;
-        var h = params.repeatY ? boundsHeight : img.size.height;
+        const w = params.repeatX ? boundsWidth : img.size.width;
+        const 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;
-        var patternRect = CGRectMake(params.posX, params.posY, w, h);
+        const patternRect = CGRectMake(params.posX, params.posY, w, h);
         img.drawAsPatternInRect(patternRect);
     }
-    var bgImage = UIGraphicsGetImageFromCurrentImageContext();
+    const bgImage = UIGraphicsGetImageFromCurrentImageContext();
     UIGraphicsEndImageContext();
     return flip ? _flipImage(bgImage) : bgImage;
 }
@@ -567,13 +564,13 @@ function generatePatternImage(img, view, flip) {
 // https://developer.apple.com/library/ios/documentation/2DDrawing/Conceptual/DrawingPrintingiOS/GraphicsDrawingOverview/GraphicsDrawingOverview.html
 function _flipImage(originalImage) {
     UIGraphicsBeginImageContextWithOptions(originalImage.size, false, 0.0);
-    var context = UIGraphicsGetCurrentContext();
+    const 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);
-    var flippedImage = UIGraphicsGetImageFromCurrentImageContext();
+    const flippedImage = UIGraphicsGetImageFromCurrentImageContext();
     UIGraphicsEndImageContext();
     return flippedImage;
 }
@@ -593,17 +590,17 @@ function getBorderCapRadius(a, b, c) {
     return a && Math.min(a, Math.min(b, c));
 }
 function calculateNonUniformBorderCappedRadii(bounds, background) {
-    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 = {
+    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 = {
         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),
@@ -612,13 +609,12 @@ function calculateNonUniformBorderCappedRadii(bounds, background) {
     return cappedOuterRadii;
 }
 function drawNonUniformBorders(nativeView, background) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-    var layer = nativeView.layer;
-    var layerBounds = layer.bounds;
+    const layer = nativeView.layer;
+    const layerBounds = layer.bounds;
     layer.borderColor = null;
     layer.borderWidth = 0;
     layer.cornerRadius = 0;
-    var cappedOuterRadii = calculateNonUniformBorderCappedRadii(layerBounds, background);
+    const cappedOuterRadii = calculateNonUniformBorderCappedRadii(layerBounds, background);
     if (nativeView.maskType === iosViewUtils.LayerMask.BORDER && layer.mask instanceof CAShapeLayer) {
         layer.mask.path = generateNonUniformBorderOuterClipPath(layerBounds, cappedOuterRadii);
     }
@@ -633,14 +629,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 = ((_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.fillColor = background.borderTopColor?.ios?.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
-            var borderTopLayer = void 0, borderRightLayer = void 0, borderBottomLayer = void 0, borderLeftLayer = void 0;
+            let borderTopLayer, borderRightLayer, borderBottomLayer, borderLeftLayer;
             if (!nativeView.hasNonUniformBorderColor) {
-                var maskLayer = CAShapeLayer.new();
+                const maskLayer = CAShapeLayer.new();
                 maskLayer.fillRule = kCAFillRuleEvenOdd;
                 // Use anti-aliasing or borders will draw incorrectly at times
                 maskLayer.shouldRasterize = true;
@@ -662,14 +658,14 @@ function drawNonUniformBorders(nativeView, background) {
                 borderBottomLayer = nativeView.borderLayer.sublayers[2];
                 borderLeftLayer = nativeView.borderLayer.sublayers[3];
             }
-            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;
+            const paths = generateNonUniformMultiColorBorderPaths(layerBounds, background);
+            borderTopLayer.fillColor = background.borderTopColor?.ios?.CGColor || UIColor.blackColor.CGColor;
             borderTopLayer.path = paths[0];
-            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.fillColor = background.borderRightColor?.ios?.CGColor || UIColor.blackColor.CGColor;
             borderRightLayer.path = paths[1];
-            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.fillColor = background.borderBottomColor?.ios?.CGColor || UIColor.blackColor.CGColor;
             borderBottomLayer.path = paths[2];
-            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.fillColor = background.borderLeftColor?.ios?.CGColor || UIColor.blackColor.CGColor;
             borderLeftLayer.path = paths[3];
             // Clip inner area to create borders
             if (nativeView.borderLayer.mask instanceof CAShapeLayer) {
@@ -679,9 +675,9 @@ function drawNonUniformBorders(nativeView, background) {
     }
 }
 function calculateInnerBorderClipRadius(radius, insetX, insetY) {
-    var innerXRadius = Math.max(0, radius - insetX);
-    var innerYRadius = Math.max(0, radius - insetY);
-    var innerMaxRadius = Math.max(innerXRadius, innerYRadius);
+    const innerXRadius = Math.max(0, radius - insetX);
+    const innerYRadius = Math.max(0, radius - insetY);
+    const innerMaxRadius = Math.max(innerXRadius, innerYRadius);
     return {
         xRadius: innerXRadius,
         yRadius: innerYRadius,
@@ -696,15 +692,14 @@ function calculateInnerBorderClipRadius(radius, insetX, insetY) {
  * @param offset
  * @returns
  */
-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();
+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();
     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);
@@ -722,25 +717,25 @@ function generateNonUniformBorderOuterClipPath(bounds, cappedRadii, offset) {
  * @returns
  */
 function generateNonUniformBorderInnerClipPath(bounds, background, cappedOuterRadii) {
-    var _a = bounds.size, width = _a.width, height = _a.height;
-    var _b = bounds.origin, x = _b.x, y = _b.y;
-    var position = {
+    const { width, height } = bounds.size;
+    const { x, y } = bounds.origin;
+    const position = {
         left: x,
         top: y,
         bottom: y + height,
         right: x + width,
     };
-    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();
+    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();
     CGPathAddRect(clipPath, null, CGRectMake(x, y, width, height));
     // Inner clip paths
     if (cappedBorderTopWidth > 0 || cappedBorderLeftWidth > 0) {
@@ -750,32 +745,32 @@ function generateNonUniformBorderInnerClipPath(bounds, background, cappedOuterRa
         CGPathMoveToPoint(clipPath, null, position.left, position.top);
     }
     if (cappedBorderTopWidth > 0 || cappedBorderRightWidth > 0) {
-        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);
+        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);
         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) {
-        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);
+        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);
         CGPathAddArc(clipPath, innerBottomRightTransform, 0, 0, maxRadius, 0, Math.PI / 2, false);
     }
     else {
         CGPathAddLineToPoint(clipPath, null, position.right, position.bottom);
     }
     if (cappedBorderBottomWidth > 0 || cappedBorderLeftWidth > 0) {
-        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);
+        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);
         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) {
-        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);
+        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);
         CGPathAddArc(clipPath, innerTopLeftTransform, 0, 0, maxRadius, Math.PI, (Math.PI * 3) / 2, false);
     }
     else {
@@ -793,16 +788,16 @@ function generateNonUniformBorderInnerClipPath(bounds, background, cappedOuterRa
  * @returns
  */
 function getBorderTriangleWidths(bounds, background) {
-    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;
+    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;
     // 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;
@@ -827,54 +822,54 @@ function getBorderTriangleWidths(bounds, background) {
  * @returns
  */
 function generateNonUniformMultiColorBorderPaths(bounds, background) {
-    var _a = bounds.size, width = _a.width, height = _a.height;
-    var _b = bounds.origin, x = _b.x, y = _b.y;
-    var position = {
+    const { width, height } = bounds.size;
+    const { x, y } = bounds.origin;
+    const position = {
         left: x,
         top: y,
         bottom: y + height,
         right: x + width,
     };
-    var borderWidths = getBorderTriangleWidths(bounds, background);
-    var paths = new Array(4);
-    var lto = {
+    const borderWidths = getBorderTriangleWidths(bounds, background);
+    const paths = new Array(4);
+    const lto = {
         x: position.left,
         y: position.top,
     }; // left-top-outside
-    var lti = {
+    const lti = {
         x: position.left + borderWidths.left,
         y: position.top + borderWidths.top,
     }; // left-top-inside
-    var rto = {
+    const rto = {
         x: position.right,
         y: position.top,
     }; // right-top-outside
-    var rti = {
+    const rti = {
         x: position.right - borderWidths.right,
         y: position.top + borderWidths.top,
     }; // right-top-inside
-    var rbo = {
+    const rbo = {
         x: position.right,
         y: position.bottom,
     }; // right-bottom-outside
-    var rbi = {
+    const rbi = {
         x: position.right - borderWidths.right,
         y: position.bottom - borderWidths.bottom,
     }; // right-bottom-inside
-    var lbo = {
+    const lbo = {
         x: position.left,
         y: position.bottom,
     }; // left-bottom-outside
-    var lbi = {
+    const lbi = {
         x: position.left + borderWidths.left,
         y: position.bottom - borderWidths.bottom,
     }; // left-bottom-inside
-    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();
+    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();
         CGPathMoveToPoint(topBorderPath, null, lto.x, lto.y);
         CGPathAddLineToPoint(topBorderPath, null, rto.x, rto.y);
         CGPathAddLineToPoint(topBorderPath, null, rti.x, rti.y);
@@ -884,8 +879,8 @@ function generateNonUniformMultiColorBorderPaths(bounds, background) {
         CGPathAddLineToPoint(topBorderPath, null, lto.x, lto.y);
         paths[0] = topBorderPath;
     }
-    if (borderWidths.right > 0 && (borderRightColor === null || borderRightColor === void 0 ? void 0 : borderRightColor.ios)) {
-        var rightBorderPath = CGPathCreateMutable();
+    if (borderWidths.right > 0 && borderRightColor?.ios) {
+        const rightBorderPath = CGPathCreateMutable();
         CGPathMoveToPoint(rightBorderPath, null, rto.x, rto.y);
         CGPathAddLineToPoint(rightBorderPath, null, rbo.x, rbo.y);
         CGPathAddLineToPoint(rightBorderPath, null, rbi.x, rbi.y);
@@ -895,8 +890,8 @@ function generateNonUniformMultiColorBorderPaths(bounds, background) {
         CGPathAddLineToPoint(rightBorderPath, null, rto.x, rto.y);
         paths[1] = rightBorderPath;
     }
-    if (borderWidths.bottom > 0 && (borderBottomColor === null || borderBottomColor === void 0 ? void 0 : borderBottomColor.ios)) {
-        var bottomBorderPath = CGPathCreateMutable();
+    if (borderWidths.bottom > 0 && borderBottomColor?.ios) {
+        const bottomBorderPath = CGPathCreateMutable();
         CGPathMoveToPoint(bottomBorderPath, null, rbo.x, rbo.y);
         CGPathAddLineToPoint(bottomBorderPath, null, lbo.x, lbo.y);
         CGPathAddLineToPoint(bottomBorderPath, null, lbi.x, lbi.y);
@@ -906,8 +901,8 @@ function generateNonUniformMultiColorBorderPaths(bounds, background) {
         CGPathAddLineToPoint(bottomBorderPath, null, rbo.x, rbo.y);
         paths[2] = bottomBorderPath;
     }
-    if (borderWidths.left > 0 && (borderLeftColor === null || borderLeftColor === void 0 ? void 0 : borderLeftColor.ios)) {
-        var leftBorderPath = CGPathCreateMutable();
+    if (borderWidths.left > 0 && borderLeftColor?.ios) {
+        const leftBorderPath = CGPathCreateMutable();
         CGPathMoveToPoint(leftBorderPath, null, lbo.x, lbo.y);
         CGPathAddLineToPoint(leftBorderPath, null, lto.x, lto.y);
         CGPathAddLineToPoint(leftBorderPath, null, lti.x, lti.y);
@@ -920,27 +915,26 @@ function generateNonUniformMultiColorBorderPaths(bounds, background) {
     return paths;
 }
 function drawBoxShadow(view) {
-    var _a, _b, _c;
-    var background = view.style.backgroundInternal;
-    var nativeView = view.nativeViewProtected;
-    var layer = nativeView.layer;
+    const background = view.style.backgroundInternal;
+    const nativeView = view.nativeViewProtected;
+    const layer = nativeView.layer;
     // There is no parent to add shadow to
     if (!layer.superlayer) {
         return;
     }
-    var bounds = nativeView.bounds;
-    var boxShadow = background.getBoxShadow();
+    const bounds = nativeView.bounds;
+    const boxShadow = background.getBoxShadow();
     // Initialize outer shadows
-    var outerShadowContainerLayer;
+    let outerShadowContainerLayer;
     if (nativeView.outerShadowContainerLayer) {
         outerShadowContainerLayer = nativeView.outerShadowContainerLayer;
     }
     else {
         outerShadowContainerLayer = CALayer.new();
         // TODO: Make this dynamic when views get support for multiple shadows
-        var shadowLayer = CALayer.new();
+        const shadowLayer = CALayer.new();
         // This mask is necessary to maintain transparent background
-        var maskLayer = CAShapeLayer.new();
+        const maskLayer = CAShapeLayer.new();
         maskLayer.fillRule = kCAFillRuleEvenOdd;
         shadowLayer.mask = maskLayer;
         outerShadowContainerLayer.addSublayer(shadowLayer);
@@ -964,21 +958,21 @@ function drawBoxShadow(view) {
     // Inherit view visibility values
     outerShadowContainerLayer.opacity = layer.opacity;
     outerShadowContainerLayer.hidden = layer.hidden;
-    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;
+    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);
             shadowLayer.allowsEdgeAntialiasing = true;
             shadowLayer.contentsScale = Screen.mainScreen.scale;
             // Shadow opacity is handled on the shadow's color instance
-            shadowLayer.shadowOpacity = ((_a = boxShadow.color) === null || _a === void 0 ? void 0 : _a.a) ? boxShadow.color.a / 255 : 1;
+            shadowLayer.shadowOpacity = boxShadow.color?.a ? boxShadow.color.a / 255 : 1;
             shadowLayer.shadowRadius = shadowRadius;
-            shadowLayer.shadowColor = (_c = (_b = boxShadow.color) === null || _b === void 0 ? void 0 : _b.ios) === null || _c === void 0 ? void 0 : _c.CGColor;
+            shadowLayer.shadowColor = boxShadow.color?.ios?.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;
@@ -1004,33 +998,33 @@ function clearBoxShadow(nativeView) {
  * @returns
  */
 function generateShadowMaskPath(bounds, boxShadow, innerClipPath) {
-    var shadowRadius = layout.toDeviceIndependentPixels(boxShadow.blurRadius);
-    var spreadRadius = layout.toDeviceIndependentPixels(boxShadow.spreadRadius);
-    var offsetX = layout.toDeviceIndependentPixels(boxShadow.offsetX);
-    var offsetY = layout.toDeviceIndependentPixels(boxShadow.offsetY);
+    const shadowRadius = layout.toDeviceIndependentPixels(boxShadow.blurRadius);
+    const spreadRadius = layout.toDeviceIndependentPixels(boxShadow.spreadRadius);
+    const offsetX = layout.toDeviceIndependentPixels(boxShadow.offsetX);
+    const offsetY = layout.toDeviceIndependentPixels(boxShadow.offsetY);
     // This value has to be large enough to avoid clipping shadow halo effect
-    var outerRectRadius = shadowRadius * 3 + spreadRadius;
-    var maskPath = CGPathCreateMutable();
+    const outerRectRadius = shadowRadius * 3 + spreadRadius;
+    const maskPath = CGPathCreateMutable();
     // Proper clip position and size
-    var outerRect = CGRectOffset(CGRectInset(bounds, -outerRectRadius, -outerRectRadius), offsetX, offsetY);
+    const outerRect = CGRectOffset(CGRectInset(bounds, -outerRectRadius, -outerRectRadius), offsetX, offsetY);
     CGPathAddPath(maskPath, null, innerClipPath);
     CGPathAddRect(maskPath, null, outerRect);
     return maskPath;
 }
 function rectPath(value, position) {
-    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);
+    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);
     return UIBezierPath.bezierPathWithRect(CGRectMake(left, top, right - left, bottom - top)).CGPath;
 }
 function insetPath(value, position) {
-    var arr = value.split(/[\s]+/);
-    var topString;
-    var rightString;
-    var bottomString;
-    var leftString;
+    const arr = value.split(/[\s]+/);
+    let topString;
+    let rightString;
+    let bottomString;
+    let leftString;
     if (arr.length === 1) {
         topString = rightString = bottomString = leftString = arr[0];
     }
@@ -1049,38 +1043,38 @@ function insetPath(value, position) {
         bottomString = arr[2];
         leftString = arr[3];
     }
-    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);
+    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);
     return UIBezierPath.bezierPathWithRect(CGRectMake(left, top, right - left, bottom - top)).CGPath;
 }
 function circlePath(value, position) {
-    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);
+    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);
     return UIBezierPath.bezierPathWithArcCenterRadiusStartAngleEndAngleClockwise(CGPointMake(x, y), radius, 0, 360, true).CGPath;
 }
 function ellipsePath(value, position) {
-    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;
+    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;
     return UIBezierPath.bezierPathWithOvalInRect(CGRectMake(left, top, width, height)).CGPath;
 }
 function polygonPath(value, position) {
-    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 = {
+    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 = {
             x: cssValueToDeviceIndependentPixels(xy[0], position.right),
             y: cssValueToDeviceIndependentPixels(xy[1], position.bottom),
         };