@leafer-in/flow 1.0.0 → 1.0.2

package/dist/flow.cjs

@@ -1 +1,738 @@
-"use strict";var t=require("@leafer-in/resize"),e=require("@leafer-ui/draw");function o(t,e,o,n){var i,r=arguments.length,h=r<3?e:null===n?n=Object.getOwnPropertyDescriptor(e,o):n;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)h=Reflect.decorate(t,e,o,n);else for(var s=t.length-1;s>=0;s--)(i=t[s])&&(h=(r<3?i(h):r>3?i(e,o,h):i(e,o))||h);return r>3&&h&&Object.defineProperty(e,o,h),h}"function"==typeof SuppressedError&&SuppressedError;class n extends e.BoxData{}exports.Flow=class extends e.Box{get __tag(){return"Flow"}constructor(t){super(t),this.__hasAutoLayout=!0}},o([e.dataProcessor(n)],exports.Flow.prototype,"__",void 0),o([e.autoLayoutType("x")],exports.Flow.prototype,"flow",void 0),exports.Flow=o([e.registerUI()],exports.Flow);const i={},r={"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"},h={"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 s(t,o,n){e.AlignHelper.toPoint(n,o,t.__layout.contentBounds,i);const r=t.__;o.x=r.__autoWidth?0:i.x,o.y=r.__autoHeight?0:i.y}const{move:c}=e.PointHelper;function a(t,e,o,n,i,r){const{children:h}=t;let s,a,{x:l,start:_}=e,u=n;l+=o;for(let t=0,o=e.count;t<o;t++)s=h[r?_-t:_+t],s.__.inFlow&&0!==s.__.visible?(a=s.__flowBounds,"from"!==i&&(u=n+(e.height-a.height)/("center"===i?2:1)),c(s,l-a.x,u-a.y),l+=a.width+e.gap):o++}function l(t,e,o){const n="width"===o?"height":"width";t[o]=Math.max(t[o],e[o]),t[n]+=t.count?e[n]+t.gap:e[n],t.list.push(e),t.count++}const _={};function u(t,e){const{gap:o,flowAlign:n,flowWrap:i,__autoWidth:s,__autoHeight:c}=t.__,a=i&&(e?!s:!c);return"object"==typeof o?(_.xGap=o.x||0,_.yGap=o.y||0):_.xGap=_.yGap=o,_.isAutoXGap="string"==typeof _.xGap&&!s,_.isAutoYGap="string"==typeof _.yGap&&!c,_.complex=a||"top-left"!==n||t.__hasGrow||_.isAutoXGap||_.isAutoYGap,_.wrap=a,_.complex&&(_.isFitXGap="fit"===_.xGap&&!s,_.isFitYGap="fit"===_.yGap&&!c,"object"==typeof n?(_.contentAlign=n.content||"top-left",_.rowXAlign=n.x||"from",_.rowYAlign=n.y||"from"):(_.contentAlign=n,_.rowXAlign=r[n],_.rowYAlign=h[n])),_}function g(t,e){return{x:0,y:0,width:0,height:0,gap:e,start:t,count:0,grow:0}}function p(t,e,o,n){const{count:i}=t;i>1&&(o>t[e]||n)&&(t.gap=(o-t[e])/(i-1),t[e]=o)}function f(t,e){return"box"===e?t.__local:t.__layout.localStrokeBounds}const{within:w}=e.MathHelper;function d(t,e,o,n){let i,r,h,s=0,c=e.hasRangeSize&&[],{grow:a,start:l}=e;const _=e.width<o?(o-e.width)/a:0,{children:u}=t;_&&(e.width=o);for(let t=0,o=e.count;t<o;t++)i=u[n?l-t:l+t],i.__.inFlow&&0!==i.__.visible?(r=i.__widthGrow)&&(h=y(i,i.__flowBounds,_*r),h?(s+=h,a-=r):c&&(i.__.widthRange?c.unshift(i):c.push(i))):o++;s&&function(t,e,o){let n,i,r,h;t.forEach((t=>{n=t.__widthGrow,i=e/o*n,h=y(t,r=t.__flowBounds,r.width+i),e-=i-h,o-=n}))}(c,s,a)}function y(t,e,o){const{widthRange:n,lockRatio:i}=t.__,r=n?w(o,n.min,n.max):o,h=r/e.width;return t.scaleResize(h,i?h:1),e.width=r,o-r}const{within:x}=e.MathHelper;function G(t,e,o,n){let i,r,h,s=0,c=e.hasRangeSize&&[],{grow:a,start:l}=e;const _=e.height<o?(o-e.height)/a:0,{children:u}=t;_&&(e.height=o);for(let t=0,o=e.count;t<o;t++)i=u[n?l-t:l+t],i.__.inFlow&&0!==i.__.visible?(r=i.__heightGrow)&&(h=m(i,i.__flowBounds,_*r),h?(s+=h,a-=r):c&&(i.__.heightRange?c.unshift(i):c.push(i))):o++;s&&function(t,e,o){let n,i,r,h;t.forEach((t=>{n=t.__heightGrow,i=e/o*n,h=m(t,r=t.__flowBounds,r.height+i),e-=i-h,o-=n}))}(c,s,a)}function m(t,e,o){const{heightRange:n,lockRatio:i}=t.__,r=n?x(o,n.min,n.max):o,h=r/e.height;return t.scaleResize(i?h:1,h),e.height=r,o-r}const{move:b}=e.PointHelper;const{move:A}=e.PointHelper;function B(t,e,o,n,i,r){const{children:h}=t;let s,c,{y:a,start:l}=e,_=o;a+=n;for(let t=0,n=e.count;t<n;t++)s=h[r?l-t:l+t],s.__.inFlow&&0!==s.__.visible?(c=s.__flowBounds,"from"!==i&&(_=o+(e.width-c.width)/("center"===i?2:1)),A(s,_-c.x,a-c.y),a+=c.height+e.gap):n++}const{move:v}=e.PointHelper;function F(t){return e.decorateLeafAttr(t,(t=>e.attr({set(o){const n="number"==typeof o?o:0;"autoWidth"===t?this.__widthGrow=n:this.__heightGrow=n,!n||this.parent&&this.parent.__hasGrow||this.waitParent((()=>{this.parent.__hasGrow=!0})),this.__setAttr(t,o)&&e.doBoundsType(this)}})))}const{copyAndSpread:R}=e.BoundsHelper;let H=function(t,e){const o="width",{children:n,itemBox:i}=t,h=u(t,!0),{complex:c,wrap:_,xGap:w,yGap:y,isAutoXGap:x,isFitXGap:G}=h;if(!n.length)return;const A=_&&{x:0,y:0,width:0,height:0,gap:0,count:0,list:[]},B=x?0:w;let v,F,R,H,P,{x:X,y:Y,width:k,height:j}=t.__layout.contentBounds;for(let r=0,h=n.length;r<h;r++)v=n[H=e?h-1-r:r],v.__.inFlow&&0!==v.__.visible&&(F=f(v,i),c?(v.__flowBounds=F,P||(P=g(H,B)),_&&P.count&&P.width+F.width>k&&(P.grow?d(t,P,k,e):x&&p(P,o,k,G),l(A,P,o),P=g(H,B)),R=F.width,v.__widthGrow&&(P.grow+=v.__widthGrow,R=0,v.__.widthRange&&(P.hasRangeSize=!0)),v.__heightGrow&&m(v,F,j),P.width+=P.count?R+B:R,P.height=Math.max(P.height,F.height),P.count++):(b(v,X-F.x,Y-F.y),X+=F.width+B));if(c){const{isAutoYGap:n,isFitYGap:i,contentAlign:c,rowXAlign:u,rowYAlign:g}=h;P.count&&(P.grow?d(t,P,k,e):x&&p(P,o,k,G),_&&l(A,P,o)),_?(n?p(A,"height",j,i):A.gap=y,function(t,e,o,n){s(t,e,o);const{list:i}=e;if(i.length>1&&(n||(n=r[o]),"from"!==n)){let t;for(let o=0,r=i.length;o<r;o++)t=i[o],t.x=e.width-t.width,"center"===n&&(t.x/=2)}}(t,A,c,u),function(t,e,o,n){const{list:i}=e,r="reverse"===t.__.flowWrap;let h,{x:s,y:c}=e;for(let l=0,_=i.length;l<_;l++)h=i[r?_-1-l:l],a(t,h,s,c,o,n),c+=h.height+e.gap}(t,A,g,e)):(s(t,P,c),a(t,P,0,P.y,g,e))}},P=function(t,e){const o="height",{children:n,itemBox:i}=t,r=u(t,!1),{complex:c,wrap:a,xGap:_,yGap:w,isAutoYGap:d,isFitYGap:x}=r;if(!n.length)return;const m=a&&{x:0,y:0,width:0,height:0,gap:0,count:0,list:[]},b=d?0:w;let A,F,R,H,P,{x:X,y:Y,width:k,height:j}=t.__layout.contentBounds;for(let r=0,h=n.length;r<h;r++)A=n[H=e?h-1-r:r],A.__.inFlow&&0!==A.__.visible&&(F=f(A,i),c?(A.__flowBounds=F,P||(P=g(H,b)),a&&P.count&&P.height+F.height>j&&(P.grow&&G(t,P,j,e),d&&p(P,o,j,x),l(m,P,o),P=g(H,b)),R=F.height,A.__heightGrow&&(P.grow+=A.__heightGrow,R=0,A.__.heightRange&&(P.hasRangeSize=!0)),A.__widthGrow&&y(A,F,k),P.height+=P.count?R+b:R,P.width=Math.max(P.width,F.width),P.count++):(v(A,X-F.x,Y-F.y),Y+=F.height+b));if(c){const{isAutoXGap:n,isFitXGap:i,contentAlign:c,rowXAlign:u,rowYAlign:g}=r;P.count&&(P.grow&&G(t,P,j,e),d&&p(P,o,j,x),a&&l(m,P,o)),a?(n?p(m,"width",k,i):m.gap=_,function(t,e,o,n){s(t,e,o);const{list:i}=e;if(i.length>1&&(n||(n=h[o]),"from"!==n)){let t;for(let o=0,r=i.length;o<r;o++)t=i[o],t.y=e.height-t.height,"center"===n&&(t.y/=2)}}(t,m,c,g),function(t,e,o,n){const{list:i}=e,r="reverse"===t.__.flowWrap;let h,{x:s,y:c}=e;for(let a=0,l=i.length;a<l;a++)h=i[r?l-1-a:a],B(t,h,s,c,o,n),s+=h.width+e.gap}(t,m,u,e)):(s(t,P,c),B(t,P,P.x,0,u,e))}};e.UI.changeAttr("autoWidth",void 0,F),e.UI.changeAttr("autoHeight",void 0,F),e.Box.prototype.__updateFlowLayout=function(){this.leafer.created=!1;const{flow:t}=this.__;switch(t){case"x":case!0:H(this);break;case"y":P(this);break;case"x-reverse":H(this,!0);break;case"y-reverse":P(this,!0)}this.leafer.created=!0},e.Box.prototype.__updateContentBounds=function(){const{padding:t}=this.__,e=this.__layout,o=e.contentBounds===e.boxBounds;t?(o&&e.shrinkContent(),R(e.contentBounds,e.boxBounds,t,!0)):o||e.shrinkContentCancel()},Object.keys(t).forEach((function(e){"default"===e||Object.prototype.hasOwnProperty.call(exports,e)||Object.defineProperty(exports,e,{enumerable:!0,get:function(){return t[e]}})}));
+'use strict';
+
+var draw = require('@leafer-ui/draw');
+
+const { M, L, C, Q, Z, N, D, X, G, F, O, P, U } = draw.PathCommandMap;
+const PathScaler = {
+    scale(data, scaleX, scaleY) {
+        if (!data)
+            return;
+        let command;
+        let i = 0, len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                    scalePoints(data, scaleX, scaleY, i, 1);
+                    i += 3;
+                    break;
+                case L:
+                    scalePoints(data, scaleX, scaleY, i, 1);
+                    i += 3;
+                    break;
+                case C:
+                    scalePoints(data, scaleX, scaleY, i, 3);
+                    i += 7;
+                    break;
+                case Q:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 5;
+                    break;
+                case Z:
+                    i += 1;
+                    break;
+                case N:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 5;
+                    break;
+                case D:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 9;
+                    break;
+                case X:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 6;
+                    break;
+                case G:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 9;
+                    break;
+                case F:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 5;
+                    break;
+                case O:
+                    data[i] = G;
+                    data.splice(i + 4, 0, data[i + 3], 0);
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 7 + 2;
+                    len += 2;
+                    break;
+                case P:
+                    data[i] = F;
+                    data.splice(i + 4, 0, data[i + 3]);
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 4 + 1;
+                    len += 1;
+                    break;
+                case U:
+                    scalePoints(data, scaleX, scaleY, i, 2);
+                    i += 6;
+                    break;
+            }
+        }
+    },
+    scalePoints(data, scaleX, scaleY, start, pointCount) {
+        for (let i = pointCount ? start + 1 : 0, end = pointCount ? i + pointCount * 2 : data.length; i < end; i += 2) {
+            data[i] *= scaleX;
+            data[i + 1] *= scaleY;
+        }
+    }
+};
+const { scalePoints } = PathScaler;
+
+const matrix = draw.MatrixHelper.get();
+const { topLeft, top, topRight, right, bottom, left } = draw.Direction9;
+function scaleResize(leaf, scaleX, scaleY) {
+    if (leaf.pathInputed) {
+        scaleResizePath(leaf, scaleX, scaleY);
+    }
+    else {
+        if (scaleX !== 1)
+            leaf.width *= scaleX;
+        if (scaleY !== 1)
+            leaf.height *= scaleY;
+    }
+}
+function scaleResizeFontSize(leaf, scaleX, scaleY) {
+    const { app } = leaf;
+    const editor = app && app.editor;
+    if (editor.editing) {
+        const layout = leaf.__layout;
+        let { width, height } = layout.boxBounds;
+        width *= (scaleY - scaleX) * (leaf.scaleX < 0 ? -1 : 1);
+        height *= (scaleX - scaleY) * (leaf.scaleY < 0 ? -1 : 1);
+        switch (editor.resizeDirection) {
+            case top:
+            case bottom:
+                leaf.fontSize *= scaleY;
+                layout.affectScaleOrRotation ? leaf.moveInner(-width / 2, 0) : leaf.x -= width / 2;
+                break;
+            case left:
+            case right:
+                leaf.fontSize *= scaleX;
+                layout.affectScaleOrRotation ? leaf.moveInner(0, -height / 2) : leaf.y -= height / 2;
+                break;
+            case topLeft:
+            case topRight:
+                leaf.fontSize *= scaleX;
+                layout.affectScaleOrRotation ? leaf.moveInner(0, -height) : leaf.y -= height;
+                break;
+            default:
+                leaf.fontSize *= scaleX;
+        }
+    }
+    else {
+        leaf.fontSize *= scaleX;
+    }
+}
+function scaleResizePath(leaf, scaleX, scaleY) {
+    PathScaler.scale(leaf.__.path, scaleX, scaleY);
+    leaf.path = leaf.__.path;
+}
+function scaleResizePoints(leaf, scaleX, scaleY) {
+    PathScaler.scalePoints(leaf.__.points, scaleX, scaleY);
+    leaf.points = leaf.__.points;
+}
+function scaleResizeGroup(group, scaleX, scaleY) {
+    const { children } = group;
+    for (let i = 0; i < children.length; i++) {
+        matrix.a = scaleX;
+        matrix.d = scaleY;
+        children[i].transform(matrix, true);
+    }
+}
+
+const leaf = draw.Leaf.prototype;
+leaf.scaleResize = function (scaleX, scaleY = scaleX, noResize) {
+    const data = this;
+    if (noResize || (data.editConfig && data.editConfig.editSize === 'scale')) {
+        data.scaleX *= scaleX;
+        data.scaleY *= scaleY;
+    }
+    else {
+        if (scaleX < 0)
+            data.scaleX *= -1, scaleX = -scaleX;
+        if (scaleY < 0)
+            data.scaleY *= -1, scaleY = -scaleY;
+        this.__scaleResize(scaleX, scaleY);
+    }
+};
+leaf.__scaleResize = function (scaleX, scaleY) {
+    scaleResize(this, scaleX, scaleY);
+};
+leaf.resizeWidth = function (width) {
+    const scale = width / this.getBounds('box', 'local').width;
+    this.scaleOf(this.__layout.boxBounds, scale, this.__.lockRatio ? scale : 1, true);
+};
+leaf.resizeHeight = function (height) {
+    const scale = height / this.getBounds('box', 'local').height;
+    this.scaleOf(this.__layout.boxBounds, this.__.lockRatio ? scale : 1, scale, true);
+};
+draw.Text.prototype.__scaleResize = function (scaleX, scaleY) {
+    if (this.__.__autoSize && (this.__.resizeFontSize || (this.editConfig && this.editConfig.editSize === 'font-size'))) {
+        scaleResizeFontSize(this, scaleX, scaleY);
+    }
+    else {
+        scaleResize(this, scaleX, scaleY);
+    }
+};
+draw.Path.prototype.__scaleResize = function (scaleX, scaleY) {
+    scaleResizePath(this, scaleX, scaleY);
+};
+draw.Line.prototype.__scaleResize = function (scaleX, scaleY) {
+    if (this.pathInputed) {
+        scaleResizePath(this, scaleX, scaleY);
+    }
+    else if (this.points) {
+        scaleResizePoints(this, scaleX, scaleY);
+    }
+    else {
+        this.width *= scaleX;
+    }
+};
+draw.Polygon.prototype.__scaleResize = function (scaleX, scaleY) {
+    if (this.pathInputed) {
+        scaleResizePath(this, scaleX, scaleY);
+    }
+    else if (this.points) {
+        scaleResizePoints(this, scaleX, scaleY);
+    }
+    else {
+        scaleResize(this, scaleX, scaleY);
+    }
+};
+draw.Group.prototype.__scaleResize = function (scaleX, scaleY) {
+    scaleResizeGroup(this, scaleX, scaleY);
+};
+draw.Box.prototype.__scaleResize = function (scaleX, scaleY) {
+    if (this.__.__autoSize && this.children.length) {
+        scaleResizeGroup(this, scaleX, scaleY);
+    }
+    else {
+        scaleResize(this, scaleX, scaleY);
+        if (this.__.resizeChildren)
+            scaleResizeGroup(this, scaleX, scaleY);
+    }
+};
+
+/******************************************************************************
+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 */
+
+
+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'; }
+    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);
+
+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',
+};
+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',
+};
+function alignContent(box, content, align) {
+    draw.AlignHelper.toPoint(align, content, box.__layout.contentBounds, point);
+    const data = box.__;
+    content.x = data.__autoWidth ? 0 : point.x;
+    content.y = data.__autoHeight ? 0 : point.y;
+}
+
+function align$1(box, data, contentAlign, innerXAlign) {
+    alignContent(box, data, contentAlign);
+    const { list } = data;
+    if (list.length > 1) {
+        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;
+            }
+        }
+    }
+}
+
+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;
+    for (let i = 0, len = list.length; i < len; i++) {
+        row = list[reverseWrap ? len - 1 - i : i];
+        layoutX(box, row, x, y, rowYAlign, reverse);
+        y += row.height + data.gap;
+    }
+}
+function layoutX(box, row, fromX, fromY, rowYAlign, reverse) {
+    const { children } = box;
+    let child, local, { x, 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);
+            move$3(child, x - local.x, y - local.y);
+            x += local.width + row.gap;
+        }
+        else {
+            end++;
+        }
+    }
+}
+
+function flowWrap(wrapData, data, wrapSide) {
+    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 needWrap = wrap && (isFlowX ? !__autoWidth : !__autoHeight);
+    if (typeof gap === 'object') {
+        p.xGap = gap.x || 0;
+        p.yGap = gap.y || 0;
+    }
+    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.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.contentAlign = align;
+            p.rowXAlign = alignToInnerXMap[align];
+            p.rowYAlign = alignToInnerYMap[align];
+        }
+    }
+    return p;
+}
+function getDrawData(start, gap) {
+    return { x: 0, y: 0, width: 0, height: 0, gap, start, count: 0, grow: 0 };
+}
+function getWrapDrawData() {
+    return { x: 0, y: 0, width: 0, height: 0, gap: 0, count: 0, list: [] };
+}
+
+function autoGap(data, side, sideTotal, fit) {
+    const { 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;
+}
+
+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 = row.width < width ? (width - row.width) / totalGrow : 0, { children } = box;
+    if (growSize)
+        row.width = width;
+    for (let j = 0, end = row.count; j < end; j++) {
+        child = children[reverse ? start - j : start + j];
+        if (child.__.inFlow && child.__.visible !== 0) {
+            if (grow = child.__widthGrow) {
+                remainSpace = resizeWidth(child, child.__flowBounds, growSize * grow);
+                if (remainSpace) {
+                    remainTotalSpace += remainSpace;
+                    totalGrow -= grow;
+                }
+                else if (list) {
+                    child.__.widthRange ? list.unshift(child) : list.push(child);
+                }
+            }
+        }
+        else {
+            end++;
+        }
+    }
+    if (remainTotalSpace)
+        assignRemainSpace$1(list, remainTotalSpace, totalGrow);
+}
+function assignRemainSpace$1(list, totalSpace, countGrow) {
+    let grow, space, local, remain;
+    list.forEach(child => {
+        grow = child.__widthGrow;
+        space = totalSpace / countGrow * grow;
+        remain = resizeWidth(child, local = child.__flowBounds, local.width + space);
+        totalSpace -= space - remain;
+        countGrow -= grow;
+    });
+}
+function resizeWidth(child, local, size) {
+    const { widthRange, 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;
+function growY(box, row, height, reverse) {
+    let child, grow, remainSpace, remainTotalSpace = 0, list = row.hasRangeSize && [], { grow: totalGrow, start } = row;
+    const growSize = row.height < height ? (height - row.height) / totalGrow : 0, { children } = box;
+    if (growSize)
+        row.height = height;
+    for (let j = 0, end = row.count; j < end; j++) {
+        child = children[reverse ? start - j : start + j];
+        if (child.__.inFlow && child.__.visible !== 0) {
+            if (grow = child.__heightGrow) {
+                remainSpace = resizeHeight(child, child.__flowBounds, growSize * grow);
+                if (remainSpace) {
+                    remainTotalSpace += remainSpace;
+                    totalGrow -= grow;
+                }
+                else if (list) {
+                    child.__.heightRange ? list.unshift(child) : list.push(child);
+                }
+            }
+        }
+        else {
+            end++;
+        }
+    }
+    if (remainTotalSpace)
+        assignRemainSpace(list, remainTotalSpace, totalGrow);
+}
+function assignRemainSpace(list, totalSpace, countGrow) {
+    let grow, space, local, remain;
+    list.forEach(child => {
+        grow = child.__heightGrow;
+        space = totalSpace / countGrow * grow;
+        remain = resizeHeight(child, local = child.__flowBounds, local.height + space);
+        totalSpace -= space - remain;
+        countGrow -= grow;
+    });
+}
+function resizeHeight(child, local, size) {
+    const { heightRange, 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;
+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 wrapData = wrap && getWrapDrawData(), xGapTempNum = isAutoXGap ? 0 : xGap;
+    let child, local, localWidth, index, data, { x, y, width, 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 (wrap && data.count && data.width + local.width > width) {
+                    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.__heightGrow)
+                    resizeHeight(child, local, height);
+                data.width += data.count ? localWidth + xGapTempNum : localWidth;
+                data.height = Math.max(data.height, local.height);
+                data.count++;
+            }
+            else {
+                move$2(child, x - local.x, y - local.y);
+                x += local.width + xGapTempNum;
+            }
+        }
+    }
+    if (complex) {
+        const { isAutoYGap, isFitYGap, contentAlign, rowXAlign, 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 (wrap) {
+            if (isAutoYGap)
+                autoGap(wrapData, 'height', height, isFitYGap);
+            else
+                wrapData.gap = yGap;
+            align$1(box, wrapData, contentAlign, rowXAlign);
+            layout$1(box, wrapData, rowYAlign, reverse);
+        }
+        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;
+    if (list.length > 1) {
+        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;
+            }
+        }
+    }
+}
+
+const { move: move$1 } = draw.PointHelper;
+function layout(box, data, rowXAlign, reverse) {
+    const { list } = data, reverseWrap = box.__.flowWrap === 'reverse';
+    let row, { x, 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);
+        x += row.width + data.gap;
+    }
+}
+function layoutY(box, row, fromX, fromY, rowXAlign, reverse) {
+    const { children } = box;
+    let child, local, { y, 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);
+            move$1(child, x - local.x, y - local.y);
+            y += local.height + row.gap;
+        }
+        else {
+            end++;
+        }
+    }
+}
+
+const { 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 wrapData = wrap && getWrapDrawData(), yGapTempNum = isAutoYGap ? 0 : yGap;
+    let child, local, localHeight, index, data, { x, y, width, 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 (wrap && data.count && data.height + local.height > height) {
+                    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.__widthGrow)
+                    resizeWidth(child, local, width);
+                data.height += data.count ? localHeight + yGapTempNum : localHeight;
+                data.width = Math.max(data.width, local.width);
+                data.count++;
+            }
+            else {
+                move(child, x - local.x, y - local.y);
+                y += local.height + yGapTempNum;
+            }
+        }
+    }
+    if (complex) {
+        const { isAutoXGap, isFitXGap, contentAlign, rowXAlign, 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 (wrap) {
+            if (!isAutoXGap)
+                wrapData.gap = xGap;
+            else
+                autoGap(wrapData, 'width', width, isFitXGap);
+            align(box, wrapData, contentAlign, rowYAlign);
+            layout(box, wrapData, rowXAlign, reverse);
+        }
+        else {
+            alignContent(box, data, contentAlign);
+            layoutY(box, data, data.x, 0, rowXAlign, reverse);
+        }
+    }
+}
+
+function autoBoundsType(defaultValue) {
+    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; });
+            this.__setAttr(key, value) && draw.doBoundsType(this);
+        }
+    }));
+}
+
+const { copyAndSpread } = draw.BoundsHelper;
+let doFlowX = flowX, doFlowY = flowY;
+draw.UI.changeAttr('autoWidth', undefined, autoBoundsType);
+draw.UI.changeAttr('autoHeight', undefined, autoBoundsType);
+draw.Box.prototype.__updateFlowLayout = function () {
+    this.leafer.created = false;
+    const { flow } = this.__;
+    switch (flow) {
+        case 'x':
+        case true:
+            doFlowX(this);
+            break;
+        case 'y':
+            doFlowY(this);
+            break;
+        case 'x-reverse':
+            doFlowX(this, true);
+            break;
+        case 'y-reverse':
+            doFlowY(this, true);
+            break;
+    }
+    this.leafer.created = true;
+};
+draw.Box.prototype.__updateContentBounds = function () {
+    const { padding } = this.__;
+    const layout = this.__layout;
+    const same = layout.contentBounds === layout.boxBounds;
+    if (padding) {
+        if (same)
+            layout.shrinkContent();
+        copyAndSpread(layout.contentBounds, layout.boxBounds, padding, true);
+    }
+    else {
+        if (!same)
+            layout.shrinkContentCancel();
+    }
+};
+
+exports.PathScaler = PathScaler;
+exports.scaleResize = scaleResize;
+exports.scaleResizeFontSize = scaleResizeFontSize;
+exports.scaleResizeGroup = scaleResizeGroup;
+exports.scaleResizePath = scaleResizePath;
+exports.scaleResizePoints = scaleResizePoints;