@fmdevui/fm-dev 1.0.113 → 1.0.115

package/es/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/core/Point.mjs

@@ -0,0 +1,130 @@
+var Point = (function () {
+    function Point(x, y) {
+        this.x = x || 0;
+        this.y = y || 0;
+    }
+    Point.prototype.copy = function (other) {
+        this.x = other.x;
+        this.y = other.y;
+        return this;
+    };
+    Point.prototype.clone = function () {
+        return new Point(this.x, this.y);
+    };
+    Point.prototype.set = function (x, y) {
+        this.x = x;
+        this.y = y;
+        return this;
+    };
+    Point.prototype.equal = function (other) {
+        return other.x === this.x && other.y === this.y;
+    };
+    Point.prototype.add = function (other) {
+        this.x += other.x;
+        this.y += other.y;
+        return this;
+    };
+    Point.prototype.scale = function (scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+    };
+    Point.prototype.scaleAndAdd = function (other, scalar) {
+        this.x += other.x * scalar;
+        this.y += other.y * scalar;
+    };
+    Point.prototype.sub = function (other) {
+        this.x -= other.x;
+        this.y -= other.y;
+        return this;
+    };
+    Point.prototype.dot = function (other) {
+        return this.x * other.x + this.y * other.y;
+    };
+    Point.prototype.len = function () {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    };
+    Point.prototype.lenSquare = function () {
+        return this.x * this.x + this.y * this.y;
+    };
+    Point.prototype.normalize = function () {
+        var len = this.len();
+        this.x /= len;
+        this.y /= len;
+        return this;
+    };
+    Point.prototype.distance = function (other) {
+        var dx = this.x - other.x;
+        var dy = this.y - other.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    };
+    Point.prototype.distanceSquare = function (other) {
+        var dx = this.x - other.x;
+        var dy = this.y - other.y;
+        return dx * dx + dy * dy;
+    };
+    Point.prototype.negate = function () {
+        this.x = -this.x;
+        this.y = -this.y;
+        return this;
+    };
+    Point.prototype.transform = function (m) {
+        if (!m) {
+            return;
+        }
+        var x = this.x;
+        var y = this.y;
+        this.x = m[0] * x + m[2] * y + m[4];
+        this.y = m[1] * x + m[3] * y + m[5];
+        return this;
+    };
+    Point.prototype.toArray = function (out) {
+        out[0] = this.x;
+        out[1] = this.y;
+        return out;
+    };
+    Point.prototype.fromArray = function (input) {
+        this.x = input[0];
+        this.y = input[1];
+    };
+    Point.set = function (p, x, y) {
+        p.x = x;
+        p.y = y;
+    };
+    Point.copy = function (p, p2) {
+        p.x = p2.x;
+        p.y = p2.y;
+    };
+    Point.len = function (p) {
+        return Math.sqrt(p.x * p.x + p.y * p.y);
+    };
+    Point.lenSquare = function (p) {
+        return p.x * p.x + p.y * p.y;
+    };
+    Point.dot = function (p0, p1) {
+        return p0.x * p1.x + p0.y * p1.y;
+    };
+    Point.add = function (out, p0, p1) {
+        out.x = p0.x + p1.x;
+        out.y = p0.y + p1.y;
+    };
+    Point.sub = function (out, p0, p1) {
+        out.x = p0.x - p1.x;
+        out.y = p0.y - p1.y;
+    };
+    Point.scale = function (out, p0, scalar) {
+        out.x = p0.x * scalar;
+        out.y = p0.y * scalar;
+    };
+    Point.scaleAndAdd = function (out, p0, p1, scalar) {
+        out.x = p0.x + p1.x * scalar;
+        out.y = p0.y + p1.y * scalar;
+    };
+    Point.lerp = function (out, p0, p1, t) {
+        var onet = 1 - t;
+        out.x = onet * p0.x + t * p1.x;
+        out.y = onet * p0.y + t * p1.y;
+    };
+    return Point;
+}());
+
+export { Point as default };

package/es/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/core/Transformable.mjs

@@ -0,0 +1,246 @@
+import { identity, create, mul, copy, invert, rotate } from './matrix.mjs';
+import { applyTransform } from './vector.mjs';
+
+var mIdentity = identity;
+var EPSILON = 5e-5;
+function isNotAroundZero(val) {
+    return val > EPSILON || val < -EPSILON;
+}
+var scaleTmp = [];
+var tmpTransform = [];
+var originTransform = create();
+var abs = Math.abs;
+var Transformable = (function () {
+    function Transformable() {
+    }
+    Transformable.prototype.getLocalTransform = function (m) {
+        return Transformable.getLocalTransform(this, m);
+    };
+    Transformable.prototype.setPosition = function (arr) {
+        this.x = arr[0];
+        this.y = arr[1];
+    };
+    Transformable.prototype.setScale = function (arr) {
+        this.scaleX = arr[0];
+        this.scaleY = arr[1];
+    };
+    Transformable.prototype.setSkew = function (arr) {
+        this.skewX = arr[0];
+        this.skewY = arr[1];
+    };
+    Transformable.prototype.setOrigin = function (arr) {
+        this.originX = arr[0];
+        this.originY = arr[1];
+    };
+    Transformable.prototype.needLocalTransform = function () {
+        return isNotAroundZero(this.rotation)
+            || isNotAroundZero(this.x)
+            || isNotAroundZero(this.y)
+            || isNotAroundZero(this.scaleX - 1)
+            || isNotAroundZero(this.scaleY - 1)
+            || isNotAroundZero(this.skewX)
+            || isNotAroundZero(this.skewY);
+    };
+    Transformable.prototype.updateTransform = function () {
+        var parentTransform = this.parent && this.parent.transform;
+        var needLocalTransform = this.needLocalTransform();
+        var m = this.transform;
+        if (!(needLocalTransform || parentTransform)) {
+            if (m) {
+                mIdentity(m);
+                this.invTransform = null;
+            }
+            return;
+        }
+        m = m || create();
+        if (needLocalTransform) {
+            this.getLocalTransform(m);
+        }
+        else {
+            mIdentity(m);
+        }
+        if (parentTransform) {
+            if (needLocalTransform) {
+                mul(m, parentTransform, m);
+            }
+            else {
+                copy(m, parentTransform);
+            }
+        }
+        this.transform = m;
+        this._resolveGlobalScaleRatio(m);
+    };
+    Transformable.prototype._resolveGlobalScaleRatio = function (m) {
+        var globalScaleRatio = this.globalScaleRatio;
+        if (globalScaleRatio != null && globalScaleRatio !== 1) {
+            this.getGlobalScale(scaleTmp);
+            var relX = scaleTmp[0] < 0 ? -1 : 1;
+            var relY = scaleTmp[1] < 0 ? -1 : 1;
+            var sx = ((scaleTmp[0] - relX) * globalScaleRatio + relX) / scaleTmp[0] || 0;
+            var sy = ((scaleTmp[1] - relY) * globalScaleRatio + relY) / scaleTmp[1] || 0;
+            m[0] *= sx;
+            m[1] *= sx;
+            m[2] *= sy;
+            m[3] *= sy;
+        }
+        this.invTransform = this.invTransform || create();
+        invert(this.invTransform, m);
+    };
+    Transformable.prototype.getComputedTransform = function () {
+        var transformNode = this;
+        var ancestors = [];
+        while (transformNode) {
+            ancestors.push(transformNode);
+            transformNode = transformNode.parent;
+        }
+        while (transformNode = ancestors.pop()) {
+            transformNode.updateTransform();
+        }
+        return this.transform;
+    };
+    Transformable.prototype.setLocalTransform = function (m) {
+        if (!m) {
+            return;
+        }
+        var sx = m[0] * m[0] + m[1] * m[1];
+        var sy = m[2] * m[2] + m[3] * m[3];
+        var rotation = Math.atan2(m[1], m[0]);
+        var shearX = Math.PI / 2 + rotation - Math.atan2(m[3], m[2]);
+        sy = Math.sqrt(sy) * Math.cos(shearX);
+        sx = Math.sqrt(sx);
+        this.skewX = shearX;
+        this.skewY = 0;
+        this.rotation = -rotation;
+        this.x = +m[4];
+        this.y = +m[5];
+        this.scaleX = sx;
+        this.scaleY = sy;
+        this.originX = 0;
+        this.originY = 0;
+    };
+    Transformable.prototype.decomposeTransform = function () {
+        if (!this.transform) {
+            return;
+        }
+        var parent = this.parent;
+        var m = this.transform;
+        if (parent && parent.transform) {
+            parent.invTransform = parent.invTransform || create();
+            mul(tmpTransform, parent.invTransform, m);
+            m = tmpTransform;
+        }
+        var ox = this.originX;
+        var oy = this.originY;
+        if (ox || oy) {
+            originTransform[4] = ox;
+            originTransform[5] = oy;
+            mul(tmpTransform, m, originTransform);
+            tmpTransform[4] -= ox;
+            tmpTransform[5] -= oy;
+            m = tmpTransform;
+        }
+        this.setLocalTransform(m);
+    };
+    Transformable.prototype.getGlobalScale = function (out) {
+        var m = this.transform;
+        out = out || [];
+        if (!m) {
+            out[0] = 1;
+            out[1] = 1;
+            return out;
+        }
+        out[0] = Math.sqrt(m[0] * m[0] + m[1] * m[1]);
+        out[1] = Math.sqrt(m[2] * m[2] + m[3] * m[3]);
+        if (m[0] < 0) {
+            out[0] = -out[0];
+        }
+        if (m[3] < 0) {
+            out[1] = -out[1];
+        }
+        return out;
+    };
+    Transformable.prototype.transformCoordToLocal = function (x, y) {
+        var v2 = [x, y];
+        var invTransform = this.invTransform;
+        if (invTransform) {
+            applyTransform(v2, v2, invTransform);
+        }
+        return v2;
+    };
+    Transformable.prototype.transformCoordToGlobal = function (x, y) {
+        var v2 = [x, y];
+        var transform = this.transform;
+        if (transform) {
+            applyTransform(v2, v2, transform);
+        }
+        return v2;
+    };
+    Transformable.prototype.getLineScale = function () {
+        var m = this.transform;
+        return m && abs(m[0] - 1) > 1e-10 && abs(m[3] - 1) > 1e-10
+            ? Math.sqrt(abs(m[0] * m[3] - m[2] * m[1]))
+            : 1;
+    };
+    Transformable.prototype.copyTransform = function (source) {
+        copyTransform(this, source);
+    };
+    Transformable.getLocalTransform = function (target, m) {
+        m = m || [];
+        var ox = target.originX || 0;
+        var oy = target.originY || 0;
+        var sx = target.scaleX;
+        var sy = target.scaleY;
+        var ax = target.anchorX;
+        var ay = target.anchorY;
+        var rotation = target.rotation || 0;
+        var x = target.x;
+        var y = target.y;
+        var skewX = target.skewX ? Math.tan(target.skewX) : 0;
+        var skewY = target.skewY ? Math.tan(-target.skewY) : 0;
+        if (ox || oy || ax || ay) {
+            var dx = ox + ax;
+            var dy = oy + ay;
+            m[4] = -dx * sx - skewX * dy * sy;
+            m[5] = -dy * sy - skewY * dx * sx;
+        }
+        else {
+            m[4] = m[5] = 0;
+        }
+        m[0] = sx;
+        m[3] = sy;
+        m[1] = skewY * sx;
+        m[2] = skewX * sy;
+        rotation && rotate(m, m, rotation);
+        m[4] += ox + x;
+        m[5] += oy + y;
+        return m;
+    };
+    Transformable.initDefaultProps = (function () {
+        var proto = Transformable.prototype;
+        proto.scaleX =
+            proto.scaleY =
+                proto.globalScaleRatio = 1;
+        proto.x =
+            proto.y =
+                proto.originX =
+                    proto.originY =
+                        proto.skewX =
+                            proto.skewY =
+                                proto.rotation =
+                                    proto.anchorX =
+                                        proto.anchorY = 0;
+    })();
+    return Transformable;
+}());
+;
+var TRANSFORMABLE_PROPS = [
+    'x', 'y', 'originX', 'originY', 'anchorX', 'anchorY', 'rotation', 'scaleX', 'scaleY', 'skewX', 'skewY'
+];
+function copyTransform(target, source) {
+    for (var i = 0; i < TRANSFORMABLE_PROPS.length; i++) {
+        var propName = TRANSFORMABLE_PROPS[i];
+        target[propName] = source[propName];
+    }
+}
+
+export { TRANSFORMABLE_PROPS, copyTransform, Transformable as default };

package/es/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/core/WeakMap.mjs

@@ -0,0 +1,43 @@
+var wmUniqueIndex = Math.round(Math.random() * 9);
+var supportDefineProperty = typeof Object.defineProperty === 'function';
+var WeakMap = (function () {
+    function WeakMap() {
+        this._id = '__ec_inner_' + wmUniqueIndex++;
+    }
+    WeakMap.prototype.get = function (key) {
+        return this._guard(key)[this._id];
+    };
+    WeakMap.prototype.set = function (key, value) {
+        var target = this._guard(key);
+        if (supportDefineProperty) {
+            Object.defineProperty(target, this._id, {
+                value: value,
+                enumerable: false,
+                configurable: true
+            });
+        }
+        else {
+            target[this._id] = value;
+        }
+        return this;
+    };
+    WeakMap.prototype["delete"] = function (key) {
+        if (this.has(key)) {
+            delete this._guard(key)[this._id];
+            return true;
+        }
+        return false;
+    };
+    WeakMap.prototype.has = function (key) {
+        return !!this._guard(key)[this._id];
+    };
+    WeakMap.prototype._guard = function (key) {
+        if (key !== Object(key)) {
+            throw TypeError('Value of WeakMap is not a non-null object.');
+        }
+        return key;
+    };
+    return WeakMap;
+}());
+
+export { WeakMap as default };

package/es/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/core/bbox.mjs

@@ -0,0 +1,127 @@
+import { create, min, max } from './vector.mjs';
+import { cubicExtrema, cubicAt, quadraticExtremum, quadraticAt } from './curve.mjs';
+
+var mathMin = Math.min;
+var mathMax = Math.max;
+var mathSin = Math.sin;
+var mathCos = Math.cos;
+var PI2 = Math.PI * 2;
+var start = create();
+var end = create();
+var extremity = create();
+function fromPoints(points, min, max) {
+    if (points.length === 0) {
+        return;
+    }
+    var p = points[0];
+    var left = p[0];
+    var right = p[0];
+    var top = p[1];
+    var bottom = p[1];
+    for (var i = 1; i < points.length; i++) {
+        p = points[i];
+        left = mathMin(left, p[0]);
+        right = mathMax(right, p[0]);
+        top = mathMin(top, p[1]);
+        bottom = mathMax(bottom, p[1]);
+    }
+    min[0] = left;
+    min[1] = top;
+    max[0] = right;
+    max[1] = bottom;
+}
+function fromLine(x0, y0, x1, y1, min, max) {
+    min[0] = mathMin(x0, x1);
+    min[1] = mathMin(y0, y1);
+    max[0] = mathMax(x0, x1);
+    max[1] = mathMax(y0, y1);
+}
+var xDim = [];
+var yDim = [];
+function fromCubic(x0, y0, x1, y1, x2, y2, x3, y3, min, max) {
+    var cubicExtrema$1 = cubicExtrema;
+    var cubicAt$1 = cubicAt;
+    var n = cubicExtrema$1(x0, x1, x2, x3, xDim);
+    min[0] = Infinity;
+    min[1] = Infinity;
+    max[0] = -Infinity;
+    max[1] = -Infinity;
+    for (var i = 0; i < n; i++) {
+        var x = cubicAt$1(x0, x1, x2, x3, xDim[i]);
+        min[0] = mathMin(x, min[0]);
+        max[0] = mathMax(x, max[0]);
+    }
+    n = cubicExtrema$1(y0, y1, y2, y3, yDim);
+    for (var i = 0; i < n; i++) {
+        var y = cubicAt$1(y0, y1, y2, y3, yDim[i]);
+        min[1] = mathMin(y, min[1]);
+        max[1] = mathMax(y, max[1]);
+    }
+    min[0] = mathMin(x0, min[0]);
+    max[0] = mathMax(x0, max[0]);
+    min[0] = mathMin(x3, min[0]);
+    max[0] = mathMax(x3, max[0]);
+    min[1] = mathMin(y0, min[1]);
+    max[1] = mathMax(y0, max[1]);
+    min[1] = mathMin(y3, min[1]);
+    max[1] = mathMax(y3, max[1]);
+}
+function fromQuadratic(x0, y0, x1, y1, x2, y2, min, max) {
+    var quadraticExtremum$1 = quadraticExtremum;
+    var quadraticAt$1 = quadraticAt;
+    var tx = mathMax(mathMin(quadraticExtremum$1(x0, x1, x2), 1), 0);
+    var ty = mathMax(mathMin(quadraticExtremum$1(y0, y1, y2), 1), 0);
+    var x = quadraticAt$1(x0, x1, x2, tx);
+    var y = quadraticAt$1(y0, y1, y2, ty);
+    min[0] = mathMin(x0, x2, x);
+    min[1] = mathMin(y0, y2, y);
+    max[0] = mathMax(x0, x2, x);
+    max[1] = mathMax(y0, y2, y);
+}
+function fromArc(x, y, rx, ry, startAngle, endAngle, anticlockwise, min$1, max$1) {
+    var vec2Min = min;
+    var vec2Max = max;
+    var diff = Math.abs(startAngle - endAngle);
+    if (diff % PI2 < 1e-4 && diff > 1e-4) {
+        min$1[0] = x - rx;
+        min$1[1] = y - ry;
+        max$1[0] = x + rx;
+        max$1[1] = y + ry;
+        return;
+    }
+    start[0] = mathCos(startAngle) * rx + x;
+    start[1] = mathSin(startAngle) * ry + y;
+    end[0] = mathCos(endAngle) * rx + x;
+    end[1] = mathSin(endAngle) * ry + y;
+    vec2Min(min$1, start, end);
+    vec2Max(max$1, start, end);
+    startAngle = startAngle % (PI2);
+    if (startAngle < 0) {
+        startAngle = startAngle + PI2;
+    }
+    endAngle = endAngle % (PI2);
+    if (endAngle < 0) {
+        endAngle = endAngle + PI2;
+    }
+    if (startAngle > endAngle && !anticlockwise) {
+        endAngle += PI2;
+    }
+    else if (startAngle < endAngle && anticlockwise) {
+        startAngle += PI2;
+    }
+    if (anticlockwise) {
+        var tmp = endAngle;
+        endAngle = startAngle;
+        startAngle = tmp;
+    }
+    for (var angle = 0; angle < endAngle; angle += Math.PI / 2) {
+        if (angle > startAngle) {
+            extremity[0] = mathCos(angle) * rx + x;
+            extremity[1] = mathSin(angle) * ry + y;
+            vec2Min(min$1, extremity, min$1);
+            vec2Max(max$1, extremity, max$1);
+        }
+    }
+}
+
+export { fromArc, fromCubic, fromLine, fromPoints, fromQuadratic };