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

package/ui/layouts/flexbox-layout/index.ios.js

@@ -8,7 +8,7 @@ var UNSPECIFIED = layout.UNSPECIFIED;
 var MEASURED_SIZE_MASK = layout.MEASURED_SIZE_MASK;
 var MEASURED_STATE_TOO_SMALL = layout.MEASURED_STATE_TOO_SMALL;
 function requestFlexboxLayout(value) {
-    var flexbox = this.parent;
+    const flexbox = this.parent;
     if (flexbox instanceof FlexboxLayoutBase) {
         flexbox.requestLayout();
     }
@@ -18,40 +18,34 @@ View.prototype[flexGrowProperty.setNative] = requestFlexboxLayout;
 View.prototype[flexShrinkProperty.setNative] = requestFlexboxLayout;
 View.prototype[flexWrapBeforeProperty.setNative] = requestFlexboxLayout;
 View.prototype[alignSelfProperty.setNative] = requestFlexboxLayout;
-var MATCH_PARENT = -1;
-var WRAP_CONTENT = -2;
-var View_sUseZeroUnspecifiedMeasureSpec = true; // NOTE: android version < M
+const MATCH_PARENT = -1;
+const WRAP_CONTENT = -2;
+const View_sUseZeroUnspecifiedMeasureSpec = true; // NOTE: android version < M
 // Long ints may not be safe in JavaScript
-var MAX_SIZE = 0x00ffffff & MEASURED_SIZE_MASK;
+const MAX_SIZE = 0x00ffffff & MEASURED_SIZE_MASK;
 var makeMeasureSpec = layout.makeMeasureSpec;
 var getMeasureSpecMode = layout.getMeasureSpecMode;
 var getMeasureSpecSize = layout.getMeasureSpecSize;
 // `eachLayoutChild` iterates over children, and we need more - indexed access.
 // This class tries to accomodate that by collecting all children in an
 // array no more than once per measure.
-var MeasureContext = /** @class */ (function () {
-    function MeasureContext(owner) {
-        var _this = this;
+class MeasureContext {
+    constructor(owner) {
         this.owner = owner;
         this.children = [];
-        this.owner.eachLayoutChild(function (child) {
-            _this.children.push(child);
+        this.owner.eachLayoutChild((child) => {
+            this.children.push(child);
         });
     }
-    Object.defineProperty(MeasureContext.prototype, "childrenCount", {
-        get: function () {
-            return this.children.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    MeasureContext.prototype.childAt = function (index) {
+    get childrenCount() {
+        return this.children.length;
+    }
+    childAt(index) {
         return this.children[index];
-    };
-    return MeasureContext;
-}());
-var FlexLine = /** @class */ (function () {
-    function FlexLine() {
+    }
+}
+class FlexLine {
+    constructor() {
         this._left = Number.MAX_VALUE;
         this._top = Number.MAX_VALUE;
         this._right = Number.MAX_VALUE;
@@ -65,91 +59,49 @@ var FlexLine = /** @class */ (function () {
         this._maxBaseline = 0;
         this._indicesAlignSelfStretch = [];
     }
-    Object.defineProperty(FlexLine.prototype, "left", {
-        get: function () {
-            return this._left;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FlexLine.prototype, "top", {
-        get: function () {
-            return this._top;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FlexLine.prototype, "right", {
-        get: function () {
-            return this._right;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FlexLine.prototype, "bottom", {
-        get: function () {
-            return this._bottom;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FlexLine.prototype, "mainSize", {
-        get: function () {
-            return this._mainSize;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FlexLine.prototype, "crossSize", {
-        get: function () {
-            return this._crossSize;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FlexLine.prototype, "itemCount", {
-        get: function () {
-            return this._itemCount;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FlexLine.prototype, "totalFlexGrow", {
-        get: function () {
-            return this._totalFlexGrow;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FlexLine.prototype, "totalFlexShrink", {
-        get: function () {
-            return this._totalFlexShrink;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return FlexLine;
-}());
-var Order = /** @class */ (function () {
-    function Order() {
+    get left() {
+        return this._left;
+    }
+    get top() {
+        return this._top;
+    }
+    get right() {
+        return this._right;
+    }
+    get bottom() {
+        return this._bottom;
+    }
+    get mainSize() {
+        return this._mainSize;
+    }
+    get crossSize() {
+        return this._crossSize;
     }
-    Order.prototype.compareTo = function (another) {
+    get itemCount() {
+        return this._itemCount;
+    }
+    get totalFlexGrow() {
+        return this._totalFlexGrow;
+    }
+    get totalFlexShrink() {
+        return this._totalFlexShrink;
+    }
+}
+class Order {
+    compareTo(another) {
         if (this.order !== another.order) {
             return this.order - another.order;
         }
         return this.index - another.index;
-    };
-    return Order;
-}());
-var FlexboxLayout = /** @class */ (function (_super) {
-    __extends(FlexboxLayout, _super);
-    function FlexboxLayout() {
+    }
+}
+export class FlexboxLayout extends FlexboxLayoutBase {
+    constructor() {
         // Omit divider
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._flexLines = [];
-        return _this;
+        super(...arguments);
+        this._flexLines = [];
     }
-    FlexboxLayout.prototype.onMeasure = function (widthMeasureSpec, heightMeasureSpec) {
+    onMeasure(widthMeasureSpec, heightMeasureSpec) {
         this.measureContext = new MeasureContext(this);
         // Omit: super.onMeasure(widthMeasureSpec, heightMeasureSpec);
         if (this._isOrderChangedFromLastMeasurement) {
@@ -171,116 +123,110 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 throw new Error('Invalid value for the flex direction is set: ' + this.flexDirection);
         }
         this._childrenFrozen.length = 0;
-    };
-    FlexboxLayout.prototype._getReorderedChildAt = function (index) {
-        var child;
+    }
+    _getReorderedChildAt(index) {
+        let child;
         if (index < 0 || index >= this._reorderedIndices.length) {
             child = null;
         }
         else {
-            var reorderedIndex = this._reorderedIndices[index];
+            const reorderedIndex = this._reorderedIndices[index];
             child = this.measureContext.childAt(reorderedIndex);
         }
         return child;
-    };
-    FlexboxLayout.prototype._createReorderedIndices = function () {
-        var childCount = this.measureContext.childrenCount;
-        var orders = this._createOrders(childCount);
+    }
+    _createReorderedIndices() {
+        const childCount = this.measureContext.childrenCount;
+        const orders = this._createOrders(childCount);
         return this._sortOrdersIntoReorderedIndices(childCount, orders);
-    };
-    FlexboxLayout.prototype._sortOrdersIntoReorderedIndices = function (childCount, orders) {
-        var _this = this;
-        orders.sort(function (a, b) { return a.compareTo(b); });
+    }
+    _sortOrdersIntoReorderedIndices(childCount, orders) {
+        orders.sort((a, b) => a.compareTo(b));
         if (!this._orderCache) {
             this._orderCache = [];
         }
         this._orderCache.length = 0;
-        var reorderedIndices = [];
-        orders.forEach(function (order, i) {
+        const reorderedIndices = [];
+        orders.forEach((order, i) => {
             reorderedIndices[i] = order.index;
-            _this._orderCache[i] = order.order;
+            this._orderCache[i] = order.order;
         });
         return reorderedIndices;
-    };
-    FlexboxLayout.prototype._createOrders = function (childCount) {
-        var orders = [];
-        for (var i = 0; i < childCount; i++) {
-            var child = this.measureContext.childAt(i);
-            var order = new Order();
+    }
+    _createOrders(childCount) {
+        const orders = [];
+        for (let i = 0; i < childCount; i++) {
+            const child = this.measureContext.childAt(i);
+            const order = new Order();
             order.order = FlexboxLayout.getOrder(child);
             order.index = i;
             orders.push(order);
         }
         return orders;
-    };
-    Object.defineProperty(FlexboxLayout.prototype, "_isOrderChangedFromLastMeasurement", {
-        get: function () {
-            var childCount = this.measureContext.childrenCount;
-            if (!this._orderCache) {
-                this._orderCache = [];
+    }
+    get _isOrderChangedFromLastMeasurement() {
+        const childCount = this.measureContext.childrenCount;
+        if (!this._orderCache) {
+            this._orderCache = [];
+        }
+        if (this._orderCache.length !== childCount) {
+            return true;
+        }
+        for (let i = 0; i < childCount; i++) {
+            const view = this.measureContext.childAt(i);
+            if (view === null) {
+                continue;
             }
-            if (this._orderCache.length !== childCount) {
+            if (FlexboxLayout.getOrder(view) !== this._orderCache[i]) {
                 return true;
             }
-            for (var i = 0; i < childCount; i++) {
-                var view = this.measureContext.childAt(i);
-                if (view === null) {
-                    continue;
-                }
-                if (FlexboxLayout.getOrder(view) !== this._orderCache[i]) {
-                    return true;
-                }
-            }
-            return false;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    FlexboxLayout.prototype._measureHorizontal = function (widthMeasureSpec, heightMeasureSpec) {
-        var _this = this;
-        var widthSize = getMeasureSpecSize(widthMeasureSpec);
-        var widthMode = getMeasureSpecMode(widthMeasureSpec);
-        var heightSize = getMeasureSpecSize(heightMeasureSpec);
-        var heightMode = getMeasureSpecMode(heightMeasureSpec);
-        var childState = 0;
+        }
+        return false;
+    }
+    _measureHorizontal(widthMeasureSpec, heightMeasureSpec) {
+        const widthSize = getMeasureSpecSize(widthMeasureSpec);
+        const widthMode = getMeasureSpecMode(widthMeasureSpec);
+        const heightSize = getMeasureSpecSize(heightMeasureSpec);
+        const heightMode = getMeasureSpecMode(heightMeasureSpec);
+        let childState = 0;
         this._flexLines.length = 0;
-        (function () {
-            var childCount = _this.measureContext.childrenCount;
-            var paddingStart = FlexboxLayout.getPaddingStart(_this);
-            var paddingEnd = FlexboxLayout.getPaddingEnd(_this);
-            var largestHeightInRow = Number.MIN_VALUE;
-            var flexLine = new FlexLine();
-            var indexInFlexLine = 0;
+        (() => {
+            const childCount = this.measureContext.childrenCount;
+            const paddingStart = FlexboxLayout.getPaddingStart(this);
+            const paddingEnd = FlexboxLayout.getPaddingEnd(this);
+            let largestHeightInRow = Number.MIN_VALUE;
+            let flexLine = new FlexLine();
+            let indexInFlexLine = 0;
             flexLine._mainSize = paddingStart + paddingEnd;
-            for (var i = 0; i < childCount; i++) {
-                var child = _this._getReorderedChildAt(i);
+            for (let i = 0; i < childCount; i++) {
+                const child = this._getReorderedChildAt(i);
                 if (child === null) {
-                    _this._addFlexLineIfLastFlexItem(i, childCount, flexLine);
+                    this._addFlexLineIfLastFlexItem(i, childCount, flexLine);
                     continue;
                 }
                 else if (child.isCollapsed) {
                     flexLine._itemCount++;
-                    _this._addFlexLineIfLastFlexItem(i, childCount, flexLine);
+                    this._addFlexLineIfLastFlexItem(i, childCount, flexLine);
                     continue;
                 }
                 child._updateEffectiveLayoutValues(widthSize, widthMode, heightSize, heightMode);
-                var lp = child; // child.style;
+                const lp = child; // child.style;
                 if (FlexboxLayout.getAlignSelf(child) === 'stretch') {
                     flexLine._indicesAlignSelfStretch.push(i);
                 }
-                var childWidth = lp.effectiveWidth;
+                let childWidth = lp.effectiveWidth;
                 if (FlexBasisPercent.DEFAULT /*lp.flexBasisPercent*/ !== FlexBasisPercent.DEFAULT && widthMode === EXACTLY) {
                     childWidth = Math.round(widthSize * FlexBasisPercent.DEFAULT /*lp.flexBasisPercent*/);
                 }
-                var childWidthMeasureSpec = FlexboxLayout.getChildMeasureSpec(widthMeasureSpec, lp.effectivePaddingLeft + lp.effectivePaddingRight + lp.effectiveMarginLeft + lp.effectiveMarginRight, childWidth < 0 ? WRAP_CONTENT : childWidth);
-                var childHeightMeasureSpec = FlexboxLayout.getChildMeasureSpec(heightMeasureSpec, lp.effectivePaddingTop + lp.effectivePaddingBottom + lp.effectiveMarginTop + lp.effectiveMarginBottom, lp.effectiveHeight < 0 ? WRAP_CONTENT : lp.effectiveHeight);
+                const childWidthMeasureSpec = FlexboxLayout.getChildMeasureSpec(widthMeasureSpec, lp.effectivePaddingLeft + lp.effectivePaddingRight + lp.effectiveMarginLeft + lp.effectiveMarginRight, childWidth < 0 ? WRAP_CONTENT : childWidth);
+                const childHeightMeasureSpec = FlexboxLayout.getChildMeasureSpec(heightMeasureSpec, lp.effectivePaddingTop + lp.effectivePaddingBottom + lp.effectiveMarginTop + lp.effectiveMarginBottom, lp.effectiveHeight < 0 ? WRAP_CONTENT : lp.effectiveHeight);
                 child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
-                _this._checkSizeConstraints(child);
+                this._checkSizeConstraints(child);
                 childState = View.combineMeasuredStates(childState, child.getMeasuredState());
                 largestHeightInRow = Math.max(largestHeightInRow, child.getMeasuredHeight() + lp.effectiveMarginTop + lp.effectiveMarginBottom);
-                if (_this._isWrapRequired(child, widthMode, widthSize, flexLine._mainSize, child.getMeasuredWidth() + lp.effectiveMarginLeft + lp.effectiveMarginRight, i, indexInFlexLine)) {
+                if (this._isWrapRequired(child, widthMode, widthSize, flexLine._mainSize, child.getMeasuredWidth() + lp.effectiveMarginLeft + lp.effectiveMarginRight, i, indexInFlexLine)) {
                     if (flexLine.itemCount > 0) {
-                        _this._addFlexLine(flexLine);
+                        this._addFlexLine(flexLine);
                     }
                     flexLine = new FlexLine();
                     flexLine._itemCount = 1;
@@ -297,58 +243,58 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 flexLine._totalFlexShrink += FlexboxLayout.getFlexShrink(child);
                 flexLine._crossSize = Math.max(flexLine._crossSize, largestHeightInRow);
                 // Omit divider
-                if (_this.flexWrap !== FlexWrap.WRAP_REVERSE) {
+                if (this.flexWrap !== FlexWrap.WRAP_REVERSE) {
                     flexLine._maxBaseline = Math.max(flexLine._maxBaseline, FlexboxLayout.getBaseline(child) + lp.effectiveMarginTop);
                 }
                 else {
                     flexLine._maxBaseline = Math.max(flexLine._maxBaseline, child.getMeasuredHeight() - FlexboxLayout.getBaseline(child) + lp.effectiveMarginBottom);
                 }
-                _this._addFlexLineIfLastFlexItem(i, childCount, flexLine);
+                this._addFlexLineIfLastFlexItem(i, childCount, flexLine);
             }
         })();
         this._determineMainSize(this.flexDirection, widthMeasureSpec, heightMeasureSpec);
         if (this.alignItems === AlignItems.BASELINE) {
-            var viewIndex_1 = 0;
-            this._flexLines.forEach(function (flexLine) {
-                var largestHeightInLine = Number.MIN_VALUE;
-                for (var i = viewIndex_1; i < viewIndex_1 + flexLine._itemCount; i++) {
-                    var child = _this._getReorderedChildAt(i);
-                    var lp = child; // .style;
-                    if (_this.flexWrap !== FlexWrap.WRAP_REVERSE) {
-                        var marginTop = flexLine._maxBaseline - FlexboxLayout.getBaseline(child);
+            let viewIndex = 0;
+            this._flexLines.forEach((flexLine) => {
+                let largestHeightInLine = Number.MIN_VALUE;
+                for (let i = viewIndex; i < viewIndex + flexLine._itemCount; i++) {
+                    const child = this._getReorderedChildAt(i);
+                    const lp = child; // .style;
+                    if (this.flexWrap !== FlexWrap.WRAP_REVERSE) {
+                        let marginTop = flexLine._maxBaseline - FlexboxLayout.getBaseline(child);
                         marginTop = Math.max(marginTop, lp.effectiveMarginTop);
                         largestHeightInLine = Math.max(largestHeightInLine, child.getActualSize().height + marginTop + lp.effectiveMarginBottom);
                     }
                     else {
-                        var marginBottom = flexLine._maxBaseline - child.getMeasuredHeight() + FlexboxLayout.getBaseline(child);
+                        let marginBottom = flexLine._maxBaseline - child.getMeasuredHeight() + FlexboxLayout.getBaseline(child);
                         marginBottom = Math.max(marginBottom, lp.effectiveMarginBottom);
                         largestHeightInLine = Math.max(largestHeightInLine, child.getActualSize().height + lp.effectiveMarginTop + marginBottom);
                     }
                 }
                 flexLine._crossSize = largestHeightInLine;
-                viewIndex_1 += flexLine.itemCount;
+                viewIndex += flexLine.itemCount;
             });
         }
         this._determineCrossSize(this.flexDirection, widthMeasureSpec, heightMeasureSpec, this.effectivePaddingTop + this.effectivePaddingBottom);
         this._stretchViews(this.flexDirection, this.alignItems);
         this._setMeasuredDimensionForFlex(this.flexDirection, widthMeasureSpec, heightMeasureSpec, childState);
-    };
-    FlexboxLayout.prototype._measureVertical = function (widthMeasureSpec, heightMeasureSpec) {
-        var widthSize = getMeasureSpecSize(widthMeasureSpec);
-        var widthMode = getMeasureSpecMode(widthMeasureSpec);
-        var heightSize = getMeasureSpecSize(heightMeasureSpec);
-        var heightMode = getMeasureSpecMode(heightMeasureSpec);
-        var childState = 0;
+    }
+    _measureVertical(widthMeasureSpec, heightMeasureSpec) {
+        const widthSize = getMeasureSpecSize(widthMeasureSpec);
+        const widthMode = getMeasureSpecMode(widthMeasureSpec);
+        const heightSize = getMeasureSpecSize(heightMeasureSpec);
+        const heightMode = getMeasureSpecMode(heightMeasureSpec);
+        let childState = 0;
         this._flexLines.length = 0;
-        var childCount = this.measureContext.childrenCount;
-        var paddingTop = this.effectivePaddingTop;
-        var paddingBottom = this.effectivePaddingBottom;
-        var largestWidthInColumn = Number.MIN_VALUE;
-        var flexLine = new FlexLine();
+        const childCount = this.measureContext.childrenCount;
+        const paddingTop = this.effectivePaddingTop;
+        const paddingBottom = this.effectivePaddingBottom;
+        let largestWidthInColumn = Number.MIN_VALUE;
+        let flexLine = new FlexLine();
         flexLine._mainSize = paddingTop + paddingBottom;
-        var indexInFlexLine = 0;
-        for (var i = 0; i < childCount; i++) {
-            var child = this._getReorderedChildAt(i);
+        let indexInFlexLine = 0;
+        for (let i = 0; i < childCount; i++) {
+            const child = this._getReorderedChildAt(i);
             if (child === null) {
                 this._addFlexLineIfLastFlexItem(i, childCount, flexLine);
                 continue;
@@ -359,17 +305,17 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 continue;
             }
             child._updateEffectiveLayoutValues(widthSize, widthMode, heightSize, heightMode);
-            var lp = child; // .style;
+            const lp = child; // .style;
             if (FlexboxLayout.getAlignSelf(child) === 'stretch') {
                 flexLine._indicesAlignSelfStretch.push(i);
             }
-            var childHeight = lp.effectiveHeight;
+            let childHeight = lp.effectiveHeight;
             // TODO: This should always be false
             if (FlexBasisPercent.DEFAULT /* lp.flexBasisPercent */ !== FlexBasisPercent.DEFAULT && heightMode === EXACTLY) {
                 childHeight = Math.round(heightSize * FlexBasisPercent.DEFAULT /* lp.flexBasisPercent */);
             }
-            var childWidthMeasureSpec = FlexboxLayout.getChildMeasureSpec(widthMeasureSpec, this.effectivePaddingLeft + this.effectivePaddingRight + lp.effectiveMarginLeft + lp.effectiveMarginRight, lp.effectiveWidth < 0 ? WRAP_CONTENT : lp.effectiveWidth);
-            var childHeightMeasureSpec = FlexboxLayout.getChildMeasureSpec(heightMeasureSpec, this.effectivePaddingTop + this.effectivePaddingBottom + lp.effectiveMarginTop + lp.effectiveMarginBottom, childHeight < 0 ? WRAP_CONTENT : childHeight);
+            const childWidthMeasureSpec = FlexboxLayout.getChildMeasureSpec(widthMeasureSpec, this.effectivePaddingLeft + this.effectivePaddingRight + lp.effectiveMarginLeft + lp.effectiveMarginRight, lp.effectiveWidth < 0 ? WRAP_CONTENT : lp.effectiveWidth);
+            const childHeightMeasureSpec = FlexboxLayout.getChildMeasureSpec(heightMeasureSpec, this.effectivePaddingTop + this.effectivePaddingBottom + lp.effectiveMarginTop + lp.effectiveMarginBottom, childHeight < 0 ? WRAP_CONTENT : childHeight);
             child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
             this._checkSizeConstraints(child);
             childState = View.combineMeasuredStates(childState, child.getMeasuredState());
@@ -399,12 +345,12 @@ var FlexboxLayout = /** @class */ (function (_super) {
         this._determineCrossSize(this.flexDirection, widthMeasureSpec, heightMeasureSpec, this.effectivePaddingLeft + this.effectivePaddingRight);
         this._stretchViews(this.flexDirection, this.alignItems);
         this._setMeasuredDimensionForFlex(this.flexDirection, widthMeasureSpec, heightMeasureSpec, childState);
-    };
-    FlexboxLayout.prototype._checkSizeConstraints = function (view) {
-        var needsMeasure = false;
-        var childWidth = view.getMeasuredWidth();
-        var childHeight = view.getMeasuredHeight();
-        var minWidth = view.effectiveMinWidth;
+    }
+    _checkSizeConstraints(view) {
+        let needsMeasure = false;
+        let childWidth = view.getMeasuredWidth();
+        let childHeight = view.getMeasuredHeight();
+        const minWidth = view.effectiveMinWidth;
         view.effectiveMinWidth = 0;
         if (view.getMeasuredWidth() < minWidth) {
             needsMeasure = true;
@@ -414,7 +360,7 @@ var FlexboxLayout = /** @class */ (function (_super) {
             needsMeasure = true;
             childWidth = MAX_SIZE /*lp.maxWidth*/;
         }
-        var minHeight = view.effectiveMinHeight;
+        const minHeight = view.effectiveMinHeight;
         view.effectiveMinHeight = 0;
         if (childHeight < minHeight) {
             needsMeasure = true;
@@ -429,25 +375,24 @@ var FlexboxLayout = /** @class */ (function (_super) {
         }
         view.effectiveMinWidth = minWidth;
         view.effectiveMinHeight = minHeight;
-    };
-    FlexboxLayout.prototype._addFlexLineIfLastFlexItem = function (childIndex, childCount, flexLine) {
+    }
+    _addFlexLineIfLastFlexItem(childIndex, childCount, flexLine) {
         if (childIndex === childCount - 1 && flexLine.itemCount !== 0) {
             this._addFlexLine(flexLine);
         }
-    };
-    FlexboxLayout.prototype._addFlexLine = function (flexLine) {
+    }
+    _addFlexLine(flexLine) {
         // Omit divider
         this._flexLines.push(flexLine);
-    };
-    FlexboxLayout.prototype._determineMainSize = function (flexDirection, widthMeasureSpec, heightMeasureSpec) {
-        var _this = this;
-        var mainSize;
-        var paddingAlongMainAxis;
+    }
+    _determineMainSize(flexDirection, widthMeasureSpec, heightMeasureSpec) {
+        let mainSize;
+        let paddingAlongMainAxis;
         switch (flexDirection) {
             case FlexDirection.ROW:
             case FlexDirection.ROW_REVERSE: {
-                var widthMode = getMeasureSpecMode(widthMeasureSpec);
-                var widthSize = getMeasureSpecSize(widthMeasureSpec);
+                const widthMode = getMeasureSpecMode(widthMeasureSpec);
+                const widthSize = getMeasureSpecSize(widthMeasureSpec);
                 if (widthMode === EXACTLY) {
                     mainSize = widthSize;
                 }
@@ -459,8 +404,8 @@ var FlexboxLayout = /** @class */ (function (_super) {
             }
             case FlexDirection.COLUMN:
             case FlexDirection.COLUMN_REVERSE: {
-                var heightMode = getMeasureSpecMode(heightMeasureSpec);
-                var heightSize = getMeasureSpecSize(heightMeasureSpec);
+                const heightMode = getMeasureSpecMode(heightMeasureSpec);
+                const heightSize = getMeasureSpecSize(heightMeasureSpec);
                 if (heightMode === EXACTLY) {
                     mainSize = heightSize;
                 }
@@ -473,30 +418,30 @@ var FlexboxLayout = /** @class */ (function (_super) {
             default:
                 throw new Error('Invalid flex direction: ' + flexDirection);
         }
-        var childIndex = 0;
-        this._flexLines.forEach(function (flexLine) {
+        let childIndex = 0;
+        this._flexLines.forEach((flexLine) => {
             if (flexLine.mainSize < mainSize) {
-                childIndex = _this._expandFlexItems(flexLine, flexDirection, mainSize, paddingAlongMainAxis, childIndex);
+                childIndex = this._expandFlexItems(flexLine, flexDirection, mainSize, paddingAlongMainAxis, childIndex);
             }
             else {
-                childIndex = _this._shrinkFlexItems(flexLine, flexDirection, mainSize, paddingAlongMainAxis, childIndex);
+                childIndex = this._shrinkFlexItems(flexLine, flexDirection, mainSize, paddingAlongMainAxis, childIndex);
             }
         });
-    };
-    FlexboxLayout.prototype._expandFlexItems = function (flexLine, flexDirection, maxMainSize, paddingAlongMainAxis, startIndex) {
-        var childIndex = startIndex;
+    }
+    _expandFlexItems(flexLine, flexDirection, maxMainSize, paddingAlongMainAxis, startIndex) {
+        let childIndex = startIndex;
         if (flexLine._totalFlexGrow <= 0 || maxMainSize < flexLine._mainSize) {
             childIndex += flexLine._itemCount;
             return childIndex;
         }
-        var sizeBeforeExpand = flexLine._mainSize;
-        var needsReexpand = false;
-        var pendingSpace = maxMainSize - flexLine._mainSize;
-        var unitSpace = pendingSpace / flexLine._totalFlexGrow;
+        const sizeBeforeExpand = flexLine._mainSize;
+        let needsReexpand = false;
+        const pendingSpace = maxMainSize - flexLine._mainSize;
+        const unitSpace = pendingSpace / flexLine._totalFlexGrow;
         flexLine._mainSize = paddingAlongMainAxis + flexLine._dividerLengthInMainSize;
-        var accumulatedRoundError = 0;
-        for (var i = 0; i < flexLine.itemCount; i++) {
-            var child = this._getReorderedChildAt(childIndex);
+        let accumulatedRoundError = 0;
+        for (let i = 0; i < flexLine.itemCount; i++) {
+            const child = this._getReorderedChildAt(childIndex);
             if (child === null) {
                 continue;
             }
@@ -504,12 +449,12 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 childIndex++;
                 continue;
             }
-            var lp = child; // .style;
+            const lp = child; // .style;
             if (this._isMainAxisDirectionHorizontal(flexDirection)) {
                 if (!this._childrenFrozen[childIndex]) {
-                    var flexGrow = FlexboxLayout.getFlexGrow(child);
-                    var rawCalculatedWidth = child.getMeasuredWidth() + unitSpace * flexGrow + accumulatedRoundError;
-                    var roundedCalculatedWidth = Math.round(rawCalculatedWidth);
+                    const flexGrow = FlexboxLayout.getFlexGrow(child);
+                    const rawCalculatedWidth = child.getMeasuredWidth() + unitSpace * flexGrow + accumulatedRoundError;
+                    let roundedCalculatedWidth = Math.round(rawCalculatedWidth);
                     // TODO: MAX_SIZE is so big, this is always false:
                     if (roundedCalculatedWidth > MAX_SIZE /* lp.maxWidth */) {
                         needsReexpand = true;
@@ -526,9 +471,9 @@ var FlexboxLayout = /** @class */ (function (_super) {
             }
             else {
                 if (!this._childrenFrozen[childIndex]) {
-                    var flexGrow = FlexboxLayout.getFlexGrow(child);
-                    var rawCalculatedHeight = child.getMeasuredHeight() + unitSpace * flexGrow + accumulatedRoundError;
-                    var roundedCalculatedHeight = Math.round(rawCalculatedHeight);
+                    const flexGrow = FlexboxLayout.getFlexGrow(child);
+                    const rawCalculatedHeight = child.getMeasuredHeight() + unitSpace * flexGrow + accumulatedRoundError;
+                    let roundedCalculatedHeight = Math.round(rawCalculatedHeight);
                     // TODO: MAX_SIZE is so big this is always false:
                     if (roundedCalculatedHeight > MAX_SIZE /*lp.maxHeight*/) {
                         needsReexpand = true;
@@ -549,20 +494,20 @@ var FlexboxLayout = /** @class */ (function (_super) {
             this._expandFlexItems(flexLine, flexDirection, maxMainSize, paddingAlongMainAxis, startIndex);
         }
         return childIndex;
-    };
-    FlexboxLayout.prototype._shrinkFlexItems = function (flexLine, flexDirection, maxMainSize, paddingAlongMainAxis, startIndex) {
-        var childIndex = startIndex;
-        var sizeBeforeShrink = flexLine._mainSize;
+    }
+    _shrinkFlexItems(flexLine, flexDirection, maxMainSize, paddingAlongMainAxis, startIndex) {
+        let childIndex = startIndex;
+        const sizeBeforeShrink = flexLine._mainSize;
         if (flexLine._totalFlexShrink <= 0 || maxMainSize > flexLine._mainSize) {
             childIndex += flexLine.itemCount;
             return childIndex;
         }
-        var needsReshrink = false;
-        var unitShrink = (flexLine._mainSize - maxMainSize) / flexLine._totalFlexShrink;
-        var accumulatedRoundError = 0;
+        let needsReshrink = false;
+        const unitShrink = (flexLine._mainSize - maxMainSize) / flexLine._totalFlexShrink;
+        let accumulatedRoundError = 0;
         flexLine._mainSize = paddingAlongMainAxis + flexLine._dividerLengthInMainSize;
-        for (var i = 0; i < flexLine.itemCount; i++) {
-            var child = this._getReorderedChildAt(childIndex);
+        for (let i = 0; i < flexLine.itemCount; i++) {
+            const child = this._getReorderedChildAt(childIndex);
             if (child === null) {
                 continue;
             }
@@ -570,14 +515,14 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 childIndex++;
                 continue;
             }
-            var lp = child; // .style;
+            const lp = child; // .style;
             if (this._isMainAxisDirectionHorizontal(flexDirection)) {
                 // The direction of main axis is horizontal
                 if (!this._childrenFrozen[childIndex]) {
-                    var flexShrink = FlexboxLayout.getFlexShrink(child);
-                    var rawCalculatedWidth = child.getMeasuredWidth() - unitShrink * flexShrink + accumulatedRoundError;
-                    var roundedCalculatedWidth = Math.round(rawCalculatedWidth);
-                    var minWidth = child.effectiveMinWidth;
+                    const flexShrink = FlexboxLayout.getFlexShrink(child);
+                    const rawCalculatedWidth = child.getMeasuredWidth() - unitShrink * flexShrink + accumulatedRoundError;
+                    let roundedCalculatedWidth = Math.round(rawCalculatedWidth);
+                    const minWidth = child.effectiveMinWidth;
                     child.effectiveMinWidth = 0;
                     if (roundedCalculatedWidth < minWidth) {
                         needsReshrink = true;
@@ -588,12 +533,12 @@ var FlexboxLayout = /** @class */ (function (_super) {
                     else {
                         accumulatedRoundError = rawCalculatedWidth - roundedCalculatedWidth;
                     }
-                    var childWidthMeasureSpec = makeMeasureSpec(roundedCalculatedWidth, EXACTLY);
+                    const childWidthMeasureSpec = makeMeasureSpec(roundedCalculatedWidth, EXACTLY);
                     // NOTE: for controls that support internal content wrapping (e.g. UILabel) reducing the width
                     // might result in increased height e.g. text that could be shown on one line for larger
                     // width needs to be wrapped in two when width is reduced.
                     // As a result we cannot unconditionally measure with EXACTLY the current measured height
-                    var childHeightMeasureSpec = FlexboxLayout.getChildMeasureSpec(this._currentHeightMeasureSpec, lp.effectivePaddingTop + lp.effectivePaddingBottom + lp.effectiveMarginTop + lp.effectiveMarginBottom, lp.effectiveHeight < 0 ? WRAP_CONTENT : lp.effectiveHeight);
+                    const childHeightMeasureSpec = FlexboxLayout.getChildMeasureSpec(this._currentHeightMeasureSpec, lp.effectivePaddingTop + lp.effectivePaddingBottom + lp.effectiveMarginTop + lp.effectiveMarginBottom, lp.effectiveHeight < 0 ? WRAP_CONTENT : lp.effectiveHeight);
                     child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
                     child.effectiveMinWidth = minWidth;
                     // make sure crossSize is up-to-date as child calculated height might have increased
@@ -603,10 +548,10 @@ var FlexboxLayout = /** @class */ (function (_super) {
             }
             else {
                 if (!this._childrenFrozen[childIndex]) {
-                    var flexShrink = FlexboxLayout.getFlexShrink(child);
-                    var rawCalculatedHeight = child.getMeasuredHeight() - unitShrink * flexShrink + accumulatedRoundError;
-                    var roundedCalculatedHeight = Math.round(rawCalculatedHeight);
-                    var minHeight = child.effectiveMinHeight;
+                    const flexShrink = FlexboxLayout.getFlexShrink(child);
+                    const rawCalculatedHeight = child.getMeasuredHeight() - unitShrink * flexShrink + accumulatedRoundError;
+                    let roundedCalculatedHeight = Math.round(rawCalculatedHeight);
+                    const minHeight = child.effectiveMinHeight;
                     child.effectiveMinHeight = 0;
                     if (roundedCalculatedHeight < minHeight) {
                         needsReshrink = true;
@@ -628,11 +573,10 @@ var FlexboxLayout = /** @class */ (function (_super) {
             this._shrinkFlexItems(flexLine, flexDirection, maxMainSize, paddingAlongMainAxis, startIndex);
         }
         return childIndex;
-    };
-    FlexboxLayout.prototype._determineCrossSize = function (flexDirection, widthMeasureSpec, heightMeasureSpec, paddingAlongCrossAxis) {
-        var _this = this;
-        var mode;
-        var size;
+    }
+    _determineCrossSize(flexDirection, widthMeasureSpec, heightMeasureSpec, paddingAlongCrossAxis) {
+        let mode;
+        let size;
         switch (flexDirection) {
             case FlexDirection.ROW:
             case FlexDirection.ROW_REVERSE:
@@ -648,24 +592,24 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 throw new Error('Invalid flex direction: ' + flexDirection);
         }
         if (mode === EXACTLY) {
-            var totalCrossSize_1 = this._getSumOfCrossSize() + paddingAlongCrossAxis;
+            const totalCrossSize = this._getSumOfCrossSize() + paddingAlongCrossAxis;
             if (this._flexLines.length === 1) {
                 this._flexLines[0]._crossSize = size - paddingAlongCrossAxis;
             }
-            else if (this._flexLines.length >= 2 && totalCrossSize_1 < size) {
+            else if (this._flexLines.length >= 2 && totalCrossSize < size) {
                 switch (this.alignContent) {
                     case AlignContent.STRETCH:
-                        (function () {
-                            var freeSpaceUnit = (size - totalCrossSize_1) / _this._flexLines.length;
-                            var accumulatedError = 0;
-                            for (var i = 0, flexLinesSize = _this._flexLines.length; i < flexLinesSize; i++) {
-                                var flexLine = _this._flexLines[i];
-                                var newCrossSizeAsFloat = flexLine._crossSize + freeSpaceUnit;
-                                if (i === _this._flexLines.length - 1) {
+                        (() => {
+                            const freeSpaceUnit = (size - totalCrossSize) / this._flexLines.length;
+                            let accumulatedError = 0;
+                            for (let i = 0, flexLinesSize = this._flexLines.length; i < flexLinesSize; i++) {
+                                const flexLine = this._flexLines[i];
+                                let newCrossSizeAsFloat = flexLine._crossSize + freeSpaceUnit;
+                                if (i === this._flexLines.length - 1) {
                                     newCrossSizeAsFloat += accumulatedError;
                                     accumulatedError = 0;
                                 }
-                                var newCrossSize = Math.round(newCrossSizeAsFloat);
+                                let newCrossSize = Math.round(newCrossSizeAsFloat);
                                 accumulatedError += newCrossSizeAsFloat - newCrossSize;
                                 if (accumulatedError > 1) {
                                     newCrossSize += 1;
@@ -680,34 +624,34 @@ var FlexboxLayout = /** @class */ (function (_super) {
                         })();
                         break;
                     case AlignContent.SPACE_AROUND:
-                        (function () {
-                            var spaceTopAndBottom = size - totalCrossSize_1;
-                            var numberOfSpaces = _this._flexLines.length * 2;
+                        (() => {
+                            let spaceTopAndBottom = size - totalCrossSize;
+                            const numberOfSpaces = this._flexLines.length * 2;
                             spaceTopAndBottom = spaceTopAndBottom / numberOfSpaces;
-                            var newFlexLines = [];
-                            var dummySpaceFlexLine = new FlexLine();
+                            const newFlexLines = [];
+                            const dummySpaceFlexLine = new FlexLine();
                             dummySpaceFlexLine._crossSize = spaceTopAndBottom;
-                            _this._flexLines.forEach(function (flexLine) {
+                            this._flexLines.forEach((flexLine) => {
                                 newFlexLines.push(dummySpaceFlexLine);
                                 newFlexLines.push(flexLine);
                                 newFlexLines.push(dummySpaceFlexLine);
                             });
-                            _this._flexLines = newFlexLines;
+                            this._flexLines = newFlexLines;
                         })();
                         break;
                     case AlignContent.SPACE_BETWEEN:
-                        (function () {
-                            var spaceBetweenFlexLine = size - totalCrossSize_1;
-                            var numberOfSpaces = _this._flexLines.length - 1;
+                        (() => {
+                            let spaceBetweenFlexLine = size - totalCrossSize;
+                            const numberOfSpaces = this._flexLines.length - 1;
                             spaceBetweenFlexLine = spaceBetweenFlexLine / numberOfSpaces;
-                            var accumulatedError = 0;
-                            var newFlexLines = [];
-                            for (var i = 0, flexLineSize = _this._flexLines.length; i < flexLineSize; i++) {
-                                var flexLine = _this._flexLines[i];
+                            let accumulatedError = 0;
+                            const newFlexLines = [];
+                            for (let i = 0, flexLineSize = this._flexLines.length; i < flexLineSize; i++) {
+                                const flexLine = this._flexLines[i];
                                 newFlexLines.push(flexLine);
-                                if (i !== _this._flexLines.length - 1) {
-                                    var dummySpaceFlexLine = new FlexLine();
-                                    if (i === _this._flexLines.length - 2) {
+                                if (i !== this._flexLines.length - 1) {
+                                    const dummySpaceFlexLine = new FlexLine();
+                                    if (i === this._flexLines.length - 2) {
                                         dummySpaceFlexLine._crossSize = Math.round(spaceBetweenFlexLine + accumulatedError);
                                         accumulatedError = 0;
                                     }
@@ -726,20 +670,20 @@ var FlexboxLayout = /** @class */ (function (_super) {
                                     newFlexLines.push(dummySpaceFlexLine);
                                 }
                             }
-                            _this._flexLines = newFlexLines;
+                            this._flexLines = newFlexLines;
                         })();
                         break;
                     case AlignContent.CENTER: {
-                        var spaceAboveAndBottom = size - totalCrossSize_1;
+                        let spaceAboveAndBottom = size - totalCrossSize;
                         spaceAboveAndBottom = spaceAboveAndBottom / 2;
-                        var newFlexLines = [];
-                        var dummySpaceFlexLine = new FlexLine();
+                        const newFlexLines = [];
+                        const dummySpaceFlexLine = new FlexLine();
                         dummySpaceFlexLine._crossSize = spaceAboveAndBottom;
-                        for (var i = 0, flexLineSize = this._flexLines.length; i < flexLineSize; i++) {
+                        for (let i = 0, flexLineSize = this._flexLines.length; i < flexLineSize; i++) {
                             if (i === 0) {
                                 newFlexLines.push(dummySpaceFlexLine);
                             }
-                            var flexLine = this._flexLines[i];
+                            const flexLine = this._flexLines[i];
                             newFlexLines.push(flexLine);
                             if (i === this._flexLines.length - 1) {
                                 newFlexLines.push(dummySpaceFlexLine);
@@ -749,8 +693,8 @@ var FlexboxLayout = /** @class */ (function (_super) {
                         break;
                     }
                     case AlignContent.FLEX_END: {
-                        var spaceTop = size - totalCrossSize_1;
-                        var dummySpaceFlexLine = new FlexLine();
+                        const spaceTop = size - totalCrossSize;
+                        const dummySpaceFlexLine = new FlexLine();
                         dummySpaceFlexLine._crossSize = spaceTop;
                         this._flexLines.unshift(dummySpaceFlexLine);
                         break;
@@ -758,26 +702,25 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 }
             }
         }
-    };
-    FlexboxLayout.prototype._stretchViews = function (flexDirection, alignItems) {
-        var _this = this;
+    }
+    _stretchViews(flexDirection, alignItems) {
         if (alignItems === AlignItems.STRETCH) {
-            var viewIndex_2 = 0;
-            this._flexLines.forEach(function (flexLine) {
-                for (var i = 0; i < flexLine.itemCount; i++, viewIndex_2++) {
-                    var view = _this._getReorderedChildAt(viewIndex_2);
-                    var alignSelf = FlexboxLayout.getAlignSelf(view);
+            let viewIndex = 0;
+            this._flexLines.forEach((flexLine) => {
+                for (let i = 0; i < flexLine.itemCount; i++, viewIndex++) {
+                    const view = this._getReorderedChildAt(viewIndex);
+                    const alignSelf = FlexboxLayout.getAlignSelf(view);
                     if (alignSelf !== 'auto' && alignSelf !== 'stretch') {
                         continue;
                     }
                     switch (flexDirection) {
                         case FlexDirection.ROW:
                         case FlexDirection.ROW_REVERSE:
-                            _this._stretchViewVertically(view, flexLine._crossSize);
+                            this._stretchViewVertically(view, flexLine._crossSize);
                             break;
                         case FlexDirection.COLUMN:
                         case FlexDirection.COLUMN_REVERSE:
-                            _this._stretchViewHorizontally(view, flexLine._crossSize);
+                            this._stretchViewHorizontally(view, flexLine._crossSize);
                             break;
                         default:
                             throw new Error('Invalid flex direction: ' + flexDirection);
@@ -786,17 +729,17 @@ var FlexboxLayout = /** @class */ (function (_super) {
             });
         }
         else {
-            this._flexLines.forEach(function (flexLine) {
-                flexLine._indicesAlignSelfStretch.forEach(function (index) {
-                    var view = _this._getReorderedChildAt(index);
+            this._flexLines.forEach((flexLine) => {
+                flexLine._indicesAlignSelfStretch.forEach((index) => {
+                    const view = this._getReorderedChildAt(index);
                     switch (flexDirection) {
                         case FlexDirection.ROW:
                         case FlexDirection.ROW_REVERSE:
-                            _this._stretchViewVertically(view, flexLine._crossSize);
+                            this._stretchViewVertically(view, flexLine._crossSize);
                             break;
                         case FlexDirection.COLUMN:
                         case FlexDirection.COLUMN_REVERSE:
-                            _this._stretchViewHorizontally(view, flexLine._crossSize);
+                            this._stretchViewHorizontally(view, flexLine._crossSize);
                             break;
                         default:
                             throw new Error('Invalid flex direction: ' + flexDirection);
@@ -804,30 +747,30 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 });
             });
         }
-    };
-    FlexboxLayout.prototype._stretchViewVertically = function (view, crossSize) {
-        var newHeight = crossSize - view.effectiveMarginTop - view.effectiveMarginBottom;
+    }
+    _stretchViewVertically(view, crossSize) {
+        let newHeight = crossSize - view.effectiveMarginTop - view.effectiveMarginBottom;
         newHeight = Math.max(newHeight, 0);
-        var originalMeasuredWidth = view.getMeasuredWidth();
-        var childWidthMeasureSpec = FlexboxLayout.getChildMeasureSpec(this._currentWidthMeasureSpec, view.effectivePaddingLeft + view.effectivePaddingRight + view.effectiveMarginLeft + view.effectiveMarginRight, view.effectiveWidth < 0 ? WRAP_CONTENT : Math.min(view.effectiveWidth, originalMeasuredWidth));
+        const originalMeasuredWidth = view.getMeasuredWidth();
+        let childWidthMeasureSpec = FlexboxLayout.getChildMeasureSpec(this._currentWidthMeasureSpec, view.effectivePaddingLeft + view.effectivePaddingRight + view.effectiveMarginLeft + view.effectiveMarginRight, view.effectiveWidth < 0 ? WRAP_CONTENT : Math.min(view.effectiveWidth, originalMeasuredWidth));
         view.measure(childWidthMeasureSpec, makeMeasureSpec(newHeight, EXACTLY));
         if (originalMeasuredWidth > view.getMeasuredWidth()) {
             childWidthMeasureSpec = makeMeasureSpec(originalMeasuredWidth, EXACTLY);
             view.measure(childWidthMeasureSpec, makeMeasureSpec(newHeight, EXACTLY));
         }
-    };
-    FlexboxLayout.prototype._stretchViewHorizontally = function (view, crossSize) {
-        var newWidth = crossSize - view.effectiveMarginLeft - view.effectiveMarginRight;
+    }
+    _stretchViewHorizontally(view, crossSize) {
+        let newWidth = crossSize - view.effectiveMarginLeft - view.effectiveMarginRight;
         newWidth = Math.max(newWidth, 0);
         view.measure(makeMeasureSpec(newWidth, EXACTLY), makeMeasureSpec(view.getMeasuredHeight(), EXACTLY));
-    };
-    FlexboxLayout.prototype._setMeasuredDimensionForFlex = function (flexDirection, widthMeasureSpec, heightMeasureSpec, childState) {
-        var widthMode = getMeasureSpecMode(widthMeasureSpec);
-        var widthSize = getMeasureSpecSize(widthMeasureSpec);
-        var heightMode = getMeasureSpecMode(heightMeasureSpec);
-        var heightSize = getMeasureSpecSize(heightMeasureSpec);
-        var calculatedMaxHeight;
-        var calculatedMaxWidth;
+    }
+    _setMeasuredDimensionForFlex(flexDirection, widthMeasureSpec, heightMeasureSpec, childState) {
+        const widthMode = getMeasureSpecMode(widthMeasureSpec);
+        let widthSize = getMeasureSpecSize(widthMeasureSpec);
+        const heightMode = getMeasureSpecMode(heightMeasureSpec);
+        let heightSize = getMeasureSpecSize(heightMeasureSpec);
+        let calculatedMaxHeight;
+        let calculatedMaxWidth;
         switch (flexDirection) {
             case FlexDirection.ROW:
             case FlexDirection.ROW_REVERSE:
@@ -842,7 +785,7 @@ var FlexboxLayout = /** @class */ (function (_super) {
             default:
                 throw new Error('Invalid flex direction: ' + flexDirection);
         }
-        var widthSizeAndState;
+        let widthSizeAndState;
         switch (widthMode) {
             case EXACTLY:
                 if (widthSize < calculatedMaxWidth) {
@@ -867,7 +810,7 @@ var FlexboxLayout = /** @class */ (function (_super) {
             default:
                 throw new Error('Unknown width mode is set: ' + widthMode);
         }
-        var heightSizeAndState;
+        let heightSizeAndState;
         switch (heightMode) {
             case EXACTLY:
                 if (heightSize < calculatedMaxHeight) {
@@ -893,8 +836,8 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 throw new Error('Unknown height mode is set: ' + heightMode);
         }
         this.setMeasuredDimension(widthSizeAndState, heightSizeAndState);
-    };
-    FlexboxLayout.prototype._isWrapRequired = function (child, mode, maxSize, currentLength, childLength, childAbsoluteIndex, childRelativeIndexInFlexLine) {
+    }
+    _isWrapRequired(child, mode, maxSize, currentLength, childLength, childAbsoluteIndex, childRelativeIndexInFlexLine) {
         if (this.flexWrap === FlexWrap.NOWRAP) {
             return false;
         }
@@ -906,20 +849,20 @@ var FlexboxLayout = /** @class */ (function (_super) {
         }
         // Omit divider
         return maxSize < currentLength + childLength;
-    };
-    FlexboxLayout.prototype._getLargestMainSize = function () {
-        return this._flexLines.reduce(function (max, flexLine) { return Math.max(max, flexLine.mainSize); }, Number.MIN_VALUE);
-    };
-    FlexboxLayout.prototype._getSumOfCrossSize = function () {
+    }
+    _getLargestMainSize() {
+        return this._flexLines.reduce((max, flexLine) => Math.max(max, flexLine.mainSize), Number.MIN_VALUE);
+    }
+    _getSumOfCrossSize() {
         // Omit divider
-        return this._flexLines.reduce(function (sum, flexLine) { return sum + flexLine._crossSize; }, 0);
-    };
-    FlexboxLayout.prototype._isMainAxisDirectionHorizontal = function (flexDirection) {
+        return this._flexLines.reduce((sum, flexLine) => sum + flexLine._crossSize, 0);
+    }
+    _isMainAxisDirectionHorizontal(flexDirection) {
         return flexDirection === FlexDirection.ROW || flexDirection === FlexDirection.ROW_REVERSE;
-    };
-    FlexboxLayout.prototype.onLayout = function (left, top, right, bottom) {
-        var insets = this.getSafeAreaInsets();
-        var isRtl;
+    }
+    onLayout(left, top, right, bottom) {
+        const insets = this.getSafeAreaInsets();
+        let isRtl;
         switch (this.flexDirection) {
             case FlexDirection.ROW:
                 isRtl = false;
@@ -946,26 +889,25 @@ var FlexboxLayout = /** @class */ (function (_super) {
             default:
                 throw new Error('Invalid flex direction is set: ' + this.flexDirection);
         }
-    };
-    FlexboxLayout.prototype._layoutHorizontal = function (isRtl, left, top, right, bottom, insets) {
-        var _this = this;
+    }
+    _layoutHorizontal(isRtl, left, top, right, bottom, insets) {
         // include insets
-        var paddingLeft = this.effectivePaddingLeft + insets.left;
-        var paddingTop = this.effectivePaddingTop + insets.top;
-        var paddingRight = this.effectivePaddingRight + insets.right;
-        var paddingBottom = this.effectivePaddingBottom + insets.bottom;
-        var childLeft;
-        var currentViewIndex = 0;
-        var height = bottom - top;
-        var width = right - left;
+        const paddingLeft = this.effectivePaddingLeft + insets.left;
+        const paddingTop = this.effectivePaddingTop + insets.top;
+        const paddingRight = this.effectivePaddingRight + insets.right;
+        const paddingBottom = this.effectivePaddingBottom + insets.bottom;
+        let childLeft;
+        let currentViewIndex = 0;
+        const height = bottom - top;
+        const width = right - left;
         // include insets
-        var childBottom = height - paddingBottom;
-        var childTop = paddingTop;
-        var childRight;
-        this._flexLines.forEach(function (flexLine, i) {
+        let childBottom = height - paddingBottom;
+        let childTop = paddingTop;
+        let childRight;
+        this._flexLines.forEach((flexLine, i) => {
             // Omit divider
-            var spaceBetweenItem = 0.0;
-            switch (_this.justifyContent) {
+            let spaceBetweenItem = 0.0;
+            switch (this.justifyContent) {
                 case JustifyContent.FLEX_START:
                     childLeft = paddingLeft;
                     childRight = width - paddingRight;
@@ -987,17 +929,17 @@ var FlexboxLayout = /** @class */ (function (_super) {
                     break;
                 case JustifyContent.SPACE_BETWEEN: {
                     childLeft = paddingLeft;
-                    var denominator = flexLine.itemCount !== 1 ? flexLine.itemCount - 1 : 1.0;
+                    const denominator = flexLine.itemCount !== 1 ? flexLine.itemCount - 1 : 1.0;
                     spaceBetweenItem = (width - insets.left - insets.right - flexLine.mainSize) / denominator;
                     childRight = width - paddingRight;
                     break;
                 }
                 default:
-                    throw new Error('Invalid justifyContent is set: ' + _this.justifyContent);
+                    throw new Error('Invalid justifyContent is set: ' + this.justifyContent);
             }
             spaceBetweenItem = Math.max(spaceBetweenItem, 0);
-            for (var j = 0; j < flexLine.itemCount; j++) {
-                var child = _this._getReorderedChildAt(currentViewIndex);
+            for (let j = 0; j < flexLine.itemCount; j++) {
+                const child = this._getReorderedChildAt(currentViewIndex);
                 if (child === null) {
                     continue;
                 }
@@ -1005,30 +947,30 @@ var FlexboxLayout = /** @class */ (function (_super) {
                     currentViewIndex++;
                     continue;
                 }
-                var lp = child; // .style;
+                const lp = child; // .style;
                 childLeft += lp.effectiveMarginLeft;
                 childRight -= lp.effectiveMarginRight;
                 // Omit divider
-                if (_this.flexWrap === FlexWrap.WRAP_REVERSE) {
+                if (this.flexWrap === FlexWrap.WRAP_REVERSE) {
                     if (isRtl) {
-                        _this._layoutSingleChildHorizontal(child, flexLine, _this.flexWrap, _this.alignItems, Math.round(childRight) - child.getMeasuredWidth(), childBottom - child.getMeasuredHeight(), Math.round(childRight), childBottom);
+                        this._layoutSingleChildHorizontal(child, flexLine, this.flexWrap, this.alignItems, Math.round(childRight) - child.getMeasuredWidth(), childBottom - child.getMeasuredHeight(), Math.round(childRight), childBottom);
                     }
                     else {
-                        _this._layoutSingleChildHorizontal(child, flexLine, _this.flexWrap, _this.alignItems, Math.round(childLeft), childBottom - child.getMeasuredHeight(), Math.round(childLeft) + child.getMeasuredWidth(), childBottom);
+                        this._layoutSingleChildHorizontal(child, flexLine, this.flexWrap, this.alignItems, Math.round(childLeft), childBottom - child.getMeasuredHeight(), Math.round(childLeft) + child.getMeasuredWidth(), childBottom);
                     }
                 }
                 else {
                     if (isRtl) {
-                        _this._layoutSingleChildHorizontal(child, flexLine, _this.flexWrap, _this.alignItems, Math.round(childRight) - child.getMeasuredWidth(), childTop, Math.round(childRight), childTop + child.getMeasuredHeight());
+                        this._layoutSingleChildHorizontal(child, flexLine, this.flexWrap, this.alignItems, Math.round(childRight) - child.getMeasuredWidth(), childTop, Math.round(childRight), childTop + child.getMeasuredHeight());
                     }
                     else {
-                        _this._layoutSingleChildHorizontal(child, flexLine, _this.flexWrap, _this.alignItems, Math.round(childLeft), childTop, Math.round(childLeft) + child.getMeasuredWidth(), childTop + child.getMeasuredHeight());
+                        this._layoutSingleChildHorizontal(child, flexLine, this.flexWrap, this.alignItems, Math.round(childLeft), childTop, Math.round(childLeft) + child.getMeasuredWidth(), childTop + child.getMeasuredHeight());
                     }
                 }
                 childLeft += child.getMeasuredWidth() + spaceBetweenItem + lp.effectiveMarginRight;
                 childRight -= child.getMeasuredWidth() + spaceBetweenItem + lp.effectiveMarginLeft;
                 currentViewIndex++;
-                var bounds = child._getCurrentLayoutBounds();
+                const bounds = child._getCurrentLayoutBounds();
                 flexLine._left = Math.min(flexLine._left, bounds.left - lp.effectiveMarginLeft);
                 flexLine._top = Math.min(flexLine._top, bounds.top - lp.effectiveMarginTop);
                 flexLine._right = Math.max(flexLine._right, bounds.right + lp.effectiveMarginRight);
@@ -1037,14 +979,14 @@ var FlexboxLayout = /** @class */ (function (_super) {
             childTop += flexLine._crossSize;
             childBottom -= flexLine._crossSize;
         });
-    };
-    FlexboxLayout.prototype._layoutSingleChildHorizontal = function (view, flexLine, flexWrap, alignItems, left, top, right, bottom) {
-        var lp = view; // .style;
-        var alignSelf = FlexboxLayout.getAlignSelf(view);
+    }
+    _layoutSingleChildHorizontal(view, flexLine, flexWrap, alignItems, left, top, right, bottom) {
+        const lp = view; // .style;
+        const alignSelf = FlexboxLayout.getAlignSelf(view);
         if (alignSelf !== 'auto') {
             alignItems = alignSelf;
         }
-        var crossSize = flexLine._crossSize;
+        const crossSize = flexLine._crossSize;
         switch (alignItems) {
             case AlignItems.FLEX_START:
             case AlignItems.STRETCH:
@@ -1057,12 +999,12 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 break;
             case AlignItems.BASELINE:
                 if (flexWrap !== FlexWrap.WRAP_REVERSE) {
-                    var marginTop = flexLine._maxBaseline - FlexboxLayout.getBaseline(view);
+                    let marginTop = flexLine._maxBaseline - FlexboxLayout.getBaseline(view);
                     marginTop = Math.max(marginTop, lp.effectiveMarginTop);
                     view.layout(left, top + marginTop, right, bottom + marginTop);
                 }
                 else {
-                    var marginBottom = flexLine._maxBaseline - view.getMeasuredHeight() + FlexboxLayout.getBaseline(view);
+                    let marginBottom = flexLine._maxBaseline - view.getMeasuredHeight() + FlexboxLayout.getBaseline(view);
                     marginBottom = Math.max(marginBottom, lp.effectiveMarginBottom);
                     view.layout(left, top - marginBottom, right, bottom - marginBottom);
                 }
@@ -1076,7 +1018,7 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 }
                 break;
             case AlignItems.CENTER: {
-                var topFromCrossAxis = (crossSize - view.getMeasuredHeight()) / 2;
+                const topFromCrossAxis = (crossSize - view.getMeasuredHeight()) / 2;
                 if (flexWrap !== FlexWrap.WRAP_REVERSE) {
                     view.layout(left, top + topFromCrossAxis + lp.effectiveMarginTop - lp.effectiveMarginBottom, right, top + topFromCrossAxis + view.getMeasuredHeight() + lp.effectiveMarginTop - lp.effectiveMarginBottom);
                 }
@@ -1086,24 +1028,23 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 break;
             }
         }
-    };
-    FlexboxLayout.prototype._layoutVertical = function (isRtl, fromBottomToTop, left, top, right, bottom, insets) {
-        var _this = this;
-        var paddingLeft = this.effectivePaddingLeft + insets.left;
-        var paddingTop = this.effectivePaddingTop + insets.top;
-        var paddingRight = this.effectivePaddingRight + insets.right;
-        var paddingBottom = this.effectivePaddingBottom + insets.bottom;
-        var childLeft = paddingLeft;
-        var currentViewIndex = 0;
-        var width = right - left;
-        var height = bottom - top;
-        var childRight = width - paddingRight;
-        var childTop;
-        var childBottom;
-        this._flexLines.forEach(function (flexLine) {
+    }
+    _layoutVertical(isRtl, fromBottomToTop, left, top, right, bottom, insets) {
+        const paddingLeft = this.effectivePaddingLeft + insets.left;
+        const paddingTop = this.effectivePaddingTop + insets.top;
+        const paddingRight = this.effectivePaddingRight + insets.right;
+        const paddingBottom = this.effectivePaddingBottom + insets.bottom;
+        let childLeft = paddingLeft;
+        let currentViewIndex = 0;
+        const width = right - left;
+        const height = bottom - top;
+        let childRight = width - paddingRight;
+        let childTop;
+        let childBottom;
+        this._flexLines.forEach((flexLine) => {
             // Omit divider.
-            var spaceBetweenItem = 0.0;
-            switch (_this.justifyContent) {
+            let spaceBetweenItem = 0.0;
+            switch (this.justifyContent) {
                 case JustifyContent.FLEX_START:
                     childTop = paddingTop;
                     childBottom = height - paddingBottom;
@@ -1125,17 +1066,17 @@ var FlexboxLayout = /** @class */ (function (_super) {
                     break;
                 case JustifyContent.SPACE_BETWEEN: {
                     childTop = paddingTop;
-                    var denominator = flexLine.itemCount !== 1 ? flexLine.itemCount - 1 : 1.0;
+                    const denominator = flexLine.itemCount !== 1 ? flexLine.itemCount - 1 : 1.0;
                     spaceBetweenItem = (height - insets.top - insets.bottom - flexLine.mainSize) / denominator;
                     childBottom = height - paddingBottom;
                     break;
                 }
                 default:
-                    throw new Error('Invalid justifyContent is set: ' + _this.justifyContent);
+                    throw new Error('Invalid justifyContent is set: ' + this.justifyContent);
             }
             spaceBetweenItem = Math.max(spaceBetweenItem, 0);
-            for (var j = 0; j < flexLine.itemCount; j++) {
-                var child = _this._getReorderedChildAt(currentViewIndex);
+            for (let j = 0; j < flexLine.itemCount; j++) {
+                const child = this._getReorderedChildAt(currentViewIndex);
                 if (child === null) {
                     continue;
                 }
@@ -1143,30 +1084,30 @@ var FlexboxLayout = /** @class */ (function (_super) {
                     currentViewIndex++;
                     continue;
                 }
-                var lp = child; // .style;
+                const lp = child; // .style;
                 childTop += lp.effectiveMarginTop;
                 childBottom -= lp.effectiveMarginBottom;
                 // Omit divider.
                 if (isRtl) {
                     if (fromBottomToTop) {
-                        _this._layoutSingleChildVertical(child, flexLine, true, _this.alignItems, childRight - child.getMeasuredWidth(), Math.round(childBottom) - child.getMeasuredHeight(), childRight, Math.round(childBottom));
+                        this._layoutSingleChildVertical(child, flexLine, true, this.alignItems, childRight - child.getMeasuredWidth(), Math.round(childBottom) - child.getMeasuredHeight(), childRight, Math.round(childBottom));
                     }
                     else {
-                        _this._layoutSingleChildVertical(child, flexLine, true, _this.alignItems, childRight - child.getMeasuredWidth(), Math.round(childTop), childRight, Math.round(childTop) + child.getMeasuredHeight());
+                        this._layoutSingleChildVertical(child, flexLine, true, this.alignItems, childRight - child.getMeasuredWidth(), Math.round(childTop), childRight, Math.round(childTop) + child.getMeasuredHeight());
                     }
                 }
                 else {
                     if (fromBottomToTop) {
-                        _this._layoutSingleChildVertical(child, flexLine, false, _this.alignItems, childLeft, Math.round(childBottom) - child.getMeasuredHeight(), childLeft + child.getMeasuredWidth(), Math.round(childBottom));
+                        this._layoutSingleChildVertical(child, flexLine, false, this.alignItems, childLeft, Math.round(childBottom) - child.getMeasuredHeight(), childLeft + child.getMeasuredWidth(), Math.round(childBottom));
                     }
                     else {
-                        _this._layoutSingleChildVertical(child, flexLine, false, _this.alignItems, childLeft, Math.round(childTop), childLeft + child.getMeasuredWidth(), Math.round(childTop) + child.getMeasuredHeight());
+                        this._layoutSingleChildVertical(child, flexLine, false, this.alignItems, childLeft, Math.round(childTop), childLeft + child.getMeasuredWidth(), Math.round(childTop) + child.getMeasuredHeight());
                     }
                 }
                 childTop += child.getMeasuredHeight() + spaceBetweenItem + lp.effectiveMarginBottom;
                 childBottom -= child.getMeasuredHeight() + spaceBetweenItem + lp.effectiveMarginTop;
                 currentViewIndex++;
-                var bounds = child._getCurrentLayoutBounds();
+                const bounds = child._getCurrentLayoutBounds();
                 flexLine._left = Math.min(flexLine._left, bounds.left - lp.effectiveMarginLeft);
                 flexLine._top = Math.min(flexLine._top, bounds.top - lp.effectiveMarginTop);
                 flexLine._right = Math.max(flexLine._right, bounds.right + lp.effectiveMarginRight);
@@ -1175,14 +1116,14 @@ var FlexboxLayout = /** @class */ (function (_super) {
             childLeft += flexLine.crossSize;
             childRight -= flexLine.crossSize;
         });
-    };
-    FlexboxLayout.prototype._layoutSingleChildVertical = function (view, flexLine, isRtl, alignItems, left, top, right, bottom) {
-        var lp = view; // .style;
-        var alignSelf = FlexboxLayout.getAlignSelf(view);
+    }
+    _layoutSingleChildVertical(view, flexLine, isRtl, alignItems, left, top, right, bottom) {
+        const lp = view; // .style;
+        const alignSelf = FlexboxLayout.getAlignSelf(view);
         if (alignSelf !== 'auto') {
             alignItems = alignSelf;
         }
-        var crossSize = flexLine.crossSize;
+        const crossSize = flexLine.crossSize;
         switch (alignItems) {
             case AlignItems.FLEX_START:
             case AlignItems.STRETCH:
@@ -1205,7 +1146,7 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 }
                 break;
             case AlignItems.CENTER: {
-                var leftFromCrossAxis = (crossSize - view.getMeasuredWidth()) / 2;
+                const leftFromCrossAxis = (crossSize - view.getMeasuredWidth()) / 2;
                 if (!isRtl) {
                     view.layout(left + leftFromCrossAxis + lp.effectiveMarginLeft - lp.effectiveMarginRight, top, right + leftFromCrossAxis + lp.effectiveMarginLeft - lp.effectiveMarginRight, bottom);
                 }
@@ -1215,16 +1156,16 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 break;
             }
         }
-    };
+    }
     // Omit divider in onDraw(), drawDividersHorizontal, drawDividersVertical, drawVerticalDivider
     // requestLayout on set flexDirection, set flexWrap, set justifyContent, set alignItems, set alignContent
     // NOTE Consider moving to View if frequently used
-    FlexboxLayout.getChildMeasureSpec = function (spec, padding, childDimension) {
-        var specMode = layout.getMeasureSpecMode(spec);
-        var specSize = layout.getMeasureSpecSize(spec);
-        var size = Math.max(0, specSize - padding);
-        var resultSize = 0;
-        var resultMode = 0;
+    static getChildMeasureSpec(spec, padding, childDimension) {
+        const specMode = layout.getMeasureSpecMode(spec);
+        const specSize = layout.getMeasureSpecSize(spec);
+        const size = Math.max(0, specSize - padding);
+        let resultSize = 0;
+        let resultMode = 0;
         switch (specMode) {
             // Parent has imposed an exact size on us
             case EXACTLY:
@@ -1271,10 +1212,8 @@ var FlexboxLayout = /** @class */ (function (_super) {
                 break;
         }
         return layout.makeMeasureSpec(resultSize, resultMode);
-    };
-    return FlexboxLayout;
-}(FlexboxLayoutBase));
-export { FlexboxLayout };
+    }
+}
 (function (FlexboxLayout) {
     function getBaseline(child) {
         // TODO: Check if we support baseline for iOS.