@triniwiz/nativescript-masonkit 1.0.0-alpha.6 → 1.0.0-alpha.8

package/helpers.js

@@ -1,96 +1,92 @@
-import { Length, Utils, isIOS } from '@nativescript/core';
+// declare const __non_webpack_require__;
+import { Length, Utils } from '@nativescript/core';
+import { style_ } from './common';
 import { parseUnit } from '@nativescript/core/css/parser';
-export let UseV8Module = false;
-if (global.isAndroid) {
-    try {
-        java.lang.System.loadLibrary('masonnative');
-        __non_webpack_require__('system_lib://libmasonnativev8.so');
-        UseV8Module = true;
-    }
-    catch (error) {
-        console.warn('Failed to enable on FastAPI');
-    }
-}
-if (global.isIOS) {
-    TSCMason.alwaysEnable = true;
-    if (!UseV8Module) {
-        try {
-            const installer = global.MasonV8ModuleInstaller.new();
-            installer.install();
-            UseV8Module = true;
-        }
-        catch (error) {
-            console.warn('Failed to enable on FastAPI');
-        }
+// if (__ANDROID__) {
+//   try {
+//     java.lang.System.loadLibrary('masonnative');
+//     __non_webpack_require__('system_lib://libmasonnativev8.so');
+//     UseV8Module = true;
+//   } catch (error) {
+//     console.warn('Failed to enable on FastAPI');
+//   }
+// }
+// if (__APPLE__) {
+//   NSCMason.alwaysEnable = true;
+//   if (!UseV8Module) {
+//     try {
+//       const installer = MasonV8Module.new();
+//       installer.install();
+//       UseV8Module = true;
+//     } catch (error) {
+//       console.warn('Failed to enable on FastAPI');
+//     }
+//   }
+// }
+function getMasonInstance(instance) {
+    const nativeView = instance?.android;
+    if (instance._isMasonChild) {
+        return org.nativescript.mason.masonkit.Mason.getShared().nodeForView(nativeView);
     }
+    return nativeView.getNode();
 }
-function getMasonInstance(instance) {
-    const nativeView = instance?.nativeView;
+function getStyleInstance(instance) {
+    const nativeView = instance?.android;
+    if (instance._isMasonChild) {
+        return org.nativescript.mason.masonkit.Mason.getShared()
+            .nodeForView(nativeView)
+            .getStyle();
+    }
+    return nativeView.getStyle();
+}
+function getNode(instance) {
+    const nativeView = instance?.ios;
     if (instance._isMasonChild) {
-        const parent = instance.parent?.nativeView;
-        return parent?.nodeForView?.(nativeView);
+        return NSCMason.shared.nodeForView(nativeView, true);
     }
-    return nativeView;
+    return nativeView.node;
+}
+function getStyle(instance) {
+    const nativeView = instance?.ios;
+    if (instance._isMasonChild) {
+        return NSCMason.shared.nodeForView(nativeView, true).style;
+    }
+    return nativeView.style;
 }
 export function _forceStyleUpdate(instance) {
     if (!instance._hasNativeView) {
         return;
     }
-    if (UseV8Module) {
-        MasonV8Module.updateNodeAndStyle(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            nodeOrView.updateNodeAndStyle();
-        }
-        if (global.isIOS) {
-            instance.ios.mason.updateNodeStyle();
-        }
-    }
+    // if (__ANDROID__) {
+    //   const nodeOrView = getMasonInstance(instance) as org.nativescript.mason.masonkit.TextView;
+    //   nodeOrView.getStyle().updateNodeAndStyle();
+    // }
+    // if (__APPLE__) {
+    //   (instance.ios as MasonUIView).node.style.updateNativeStyle();
+    // }
 }
 export function _markDirty(instance) {
     if (!instance._hasNativeView) {
         return;
     }
-    if (UseV8Module) {
-        MasonV8Module.markDirty(instance._masonPtr, instance._masonNodePtr);
+    if (__ANDROID__) {
+        const nodeOrView = getMasonInstance(instance);
+        nodeOrView.dirty();
     }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                nodeOrView.dirty();
-            }
-            else {
-                nodeOrView.markNodeDirty();
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.mason.markDirty();
-        }
+    if (__APPLE__) {
+        getNode(instance).markDirty();
     }
 }
 export function _isDirty(instance) {
     if (!instance._hasNativeView) {
         return;
     }
-    if (UseV8Module) {
-        return MasonV8Module.isDirty(instance._masonPtr, instance._masonNodePtr);
+    if (__ANDROID__) {
+        const nodeOrView = getMasonInstance(instance);
+        return nodeOrView.isDirty();
     }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                return nodeOrView.isDirty();
-            }
-            else {
-                return nodeOrView.isNodeDirty();
-            }
-        }
-        if (global.isAndroid) {
-            return instance.ios.mason.isDirty;
-        }
+    if (__APPLE__) {
+        return getNode(instance).isDirty;
     }
     return false;
 }
@@ -107,7 +103,7 @@ export function _intoType(type) {
     }
 }
 export function _parseDimension(dim) {
-    if (global.isIOS) {
+    if (__APPLE__) {
         const type = dim.type;
         const value = dim.value;
         switch (type) {
@@ -130,7 +126,7 @@ export function _parseDimension(dim) {
     }
 }
 export function _parseLengthPercentage(dim) {
-    if (global.isIOS) {
+    if (__APPLE__) {
         const type = dim.type;
         const value = dim.value;
         switch (type) {
@@ -151,7 +147,7 @@ export function _parseLengthPercentage(dim) {
     }
 }
 export function _parseLengthPercentageAuto(dim) {
-    if (global.isIOS) {
+    if (__APPLE__) {
         const type = dim.type;
         const value = dim.value;
         switch (type) {
@@ -204,7 +200,7 @@ export function _intoMasonDimension(value) {
     if (value === undefined || value === null) {
         return null;
     }
-    if (global.isIOS) {
+    if (__APPLE__) {
         if (value === 'auto') {
             return MasonDimensionCompat.Auto;
         }
@@ -224,7 +220,7 @@ export function _intoMasonDimension(value) {
         }
         return MasonDimensionCompat.alloc().initWithPoints(Utils.layout.toDevicePixels(value));
     }
-    if (global.isAndroid) {
+    if (__ANDROID__) {
         if (value === 'auto') {
             return org.nativescript.mason.masonkit.Dimension.Auto;
         }
@@ -295,643 +291,120 @@ export function _toLengthPercentage(value) {
     }
     return { value: value, type: 'points', native_type: 0 /* MasonLengthPercentageCompatType.Points */ };
 }
+function syncStyle(instance) {
+    // noop
+}
 export function _setDisplay(value, instance, initial = false) {
-    if (initial && value === 'flex') {
+    if (initial && value === 'block') {
         return;
     }
     if (instance._hasNativeView) {
-        if (UseV8Module) {
-            let nativeValue = -1;
-            switch (value) {
-                case 'none':
-                    nativeValue = 0 /* Display.None */;
-                    break;
-                case 'flex':
-                    nativeValue = 1 /* Display.Flex */;
-                    break;
-                case 'grid':
-                    nativeValue = 2 /* Display.Grid */;
-                    break;
-                case 'block':
-                    nativeValue = 3 /* Display.Block */;
-                    break;
-            }
-            if (nativeValue !== -1) {
-                MasonV8Module.setDisplay(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-            }
-        }
-        else {
-            if (global.isAndroid) {
-                let nativeValue = null;
-                switch (value) {
-                    case 'flex':
-                        nativeValue = org.nativescript.mason.masonkit.Display.Flex;
-                        break;
-                    case 'grid':
-                        nativeValue = org.nativescript.mason.masonkit.Display.Grid;
-                        break;
-                    case 'block':
-                        nativeValue = org.nativescript.mason.masonkit.Display.Block;
-                        break;
-                    case 'none':
-                        nativeValue = org.nativescript.mason.masonkit.Display.None;
-                        break;
-                }
-                if (!Utils.isNullOrUndefined(nativeValue)) {
-                    const nodeOrView = getMasonInstance(instance);
-                    if (instance._isMasonChild) {
-                        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setDisplay(nodeOrView, nativeValue);
-                    }
-                    else {
-                        nodeOrView.setDisplay(nativeValue);
-                    }
-                }
-            }
-            if (global.isIOS) {
-                let nativeValue = -1;
-                switch (value) {
-                    case 'flex':
-                        nativeValue = 1 /* Display.Flex */;
-                        break;
-                    case 'grid':
-                        nativeValue = 2 /* Display.Grid */;
-                        break;
-                    case 'block':
-                        nativeValue = 3 /* Display.Block */;
-                        break;
-                    case 'none':
-                        nativeValue = 0 /* Display.None */;
-                        break;
-                }
-                if (nativeValue !== -1) {
-                    instance.ios.display = nativeValue;
-                }
-            }
-        }
+        instance._styleHelper.display = value;
+        syncStyle(instance);
     }
 }
 export function _getDisplay(instance) {
-    if (!instance._hasNativeView) {
-        return instance.style.display;
-    }
-    if (UseV8Module) {
-        const value = MasonV8Module.getDisplay(instance._masonStylePtr);
-        switch (value) {
-            case 0:
-                return 'none';
-            case 1:
-                return 'flex';
-            case 2:
-                return 'grid';
-            case 3:
-                return 'block';
-        }
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let display;
-            if (instance._isMasonChild) {
-                display = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getDisplay(nodeOrView);
-            }
-            else {
-                display = nodeOrView.getDisplay();
-            }
-            switch (display) {
-                case org.nativescript.mason.masonkit.Display.None:
-                    return 'none';
-                case org.nativescript.mason.masonkit.Display.Flex:
-                    return 'flex';
-                case org.nativescript.mason.masonkit.Display.Grid:
-                    return 'grid';
-                case org.nativescript.mason.masonkit.Display.Block:
-                    return 'block';
-            }
-        }
-        if (global.isIOS) {
-            switch (instance.ios.display) {
-                case 0 /* Display.None */:
-                    return 'none';
-                case 1 /* Display.Flex */:
-                    return 'flex';
-                case 2 /* Display.Grid */:
-                    return 'grid';
-                case 3 /* Display.Block */:
-                    return 'block';
-            }
-        }
-    }
-    return instance.style.display;
+    return instance._styleHelper.display;
 }
 export function _setMinWidth(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toMasonDimension(value);
-    if (UseV8Module) {
-        MasonV8Module.setMinWidth(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setMinSizeWidth(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setMinSizeWidth(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setMinSizeWidth(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.minWidth = value;
+    syncStyle(instance);
 }
 export function _getMinWidth(instance) {
     if (!instance._hasNativeView) {
         return instance.style.minWidth;
     }
-    if (UseV8Module) {
-        return MasonV8Module.getMinWidth(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let min;
-            if (instance._isMasonChild) {
-                min = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getMinSizeWidth(nodeOrView);
-            }
-            else {
-                min = nodeOrView.getMinSizeWidth();
-            }
-            return _parseDimension(min);
-        }
-        if (global.isIOS) {
-            return _parseDimension(instance.ios.getMinSizeWidth());
-        }
-    }
+    return instance._styleHelper.minWidth;
 }
 export function _setMinHeight(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toMasonDimension(value);
-    if (UseV8Module) {
-        MasonV8Module.setMinHeight(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setMinSizeHeight(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setMinSizeHeight(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setMinSizeHeight(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.minHeight = value;
+    syncStyle(instance);
 }
 export function _getMinHeight(instance) {
     if (!instance._hasNativeView) {
         return instance.style.minHeight;
     }
-    if (UseV8Module) {
-        return MasonV8Module.getMinHeight(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let min;
-            if (instance._isMasonChild) {
-                min = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getMinSizeHeight(nodeOrView);
-            }
-            else {
-                min = nodeOrView.getMinSizeHeight();
-            }
-            return _parseDimension(min);
-        }
-        if (global.isIOS) {
-            return _parseDimension(instance.ios.getMinSizeHeight());
-        }
-    }
+    return instance._styleHelper.minHeight;
 }
 export function _setWidth(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toMasonDimension(value);
-    if (UseV8Module) {
-        MasonV8Module.setWidth(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setSizeWidth(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setSizeWidth(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setSizeWidth(val.value, val.native_type);
-        }
+    if (instance._styleHelper) {
+        instance._styleHelper.width = value;
     }
+    syncStyle(instance);
 }
 export function _getWidth(instance) {
     if (!instance._hasNativeView) {
         return instance.style.width;
     }
-    if (UseV8Module) {
-        return MasonV8Module.getWidth(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let size;
-            if (instance._isMasonChild) {
-                size = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getSizeWidth(nodeOrView);
-            }
-            else {
-                size = nodeOrView.getSizeWidth();
-            }
-            return _parseDimension(size);
-        }
-        if (global.isIOS) {
-            return _parseDimension(instance.ios.getSizeWidth());
-        }
-    }
+    return instance._styleHelper.width;
 }
 export function _setHeight(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toMasonDimension(value);
-    if (UseV8Module) {
-        MasonV8Module.setHeight(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setSizeHeight(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setSizeHeight(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setSizeHeight(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.height = value;
 }
 export function _getHeight(instance) {
     if (!instance._hasNativeView) {
         return instance.style.height;
     }
-    if (UseV8Module) {
-        return MasonV8Module.getHeight(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let size;
-            if (instance._isMasonChild) {
-                size = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getSizeHeight(nodeOrView);
-            }
-            else {
-                size = nodeOrView.getSizeHeight();
-            }
-            return _parseDimension(size);
-        }
-        if (global.isIOS) {
-            return _parseDimension(instance.ios.getSizeHeight());
-        }
-    }
+    return instance._styleHelper.height;
 }
 export function _setMaxWidth(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toMasonDimension(value);
-    if (UseV8Module) {
-        MasonV8Module.setMaxWidth(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setMaxSizeWidth(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setMaxSizeWidth(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setMaxSizeWidth(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.maxWidth = value;
+    syncStyle(instance);
 }
 export function _getMaxWidth(instance) {
     if (!instance._hasNativeView) {
         return instance.style.maxWidth;
     }
-    if (UseV8Module) {
-        return MasonV8Module.getMaxWidth(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let max;
-            if (instance._isMasonChild) {
-                max = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getMaxSizeWidth(nodeOrView);
-            }
-            else {
-                max = nodeOrView.getMaxSizeWidth();
-            }
-            return _parseDimension(max);
-        }
-        if (global.isIOS) {
-            return _parseDimension(instance.ios.getMaxSizeWidth());
-        }
-    }
+    return instance._styleHelper.maxWidth;
 }
 export function _setMaxHeight(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toMasonDimension(value);
-    if (UseV8Module) {
-        MasonV8Module.setMaxHeight(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setMaxSizeHeight(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setMaxSizeHeight(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setMaxSizeHeight(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.maxHeight = value;
+    syncStyle(instance);
 }
 export function _getMaxHeight(instance) {
     if (!instance._hasNativeView) {
         return instance.style.maxHeight;
     }
-    if (UseV8Module) {
-        return MasonV8Module.getMaxHeight(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let max;
-            if (instance._isMasonChild) {
-                max = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getMaxSizeHeight(nodeOrView);
-            }
-            else {
-                max = nodeOrView.getMaxSizeHeight();
-            }
-            return _parseDimension(max);
-        }
-        if (global.isIOS) {
-            return _parseDimension(instance.ios.getMaxSizeHeight());
-        }
-    }
+    return instance._styleHelper.maxHeight;
 }
 export function _setFlexDirection(value, instance, initial = false) {
     if (initial && value === 'row') {
         return;
     }
     if (instance._hasNativeView) {
-        let nativeValue = null;
-        switch (value) {
-            case 'column':
-                if (UseV8Module) {
-                    nativeValue = 1 /* FlexDirection.Column */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.FlexDirection.Column;
-                    }
-                    else if (global.isIOS) {
-                        nativeValue = 1 /* FlexDirection.Column */;
-                    }
-                }
-                break;
-            case 'row':
-                if (UseV8Module) {
-                    nativeValue = 0 /* FlexDirection.Row */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.FlexDirection.Row;
-                    }
-                    else if (global.isIOS) {
-                        nativeValue = 0 /* FlexDirection.Row */;
-                    }
-                }
-                break;
-            case 'column-reverse':
-                if (UseV8Module) {
-                    nativeValue = 3 /* FlexDirection.ColumnReverse */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.FlexDirection.ColumnReverse;
-                    }
-                    else if (global.isIOS) {
-                        nativeValue = 3 /* FlexDirection.ColumnReverse */;
-                    }
-                }
-                break;
-            case 'row-reverse':
-                if (UseV8Module) {
-                    nativeValue = 2 /* FlexDirection.RowReverse */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.FlexDirection.RowReverse;
-                    }
-                    else if (global.isIOS) {
-                        nativeValue = 2 /* FlexDirection.RowReverse */;
-                    }
-                }
-                break;
-        }
-        if (!Utils.isNullOrUndefined(nativeValue)) {
-            if (UseV8Module) {
-                MasonV8Module.setFlexDirection(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-            }
-            else {
-                if (global.isAndroid) {
-                    const nodeOrView = getMasonInstance(instance);
-                    if (instance._isMasonChild) {
-                        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setFlexDirection(nodeOrView, nativeValue);
-                    }
-                    else {
-                        nodeOrView.setFlexDirection(nativeValue);
-                    }
-                }
-                if (global.isIOS) {
-                    instance.ios.flexDirection = nativeValue;
-                }
-            }
-        }
+        instance._styleHelper.flexDirection = value;
     }
 }
 export function _getFlexDirection(instance) {
-    if (instance._hasNativeView) {
-        if (UseV8Module) {
-            const value = MasonV8Module.getFlexDirection(instance._masonStylePtr);
-            switch (value) {
-                case 0 /* FlexDirection.Row */:
-                    return 'row';
-                case 1 /* FlexDirection.Column */:
-                    return 'column';
-                case 2 /* FlexDirection.RowReverse */:
-                    return 'row-reverse';
-                case 3 /* FlexDirection.ColumnReverse */:
-                    return 'column-reverse';
-            }
-        }
-        else {
-            if (global.isAndroid) {
-                const nodeOrView = getMasonInstance(instance);
-                let value;
-                if (instance._isMasonChild) {
-                    value = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getFlexDirection(nodeOrView);
-                }
-                else {
-                    value = nodeOrView.getFlexDirection();
-                }
-                switch (value) {
-                    case org.nativescript.mason.masonkit.FlexDirection.Row:
-                        return 'row';
-                    case org.nativescript.mason.masonkit.FlexDirection.Column:
-                        return 'column';
-                    case org.nativescript.mason.masonkit.FlexDirection.RowReverse:
-                        return 'row-reverse';
-                    case org.nativescript.mason.masonkit.FlexDirection.ColumnReverse:
-                        return 'column-reverse';
-                }
-            }
-            if (global.isIOS) {
-                const value = instance.ios.flexDirection;
-                switch (value) {
-                    case 0 /* FlexDirection.Row */:
-                        return 'row';
-                    case 1 /* FlexDirection.Column */:
-                        return 'column';
-                    case 2 /* FlexDirection.RowReverse */:
-                        return 'row-reverse';
-                    case 3 /* FlexDirection.ColumnReverse */:
-                        return 'column-reverse';
-                }
-            }
-        }
-    }
-    return instance.style.flexDirection;
+    return instance._styleHelper.flexDirection;
 }
 export function _getPosition(instance) {
-    if (!instance._hasNativeView) {
-        return instance.style.position;
-    }
-    if (UseV8Module) {
-        const value = MasonV8Module.getPosition(instance._masonStylePtr);
-        switch (value) {
-            case 0:
-                return 'relative';
-            case 1:
-                return 'absolute';
-        }
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let value;
-            if (instance._isMasonChild) {
-                value = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getPosition(nodeOrView);
-            }
-            else {
-                value = nodeOrView.getPosition();
-            }
-            switch (value) {
-                case org.nativescript.mason.masonkit.Position.Absolute:
-                    return 'absolute';
-                case org.nativescript.mason.masonkit.Position.Relative:
-                    return 'relative';
-            }
-        }
-        if (global.isIOS) {
-            switch (instance.ios._position) {
-                case 1 /* Position.Absolute */:
-                    return 'absolute';
-                case 0 /* Position.Relative */:
-                    return 'relative';
-            }
-        }
-    }
+    return instance._styleHelper.position;
 }
 export function _setPosition(value, instance, initial = false) {
     if (initial && value === 'relative') {
         return;
     }
     if (instance._hasNativeView) {
-        let nativeValue = null;
-        switch (value) {
-            case 'absolute':
-                if (UseV8Module) {
-                    nativeValue = 1 /* PositionType.Absolute */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.Position.Absolute;
-                    }
-                    else {
-                        nativeValue = 1;
-                    }
-                }
-                break;
-            case 'relative':
-                if (UseV8Module) {
-                    nativeValue = 0 /* PositionType.Relative */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.Position.Relative;
-                    }
-                    else {
-                        nativeValue = 0;
-                    }
-                }
-                break;
-        }
-        if (!Utils.isNullOrUndefined(nativeValue)) {
-            if (UseV8Module) {
-                MasonV8Module.setPosition(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-            }
-            else {
-                if (global.isAndroid) {
-                    const nodeOrView = getMasonInstance(instance);
-                    if (instance._isMasonChild) {
-                        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setPosition(nodeOrView, nativeValue);
-                    }
-                    else {
-                        nodeOrView.setPosition(nativeValue);
-                    }
-                }
-                if (global.isIOS) {
-                    instance.ios._position = nativeValue;
-                }
-            }
-        }
+        instance._styleHelper.position = value;
     }
 }
 export function _setFlexWrap(value, instance, initial = false) {
@@ -939,113 +412,12 @@ export function _setFlexWrap(value, instance, initial = false) {
         return;
     }
     if (instance._hasNativeView) {
-        let nativeValue = null;
-        switch (value) {
-            case 'no-wrap':
-                if (UseV8Module) {
-                    nativeValue = 0 /* FlexWrap.NoWrap */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.FlexWrap.NoWrap;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 0 /* FlexWrap.NoWrap */;
-                    }
-                }
-                break;
-            case 'wrap':
-                if (UseV8Module) {
-                    nativeValue = 1 /* FlexWrap.Wrap */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.FlexWrap.Wrap;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 1 /* FlexWrap.Wrap */;
-                    }
-                }
-                break;
-            case 'wrap-reverse':
-                if (UseV8Module) {
-                    nativeValue = 2 /* FlexWrap.WrapReverse */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.FlexWrap.WrapReverse;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 2 /* FlexWrap.WrapReverse */;
-                    }
-                }
-                break;
-        }
-        if (!Utils.isNullOrUndefined(nativeValue)) {
-            if (UseV8Module) {
-                MasonV8Module.setFlexWrap(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-            }
-            else {
-                if (global.isAndroid) {
-                    const nodeOrView = getMasonInstance(instance);
-                    if (instance._isMasonChild) {
-                        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setFlexWrap(nodeOrView, nativeValue);
-                    }
-                    else {
-                        nodeOrView.setFlexWrap(nativeValue);
-                    }
-                }
-                if (global.isIOS) {
-                    instance.ios.flexWrap = nativeValue;
-                }
-            }
-        }
+        instance._styleHelper.flexWrap = value;
     }
 }
 export function _getFlexWrap(instance) {
     if (instance._hasNativeView) {
-        if (UseV8Module) {
-            const value = MasonV8Module.getFlexWrap(instance._masonStylePtr);
-            switch (value) {
-                case 0:
-                    return 'no-wrap';
-                case 1:
-                    return 'wrap';
-                case 2:
-                    return 'wrap-reverse';
-            }
-        }
-        else {
-            if (global.isAndroid) {
-                const nodeOrView = getMasonInstance(instance);
-                let value;
-                if (instance._isMasonChild) {
-                    value = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getFlexWrap(nodeOrView);
-                }
-                else {
-                    value = nodeOrView.getFlexWrap();
-                }
-                switch (value) {
-                    case org.nativescript.mason.masonkit.FlexWrap.NoWrap:
-                        return 'no-wrap';
-                    case org.nativescript.mason.masonkit.FlexWrap.Wrap:
-                        return 'wrap';
-                    case org.nativescript.mason.masonkit.FlexWrap.WrapReverse:
-                        return 'wrap-reverse';
-                }
-            }
-            if (global.isIOS) {
-                const value = instance.ios.flexWrap;
-                switch (value) {
-                    case 0 /* FlexWrap.NoWrap */:
-                        return 'no-wrap';
-                    case 1 /* FlexWrap.Wrap */:
-                        return 'wrap';
-                    case 2 /* FlexWrap.WrapReverse */:
-                        return 'wrap-reverse';
-                }
-            }
-        }
+        return instance._styleHelper.flexWrap;
     }
     return instance.style.flexWrap;
 }
@@ -1054,156 +426,12 @@ export function _setAlignItems(value, instance, initial = false) {
         return;
     }
     if (instance._hasNativeView) {
-        let nativeValue = null;
-        switch (value) {
-            case 'normal':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = -1 /* AlignItems.Normal */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignItems.Normal;
-                }
-                break;
-            case 'baseline':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 3 /* AlignItems.Baseline */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignItems.Baseline;
-                }
-                break;
-            case 'center':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 2 /* AlignItems.Center */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignItems.Center;
-                }
-                break;
-            case 'flex-end':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 6 /* AlignItems.FlexEnd */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignItems.FlexEnd;
-                }
-                break;
-            case 'end':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 1 /* AlignItems.End */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignItems.End;
-                }
-                break;
-            case 'flex-start':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 5 /* AlignItems.FlexStart */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignItems.FlexStart;
-                }
-                break;
-            case 'start':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 0 /* AlignItems.Start */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignItems.Start;
-                }
-                break;
-            case 'stretch':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 4 /* AlignItems.Stretch */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignItems.Stretch;
-                }
-                break;
-        }
-        if (!Utils.isNullOrUndefined(nativeValue)) {
-            if (UseV8Module) {
-                MasonV8Module.setAlignItems(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-            }
-            else {
-                if (global.isAndroid) {
-                    const nodeOrView = getMasonInstance(instance);
-                    if (instance._isMasonChild) {
-                        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setAlignItems(nodeOrView, nativeValue);
-                    }
-                    else {
-                        nodeOrView.setAlignItems(nativeValue);
-                    }
-                }
-                if (global.isIOS) {
-                    instance.ios.alignItems = nativeValue;
-                }
-            }
-        }
+        instance._styleHelper.alignItems = value;
     }
 }
 export function _getAlignItems(instance) {
     if (instance._hasNativeView) {
-        if (UseV8Module) {
-            const value = MasonV8Module.getAlignItems(instance._masonStylePtr);
-            switch (value) {
-                case -1 /* AlignItems.Normal */:
-                    return 'normal';
-                case 3 /* AlignItems.Baseline */:
-                    return 'baseline';
-                case 2 /* AlignItems.Center */:
-                    return 'center';
-                case 1 /* AlignItems.End */:
-                    return 'end';
-                case 0 /* AlignItems.Start */:
-                    return 'start';
-                case 4 /* AlignItems.Stretch */:
-                    return 'stretch';
-            }
-        }
-        else {
-            if (global.isAndroid) {
-                const nodeOrView = getMasonInstance(instance);
-                let value;
-                if (instance._isMasonChild) {
-                    value = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getAlignItems(nodeOrView);
-                }
-                else {
-                    value = nodeOrView.getAlignItems();
-                }
-                switch (value) {
-                    case org.nativescript.mason.masonkit.AlignItems.Normal:
-                        return 'normal';
-                    case org.nativescript.mason.masonkit.AlignItems.Baseline:
-                        return 'baseline';
-                    case org.nativescript.mason.masonkit.AlignItems.Center:
-                        return 'center';
-                    case org.nativescript.mason.masonkit.AlignItems.End:
-                        return 'end';
-                    case org.nativescript.mason.masonkit.AlignItems.Start:
-                        return 'start';
-                    case org.nativescript.mason.masonkit.AlignItems.Stretch:
-                        return 'stretch';
-                }
-            }
-            if (global.isIOS) {
-                const value = instance.ios.alignItems;
-                switch (value) {
-                    case -1 /* AlignItems.Normal */:
-                        return 'normal';
-                    case 3 /* AlignItems.Baseline */:
-                        return 'baseline';
-                    case 2 /* AlignItems.Center */:
-                        return 'center';
-                    case 1 /* AlignItems.End */:
-                        return 'end';
-                    case 0 /* AlignItems.Start */:
-                        return 'start';
-                    case 4 /* AlignItems.Stretch */:
-                        return 'stretch';
-                }
-            }
-        }
+        return instance._styleHelper.alignItems;
     }
     return instance.style.alignItems;
 }
@@ -1212,156 +440,12 @@ export function _setAlignSelf(value, instance, initial = false) {
         return;
     }
     if (instance._hasNativeView) {
-        let nativeValue = null;
-        switch (value) {
-            case 'normal':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = -1 /* AlignSelf.Normal */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignSelf.Normal;
-                }
-                break;
-            case 'baseline':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 3 /* AlignSelf.Baseline */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignSelf.Baseline;
-                }
-                break;
-            case 'center':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 2 /* AlignSelf.Center */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignSelf.Center;
-                }
-                break;
-            case 'flex-end':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 6 /* AlignSelf.FlexEnd */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignSelf.FlexEnd;
-                }
-                break;
-            case 'end':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 1 /* AlignSelf.End */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignSelf.End;
-                }
-                break;
-            case 'flex-start':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 5 /* AlignSelf.FlexStart */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignSelf.FlexStart;
-                }
-                break;
-            case 'start':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 0 /* AlignSelf.Start */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignSelf.Start;
-                }
-                break;
-            case 'stretch':
-                if (UseV8Module || global.isIOS) {
-                    nativeValue = 4 /* AlignSelf.Stretch */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.AlignSelf.Stretch;
-                }
-                break;
-        }
-        if (!Utils.isNullOrUndefined(nativeValue)) {
-            if (UseV8Module) {
-                MasonV8Module.setAlignSelf(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-            }
-            else {
-                if (global.isAndroid) {
-                    const nodeOrView = getMasonInstance(instance);
-                    if (instance._isMasonChild) {
-                        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setAlignSelf(nodeOrView, nativeValue);
-                    }
-                    else {
-                        nodeOrView.setAlignSelf(nativeValue);
-                    }
-                }
-                if (global.isIOS) {
-                    instance.ios.alignSelf = nativeValue;
-                }
-            }
-        }
+        instance._styleHelper.alignSelf = value;
     }
 }
 export function _getAlignSelf(instance) {
     if (instance._hasNativeView) {
-        if (UseV8Module) {
-            const value = MasonV8Module.getAlignSelf(instance._masonStylePtr);
-            switch (value) {
-                case -1 /* AlignSelf.Normal */:
-                    return 'normal';
-                case 3 /* AlignSelf.Baseline */:
-                    return 'baseline';
-                case 2 /* AlignSelf.Center */:
-                    return 'center';
-                case 1 /* AlignSelf.End */:
-                    return 'end';
-                case 0 /* AlignSelf.Start */:
-                    return 'start';
-                case 4 /* AlignSelf.Stretch */:
-                    return 'stretch';
-            }
-        }
-        else {
-            if (global.isAndroid) {
-                const nodeOrView = getMasonInstance(instance);
-                let value;
-                if (instance._isMasonChild) {
-                    value = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getAlignSelf(nodeOrView);
-                }
-                else {
-                    value = nodeOrView.getAlignSelf();
-                }
-                switch (value) {
-                    case org.nativescript.mason.masonkit.AlignSelf.Normal:
-                        return 'normal';
-                    case org.nativescript.mason.masonkit.AlignSelf.Baseline:
-                        return 'baseline';
-                    case org.nativescript.mason.masonkit.AlignSelf.Center:
-                        return 'center';
-                    case org.nativescript.mason.masonkit.AlignSelf.End:
-                        return 'end';
-                    case org.nativescript.mason.masonkit.AlignSelf.Start:
-                        return 'start';
-                    case org.nativescript.mason.masonkit.AlignSelf.Stretch:
-                        return 'stretch';
-                }
-            }
-            if (global.isIOS) {
-                const value = instance.ios.alignSelf;
-                switch (value) {
-                    case -1 /* AlignSelf.Normal */:
-                        return 'normal';
-                    case 3 /* AlignSelf.Baseline */:
-                        return 'baseline';
-                    case 2 /* AlignSelf.Center */:
-                        return 'center';
-                    case 1 /* AlignSelf.End */:
-                        return 'end';
-                    case 0 /* AlignSelf.Start */:
-                        return 'start';
-                    case 4 /* AlignSelf.Stretch */:
-                        return 'stretch';
-                }
-            }
-        }
+        return instance._styleHelper.alignSelf;
     }
     return instance.style.alignSelf;
 }
@@ -1370,234 +454,14 @@ export function _setAlignContent(value, instance, initial = false) {
         return;
     }
     if (instance._hasNativeView) {
-        let nativeValue = null;
-        switch (value) {
-            case 'normal':
-                if (UseV8Module) {
-                    nativeValue = -1 /* AlignContent.Normal */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.AlignContent.Normal;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = -1 /* AlignContent.Normal */;
-                    }
-                }
-                break;
-            case 'space-around':
-                if (UseV8Module) {
-                    nativeValue = 5 /* AlignContent.SpaceAround */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.AlignContent.SpaceAround;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 5 /* AlignContent.SpaceAround */;
-                    }
-                }
-                break;
-            case 'space-between':
-                if (UseV8Module) {
-                    nativeValue = 4 /* AlignContent.SpaceBetween */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.AlignContent.SpaceBetween;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 4 /* AlignContent.SpaceBetween */;
-                    }
-                }
-                break;
-            case 'space-evenly':
-                if (UseV8Module) {
-                    nativeValue = 6 /* AlignContent.SpaceEvenly */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.AlignContent.SpaceEvenly;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 6 /* AlignContent.SpaceEvenly */;
-                    }
-                }
-                break;
-            case 'center':
-                if (UseV8Module) {
-                    nativeValue = 2 /* AlignContent.Center */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.AlignContent.Center;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 2 /* AlignContent.Center */;
-                    }
-                }
-                break;
-            case 'flex-end':
-                if (UseV8Module) {
-                    nativeValue = 8 /* AlignContent.FlexEnd */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.AlignContent.FlexEnd;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 8 /* AlignContent.FlexEnd */;
-                    }
-                }
-                break;
-            case 'end':
-                if (UseV8Module) {
-                    nativeValue = 1 /* AlignContent.End */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.AlignContent.End;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 1 /* AlignContent.End */;
-                    }
-                }
-                break;
-            case 'flex-start':
-                if (UseV8Module) {
-                    nativeValue = 7 /* AlignContent.FlexStart */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.AlignContent.FlexStart;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 7 /* AlignContent.FlexStart */;
-                    }
-                }
-                break;
-            case 'start':
-                if (UseV8Module) {
-                    nativeValue = 0 /* AlignContent.Start */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.AlignContent.Start;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 0 /* AlignContent.Start */;
-                    }
-                }
-                break;
-            case 'stretch':
-                if (UseV8Module) {
-                    nativeValue = 3 /* AlignContent.Stretch */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.AlignContent.Stretch;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 3 /* AlignContent.Stretch */;
-                    }
-                }
-                break;
-        }
-        if (!Utils.isNullOrUndefined(nativeValue)) {
-            if (UseV8Module) {
-                MasonV8Module.setAlignContent(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-            }
-            else {
-                if (global.isAndroid) {
-                    const nodeOrView = getMasonInstance(instance);
-                    if (instance._isMasonChild) {
-                        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setAlignContent(nodeOrView, nativeValue);
-                    }
-                    else {
-                        nodeOrView.setAlignContent(nativeValue);
-                    }
-                }
-                if (global.isIOS) {
-                    instance.ios.alignContent = nativeValue;
-                }
-            }
+        if (instance._styleHelper) {
+            instance._styleHelper.alignContent = value;
         }
     }
 }
 export function _getAlignContent(instance) {
     if (instance._hasNativeView) {
-        if (UseV8Module) {
-            const value = MasonV8Module.getAlignContent(instance._masonStylePtr);
-            switch (value) {
-                case -1 /* AlignContent.Normal */:
-                    return 'normal';
-                case 5 /* AlignContent.SpaceAround */:
-                    return 'space-around';
-                case 4 /* AlignContent.SpaceBetween */:
-                    return 'space-between';
-                case 6 /* AlignContent.SpaceEvenly */:
-                    return 'space-evenly';
-                case 2 /* AlignContent.Center */:
-                    return 'center';
-                case 1 /* AlignContent.End */:
-                    return 'end';
-                case 0 /* AlignContent.Start */:
-                    return 'start';
-                case 3 /* AlignContent.Stretch */:
-                    return 'stretch';
-            }
-        }
-        else {
-            if (global.isAndroid) {
-                const nodeOrView = getMasonInstance(instance);
-                let value;
-                if (instance._isMasonChild) {
-                    value = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getAlignContent(nodeOrView);
-                }
-                else {
-                    value = nodeOrView.getAlignContent();
-                }
-                switch (value) {
-                    case org.nativescript.mason.masonkit.AlignContent.Normal:
-                        return 'normal';
-                    case org.nativescript.mason.masonkit.AlignContent.SpaceAround:
-                        return 'space-around';
-                    case org.nativescript.mason.masonkit.AlignContent.SpaceBetween:
-                        return 'space-between';
-                    case org.nativescript.mason.masonkit.AlignContent.SpaceEvenly:
-                        return 'space-evenly';
-                    case org.nativescript.mason.masonkit.AlignContent.Center:
-                        return 'center';
-                    case org.nativescript.mason.masonkit.AlignContent.End:
-                        return 'end';
-                    case org.nativescript.mason.masonkit.AlignContent.Start:
-                        return 'start';
-                    case org.nativescript.mason.masonkit.AlignContent.Stretch:
-                        return 'stretch';
-                }
-            }
-            if (global.isIOS) {
-                const value = instance.ios.alignContent;
-                switch (value) {
-                    case -1 /* AlignContent.Normal */:
-                        return 'normal';
-                    case 5 /* AlignContent.SpaceAround */:
-                        return 'space-around';
-                    case 4 /* AlignContent.SpaceBetween */:
-                        return 'space-between';
-                    case 6 /* AlignContent.SpaceEvenly */:
-                        return 'space-evenly';
-                    case 2 /* AlignContent.Center */:
-                        return 'center';
-                    case 1 /* AlignContent.End */:
-                        return 'end';
-                    case 0 /* AlignContent.Start */:
-                        return 'start';
-                    case 3 /* AlignContent.Stretch */:
-                        return 'stretch';
-                }
-            }
-        }
+        return instance._styleHelper.alignContent;
     }
     return instance.style.alignContent;
 }
@@ -1606,156 +470,12 @@ export function _setJustifyItems(value, instance, initial = false) {
         return;
     }
     if (instance._hasNativeView) {
-        let nativeValue = null;
-        switch (value) {
-            case 'normal':
-                if (UseV8Module) {
-                    nativeValue = -1 /* JustifyItems.Normal */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifyItems.Normal;
-                }
-                break;
-            case 'baseline':
-                if (UseV8Module) {
-                    nativeValue = 3 /* JustifyItems.Baseline */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifyItems.Baseline;
-                }
-                break;
-            case 'center':
-                if (UseV8Module) {
-                    nativeValue = 2 /* JustifyItems.Center */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifyItems.Center;
-                }
-                break;
-            case 'flex-end':
-                if (UseV8Module) {
-                    nativeValue = 6 /* JustifyItems.FlexEnd */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifyItems.FlexEnd;
-                }
-                break;
-            case 'end':
-                if (UseV8Module) {
-                    nativeValue = 1 /* JustifyItems.End */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifyItems.End;
-                }
-                break;
-            case 'flex-start':
-                if (UseV8Module) {
-                    nativeValue = 5 /* JustifyItems.FlexStart */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifyItems.FlexStart;
-                }
-                break;
-            case 'start':
-                if (UseV8Module) {
-                    nativeValue = 0 /* JustifyItems.Start */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifyItems.Start;
-                }
-                break;
-            case 'stretch':
-                if (UseV8Module) {
-                    nativeValue = 4 /* JustifyItems.Stretch */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifyItems.Stretch;
-                }
-                break;
-        }
-        if (!Utils.isNullOrUndefined(nativeValue)) {
-            if (UseV8Module) {
-                MasonV8Module.setJustifyItems(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-            }
-            else {
-                if (global.isAndroid) {
-                    const nodeOrView = getMasonInstance(instance);
-                    if (instance._isMasonChild) {
-                        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setJustifyItems(nodeOrView, nativeValue);
-                    }
-                    else {
-                        nodeOrView.setJustifyItems(nativeValue);
-                    }
-                }
-                if (global.isIOS) {
-                    instance.ios.justifyItems = nativeValue;
-                }
-            }
-        }
+        instance._styleHelper.justifyItems = value;
     }
 }
 export function _getJustifyItems(instance) {
     if (instance._hasNativeView) {
-        if (UseV8Module) {
-            const value = MasonV8Module.getJustifyItems(instance._masonStylePtr);
-            switch (value) {
-                case -1 /* JustifyItems.Normal */:
-                    return 'normal';
-                case 3 /* JustifyItems.Baseline */:
-                    return 'baseline';
-                case 2 /* JustifyItems.Center */:
-                    return 'center';
-                case 1 /* JustifyItems.End */:
-                    return 'end';
-                case 0 /* JustifyItems.Start */:
-                    return 'start';
-                case 4 /* JustifyItems.Stretch */:
-                    return 'stretch';
-            }
-        }
-        else {
-            if (global.isAndroid) {
-                const nodeOrView = getMasonInstance(instance);
-                let value;
-                if (instance._isMasonChild) {
-                    value = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getJustifyItems(nodeOrView);
-                }
-                else {
-                    value = nodeOrView.getJustifyItems();
-                }
-                switch (value) {
-                    case org.nativescript.mason.masonkit.JustifyItems.Normal:
-                        return 'normal';
-                    case org.nativescript.mason.masonkit.JustifyItems.Baseline:
-                        return 'baseline';
-                    case org.nativescript.mason.masonkit.JustifyItems.Center:
-                        return 'center';
-                    case org.nativescript.mason.masonkit.JustifyItems.End:
-                        return 'end';
-                    case org.nativescript.mason.masonkit.JustifyItems.Start:
-                        return 'start';
-                    case org.nativescript.mason.masonkit.JustifyItems.Stretch:
-                        return 'stretch';
-                }
-            }
-            if (global.isIOS) {
-                const value = instance.ios.justifyItems;
-                switch (value) {
-                    case -1 /* JustifyItems.Normal */:
-                        return 'normal';
-                    case 3 /* JustifyItems.Baseline */:
-                        return 'baseline';
-                    case 2 /* JustifyItems.Center */:
-                        return 'center';
-                    case 1 /* JustifyItems.End */:
-                        return 'end';
-                    case 0 /* JustifyItems.Start */:
-                        return 'start';
-                    case 4 /* JustifyItems.Stretch */:
-                        return 'stretch';
-                }
-            }
-        }
+        return instance._styleHelper.justifyItems;
     }
     return instance.style.justifyItems;
 }
@@ -1764,156 +484,12 @@ export function _setJustifySelf(value, instance, initial = false) {
         return;
     }
     if (instance._hasNativeView) {
-        let nativeValue = null;
-        switch (value) {
-            case 'normal':
-                if (UseV8Module) {
-                    nativeValue = -1 /* JustifySelf.Normal */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifySelf.Normal;
-                }
-                break;
-            case 'baseline':
-                if (UseV8Module) {
-                    nativeValue = 3 /* JustifySelf.Baseline */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifySelf.Baseline;
-                }
-                break;
-            case 'center':
-                if (UseV8Module) {
-                    nativeValue = 2 /* JustifySelf.Center */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifySelf.Center;
-                }
-                break;
-            case 'flex-end':
-                if (UseV8Module) {
-                    nativeValue = 6 /* JustifySelf.FlexEnd */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifySelf.FlexEnd;
-                }
-                break;
-            case 'end':
-                if (UseV8Module) {
-                    nativeValue = 1 /* JustifySelf.End */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifySelf.End;
-                }
-                break;
-            case 'flex-start':
-                if (UseV8Module) {
-                    nativeValue = 5 /* JustifySelf.FlexStart */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifySelf.FlexStart;
-                }
-                break;
-            case 'start':
-                if (UseV8Module) {
-                    nativeValue = 0 /* JustifySelf.Start */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifySelf.Start;
-                }
-                break;
-            case 'stretch':
-                if (UseV8Module) {
-                    nativeValue = 4 /* JustifySelf.Stretch */;
-                }
-                else {
-                    nativeValue = org.nativescript.mason.masonkit.JustifySelf.Stretch;
-                }
-                break;
-        }
-        if (!Utils.isNullOrUndefined(nativeValue)) {
-            if (UseV8Module) {
-                MasonV8Module.setJustifySelf(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-            }
-            else {
-                if (global.isAndroid) {
-                    const nodeOrView = getMasonInstance(instance);
-                    if (instance._isMasonChild) {
-                        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setJustifySelf(nodeOrView, nativeValue);
-                    }
-                    else {
-                        nodeOrView.setJustifySelf(nativeValue);
-                    }
-                }
-                if (global.isIOS) {
-                    instance.ios.justifySelf = nativeValue;
-                }
-            }
-        }
+        instance._styleHelper.justifySelf = value;
     }
 }
 export function _getJustifySelf(instance) {
     if (instance._hasNativeView) {
-        if (UseV8Module) {
-            const value = MasonV8Module.getJustifySelf(instance._masonStylePtr);
-            switch (value) {
-                case -1 /* JustifySelf.Normal */:
-                    return 'normal';
-                case 3 /* JustifySelf.Baseline */:
-                    return 'baseline';
-                case 2 /* JustifySelf.Center */:
-                    return 'center';
-                case 1 /* JustifySelf.End */:
-                    return 'end';
-                case 0 /* JustifySelf.Start */:
-                    return 'start';
-                case 4 /* JustifySelf.Stretch */:
-                    return 'stretch';
-            }
-        }
-        else {
-            if (global.isAndroid) {
-                const nodeOrView = getMasonInstance(instance);
-                let value;
-                if (instance._isMasonChild) {
-                    value = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getJustifySelf(nodeOrView);
-                }
-                else {
-                    value = nodeOrView.getJustifySelf();
-                }
-                switch (value) {
-                    case org.nativescript.mason.masonkit.JustifySelf.Normal:
-                        return 'normal';
-                    case org.nativescript.mason.masonkit.JustifySelf.Baseline:
-                        return 'baseline';
-                    case org.nativescript.mason.masonkit.JustifySelf.Center:
-                        return 'center';
-                    case org.nativescript.mason.masonkit.JustifySelf.End:
-                        return 'end';
-                    case org.nativescript.mason.masonkit.JustifySelf.Start:
-                        return 'start';
-                    case org.nativescript.mason.masonkit.JustifySelf.Stretch:
-                        return 'stretch';
-                }
-            }
-            if (global.isIOS) {
-                const value = instance.ios.justifySelf;
-                switch (value) {
-                    case -1 /* JustifySelf.Normal */:
-                        return 'normal';
-                    case 3 /* JustifySelf.Baseline */:
-                        return 'baseline';
-                    case 2 /* JustifySelf.Center */:
-                        return 'center';
-                    case 1 /* JustifySelf.End */:
-                        return 'end';
-                    case 0 /* JustifySelf.Start */:
-                        return 'start';
-                    case 4 /* JustifySelf.Stretch */:
-                        return 'stretch';
-                }
-            }
-        }
+        return instance._styleHelper.justifySelf;
     }
     return instance.style.justifySelf;
 }
@@ -1924,230 +500,14 @@ export function _setJustifyContent(value, instance, initial = false) {
     if (!value)
         value = 'normal';
     if (instance._hasNativeView) {
-        let nativeValue = null;
-        switch (value) {
-            case 'normal':
-                if (UseV8Module) {
-                    nativeValue = -1 /* JustifyContent.Normal */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.JustifyContent.Normal;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = -1 /* JustifyContent.Normal */;
-                    }
-                }
-                break;
-            case 'space-around':
-                if (UseV8Module) {
-                    nativeValue = 5 /* JustifyContent.SpaceAround */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.JustifyContent.SpaceAround;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 5 /* JustifyContent.SpaceAround */;
-                    }
-                }
-                break;
-            case 'space-between':
-                if (UseV8Module) {
-                    nativeValue = 4 /* JustifyContent.SpaceBetween */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.JustifyContent.SpaceBetween;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 4 /* JustifyContent.SpaceBetween */;
-                    }
-                }
-                break;
-            case 'space-evenly':
-                if (UseV8Module) {
-                    nativeValue = 6 /* JustifyContent.SpaceEvenly */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.JustifyContent.SpaceEvenly;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 6 /* JustifyContent.SpaceEvenly */;
-                    }
-                }
-                break;
-            case 'center':
-                if (UseV8Module) {
-                    nativeValue = 2 /* JustifyContent.Center */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.JustifyContent.Center;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 2 /* JustifyContent.Center */;
-                    }
-                }
-                break;
-            case 'flex-end':
-                if (UseV8Module) {
-                    nativeValue = 8 /* JustifyContent.FlexEnd */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.JustifyContent.FlexEnd;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 8 /* JustifyContent.FlexEnd */;
-                    }
-                }
-                break;
-            case 'end':
-                if (UseV8Module) {
-                    nativeValue = 1 /* JustifyContent.End */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.JustifyContent.End;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 1 /* JustifyContent.End */;
-                    }
-                }
-                break;
-            case 'flex-start':
-                if (UseV8Module) {
-                    nativeValue = 7 /* JustifyContent.FlexStart */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.JustifyContent.FlexStart;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 7 /* JustifyContent.FlexStart */;
-                    }
-                }
-                break;
-            case 'start':
-                if (UseV8Module) {
-                    nativeValue = 0 /* JustifyContent.Start */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.JustifyContent.Start;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 0 /* JustifyContent.Start */;
-                    }
-                }
-                break;
-            case 'stretch':
-                if (UseV8Module) {
-                    nativeValue = 3 /* JustifyContent.Stretch */;
-                }
-                else {
-                    if (global.isAndroid) {
-                        nativeValue = org.nativescript.mason.masonkit.JustifyContent.Stretch;
-                    }
-                    if (global.isIOS) {
-                        nativeValue = 3 /* JustifyContent.Stretch */;
-                    }
-                }
-                break;
-        }
-        if (UseV8Module) {
-            MasonV8Module.setJustifyContent(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-        }
-        else {
-            if (global.isAndroid) {
-                const nodeOrView = getMasonInstance(instance);
-                if (instance._isMasonChild) {
-                    org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setJustifyContent(nodeOrView, nativeValue);
-                }
-                else {
-                    nodeOrView.setJustifyContent(nativeValue);
-                }
-            }
-            if (global.isIOS) {
-                instance.ios.justifyContent = nativeValue;
-            }
+        if (instance._styleHelper) {
+            instance._styleHelper.justifyContent = value;
         }
     }
 }
 export function _getJustifyContent(instance) {
     if (instance._hasNativeView) {
-        if (UseV8Module) {
-            const value = MasonV8Module.getJustifyContent(instance._masonStylePtr);
-            switch (value) {
-                case -1 /* JustifyContent.Normal */:
-                    return 'normal';
-                case 5 /* JustifyContent.SpaceAround */:
-                    return 'space-around';
-                case 4 /* JustifyContent.SpaceBetween */:
-                    return 'space-between';
-                case 6 /* JustifyContent.SpaceEvenly */:
-                    return 'space-evenly';
-                case 2 /* JustifyContent.Center */:
-                    return 'center';
-                case 1 /* JustifyContent.End */:
-                    return 'end';
-                case 0 /* JustifyContent.Start */:
-                    return 'start';
-            }
-        }
-        else {
-            if (global.isAndroid) {
-                const nodeOrView = getMasonInstance(instance);
-                let value;
-                if (instance._isMasonChild) {
-                    value = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getJustifyContent(nodeOrView);
-                }
-                else {
-                    value = nodeOrView.getJustifyContent();
-                }
-                switch (value) {
-                    case org.nativescript.mason.masonkit.JustifyContent.Normal:
-                        return 'normal';
-                    case org.nativescript.mason.masonkit.JustifyContent.SpaceAround:
-                        return 'space-around';
-                    case org.nativescript.mason.masonkit.JustifyContent.SpaceBetween:
-                        return 'space-between';
-                    case org.nativescript.mason.masonkit.JustifyContent.SpaceEvenly:
-                        return 'space-evenly';
-                    case org.nativescript.mason.masonkit.JustifyContent.Center:
-                        return 'center';
-                    case org.nativescript.mason.masonkit.JustifyContent.End:
-                        return 'end';
-                    case org.nativescript.mason.masonkit.JustifyContent.Start:
-                        return 'start';
-                    case org.nativescript.mason.masonkit.JustifyContent.Stretch:
-                        return 'stretch';
-                }
-            }
-            if (global.isIOS) {
-                const value = instance.ios.justifyContent;
-                switch (value) {
-                    case -1 /* JustifyContent.Normal */:
-                        return 'normal';
-                    case 5 /* JustifyContent.SpaceAround */:
-                        return 'space-around';
-                    case 4 /* JustifyContent.SpaceBetween */:
-                        return 'space-between';
-                    case 6 /* JustifyContent.SpaceEvenly */:
-                        return 'space-evenly';
-                    case 2 /* JustifyContent.Center */:
-                        return 'center';
-                    case 1 /* JustifyContent.End */:
-                        return 'end';
-                    case 0 /* JustifyContent.Start */:
-                        return 'start';
-                    case 3 /* JustifyContent.Stretch */:
-                        return 'stretch';
-                }
-            }
-        }
+        return instance._styleHelper.justifyContent;
     }
     return instance.style.justifyContent;
 }
@@ -2155,857 +515,204 @@ export function _setLeft(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentageAuto(value);
-    if (UseV8Module) {
-        MasonV8Module.setInsetLeft(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setInsetLeft(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setInsetLeft(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setInsetLeft(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.left = value;
 }
 export function _setRight(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentageAuto(value);
-    if (UseV8Module) {
-        MasonV8Module.setInsetRight(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setInsetRight(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setInsetRight(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setInsetRight(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.right = value;
 }
 export function _setTop(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentageAuto(value);
-    if (UseV8Module) {
-        MasonV8Module.setInsetTop(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setInsetTop(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setInsetTop(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setInsetTop(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.top = value;
 }
 export function _setBottom(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentageAuto(value);
-    if (UseV8Module) {
-        MasonV8Module.setInsetBottom(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setInsetBottom(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setInsetBottom(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setInsetBottom(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.bottom = value;
 }
 export function _setMarginLeft(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentageAuto(value);
-    if (UseV8Module) {
-        MasonV8Module.setMarginLeft(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setMarginLeft(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setMarginLeft(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setMarginLeft(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.marginLeft = value;
 }
 export function _setMarginRight(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentageAuto(value);
-    if (UseV8Module) {
-        MasonV8Module.setMarginRight(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setMarginRight(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setMarginRight(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setMarginRight(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.marginRight = value;
 }
 export function _setMarginTop(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentageAuto(value);
-    if (UseV8Module) {
-        MasonV8Module.setMarginTop(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setMarginTop(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setMarginTop(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setMarginTop(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.marginTop = value;
 }
 export function _setMarginBottom(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentageAuto(value);
-    if (UseV8Module) {
-        MasonV8Module.setMarginBottom(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setMarginBottom(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setMarginBottom(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setMarginBottom(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.marginBottom = value;
 }
 export function _setPaddingLeft(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentage(value);
-    if (UseV8Module) {
-        MasonV8Module.setPaddingLeft(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setPaddingLeft(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setPaddingLeft(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setPaddingLeft(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.paddingLeft = value;
 }
 export function _setPaddingRight(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentage(value);
-    if (UseV8Module) {
-        MasonV8Module.setPaddingRight(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setPaddingRight(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setPaddingRight(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setPaddingRight(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.paddingRight = value;
 }
 export function _setPaddingTop(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentage(value);
-    if (UseV8Module) {
-        MasonV8Module.setPaddingTop(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setPaddingTop(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setPaddingTop(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setPaddingTop(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.paddingTop = value;
 }
 export function _setPaddingBottom(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentage(value);
-    if (UseV8Module) {
-        MasonV8Module.setPaddingBottom(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setPaddingBottom(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setPaddingBottom(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setPaddingBottom(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.paddingBottom = value;
 }
 export function _setBorderLeft(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentage(value);
-    if (UseV8Module) {
-        MasonV8Module.setBorderLeft(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setBorderLeft(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setBorderLeft(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setBorderLeft(val.value, val.native_type);
-        }
-    }
 }
 export function _setBorderRight(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentage(value);
-    if (UseV8Module) {
-        MasonV8Module.setBorderRight(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setBorderRight(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setBorderRight(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setBorderRight(val.value, val.native_type);
-        }
-    }
 }
 export function _setBorderTop(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentage(value);
-    if (UseV8Module) {
-        MasonV8Module.setBorderTop(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setBorderTop(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setBorderTop(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setBorderTop(val.value, val.native_type);
-        }
-    }
 }
 export function _setBorderBottom(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentage(value);
-    if (UseV8Module) {
-        MasonV8Module.setBorderBottom(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setBorderBottom(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setBorderBottom(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setBorderBottom(val.value, val.native_type);
-        }
-    }
 }
 export function _setFlexBasis(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    if (UseV8Module) {
-        const val = _toMasonDimension(value);
-        MasonV8Module.setFlexBasis(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const val = _toMasonDimension(value);
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setFlexBasis(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setFlexBasis(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.flexBasisCompat = _intoMasonDimension(value);
-        }
-    }
+    instance._styleHelper.flexBasis = value;
 }
 export function _getFlexBasis(instance) {
     if (!instance._hasNativeView) {
         return instance.style.flexBasis;
     }
-    if (UseV8Module) {
-        return MasonV8Module.getFlexBasis(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let value;
-            if (instance._isMasonChild) {
-                value = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getFlexBasis(nodeOrView);
-            }
-            else {
-                value = nodeOrView.getFlexBasis();
-            }
-            return _parseDimension(value);
-        }
-        if (global.isIOS) {
-            return _parseDimension(instance.ios.flexBasisCompat);
-        }
-        return instance.style.flexBasis;
-    }
+    return instance._styleHelper.flexBasis;
 }
 export function _setGap(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const width = _toLengthPercentage(value.width);
-    const height = _toLengthPercentage(value.height);
-    if (UseV8Module) {
-        MasonV8Module.setGap(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, width.value, width.native_type, height.value, height.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGap(nodeOrView, width.value, width.native_type, height.value, height.native_type);
-            }
-            else {
-                nodeOrView.setGap(width.value, width.native_type, height.value, height.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setGapWithWidthHeightType(width.value, width.native_type, height.value, height.native_type);
-        }
-    }
 }
 export function _getGap(instance) {
     if (!instance._hasNativeView) {
         return instance.style.gap;
     }
-    if (UseV8Module) {
-        return MasonV8Module.getGap(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let gap;
-            if (instance._isMasonChild) {
-                gap = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getGap(nodeOrView);
-            }
-            else {
-                gap = nodeOrView.getGap();
-            }
-            const width = _parseLengthPercentage(gap.getWidth());
-            const height = _parseLengthPercentage(gap.getHeight());
-            return { width, height };
-        }
-        if (global.isIOS) {
-            const gap = instance.ios.getGap();
-            const width = _parseLengthPercentage(gap.width);
-            const height = _parseLengthPercentage(gap.height);
-            return { width, height };
-        }
-    }
-}
-function toOverflowValue(value) {
-    let nativeValue = 0;
-    switch (value) {
-        case 0:
-            nativeValue = 0 /* Overflow.Visible */;
-            break;
-        case 1:
-            nativeValue = 1 /* Overflow.Hidden */;
-            break;
-        case 2:
-            nativeValue = 2 /* Overflow.Scroll */;
-            break;
-        default:
-            nativeValue = 0 /* Overflow.Visible */;
-    }
-    return nativeValue;
-}
-function toOverflowJSValue(value) {
-    if (__IOS__) {
-        switch (value) {
-            case 0 /* Overflow.Visible */:
-                return 'visible';
-            case 1 /* Overflow.Hidden */:
-                return 'hidden';
-            case 2 /* Overflow.Scroll */:
-                return 'scroll';
-            default:
-                return 'visible';
-        }
-    }
-    switch (value) {
-        case org.nativescript.mason.masonkit.Overflow.Visible:
-            return 'visible';
-        case org.nativescript.mason.masonkit.Overflow.Hidden:
-            return 'hidden';
-        case org.nativescript.mason.masonkit.Overflow.Scroll:
-            return 'scroll';
-        default:
-            return 'visible';
-    }
-}
-function toOverflowJavaValue(value) {
-    let nativeValue = org.nativescript.mason.masonkit.Overflow.Visible;
-    switch (value) {
-        case 0:
-            nativeValue = org.nativescript.mason.masonkit.Overflow.Visible;
-            break;
-        case 1:
-            nativeValue = org.nativescript.mason.masonkit.Overflow.Hidden;
-            break;
-        case 2:
-            nativeValue = org.nativescript.mason.masonkit.Overflow.Scroll;
-            break;
-        default:
-            nativeValue = org.nativescript.mason.masonkit.Overflow.Visible;
-    }
-    return nativeValue;
+    return {
+        row: this._styleHelper.rowGap,
+        column: this._styleHelper.columnGap,
+    };
 }
 export function _setOverflow(value, instance) {
     if (!instance._hasNativeView) {
         return;
     }
-    if (UseV8Module) {
-        const nativeValue = toOverflowValue(value);
-        MasonV8Module.setOverflow(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setOverflow(nodeOrView, toOverflowJavaValue(value));
-            }
-            else {
-                nodeOrView.setOverflow(toOverflowJavaValue(value));
-            }
-        }
-        if (global.isIOS) {
-            const nativeValue = toOverflowValue(value);
-            instance.ios.overflow = nativeValue;
-        }
-    }
+    instance._styleHelper.overflow = value;
 }
 export function _getOverflow(instance) {
     if (!instance._hasNativeView) {
         return instance.style.flexGrow;
     }
-    if (UseV8Module) {
-        return MasonV8Module.getOverflow(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                return toOverflowJSValue(org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getOverflow(nodeOrView));
-            }
-            else {
-                return toOverflowJSValue(nodeOrView.getOverflow());
-            }
-        }
-        if (global.isIOS) {
-            return toOverflowJSValue(instance.ios.overflow);
-        }
-    }
+    return instance._styleHelper.overflow;
 }
-export function _setOverflowX(value, instance) {
-    if (!instance._hasNativeView) {
-        return;
-    }
-    if (UseV8Module) {
-        const nativeValue = toOverflowValue(value);
-        MasonV8Module.setOverflowX(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setOverflowX(nodeOrView, toOverflowJavaValue(value));
-            }
-            else {
-                nodeOrView.setOverflowX(toOverflowJavaValue(value));
-            }
-        }
-        if (global.isIOS) {
-            const nativeValue = toOverflowValue(value);
-            // TODO
-            instance.ios.overflowX = nativeValue;
-        }
+export function _setOverflowX(value, instance) {
+    if (!instance._hasNativeView) {
+        return;
     }
+    instance._styleHelper.overflowX = value;
 }
 export function _getOverflowX(instance) {
     if (!instance._hasNativeView) {
-        return instance.style.flexGrow;
-    }
-    if (UseV8Module) {
-        return MasonV8Module.getOverflowX(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                return toOverflowJSValue(org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getOverflowX(nodeOrView));
-            }
-            else {
-                return toOverflowJSValue(nodeOrView.getOverflowX());
-            }
-        }
-        if (global.isIOS) {
-            return toOverflowJSValue(instance.ios.overflowX);
-        }
+        return instance.style.overflowX;
     }
+    return instance._styleHelper.overflowX;
 }
 export function _setOverflowY(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    if (UseV8Module) {
-        const nativeValue = toOverflowValue(value);
-        MasonV8Module.setOverflowY(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setOverflowY(nodeOrView, toOverflowJavaValue(value));
-            }
-            else {
-                nodeOrView.setOverflowY(toOverflowJavaValue(value));
-            }
-        }
-        if (global.isIOS) {
-            const nativeValue = toOverflowValue(value);
-            // TODO
-            instance.ios.overflowY = nativeValue;
-        }
-    }
+    instance._styleHelper.overflowY = value;
 }
 export function _getOverflowY(instance) {
     if (!instance._hasNativeView) {
-        return instance.style.flexGrow;
-    }
-    if (UseV8Module) {
-        return MasonV8Module.getOverflowY(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                return toOverflowJSValue(org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getOverflowY(nodeOrView));
-            }
-            else {
-                return toOverflowJSValue(nodeOrView.getOverflowY());
-            }
-        }
-        if (global.isIOS) {
-            return toOverflowJSValue(instance.ios.overflowY);
-        }
+        return instance.style.overflowY;
     }
+    return instance._styleHelper.overflowY;
 }
 export function _setScrollbarWidth(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    value = _toMasonDimension(value).value;
-    if (UseV8Module) {
-        MasonV8Module.setScrollbarWidth(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, value, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                return org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setScrollBarWidth(nodeOrView, value);
-            }
-            else {
-                return nodeOrView.setScrollBarWidth(value);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.scrollBarWidthCompat = MasonDimensionCompat.alloc().initWithPoints(value);
-        }
-    }
+    instance._styleHelper.scrollBarWidth = value;
 }
 export function getScrollbarWidth(instance) {
     if (!instance._hasNativeView) {
-        return instance.style.flexGrow;
-    }
-    if (UseV8Module) {
-        return MasonV8Module.getScrollbarWidth(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                return org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getScrollBarWidth(nodeOrView);
-            }
-            else {
-                return nodeOrView.getScrollBarWidth();
-            }
-        }
-        if (global.isIOS) {
-            return _parseDimension(instance.ios.scrollBarWidthCompat);
-        }
+        return instance.style.scrollBarWidth;
     }
+    return instance._styleHelper.scrollBarWidth;
 }
 export function _setFlexGrow(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    if (UseV8Module) {
-        MasonV8Module.setFlexGrow(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, value, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setFlexGrow(nodeOrView, value);
-            }
-            else {
-                nodeOrView.setFlexGrow(value);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.flexGrow = value;
-        }
-    }
+    instance._styleHelper.flexGrow = value;
 }
 export function _getFlexGrow(instance) {
     if (!instance._hasNativeView) {
         return instance.style.flexGrow;
     }
-    if (UseV8Module) {
-        return MasonV8Module.getFlexGrow(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let value;
-            if (instance._isMasonChild) {
-                value = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getFlexGrow(nodeOrView);
-            }
-            else {
-                value = nodeOrView.getFlexGrow();
-            }
-            return value;
-        }
-        if (global.isiOS) {
-            return instance.ios.flexGrow;
-        }
-        return instance.style.flexGrow;
-    }
+    return instance._styleHelper.flexGrow;
 }
 export function _setFlexShrink(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    if (UseV8Module) {
-        MasonV8Module.setFlexShrink(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, value, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setFlexShrink(nodeOrView, value);
-            }
-            else {
-                nodeOrView.setFlexShrink(value);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.flexShrink = value;
-        }
-    }
+    instance._styleHelper.flexShrink = value;
 }
 export function _getFlexShrink(instance) {
     if (!instance._hasNativeView) {
         return instance.style.flexShrink;
     }
-    if (UseV8Module) {
-        return MasonV8Module.getFlexShrink(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let value;
-            if (instance._isMasonChild) {
-                value = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getFlexShrink(nodeOrView);
-            }
-            else {
-                value = nodeOrView.getFlexShrink();
-            }
-            return value;
-        }
-        if (global.isIOS) {
-            return instance.ios.flexShrink;
-        }
-        return instance.style.flexShrink;
-    }
+    return instance._styleHelper.flexShrink;
 }
 export function _setAspectRatio(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    if (UseV8Module) {
-        MasonV8Module.setAspectRatio(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, value, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const val = Number.isNaN(value) ? null : value;
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setAspectRatio(nodeOrView, val);
-            }
-            else {
-                nodeOrView.setAspectRatio(val);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.aspectRatio = value;
-        }
-    }
+    instance._styleHelper.aspectRatio = value ? value : Number.NaN;
 }
 export function _getAspectRatio(instance) {
     if (!instance._hasNativeView) {
         return instance.style.aspectRatio;
     }
-    if (UseV8Module) {
-        return MasonV8Module.getAspectRatio(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let value;
-            if (instance._isMasonChild) {
-                value = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getAspectRatio(nodeOrView);
-            }
-            else {
-                value = nodeOrView.getAspectRatio();
-            }
-            return value;
-        }
-        if (global.isIOS) {
-            const ratio = instance.ios.aspectRatio;
-            return Number.isNaN(ratio) ? null : ratio;
-        }
-        return null;
-    }
+    const ratio = instance._styleHelper.aspectRatio;
+    return Number.isNaN(ratio) ? null : ratio;
 }
 function _parseGridLine(value) {
     let parsedValue = undefined;
@@ -3042,48 +749,42 @@ function _parseGridLine(value) {
         }
     }
     if (parsedType === 0) {
-        if (!UseV8Module) {
-            if (global.isAndroid) {
-                parsedType = org.nativescript.mason.masonkit.GridPlacement.Auto;
-                nativeValue = org.nativescript.mason.masonkit.GridPlacement.Auto.INSTANCE;
-            }
-            if (global.isIOS) {
-                parsedType = 0 /* GridPlacementCompatType.Auto */;
-                nativeValue = GridPlacementCompat.Auto;
-            }
+        if (__ANDROID__) {
+            parsedType = org.nativescript.mason.masonkit.GridPlacement.Auto;
+            nativeValue = org.nativescript.mason.masonkit.GridPlacement.Auto.INSTANCE;
+        }
+        if (__APPLE__) {
+            parsedType = 0 /* GridPlacementCompatType.Auto */;
+            nativeValue = GridPlacementCompat.Auto;
         }
     }
     else if (parsedType === 1) {
-        if (!UseV8Module) {
-            const isValid = !Number.isNaN(parsedValue);
-            if (global.isAndroid) {
-                parsedType = org.nativescript.mason.masonkit.GridPlacement.Line;
-                if (isValid) {
-                    nativeValue = new org.nativescript.mason.masonkit.GridPlacement.Line(parsedValue);
-                }
+        const isValid = !Number.isNaN(parsedValue);
+        if (__ANDROID__) {
+            parsedType = org.nativescript.mason.masonkit.GridPlacement.Line;
+            if (isValid) {
+                nativeValue = new org.nativescript.mason.masonkit.GridPlacement.Line(parsedValue);
             }
-            if (global.isIOS) {
-                parsedType = 1 /* GridPlacementCompatType.Line */;
-                if (isValid) {
-                    nativeValue = GridPlacementCompat.alloc().initWithLine(parsedValue);
-                }
+        }
+        if (__APPLE__) {
+            parsedType = 1 /* GridPlacementCompatType.Line */;
+            if (isValid) {
+                nativeValue = GridPlacementCompat.alloc().initWithLine(parsedValue);
             }
         }
     }
     else {
-        if (!UseV8Module) {
-            const isValid = !Number.isNaN(parsedValue);
-            if (global.isAndroid) {
-                parsedType = org.nativescript.mason.masonkit.GridPlacement.Span;
-                if (isValid) {
-                    nativeValue = new org.nativescript.mason.masonkit.GridPlacement.Span(parsedValue);
-                }
+        const isValid = !Number.isNaN(parsedValue);
+        if (__ANDROID__) {
+            parsedType = org.nativescript.mason.masonkit.GridPlacement.Span;
+            if (isValid) {
+                nativeValue = new org.nativescript.mason.masonkit.GridPlacement.Span(parsedValue);
             }
-            if (global.isIOS) {
-                parsedType = 2 /* GridPlacementCompatType.Span */;
-                if (isValid) {
-                    nativeValue = GridPlacementCompat.alloc().initWithSpan(parsedValue);
-                }
+        }
+        if (__APPLE__) {
+            parsedType = 2 /* GridPlacementCompatType.Span */;
+            if (isValid) {
+                nativeValue = GridPlacementCompat.alloc().initWithSpan(parsedValue);
             }
         }
     }
@@ -3097,22 +798,12 @@ export function _setGridColumnStart(value, instance, initial = false) {
     if (val.value === undefined || val.type === undefined) {
         return;
     }
-    if (UseV8Module) {
-        MasonV8Module.setColumnStart(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val, !instance._inBatch);
+    if (__ANDROID__) {
+        const nodeOrView = getMasonInstance(instance);
+        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridColumnStart(nodeOrView, val.native_value);
     }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridColumnStart(nodeOrView, val.native_value);
-            }
-            else {
-                nodeOrView.setGridColumnStart(val.native_value);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.gridColumnStartCompat = val.native_value;
-        }
+    if (__APPLE__) {
+        instance.ios.gridColumnStartCompat = val.native_value;
     }
 }
 export function _setGridColumnEnd(value, instance, initial = false) {
@@ -3123,22 +814,12 @@ export function _setGridColumnEnd(value, instance, initial = false) {
     if (val.value === undefined || val.type === undefined) {
         return;
     }
-    if (UseV8Module) {
-        MasonV8Module.setColumnEnd(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val, !instance._inBatch);
+    if (__ANDROID__) {
+        const nodeOrView = getMasonInstance(instance);
+        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridColumnEnd(nodeOrView, val.native_value);
     }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridColumnEnd(nodeOrView, val.native_value);
-            }
-            else {
-                nodeOrView.setGridColumnEnd(val.native_value);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.gridColumnEndCompat = val.native_value;
-        }
+    if (__APPLE__) {
+        instance.ios.gridColumnEndCompat = val.native_value;
     }
 }
 export function _setGridRowStart(value, instance, initial = false) {
@@ -3149,22 +830,12 @@ export function _setGridRowStart(value, instance, initial = false) {
     if (val.value === undefined || val.type === undefined) {
         return;
     }
-    if (UseV8Module) {
-        MasonV8Module.setRowStart(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val, !instance._inBatch);
+    if (__ANDROID__) {
+        const nodeOrView = getMasonInstance(instance);
+        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridRowStart(nodeOrView, val.native_value);
     }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridRowStart(nodeOrView, val.native_value);
-            }
-            else {
-                nodeOrView.setGridRowStart(val.native_value);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.gridRowStartCompat = val.native_value;
-        }
+    if (__APPLE__) {
+        instance.ios.gridRowStartCompat = val.native_value;
     }
 }
 export function _setGridRowEnd(value, instance, initial = false) {
@@ -3175,125 +846,37 @@ export function _setGridRowEnd(value, instance, initial = false) {
     if (val.value === undefined || val.type === undefined) {
         return;
     }
-    if (UseV8Module) {
-        MasonV8Module.setRowEnd(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val, !instance._inBatch);
+    if (__ANDROID__) {
+        const nodeOrView = getMasonInstance(instance);
+        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridRowEnd(nodeOrView, val.native_value);
     }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridRowEnd(nodeOrView, val.native_value);
-            }
-            else {
-                nodeOrView.setGridRowEnd(val.native_value);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.gridRowEndCompat = val.native_value;
-        }
+    if (__APPLE__) {
+        instance.ios.gridRowEndCompat = val.native_value;
     }
 }
 export function _setRowGap(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentage(value);
-    if (val.value === undefined || val.type === undefined) {
-        return;
-    }
-    if (UseV8Module) {
-        MasonV8Module.setRowGap(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGapRow(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setGapRow(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setRowGap(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.rowGap = value;
 }
 export function _getRowGap(instance) {
     if (!instance._hasNativeView) {
-        return instance.style.gap;
-    }
-    if (UseV8Module) {
-        return MasonV8Module.getRowGap(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let gap;
-            if (instance._isMasonChild) {
-                gap = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getGapRow(nodeOrView);
-            }
-            else {
-                gap = nodeOrView.getGapRow();
-            }
-            return _parseLengthPercentage(gap);
-        }
-        if (global.isIOS) {
-            const gap = instance.ios.getRowGap();
-            return _parseLengthPercentage(gap);
-        }
+        return instance.style.rowGap;
     }
+    return instance._styleHelper.rowGap;
 }
 export function _setColumnGap(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    const val = _toLengthPercentage(value);
-    if (val.value === undefined || val.type === undefined) {
-        return;
-    }
-    if (UseV8Module) {
-        MasonV8Module.setColumnGap(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, val.value, val.native_type, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGapColumn(nodeOrView, val.value, val.native_type);
-            }
-            else {
-                nodeOrView.setGapColumn(val.value, val.native_type);
-            }
-        }
-        if (global.isIOS) {
-            instance.ios.setColumnGap(val.value, val.native_type);
-        }
-    }
+    instance._styleHelper.columnGap = value;
 }
 export function _getColumnGap(instance) {
     if (!instance._hasNativeView) {
         return instance.style.gap;
     }
-    if (UseV8Module) {
-        return MasonV8Module.getColumnGap(instance._masonStylePtr);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            let gap;
-            if (instance._isMasonChild) {
-                gap = org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getGapColumn(nodeOrView);
-            }
-            else {
-                gap = nodeOrView.getGapColumn();
-            }
-            return _parseLengthPercentage(gap);
-        }
-        if (global.isIOS) {
-            const gap = instance.ios.getColumnGap();
-            return _parseLengthPercentage(gap);
-        }
-    }
+    return instance._styleHelper.columnGap;
 }
 const Auto = 'auto';
 const None = 'none';
@@ -3330,7 +913,7 @@ export function _parseMinMaxValue(value) {
             return {
                 min_type: 0 /* MinSizingType.Auto */,
                 min_value: 0,
-                max_type: 5 /* MaxSizingType.Flex */,
+                max_type: 5 /* MaxSizingType.Fraction */,
                 max_value: flex,
             };
         }
@@ -3395,15 +978,6 @@ export function _parseMinMaxValue(value) {
                 max_value: percent,
             };
         }
-        else if (value.indexOf('fr') > -1) {
-            const flex = parseFloat(value.replace('fr', ''));
-            return {
-                min_type: 0 /* MinSizingType.Auto */,
-                min_value: 0,
-                max_type: 5 /* MaxSizingType.Flex */,
-                max_value: flex,
-            };
-        }
         else {
             const dip = Utils.layout.toDevicePixels(Number(value));
             return {
@@ -3452,11 +1026,13 @@ export function _parseGridTemplates(value) {
                         repeating_type = 1 /* TSCGridTrackRepetition.AutoFit */;
                         break;
                     default:
-                        const number = parseInt(repetition);
-                        repeating_type = 2 /* TSCGridTrackRepetition.Count */;
-                        isValid = !Number.isNaN(number);
-                        if (isValid) {
-                            repeat_count = number;
+                        {
+                            const number = parseInt(repetition);
+                            repeating_type = 2 /* TSCGridTrackRepetition.Count */;
+                            isValid = !Number.isNaN(number);
+                            if (isValid) {
+                                repeat_count = number;
+                            }
                         }
                         break;
                 }
@@ -3490,189 +1066,172 @@ export function _setGridTemplateRows(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    if (UseV8Module) {
-        MasonV8Module.setGridTemplateRows(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, value, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const array = Array.create('org.nativescript.mason.masonkit.TrackSizingFunction', value.length);
-            const length = value.length;
-            for (let i = 0; i < length; i++) {
-                const item = value[i];
-                if (item.is_repeating) {
-                    const repeating = item.value;
-                    const tracks = Array.create('org.nativescript.mason.masonkit.MinMax', repeating.length);
-                    let gridTrackRepetition = null;
-                    switch (item.repeating_type) {
-                        case 0 /* TSCGridTrackRepetition.AutoFill */:
-                            gridTrackRepetition = org.nativescript.mason.masonkit.GridTrackRepetition.AutoFill;
-                            break;
-                        case 1 /* TSCGridTrackRepetition.AutoFit */:
-                            gridTrackRepetition = org.nativescript.mason.masonkit.GridTrackRepetition.AutoFit;
-                            break;
-                        case 2 /* TSCGridTrackRepetition.Count */:
-                            gridTrackRepetition = new org.nativescript.mason.masonkit.GridTrackRepetition.Count(item.repeating_count);
-                            break;
-                    }
-                    if (gridTrackRepetition === null) {
-                        continue;
-                    }
-                    const repeatingLength = repeating.length;
-                    for (let j = 0; j < repeatingLength; j++) {
-                        const repeat = repeating[j];
-                        tracks[j] = org.nativescript.mason.masonkit.MinMax.fromTypeValue(repeat.min_type, repeat.min_value, repeat.max_type, repeat.max_value);
-                    }
-                    const repeat = new org.nativescript.mason.masonkit.TrackSizingFunction.AutoRepeat(gridTrackRepetition, tracks);
-                    array[i] = repeat;
+    if (__ANDROID__) {
+        const array = Array.create('org.nativescript.mason.masonkit.TrackSizingFunction', value.length);
+        const length = value.length;
+        for (let i = 0; i < length; i++) {
+            const item = value[i];
+            if (item.is_repeating) {
+                const repeating = item.value;
+                const tracks = Array.create('org.nativescript.mason.masonkit.MinMax', repeating.length);
+                let gridTrackRepetition = null;
+                switch (item.repeating_type) {
+                    case 0 /* TSCGridTrackRepetition.AutoFill */:
+                        gridTrackRepetition = org.nativescript.mason.masonkit.GridTrackRepetition.AutoFill;
+                        break;
+                    case 1 /* TSCGridTrackRepetition.AutoFit */:
+                        gridTrackRepetition = org.nativescript.mason.masonkit.GridTrackRepetition.AutoFit;
+                        break;
+                    case 2 /* TSCGridTrackRepetition.Count */:
+                        gridTrackRepetition = new org.nativescript.mason.masonkit.GridTrackRepetition.Count(item.repeating_count);
+                        break;
                 }
-                else {
-                    const single = item.value;
-                    const trackSizingFunction = new org.nativescript.mason.masonkit.TrackSizingFunction.Single(org.nativescript.mason.masonkit.MinMax.fromTypeValue(single.min_type, single.min_value, single.max_type, single.max_value));
-                    array[i] = trackSizingFunction;
+                if (gridTrackRepetition === null) {
+                    continue;
                 }
-            }
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridTemplateRows(nodeOrView, array);
+                const repeatingLength = repeating.length;
+                for (let j = 0; j < repeatingLength; j++) {
+                    const repeat = repeating[j];
+                    tracks[j] = org.nativescript.mason.masonkit.MinMax.fromTypeValue(repeat.min_type, repeat.min_value, repeat.max_type, repeat.max_value);
+                }
+                const repeat = new org.nativescript.mason.masonkit.TrackSizingFunction.AutoRepeat(gridTrackRepetition, tracks);
+                array[i] = repeat;
             }
             else {
-                nodeOrView.setGridTemplateRows(array);
+                const single = item.value;
+                const trackSizingFunction = new org.nativescript.mason.masonkit.TrackSizingFunction.Single(org.nativescript.mason.masonkit.MinMax.fromTypeValue(single.min_type, single.min_value, single.max_type, single.max_value));
+                array[i] = trackSizingFunction;
             }
         }
-        if (global.isIOS) {
-            const length = value.length;
-            const array = NSMutableArray.arrayWithCapacity(length);
-            for (let i = 0; i < length; i++) {
-                const item = value[i];
-                if (item.is_repeating) {
-                    const repeating = item.value;
-                    const repeatingLength = repeating.length;
-                    const tracks = NSMutableArray.arrayWithCapacity(repeatingLength);
-                    let gridTrackRepetition = null;
-                    switch (item.repeating_type) {
-                        case 0 /* TSCGridTrackRepetition.AutoFill */:
-                            gridTrackRepetition = 0 /* TSCGridTrackRepetition.AutoFill */;
-                            break;
-                        case 1 /* TSCGridTrackRepetition.AutoFit */:
-                            gridTrackRepetition = 1 /* TSCGridTrackRepetition.AutoFit */;
-                            break;
-                        case 2 /* TSCGridTrackRepetition.Count */:
-                            gridTrackRepetition = GridTrackRepetition.Count(item.repeating_count);
-                            break;
-                    }
-                    if (gridTrackRepetition === null) {
-                        continue;
-                    }
-                    for (let j = 0; j < repeatingLength; j++) {
-                        const repeat = repeating[j];
-                        tracks.addObject(MinMax.fromTypeValue(repeat.min_type, repeat.min_value, repeat.max_type, repeat.max_value));
-                    }
-                    const repeat = TrackSizingFunction.AutoRepeat(gridTrackRepetition, tracks);
-                    array.addObject(repeat);
+        const nodeOrView = getMasonInstance(instance);
+        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridTemplateRows(nodeOrView, array);
+    }
+    if (__APPLE__) {
+        const length = value.length;
+        const array = NSMutableArray.arrayWithCapacity(length);
+        for (let i = 0; i < length; i++) {
+            const item = value[i];
+            if (item.is_repeating) {
+                const repeating = item.value;
+                const repeatingLength = repeating.length;
+                const tracks = NSMutableArray.arrayWithCapacity(repeatingLength);
+                let gridTrackRepetition = null;
+                switch (item.repeating_type) {
+                    case 0 /* TSCGridTrackRepetition.AutoFill */:
+                        gridTrackRepetition = 0 /* TSCGridTrackRepetition.AutoFill */;
+                        break;
+                    case 1 /* TSCGridTrackRepetition.AutoFit */:
+                        gridTrackRepetition = 1 /* TSCGridTrackRepetition.AutoFit */;
+                        break;
+                    case 2 /* TSCGridTrackRepetition.Count */:
+                        gridTrackRepetition = GridTrackRepetition.Count(item.repeating_count);
+                        break;
                 }
-                else {
-                    const single = item.value;
-                    const trackSizingFunction = TrackSizingFunction.Single(MinMax.fromTypeValue(single.min_type, single.min_value, single.max_type, single.max_value));
-                    array.addObject(trackSizingFunction);
+                if (gridTrackRepetition === null) {
+                    continue;
                 }
+                for (let j = 0; j < repeatingLength; j++) {
+                    const repeat = repeating[j];
+                    tracks.addObject(MinMax.fromTypeValue(repeat.min_type, repeat.min_value, repeat.max_type, repeat.max_value));
+                }
+                const repeat = TrackSizingFunction.AutoRepeat(gridTrackRepetition, tracks);
+                array.addObject(repeat);
+            }
+            else {
+                const single = item.value;
+                const trackSizingFunction = TrackSizingFunction.Single(MinMax.fromTypeValue(single.min_type, single.min_value, single.max_type, single.max_value));
+                array.addObject(trackSizingFunction);
             }
-            instance.ios.gridTemplateRows = array;
         }
+        instance.ios.gridTemplateRows = array;
     }
 }
 export function _setGridTemplateColumns(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
-    if (UseV8Module) {
-        MasonV8Module.setGridTemplateColumns(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, value, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const array = Array.create('org.nativescript.mason.masonkit.TrackSizingFunction', value.length);
-            const length = value.length;
-            for (let i = 0; i < length; i++) {
-                const item = value[i];
-                if (item.is_repeating) {
-                    const repeating = item.value;
-                    const tracks = Array.create('org.nativescript.mason.masonkit.MinMax', repeating.length);
-                    let gridTrackRepetition = null;
-                    switch (item.repeating_type) {
-                        case 0 /* TSCGridTrackRepetition.AutoFill */:
-                            gridTrackRepetition = org.nativescript.mason.masonkit.GridTrackRepetition.AutoFill.INSTANCE;
-                            break;
-                        case 1 /* TSCGridTrackRepetition.AutoFit */:
-                            gridTrackRepetition = org.nativescript.mason.masonkit.GridTrackRepetition.AutoFit.INSTANCE;
-                            break;
-                        case 2 /* TSCGridTrackRepetition.Count */:
-                            gridTrackRepetition = new org.nativescript.mason.masonkit.GridTrackRepetition.Count(item.repeating_count);
-                            break;
-                    }
-                    if (gridTrackRepetition === null) {
-                        continue;
-                    }
-                    const repeatingLength = repeating.length;
-                    for (let j = 0; j < repeatingLength; j++) {
-                        const repeat = repeating[j];
-                        tracks[j] = org.nativescript.mason.masonkit.MinMax.fromTypeValue(repeat.min_type, repeat.min_value, repeat.max_type, repeat.max_value);
-                    }
-                    const repeat = new org.nativescript.mason.masonkit.TrackSizingFunction.AutoRepeat(gridTrackRepetition, tracks);
-                    array[i] = repeat;
+    if (__ANDROID__) {
+        const array = Array.create('org.nativescript.mason.masonkit.TrackSizingFunction', value.length);
+        const length = value.length;
+        for (let i = 0; i < length; i++) {
+            const item = value[i];
+            if (item.is_repeating) {
+                const repeating = item.value;
+                const tracks = Array.create('org.nativescript.mason.masonkit.MinMax', repeating.length);
+                let gridTrackRepetition = null;
+                switch (item.repeating_type) {
+                    case 0 /* TSCGridTrackRepetition.AutoFill */:
+                        gridTrackRepetition = org.nativescript.mason.masonkit.GridTrackRepetition.AutoFill.INSTANCE;
+                        break;
+                    case 1 /* TSCGridTrackRepetition.AutoFit */:
+                        gridTrackRepetition = org.nativescript.mason.masonkit.GridTrackRepetition.AutoFit.INSTANCE;
+                        break;
+                    case 2 /* TSCGridTrackRepetition.Count */:
+                        gridTrackRepetition = new org.nativescript.mason.masonkit.GridTrackRepetition.Count(item.repeating_count);
+                        break;
                 }
-                else {
-                    const single = item.value;
-                    const minMax = single ? org.nativescript.mason.masonkit.MinMax.fromTypeValue(single.min_type, single.min_value, single.max_type, single.max_value) : org.nativescript.mason.masonkit.MinMax.Auto.INSTANCE;
-                    const trackSizingFunction = new org.nativescript.mason.masonkit.TrackSizingFunction.Single(minMax);
-                    array[i] = trackSizingFunction;
+                if (gridTrackRepetition === null) {
+                    continue;
                 }
-            }
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridTemplateColumns(nodeOrView, array);
+                const repeatingLength = repeating.length;
+                for (let j = 0; j < repeatingLength; j++) {
+                    const repeat = repeating[j];
+                    tracks[j] = org.nativescript.mason.masonkit.MinMax.fromTypeValue(repeat.min_type, repeat.min_value, repeat.max_type, repeat.max_value);
+                }
+                const repeat = new org.nativescript.mason.masonkit.TrackSizingFunction.AutoRepeat(gridTrackRepetition, tracks);
+                array[i] = repeat;
             }
             else {
-                nodeOrView.setGridTemplateColumns(array);
+                const single = item.value;
+                const minMax = single ? org.nativescript.mason.masonkit.MinMax.fromTypeValue(single.min_type, single.min_value, single.max_type, single.max_value) : org.nativescript.mason.masonkit.MinMax.Auto.INSTANCE;
+                const trackSizingFunction = new org.nativescript.mason.masonkit.TrackSizingFunction.Single(minMax);
+                array[i] = trackSizingFunction;
             }
         }
-        if (global.isIOS) {
-            const length = value.length;
-            const array = NSMutableArray.arrayWithCapacity(length);
-            for (let i = 0; i < length; i++) {
-                const item = value[i];
-                if (item.is_repeating) {
-                    const repeating = item.value;
-                    const repeatingLength = repeating.length;
-                    const tracks = NSMutableArray.arrayWithCapacity(repeatingLength);
-                    let gridTrackRepetition = null;
-                    switch (item.repeating_type) {
-                        case 0 /* TSCGridTrackRepetition.AutoFill */:
-                            gridTrackRepetition = 0 /* TSCGridTrackRepetition.AutoFill */;
-                            break;
-                        case 1 /* TSCGridTrackRepetition.AutoFit */:
-                            gridTrackRepetition = 1 /* TSCGridTrackRepetition.AutoFit */;
-                            break;
-                        case 2 /* TSCGridTrackRepetition.Count */:
-                            gridTrackRepetition = GridTrackRepetition.Count(item.repeating_count);
-                            break;
-                    }
-                    if (gridTrackRepetition === null) {
-                        continue;
-                    }
-                    for (let j = 0; j < repeatingLength; j++) {
-                        const repeat = repeating[j];
-                        tracks.addObject(MinMax.fromTypeValue(repeat.min_type, repeat.min_value, repeat.max_type, repeat.max_value));
-                    }
-                    const repeat = TrackSizingFunction.AutoRepeat(gridTrackRepetition, tracks);
-                    array.addObject(repeat);
+        const nodeOrView = getMasonInstance(instance);
+        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridTemplateColumns(nodeOrView, array);
+    }
+    if (__APPLE__) {
+        const length = value.length;
+        const array = NSMutableArray.new();
+        for (let i = 0; i < length; i++) {
+            const item = value[i];
+            if (item.is_repeating) {
+                const repeating = item.value;
+                const repeatingLength = repeating.length;
+                const tracks = NSMutableArray.arrayWithCapacity(repeatingLength);
+                let gridTrackRepetition = null;
+                switch (item.repeating_type) {
+                    case 0 /* TSCGridTrackRepetition.AutoFill */:
+                        gridTrackRepetition = 0 /* TSCGridTrackRepetition.AutoFill */;
+                        break;
+                    case 1 /* TSCGridTrackRepetition.AutoFit */:
+                        gridTrackRepetition = 1 /* TSCGridTrackRepetition.AutoFit */;
+                        break;
+                    case 2 /* TSCGridTrackRepetition.Count */:
+                        gridTrackRepetition = GridTrackRepetition.Count(item.repeating_count);
+                        break;
                 }
-                else {
-                    const single = item.value;
-                    const trackSizingFunction = TrackSizingFunction.Single(MinMax.fromTypeValue(single.min_type, single.min_value, single.max_type, single.max_value));
-                    array.addObject(trackSizingFunction);
+                if (gridTrackRepetition === null) {
+                    continue;
                 }
+                for (let j = 0; j < repeatingLength; j++) {
+                    const repeat = repeating[j];
+                    tracks.addObject(MinMax.fromTypeValue(repeat.min_type, repeat.min_value, repeat.max_type, repeat.max_value));
+                }
+                const repeat = TrackSizingFunction.AutoRepeat(gridTrackRepetition, tracks);
+                array.addObject(repeat);
+            }
+            else {
+                const single = item.value;
+                const trackSizingFunction = TrackSizingFunction.Single(MinMax.fromTypeValue(single.min_type, single.min_value, single.max_type, single.max_value));
+                array.addObject(trackSizingFunction);
             }
-            instance.ios.gridTemplateColumns = array;
         }
+        instance.ios.gridTemplateColumns = array;
+        console.log('gridTemplateColumns', instance.ios.gridTemplateColumns);
+        console.log('gridTemplateColumns', instance.ios.gridTemplateColumns.count);
+        console.log(instance.ios.style);
     }
 }
 export function _parseGridAutoRowsColumns(value) {
@@ -3690,142 +1249,43 @@ export function _parseGridAutoRowsColumns(value) {
     }
     return array;
 }
-function toGridAutoFlow(value) {
-    if (isIOS || UseV8Module) {
-        switch (value) {
-            case 'row':
-                return 0 /* FlexGridAutoFlowWrap.Row */;
-            case 'column':
-                return 1 /* FlexGridAutoFlowWrap.Column */;
-            case 'row dense':
-                return 2 /* FlexGridAutoFlowWrap.RowDense */;
-            case 'column dense':
-                return 3 /* FlexGridAutoFlowWrap.ColumnDense */;
-            default:
-                return 0 /* FlexGridAutoFlowWrap.Row */;
-        }
-    }
-    switch (value) {
-        case 'row':
-            return org.nativescript.mason.masonkit.GridAutoFlow.Row;
-        case 'column':
-            return org.nativescript.mason.masonkit.GridAutoFlow.Column;
-        case 'row dense':
-            return org.nativescript.mason.masonkit.GridAutoFlow.RowDense;
-        case 'column dense':
-            return org.nativescript.mason.masonkit.GridAutoFlow.ColumnDense;
-        default:
-            return org.nativescript.mason.masonkit.GridAutoFlow.Row;
-    }
-}
 export function _setGridAutoFlow(value, instance) {
     if (!instance._hasNativeView) {
         return;
     }
-    const nativeValue = toGridAutoFlow(value);
-    if (UseV8Module) {
-        MasonV8Module.setGridAutoFlow(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, nativeValue, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridAutoFlow(nodeOrView, nativeValue);
-            }
-            else {
-                nodeOrView.setGridAutoFlow(nativeValue);
-            }
-        }
-        if (isIOS) {
-            instance.ios.gridAutoFlow = nativeValue;
-        }
-    }
-}
-function parseGridAutoFlow(value) {
-    if (isIOS || UseV8Module) {
-        switch (value) {
-            case 0 /* FlexGridAutoFlowWrap.Row */:
-                return 'row';
-            case 1 /* FlexGridAutoFlowWrap.Column */:
-                return 'column';
-            case 2 /* FlexGridAutoFlowWrap.RowDense */:
-                return 'row dense';
-            case 3 /* FlexGridAutoFlowWrap.ColumnDense */:
-                return 'column dense';
-            default:
-                return 'row';
-        }
-    }
-    switch (value) {
-        case org.nativescript.mason.masonkit.GridAutoFlow.Row:
-            return 'row';
-        case org.nativescript.mason.masonkit.GridAutoFlow.Column:
-            return 'column';
-        case org.nativescript.mason.masonkit.GridAutoFlow.RowDense:
-            return 'row dense';
-        case org.nativescript.mason.masonkit.GridAutoFlow.ColumnDense:
-            return 'column dense';
-        default:
-            return 'row';
-    }
+    instance.ios.gridAutoFlow = value;
 }
 export function _getGridAutoFlow(instance) {
     if (!instance._hasNativeView) {
         return;
     }
-    if (UseV8Module) {
-        return parseGridAutoFlow(MasonV8Module.getGridAutoFlow(instance._masonStylePtr));
-    }
-    else {
-        if (global.isAndroid) {
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                return parseGridAutoFlow(org.nativescript.mason.masonkit.NodeHelper.INSTANCE.getGridAutoFlow(nodeOrView));
-            }
-            else {
-                return parseGridAutoFlow(nodeOrView.getGridAutoFlow());
-            }
-        }
-        if (isIOS) {
-            return parseGridAutoFlow(instance.ios.gridAutoFlow);
-        }
-    }
+    return this._styleHelper.gridAutoFlow;
 }
 export function _setGridAutoRows(value, instance, initial = false) {
     if (!instance._hasNativeView) {
         return;
     }
     const values = _parseGridAutoRowsColumns(value);
-    if (UseV8Module) {
-        MasonV8Module.setGridAutoRows(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, values, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const array = Array.create('org.nativescript.mason.masonkit.MinMax', values.length);
-            const length = value.length;
-            for (let i = 0; i < length; i++) {
-                const item = value[i];
-                const minMax = org.nativescript.mason.masonkit.MinMax.fromTypeValue(item.min_type, item.min_value, item.max_type, item.max_value);
-                array[i] = minMax;
-            }
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridAutoRows(nodeOrView, array);
-            }
-            else {
-                nodeOrView.setGridAutoRows(array);
-            }
+    if (__ANDROID__) {
+        const array = Array.create('org.nativescript.mason.masonkit.MinMax', values.length);
+        const length = value.length;
+        for (let i = 0; i < length; i++) {
+            const item = value[i];
+            const minMax = org.nativescript.mason.masonkit.MinMax.fromTypeValue(item.min_type, item.min_value, item.max_type, item.max_value);
+            array[i] = minMax;
         }
-        if (global.isIOS) {
-            const length = value.length;
-            const array = NSMutableArray.arrayWithCapacity(length);
-            for (let i = 0; i < length; i++) {
-                const item = value[i];
-                const minMax = MinMax.fromTypeValue(item.min_type, item.min_value, item.max_type, item.max_value);
-                array.addObject(minMax);
-            }
-            instance.ios.gridAutoRows = array;
+        const nodeOrView = getMasonInstance(instance);
+        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridAutoRows(nodeOrView, array);
+    }
+    if (__APPLE__) {
+        const length = value.length;
+        const array = NSMutableArray.arrayWithCapacity(length);
+        for (let i = 0; i < length; i++) {
+            const item = value[i];
+            const minMax = MinMax.fromTypeValue(item.min_type, item.min_value, item.max_type, item.max_value);
+            array.addObject(minMax);
         }
+        instance.ios.gridAutoRows = array;
     }
 }
 export function _setGridAutoColumns(value, instance, initial = false) {
@@ -3833,36 +1293,26 @@ export function _setGridAutoColumns(value, instance, initial = false) {
         return;
     }
     const values = _parseGridAutoRowsColumns(value);
-    if (UseV8Module) {
-        MasonV8Module.setGridAutoColumns(instance._masonPtr, instance._masonNodePtr, instance._masonStylePtr, values, !instance._inBatch);
-    }
-    else {
-        if (global.isAndroid) {
-            const array = Array.create('org.nativescript.mason.masonkit.MinMax', values.length);
-            const length = value.length;
-            for (let i = 0; i < length; i++) {
-                const item = value[i];
-                const minMax = org.nativescript.mason.masonkit.MinMax.fromTypeValue(item.min_type, item.min_value, item.max_type, item.max_value);
-                array[i] = minMax;
-            }
-            const nodeOrView = getMasonInstance(instance);
-            if (instance._isMasonChild) {
-                org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridAutoColumns(nodeOrView, array);
-            }
-            else {
-                nodeOrView.setGridAutoColumns(array);
-            }
-        }
-        if (global.isIOS) {
-            const length = value.length;
-            const array = NSMutableArray.arrayWithCapacity(length);
-            for (let i = 0; i < length; i++) {
-                const item = value[i];
-                const minMax = MinMax.fromTypeValue(item.min_type, item.min_value, item.max_type, item.max_value);
-                array.addObject(minMax);
-            }
-            instance.ios.gridAutoColumns = array;
-        }
+    if (__ANDROID__) {
+        const array = Array.create('org.nativescript.mason.masonkit.MinMax', values.length);
+        const length = value.length;
+        for (let i = 0; i < length; i++) {
+            const item = value[i];
+            const minMax = org.nativescript.mason.masonkit.MinMax.fromTypeValue(item.min_type, item.min_value, item.max_type, item.max_value);
+            array[i] = minMax;
+        }
+        const nodeOrView = getMasonInstance(instance);
+        org.nativescript.mason.masonkit.NodeHelper.INSTANCE.setGridAutoColumns(nodeOrView, array);
+    }
+    if (__APPLE__) {
+        const length = value.length;
+        const array = NSMutableArray.arrayWithCapacity(length);
+        for (let i = 0; i < length; i++) {
+            const item = value[i];
+            const minMax = MinMax.fromTypeValue(item.min_type, item.min_value, item.max_type, item.max_value);
+            array.addObject(minMax);
+        }
+        instance.ios.gridAutoColumns = array;
     }
 }
 //# sourceMappingURL=helpers.js.map