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

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