@leafer-in/flow 1.8.0 → 1.9.1

package/dist/flow.js

@@ -1,115 +1,84 @@
 this.LeaferIN = this.LeaferIN || {};
-this.LeaferIN.flow = (function (exports, draw) {
-    'use strict';
 
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-    function __decorate(decorators, target, key, desc) {
-        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-        return c > 3 && r && Object.defineProperty(target, key, r), r;
-    }
-
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-        var e = new Error(message);
-        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-
-    class FlowData extends draw.BoxData {
+this.LeaferIN.flow = function(exports, draw) {
+    "use strict";
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
     }
-
+    typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    class FlowData extends draw.BoxData {}
     exports.Flow = class Flow extends draw.Box {
-        get __tag() { return 'Flow'; }
+        get __tag() {
+            return "Flow";
+        }
         constructor(data) {
             super(data);
             this.__hasAutoLayout = true;
         }
     };
-    __decorate([
-        draw.dataProcessor(FlowData)
-    ], exports.Flow.prototype, "__", void 0);
-    __decorate([
-        draw.autoLayoutType('x')
-    ], exports.Flow.prototype, "flow", void 0);
-    exports.Flow = __decorate([
-        draw.registerUI()
-    ], exports.Flow);
-
+    __decorate([ draw.dataProcessor(FlowData) ], exports.Flow.prototype, "__", void 0);
+    __decorate([ draw.autoLayoutType("x") ], exports.Flow.prototype, "flow", void 0);
+    exports.Flow = __decorate([ draw.registerUI() ], exports.Flow);
     const point = {};
     const alignToInnerXMap = {
-        'top-left': 'from',
-        'top': 'center',
-        'top-right': 'to',
-        'right': 'to',
-        'bottom-right': 'to',
-        'bottom': 'center',
-        'bottom-left': 'from',
-        'left': 'from',
-        'center': 'center',
-        'baseline-left': 'from',
-        'baseline-center': 'center',
-        'baseline-right': 'to',
+        "top-left": "from",
+        top: "center",
+        "top-right": "to",
+        right: "to",
+        "bottom-right": "to",
+        bottom: "center",
+        "bottom-left": "from",
+        left: "from",
+        center: "center",
+        "baseline-left": "from",
+        "baseline-center": "center",
+        "baseline-right": "to"
     };
     const alignToInnerYMap = {
-        'top-left': 'from',
-        'top': 'from',
-        'top-right': 'from',
-        'right': 'center',
-        'bottom-right': 'to',
-        'bottom': 'to',
-        'bottom-left': 'to',
-        'left': 'center',
-        'center': 'center',
-        'baseline-left': 'to',
-        'baseline-center': 'to',
-        'baseline-right': 'to',
+        "top-left": "from",
+        top: "from",
+        "top-right": "from",
+        right: "center",
+        "bottom-right": "to",
+        bottom: "to",
+        "bottom-left": "to",
+        left: "center",
+        center: "center",
+        "baseline-left": "to",
+        "baseline-center": "to",
+        "baseline-right": "to"
     };
     function alignContent(box, content, align) {
         const data = box.__;
-        const { contentBounds } = box.__layout;
+        const {contentBounds: contentBounds} = box.__layout;
         draw.AlignHelper.toPoint(align, content, contentBounds, point);
         content.x = data.__autoWidth ? contentBounds.x : point.x;
         content.y = data.__autoHeight ? contentBounds.y : point.y;
     }
-
     function align$1(box, data, contentAlign, innerXAlign) {
         alignContent(box, data, contentAlign);
-        const { list } = data;
+        const {list: list} = data;
         if (list.length > 1) {
-            if (!innerXAlign)
-                innerXAlign = alignToInnerXMap[contentAlign];
-            if (innerXAlign !== 'from') {
+            if (!innerXAlign) innerXAlign = alignToInnerXMap[contentAlign];
+            if (innerXAlign !== "from") {
                 let row;
                 for (let i = 0, len = list.length; i < len; i++) {
                     row = list[i];
                     row.x = data.width - row.width;
-                    if (innerXAlign === 'center')
-                        row.x /= 2;
+                    if (innerXAlign === "center") row.x /= 2;
                 }
             }
         }
     }
-
-    const { move: move$3 } = draw.PointHelper;
+    const {move: move$3} = draw.PointHelper;
     function layout$1(box, data, rowYAlign, reverse) {
-        const { list } = data, reverseWrap = box.__.flowWrap === 'reverse';
-        let row, { x, y } = data;
+        const {list: list} = data, reverseWrap = box.__.flowWrap === "reverse";
+        let row, {x: x, y: y} = data;
         for (let i = 0, len = list.length; i < len; i++) {
             row = list[reverseWrap ? len - 1 - i : i];
             layoutX(box, row, x, y, rowYAlign, reverse);
@@ -117,56 +86,50 @@ this.LeaferIN.flow = (function (exports, draw) {
         }
     }
     function layoutX(box, row, fromX, fromY, rowYAlign, reverse) {
-        const { children } = box;
-        let child, local, { x, start } = row, y = fromY;
+        const {children: children} = box;
+        let child, local, {x: x, start: start} = row, y = fromY;
         x += fromX;
         for (let j = 0, end = row.count; j < end; j++) {
             child = children[reverse ? start - j : start + j];
             if (child.__.inFlow && child.__.visible !== 0) {
                 local = child.__flowBounds;
-                if (rowYAlign !== 'from')
-                    y = fromY + (row.height - local.height) / (rowYAlign === 'center' ? 2 : 1);
+                if (rowYAlign !== "from") y = fromY + (row.height - local.height) / (rowYAlign === "center" ? 2 : 1);
                 move$3(child, x - local.x, y - local.y);
                 x += local.width + row.gap;
-            }
-            else {
+            } else {
                 end++;
             }
         }
     }
-
     function flowWrap(wrapData, data, wrapSide) {
-        const otherSide = wrapSide === 'width' ? 'height' : 'width';
+        const otherSide = wrapSide === "width" ? "height" : "width";
         wrapData[wrapSide] = Math.max(wrapData[wrapSide], data[wrapSide]);
         wrapData[otherSide] += wrapData.count ? data[otherSide] + wrapData.gap : data[otherSide];
         wrapData.list.push(data);
         wrapData.count++;
     }
-
     const p = {};
     function getParseData(box, isFlowX) {
-        const { gap, flowAlign: align, flowWrap: wrap, __autoWidth, __autoHeight } = box.__;
+        const {gap: gap, flowAlign: align, flowWrap: wrap, __autoWidth: __autoWidth, __autoHeight: __autoHeight} = box.__;
         const needWrap = wrap && (isFlowX ? !__autoWidth : !__autoHeight);
-        if (typeof gap === 'object') {
+        if (draw.isObject(gap)) {
             p.xGap = gap.x || 0;
             p.yGap = gap.y || 0;
+        } else {
+            p.xGap = p.yGap = draw.tryToNumber(gap);
         }
-        else {
-            p.xGap = p.yGap = gap;
-        }
-        p.isAutoXGap = typeof p.xGap === 'string' && !__autoWidth;
-        p.isAutoYGap = typeof p.yGap === 'string' && !__autoHeight;
-        p.complex = needWrap || align !== 'top-left' || box.__hasGrow || p.isAutoXGap || p.isAutoYGap;
+        p.isAutoXGap = draw.isString(p.xGap) && !__autoWidth;
+        p.isAutoYGap = draw.isString(p.yGap) && !__autoHeight;
+        p.complex = needWrap || align !== "top-left" || box.__hasGrow || p.isAutoXGap || p.isAutoYGap;
         p.wrap = needWrap;
         if (p.complex) {
-            p.isFitXGap = p.xGap === 'fit' && !__autoWidth;
-            p.isFitYGap = p.yGap === 'fit' && !__autoHeight;
-            if (typeof align === 'object') {
-                p.contentAlign = align.content || 'top-left';
-                p.rowXAlign = align.x || 'from';
-                p.rowYAlign = align.y || 'from';
-            }
-            else {
+            p.isFitXGap = p.xGap === "fit" && !__autoWidth;
+            p.isFitYGap = p.yGap === "fit" && !__autoHeight;
+            if (draw.isObject(align)) {
+                p.contentAlign = align.content || "top-left";
+                p.rowXAlign = align.x || "from";
+                p.rowYAlign = align.y || "from";
+            } else {
                 p.contentAlign = align;
                 p.rowXAlign = alignToInnerXMap[align];
                 p.rowYAlign = alignToInnerYMap[align];
@@ -175,30 +138,43 @@ this.LeaferIN.flow = (function (exports, draw) {
         return p;
     }
     function getDrawData(start, gap) {
-        return { x: 0, y: 0, width: 0, height: 0, gap, start, count: 0, grow: 0 };
+        return {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            gap: gap,
+            start: start,
+            count: 0,
+            grow: 0
+        };
     }
     function getWrapDrawData() {
-        return { x: 0, y: 0, width: 0, height: 0, gap: 0, count: 0, list: [] };
+        return {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            gap: 0,
+            count: 0,
+            list: []
+        };
     }
-
     function autoGap(data, side, sideTotal, fit) {
-        const { count } = data;
+        const {count: count} = data;
         if (count > 1 && (sideTotal > data[side] || fit)) {
             data.gap = (sideTotal - data[side]) / (count - 1);
             data[side] = sideTotal;
         }
     }
-
     function getItemBounds(child, itemBox) {
-        return itemBox === 'box' ? child.__local : child.__layout.localStrokeBounds;
+        return itemBox === "box" ? child.__local : child.__layout.localStrokeBounds;
     }
-
-    const { within: within$1 } = draw.MathHelper;
+    const {within: within$1} = draw.MathHelper;
     function growX(box, row, width, reverse) {
-        let child, grow, remainSpace, remainTotalSpace = 0, list = row.hasRangeSize && [], { grow: totalGrow, start } = row;
-        const growSize = (width - row.width) / totalGrow, { children } = box;
-        if (growSize <= 0)
-            return;
+        let child, grow, remainSpace, remainTotalSpace = 0, list = row.hasRangeSize && [], {grow: totalGrow, start: start} = row;
+        const growSize = (width - row.width) / totalGrow, {children: children} = box;
+        if (growSize <= 0) return;
         row.width = width;
         for (let j = 0, end = row.count; j < end; j++) {
             child = children[reverse ? start - j : start + j];
@@ -208,18 +184,15 @@ this.LeaferIN.flow = (function (exports, draw) {
                     if (remainSpace) {
                         remainTotalSpace += remainSpace;
                         totalGrow -= grow;
-                    }
-                    else if (list) {
+                    } else if (list) {
                         child.__.widthRange ? list.unshift(child) : list.push(child);
                     }
                 }
-            }
-            else {
+            } else {
                 end++;
             }
         }
-        if (remainTotalSpace)
-            assignRemainSpace$1(list, remainTotalSpace, totalGrow);
+        if (remainTotalSpace) assignRemainSpace$1(list, remainTotalSpace, totalGrow);
     }
     function assignRemainSpace$1(list, totalSpace, countGrow) {
         let grow, space, local, remain;
@@ -232,20 +205,18 @@ this.LeaferIN.flow = (function (exports, draw) {
         });
     }
     function resizeWidth(child, local, size) {
-        const { widthRange, lockRatio } = child.__;
+        const {widthRange: widthRange, lockRatio: lockRatio} = child.__;
         const realSize = widthRange ? within$1(size, widthRange) : size;
         const scale = realSize / local.width;
         child.scaleResize(scale, lockRatio ? scale : 1);
         local.width = realSize;
         return size - realSize;
     }
-
-    const { within } = draw.MathHelper;
+    const {within: within} = draw.MathHelper;
     function growY(box, row, height, reverse) {
-        let child, grow, remainSpace, remainTotalSpace = 0, list = row.hasRangeSize && [], { grow: totalGrow, start } = row;
-        const growSize = (height - row.height) / totalGrow, { children } = box;
-        if (growSize <= 0)
-            return;
+        let child, grow, remainSpace, remainTotalSpace = 0, list = row.hasRangeSize && [], {grow: totalGrow, start: start} = row;
+        const growSize = (height - row.height) / totalGrow, {children: children} = box;
+        if (growSize <= 0) return;
         row.height = height;
         for (let j = 0, end = row.count; j < end; j++) {
             child = children[reverse ? start - j : start + j];
@@ -255,18 +226,15 @@ this.LeaferIN.flow = (function (exports, draw) {
                     if (remainSpace) {
                         remainTotalSpace += remainSpace;
                         totalGrow -= grow;
-                    }
-                    else if (list) {
+                    } else if (list) {
                         child.__.heightRange ? list.unshift(child) : list.push(child);
                     }
                 }
-            }
-            else {
+            } else {
                 end++;
             }
         }
-        if (remainTotalSpace)
-            assignRemainSpace(list, remainTotalSpace, totalGrow);
+        if (remainTotalSpace) assignRemainSpace(list, remainTotalSpace, totalGrow);
     }
     function assignRemainSpace(list, totalSpace, countGrow) {
         let grow, space, local, remain;
@@ -279,103 +247,82 @@ this.LeaferIN.flow = (function (exports, draw) {
         });
     }
     function resizeHeight(child, local, size) {
-        const { heightRange, lockRatio } = child.__;
+        const {heightRange: heightRange, lockRatio: lockRatio} = child.__;
         const realSize = heightRange ? within(size, heightRange) : size;
         const scale = realSize / local.height;
         child.scaleResize(lockRatio ? scale : 1, scale);
         local.height = realSize;
         return size - realSize;
     }
-
-    const { move: move$2 } = draw.PointHelper;
+    const {move: move$2} = draw.PointHelper;
     function flowX(box, reverse) {
-        const side = 'width', { children, itemBox } = box, pData = getParseData(box, true);
-        const { complex, wrap, xGap, yGap, isAutoXGap, isFitXGap } = pData;
-        if (!children.length)
-            return;
+        const side = "width", {children: children, itemBox: itemBox} = box, pData = getParseData(box, true);
+        const {complex: complex, wrap: wrap, xGap: xGap, yGap: yGap, isAutoXGap: isAutoXGap, isFitXGap: isFitXGap} = pData;
+        if (!children.length) return;
         const wrapData = wrap && getWrapDrawData(), xGapTempNum = isAutoXGap ? 0 : xGap;
-        let child, local, localWidth, index, data, { x, y, width, height } = box.__layout.contentBounds;
+        let child, local, localWidth, index, data, {x: x, y: y, width: width, height: height} = box.__layout.contentBounds;
         for (let i = 0, len = children.length; i < len; i++) {
             child = children[index = reverse ? len - 1 - i : i];
             if (child.__.inFlow && child.__.visible !== 0) {
                 local = getItemBounds(child, itemBox);
                 if (complex) {
                     child.__flowBounds = local;
-                    if (!data)
-                        data = getDrawData(index, xGapTempNum);
+                    if (!data) data = getDrawData(index, xGapTempNum);
                     if (wrap && data.count && data.width + local.width > width) {
-                        if (data.grow)
-                            growX(box, data, width, reverse);
-                        else if (isAutoXGap)
-                            autoGap(data, side, width, isFitXGap);
+                        if (data.grow) growX(box, data, width, reverse); else if (isAutoXGap) autoGap(data, side, width, isFitXGap);
                         flowWrap(wrapData, data, side);
                         data = getDrawData(index, xGapTempNum);
                     }
                     localWidth = local.width;
                     if (child.__widthGrow) {
                         data.grow += child.__widthGrow, localWidth = 0;
-                        if (child.__.widthRange)
-                            data.hasRangeSize = true;
+                        if (child.__.widthRange) data.hasRangeSize = true;
                     }
-                    if (child.__heightGrow)
-                        resizeHeight(child, local, height);
+                    if (child.__heightGrow) resizeHeight(child, local, height);
                     data.width += data.count ? localWidth + xGapTempNum : localWidth;
                     data.height = Math.max(data.height, local.height);
                     data.count++;
-                }
-                else {
+                } else {
                     move$2(child, x - local.x, y - local.y);
                     x += local.width + xGapTempNum;
                 }
             }
         }
         if (complex && data) {
-            const { isAutoYGap, isFitYGap, contentAlign, rowXAlign, rowYAlign } = pData;
+            const {isAutoYGap: isAutoYGap, isFitYGap: isFitYGap, contentAlign: contentAlign, rowXAlign: rowXAlign, rowYAlign: rowYAlign} = pData;
             if (data.count) {
-                if (data.grow)
-                    growX(box, data, width, reverse);
-                else if (isAutoXGap)
-                    autoGap(data, side, width, isFitXGap);
-                if (wrap)
-                    flowWrap(wrapData, data, side);
+                if (data.grow) growX(box, data, width, reverse); else if (isAutoXGap) autoGap(data, side, width, isFitXGap);
+                if (wrap) flowWrap(wrapData, data, side);
             }
             if (wrap) {
-                if (isAutoYGap)
-                    autoGap(wrapData, 'height', height, isFitYGap);
-                else
-                    wrapData.height += (wrapData.gap = yGap) * (wrapData.list.length - 1);
+                if (isAutoYGap) autoGap(wrapData, "height", height, isFitYGap); else wrapData.height += (wrapData.gap = yGap) * (wrapData.list.length - 1);
                 align$1(box, wrapData, contentAlign, rowXAlign);
                 layout$1(box, wrapData, rowYAlign, reverse);
-            }
-            else {
+            } else {
                 alignContent(box, data, contentAlign);
                 layoutX(box, data, 0, data.y, rowYAlign, reverse);
             }
         }
     }
-
     function align(box, data, contentAlign, rowYAlign) {
         alignContent(box, data, contentAlign);
-        const { list } = data;
+        const {list: list} = data;
         if (list.length > 1) {
-            if (!rowYAlign)
-                rowYAlign = alignToInnerYMap[contentAlign];
-            if (rowYAlign !== 'from') {
+            if (!rowYAlign) rowYAlign = alignToInnerYMap[contentAlign];
+            if (rowYAlign !== "from") {
                 let row;
                 for (let i = 0, len = list.length; i < len; i++) {
                     row = list[i];
                     row.y = data.height - row.height;
-                    if (rowYAlign === 'center')
-                        row.y /= 2;
+                    if (rowYAlign === "center") row.y /= 2;
                 }
             }
         }
     }
-
-    const { move: move$1 } = draw.PointHelper;
+    const {move: move$1} = draw.PointHelper;
     function layout(box, data, rowXAlign, reverse) {
-        const { list } = data, reverseWrap = box.__.flowWrap === 'reverse';
-        let row, { x, y } = data;
+        const {list: list} = data, reverseWrap = box.__.flowWrap === "reverse";
+        let row, {x: x, y: y} = data;
         for (let i = 0, len = list.length; i < len; i++) {
             row = list[reverseWrap ? len - 1 - i : i];
             layoutY(box, row, x, y, rowXAlign, reverse);
@@ -383,185 +330,156 @@ this.LeaferIN.flow = (function (exports, draw) {
         }
     }
     function layoutY(box, row, fromX, fromY, rowXAlign, reverse) {
-        const { children } = box;
-        let child, local, { y, start } = row, x = fromX;
+        const {children: children} = box;
+        let child, local, {y: y, start: start} = row, x = fromX;
         y += fromY;
         for (let j = 0, end = row.count; j < end; j++) {
             child = children[reverse ? start - j : start + j];
             if (child.__.inFlow && child.__.visible !== 0) {
                 local = child.__flowBounds;
-                if (rowXAlign !== 'from')
-                    x = fromX + (row.width - local.width) / (rowXAlign === 'center' ? 2 : 1);
+                if (rowXAlign !== "from") x = fromX + (row.width - local.width) / (rowXAlign === "center" ? 2 : 1);
                 move$1(child, x - local.x, y - local.y);
                 y += local.height + row.gap;
-            }
-            else {
+            } else {
                 end++;
             }
         }
     }
-
-    const { move } = draw.PointHelper;
+    const {move: move} = draw.PointHelper;
     function flowY(box, reverse) {
-        const side = 'height', { children, itemBox } = box, pData = getParseData(box, false);
-        const { complex, wrap, xGap, yGap, isAutoYGap, isFitYGap } = pData;
-        if (!children.length)
-            return;
+        const side = "height", {children: children, itemBox: itemBox} = box, pData = getParseData(box, false);
+        const {complex: complex, wrap: wrap, xGap: xGap, yGap: yGap, isAutoYGap: isAutoYGap, isFitYGap: isFitYGap} = pData;
+        if (!children.length) return;
         const wrapData = wrap && getWrapDrawData(), yGapTempNum = isAutoYGap ? 0 : yGap;
-        let child, local, localHeight, index, data, { x, y, width, height } = box.__layout.contentBounds;
+        let child, local, localHeight, index, data, {x: x, y: y, width: width, height: height} = box.__layout.contentBounds;
         for (let i = 0, len = children.length; i < len; i++) {
             child = children[index = reverse ? len - 1 - i : i];
             if (child.__.inFlow && child.__.visible !== 0) {
                 local = getItemBounds(child, itemBox);
                 if (complex) {
                     child.__flowBounds = local;
-                    if (!data)
-                        data = getDrawData(index, yGapTempNum);
+                    if (!data) data = getDrawData(index, yGapTempNum);
                     if (wrap && data.count && data.height + local.height > height) {
-                        if (data.grow)
-                            growY(box, data, height, reverse);
-                        if (isAutoYGap)
-                            autoGap(data, side, height, isFitYGap);
+                        if (data.grow) growY(box, data, height, reverse);
+                        if (isAutoYGap) autoGap(data, side, height, isFitYGap);
                         flowWrap(wrapData, data, side);
                         data = getDrawData(index, yGapTempNum);
                     }
                     localHeight = local.height;
                     if (child.__heightGrow) {
                         data.grow += child.__heightGrow, localHeight = 0;
-                        if (child.__.heightRange)
-                            data.hasRangeSize = true;
+                        if (child.__.heightRange) data.hasRangeSize = true;
                     }
-                    if (child.__widthGrow)
-                        resizeWidth(child, local, width);
+                    if (child.__widthGrow) resizeWidth(child, local, width);
                     data.height += data.count ? localHeight + yGapTempNum : localHeight;
                     data.width = Math.max(data.width, local.width);
                     data.count++;
-                }
-                else {
+                } else {
                     move(child, x - local.x, y - local.y);
                     y += local.height + yGapTempNum;
                 }
             }
         }
         if (complex && data) {
-            const { isAutoXGap, isFitXGap, contentAlign, rowXAlign, rowYAlign } = pData;
+            const {isAutoXGap: isAutoXGap, isFitXGap: isFitXGap, contentAlign: contentAlign, rowXAlign: rowXAlign, rowYAlign: rowYAlign} = pData;
             if (data.count) {
-                if (data.grow)
-                    growY(box, data, height, reverse);
-                if (isAutoYGap)
-                    autoGap(data, side, height, isFitYGap);
-                if (wrap)
-                    flowWrap(wrapData, data, side);
+                if (data.grow) growY(box, data, height, reverse);
+                if (isAutoYGap) autoGap(data, side, height, isFitYGap);
+                if (wrap) flowWrap(wrapData, data, side);
             }
             if (wrap) {
-                if (isAutoXGap)
-                    autoGap(wrapData, 'width', width, isFitXGap);
-                else
-                    wrapData.width += (wrapData.gap = xGap) * (wrapData.list.length - 1);
+                if (isAutoXGap) autoGap(wrapData, "width", width, isFitXGap); else wrapData.width += (wrapData.gap = xGap) * (wrapData.list.length - 1);
                 align(box, wrapData, contentAlign, rowYAlign);
                 layout(box, wrapData, rowXAlign, reverse);
-            }
-            else {
+            } else {
                 alignContent(box, data, contentAlign);
                 layoutY(box, data, data.x, 0, rowXAlign, reverse);
             }
         }
     }
-
     function autoBoundsType(defaultValue) {
-        return draw.decorateLeafAttr(defaultValue, (key) => draw.attr({
+        return draw.decorateLeafAttr(defaultValue, key => draw.attr({
             set(value) {
-                const grow = typeof value === 'number' ? value : 0;
-                key === 'autoWidth' ? this.__widthGrow = grow : this.__heightGrow = grow;
-                if (grow && !(this.parent && this.parent.__hasGrow))
-                    this.waitParent(() => { this.parent.__hasGrow = true; });
+                const grow = draw.isNumber(value) ? value : 0;
+                key === "autoWidth" ? this.__widthGrow = grow : this.__heightGrow = grow;
+                if (grow && !(this.parent && this.parent.__hasGrow)) this.waitParent(() => {
+                    this.parent.__hasGrow = true;
+                });
                 this.__setAttr(key, value) && draw.doBoundsType(this);
             }
         }));
     }
-
-    draw.Plugin.add('flow', 'resize');
-    const box = draw.Box.prototype, { __updateBoxBounds } = draw.Group.prototype;
-    draw.UI.addAttr('flow', false, draw.autoLayoutType);
-    draw.UI.addAttr('gap', 0, draw.boundsType);
-    draw.UI.addAttr('flowAlign', 'top-left', draw.boundsType);
-    draw.UI.addAttr('flowWrap', false, draw.boundsType);
-    draw.UI.addAttr('itemBox', 'box', draw.boundsType);
-    draw.UI.addAttr('inFlow', true, draw.boundsType);
-    draw.UI.addAttr('autoWidth', undefined, autoBoundsType);
-    draw.UI.addAttr('autoHeight', undefined, autoBoundsType);
-    draw.UI.addAttr('autoBox', undefined, draw.boundsType);
-    const { copyAndSpread } = draw.BoundsHelper;
-    box.__updateFlowLayout = function () {
-        const { leaferIsCreated, flow } = this;
-        if (leaferIsCreated)
-            this.leafer.created = false;
+    draw.Plugin.add("flow", "resize");
+    const box = draw.Box.prototype, {__updateBoxBounds: __updateBoxBounds} = draw.Group.prototype;
+    draw.UI.addAttr("flow", false, draw.autoLayoutType);
+    draw.UI.addAttr("gap", 0, draw.boundsType);
+    draw.UI.addAttr("flowAlign", "top-left", draw.boundsType);
+    draw.UI.addAttr("flowWrap", false, draw.boundsType);
+    draw.UI.addAttr("itemBox", "box", draw.boundsType);
+    draw.UI.addAttr("inFlow", true, draw.boundsType);
+    draw.UI.addAttr("autoWidth", undefined, autoBoundsType);
+    draw.UI.addAttr("autoHeight", undefined, autoBoundsType);
+    draw.UI.addAttr("autoBox", undefined, draw.boundsType);
+    const {copyAndSpread: copyAndSpread} = draw.BoundsHelper;
+    box.__updateFlowLayout = function() {
+        const {leaferIsCreated: leaferIsCreated, flow: flow} = this;
+        if (leaferIsCreated) this.leafer.created = false;
         switch (flow) {
-            case 'x':
-            case true:
-                flowX(this);
-                break;
-            case 'y':
-                flowY(this);
-                break;
-            case 'x-reverse':
-                flowX(this, true);
-                break;
-            case 'y-reverse':
-                flowY(this, true);
-                break;
+          case "x":
+          case true:
+            flowX(this);
+            break;
+
+          case "y":
+            flowY(this);
+            break;
+
+          case "x-reverse":
+            flowX(this, true);
+            break;
+
+          case "y-reverse":
+            flowY(this, true);
+            break;
         }
-        if (leaferIsCreated)
-            this.leafer.created = true;
+        if (leaferIsCreated) this.leafer.created = true;
     };
-    box.__updateContentBounds = function () {
-        const { padding } = this.__;
+    box.__updateContentBounds = function() {
+        const {padding: padding} = this.__;
         const layout = this.__layout;
         const same = layout.contentBounds === layout.boxBounds;
         if (padding) {
-            if (same)
-                layout.shrinkContent();
+            if (same) layout.shrinkContent();
             copyAndSpread(layout.contentBounds, layout.boxBounds, padding, true);
-        }
-        else {
-            if (!same)
-                layout.shrinkContentCancel();
+        } else {
+            if (!same) layout.shrinkContentCancel();
         }
     };
-    box.__updateBoxBounds = function (secondLayout) {
+    box.__updateBoxBounds = function(secondLayout) {
         if (this.children.length && !this.pathInputed) {
-            const data = this.__, { flow } = data;
+            const data = this.__, {flow: flow} = data;
             if (data.__autoSide) {
-                if (data.__hasSurface)
-                    this.__extraUpdate();
+                if (data.__hasSurface) this.__extraUpdate();
                 flow && !secondLayout ? this.__updateRectBoxBounds() : __updateBoxBounds.call(this);
-                const { boxBounds } = this.__layout;
+                const {boxBounds: boxBounds} = this.__layout;
                 if (!data.__autoSize) {
                     if (data.__autoWidth) {
-                        if (!flow)
-                            boxBounds.width += boxBounds.x, boxBounds.x = 0;
+                        if (!flow) boxBounds.width += boxBounds.x, boxBounds.x = 0;
                         boxBounds.height = data.height, boxBounds.y = 0;
-                    }
-                    else {
-                        if (!flow)
-                            boxBounds.height += boxBounds.y, boxBounds.y = 0;
+                    } else {
+                        if (!flow) boxBounds.height += boxBounds.y, boxBounds.y = 0;
                         boxBounds.width = data.width, boxBounds.x = 0;
                     }
                 }
-                flow && secondLayout && data.padding && copyAndSpread(boxBounds, boxBounds, data.padding, false, data.__autoSize ? null : (data.__autoWidth ? 'width' : 'height'));
+                flow && secondLayout && data.padding && copyAndSpread(boxBounds, boxBounds, data.padding, false, data.__autoSize ? null : data.__autoWidth ? "width" : "height");
                 this.__updateNaturalSize();
-            }
-            else {
+            } else {
                 this.__updateRectBoxBounds();
             }
-            if (flow)
-                this.__updateContentBounds();
-        }
-        else {
+            if (flow) this.__updateContentBounds();
+        } else {
             this.__updateRectBoxBounds();
         }
     };
-
     return exports;
-
-})({}, LeaferUI);
+}({}, LeaferUI);