@leafer-in/motion-path 1.0.6-rc1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023-present, Chao (Leafer) Wan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @leafer-in/motion-path

package/dist/motion-path.cjs

@@ -0,0 +1,317 @@
+'use strict';
+
+var draw = require('@leafer-ui/draw');
+
+const gaussNodes = [0.1488743389, 0.4333953941, 0.6794095682, 0.8650633666, 0.9739065285];
+const gaussWeights = [0.2955242247, 0.2692667193, 0.2190863625, 0.1494513491, 0.0666713443];
+const { sqrt } = Math;
+const HighBezierHelper = {
+    getDistance(fromX, fromY, x1, y1, x2, y2, toX, toY) {
+        let distance = 0, t1, t2, d1X, d1Y, d2X, d2Y;
+        for (let i = 0; i < gaussNodes.length; i++) {
+            t1 = 0.5 * (1 + gaussNodes[i]);
+            t2 = 0.5 * (1 - gaussNodes[i]);
+            d1X = getDerivative(t1, fromX, x1, x2, toX);
+            d1Y = getDerivative(t1, fromY, y1, y2, toY);
+            d2X = getDerivative(t2, fromX, x1, x2, toX);
+            d2Y = getDerivative(t2, fromY, y1, y2, toY);
+            distance += gaussWeights[i] * (sqrt(d1X * d1X + d1Y * d1Y) + sqrt(d2X * d2X + d2Y * d2Y));
+        }
+        return distance * 0.5;
+    },
+    getDerivative(t, fromV, v1, v2, toV) {
+        const o = 1 - t;
+        return 3 * o * o * (v1 - fromV) + 6 * o * t * (v2 - v1) + 3 * t * t * (toV - v2);
+    },
+    cut(data, t, fromX, fromY, x1, y1, x2, y2, toX, toY) {
+        const o = 1 - t;
+        const ax = o * fromX + t * x1, ay = o * fromY + t * y1;
+        const mbx = o * x1 + t * x2, mby = o * y1 + t * y2;
+        const mcx = o * x2 + t * toX, mcy = o * y2 + t * toY;
+        const bx = o * ax + t * mbx, by = o * ay + t * mby;
+        const mbcx = o * mbx + t * mcx, mbcy = o * mby + t * mcy;
+        const cx = o * bx + t * mbcx, cy = o * by + t * mbcy;
+        data.push(draw.PathCommandMap.C, ax, ay, bx, by, cx, cy);
+    }
+};
+const { getDerivative } = HighBezierHelper;
+
+const { M, L, C, Z } = draw.PathCommandMap;
+const tempPoint = {}, tempFrom = {};
+const HighCurveHelper = {
+    transform(data, matrix) {
+        let i = 0, command;
+        const len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                case L:
+                    HighCurveHelper.transformPoints(data, matrix, i, 1);
+                    i += 3;
+                    break;
+                case C:
+                    HighCurveHelper.transformPoints(data, matrix, i, 3);
+                    i += 7;
+                    break;
+                case Z:
+                    i += 1;
+            }
+        }
+    },
+    transformPoints(data, matrix, start, pointCount) {
+        for (let i = start + 1, end = i + pointCount * 2; i < end; i += 2) {
+            tempPoint.x = data[i];
+            tempPoint.y = data[i + 1];
+            draw.MatrixHelper.toOuterPoint(matrix, tempPoint);
+            data[i] = tempPoint.x;
+            data[i + 1] = tempPoint.y;
+        }
+    },
+    getMotionPathData(data) {
+        let total = 0, distance, segments = [];
+        let i = 0, x = 0, y = 0, toX, toY, command;
+        const len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                case L:
+                    toX = data[i + 1];
+                    toY = data[i + 2];
+                    distance = (command === L && i > 0) ? draw.PointHelper.getDistanceFrom(x, y, toX, toY) : 0;
+                    x = toX;
+                    y = toY;
+                    i += 3;
+                    break;
+                case C:
+                    toX = data[i + 5];
+                    toY = data[i + 6];
+                    distance = HighBezierHelper.getDistance(x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], toX, toY);
+                    x = toX;
+                    y = toY;
+                    i += 7;
+                    break;
+                case Z:
+                    i += 1;
+                default:
+                    distance = 0;
+            }
+            segments.push(distance);
+            total += distance;
+        }
+        return { total, segments, data };
+    },
+    getDistancePoint(distanceData, motionDistance) {
+        const { segments, data } = distanceData;
+        motionDistance = draw.UnitConvert.number(motionDistance, distanceData.total);
+        let total = 0, distance, to = {};
+        let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
+        const len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                case L:
+                    toX = data[i + 1];
+                    toY = data[i + 2];
+                    distance = segments[index];
+                    if (total + distance > motionDistance || !distanceData.total) {
+                        if (!i)
+                            x = toX, y = toY;
+                        tempFrom.x = x;
+                        tempFrom.y = y;
+                        to.x = toX;
+                        to.y = toY;
+                        draw.PointHelper.getDistancePoint(tempFrom, to, motionDistance - total, true);
+                        to.rotation = draw.PointHelper.getAngle(tempFrom, to);
+                        return to;
+                    }
+                    x = toX;
+                    y = toY;
+                    i += 3;
+                    break;
+                case C:
+                    toX = data[i + 5];
+                    toY = data[i + 6];
+                    distance = segments[index];
+                    if (total + distance > motionDistance) {
+                        const x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
+                        motionDistance -= total;
+                        draw.BezierHelper.getPointAndSet(motionDistance / distance, x, y, x1, y1, x2, y2, toX, toY, to);
+                        draw.BezierHelper.getPointAndSet(Math.max(0, motionDistance - 0.1) / distance, x, y, x1, y1, x2, y2, toX, toY, tempFrom);
+                        to.rotation = draw.PointHelper.getAngle(tempFrom, to);
+                        return to;
+                    }
+                    x = toX;
+                    y = toY;
+                    i += 7;
+                    break;
+                case Z:
+                    i += 1;
+                default:
+                    distance = 0;
+            }
+            index++;
+            total += distance;
+        }
+        return to;
+    },
+    getDistancePath(distanceData, motionDistance) {
+        const { segments, data } = distanceData, path = [];
+        motionDistance = draw.UnitConvert.number(motionDistance, distanceData.total);
+        let total = 0, distance, to = {};
+        let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
+        const len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                case L:
+                    toX = data[i + 1];
+                    toY = data[i + 2];
+                    distance = segments[index];
+                    if (total + distance > motionDistance || !distanceData.total) {
+                        if (!i)
+                            x = toX, y = toY;
+                        tempFrom.x = x;
+                        tempFrom.y = y;
+                        to.x = toX;
+                        to.y = toY;
+                        draw.PointHelper.getDistancePoint(tempFrom, to, motionDistance - total, true);
+                        path.push(command, to.x, to.y);
+                        return path;
+                    }
+                    x = toX;
+                    y = toY;
+                    i += 3;
+                    path.push(command, x, y);
+                    break;
+                case C:
+                    const x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
+                    toX = data[i + 5];
+                    toY = data[i + 6];
+                    distance = segments[index];
+                    if (total + distance > motionDistance) {
+                        HighBezierHelper.cut(path, (motionDistance - total) / distance, x, y, x1, y1, x2, y2, toX, toY);
+                        return path;
+                    }
+                    x = toX;
+                    y = toY;
+                    i += 7;
+                    path.push(command, x1, y1, x2, y2, toX, toY);
+                    break;
+                case Z:
+                    i += 1;
+                    path.push(command);
+                default:
+                    distance = 0;
+            }
+            index++;
+            total += distance;
+        }
+        return path;
+    }
+};
+
+function motionPathType(defaultValue) {
+    return draw.decorateLeafAttr(defaultValue, (key) => draw.attr({
+        set(value) {
+            this.__setAttr(key, value);
+            this.__hasMotionPath = this.motionPath || !draw.isNull(this.motion);
+            this.__layout.matrixChanged || this.__layout.matrixChange();
+        }
+    }));
+}
+
+draw.Transition.register('motion', function (from, to, t, target) {
+    if (!from)
+        from = 0;
+    else if (typeof from === 'object')
+        from = draw.UnitConvert.number(from, target.getMotionTotal());
+    if (!to)
+        to = 0;
+    else if (typeof to === 'object')
+        to = draw.UnitConvert.number(to, target.getMotionTotal());
+    return draw.Transition.number(from, to, t);
+});
+const ui = draw.UI.prototype;
+motionPathType()(ui, 'motionPath');
+motionPathType()(ui, 'motion');
+motionPathType(true)(ui, 'motionRotation');
+ui.getMotionPathData = function () {
+    const { parent } = this;
+    if (!this.motionPath && parent) {
+        const { children } = parent;
+        for (let i = 0; i < children.length; i++) {
+            if (children[i].motionPath)
+                return children[i].getMotionPathData();
+        }
+    }
+    const data = this.__;
+    if (data.__pathForMotion)
+        return data.__pathForMotion;
+    return data.__pathForMotion = HighCurveHelper.getMotionPathData(this.getPath(true, true));
+};
+ui.getMotionPoint = function (motionDistance) {
+    const data = this.getMotionPathData();
+    const point = HighCurveHelper.getDistancePoint(data, motionDistance);
+    draw.MatrixHelper.toOuterPoint(this.localTransform, point);
+    return point;
+};
+ui.getMotionTotal = function () {
+    return this.getMotionPathData().total;
+};
+ui.__updateMotionPath = function () {
+    const data = this.__;
+    if (this.__layout.resized && data.__pathForMotion)
+        data.__pathForMotion = undefined;
+    if (this.motionPath) {
+        let child;
+        const { children } = this.parent;
+        for (let i = 0; i < children.length; i++) {
+            child = children[i];
+            if (!draw.isNull(child.motion))
+                updateMotion(child);
+        }
+    }
+    else {
+        updateMotion(this);
+    }
+};
+function updateMotion(leaf) {
+    const { motion, motionRotation } = leaf;
+    if (draw.isNull(motion))
+        return;
+    if (leaf.motionPath) {
+        const data = leaf.getMotionPathData();
+        if (data.total)
+            leaf.__.__pathForRender = HighCurveHelper.getDistancePath(data, motion);
+    }
+    else {
+        let child;
+        const { children } = leaf.parent;
+        for (let i = 0; i < children.length; i++) {
+            child = children[i];
+            if (child.motionPath) {
+                const data = child.getMotionPathData();
+                if (!data.total)
+                    return;
+                const point = child.getMotionPoint(motion);
+                if (motionRotation === false)
+                    delete point.rotation;
+                else {
+                    point.rotation += child.rotation;
+                    if (typeof motionRotation === 'number')
+                        point.rotation += motionRotation;
+                }
+                leaf.set(point);
+                break;
+            }
+        }
+    }
+}
+
+exports.HighBezierHelper = HighBezierHelper;
+exports.HighCurveHelper = HighCurveHelper;
+exports.motionPathType = motionPathType;

package/dist/motion-path.esm.js

@@ -0,0 +1,313 @@
+import { PathCommandMap, MatrixHelper, PointHelper, UnitConvert, BezierHelper, decorateLeafAttr, attr, isNull, Transition, UI } from '@leafer-ui/draw';
+
+const gaussNodes = [0.1488743389, 0.4333953941, 0.6794095682, 0.8650633666, 0.9739065285];
+const gaussWeights = [0.2955242247, 0.2692667193, 0.2190863625, 0.1494513491, 0.0666713443];
+const { sqrt } = Math;
+const HighBezierHelper = {
+    getDistance(fromX, fromY, x1, y1, x2, y2, toX, toY) {
+        let distance = 0, t1, t2, d1X, d1Y, d2X, d2Y;
+        for (let i = 0; i < gaussNodes.length; i++) {
+            t1 = 0.5 * (1 + gaussNodes[i]);
+            t2 = 0.5 * (1 - gaussNodes[i]);
+            d1X = getDerivative(t1, fromX, x1, x2, toX);
+            d1Y = getDerivative(t1, fromY, y1, y2, toY);
+            d2X = getDerivative(t2, fromX, x1, x2, toX);
+            d2Y = getDerivative(t2, fromY, y1, y2, toY);
+            distance += gaussWeights[i] * (sqrt(d1X * d1X + d1Y * d1Y) + sqrt(d2X * d2X + d2Y * d2Y));
+        }
+        return distance * 0.5;
+    },
+    getDerivative(t, fromV, v1, v2, toV) {
+        const o = 1 - t;
+        return 3 * o * o * (v1 - fromV) + 6 * o * t * (v2 - v1) + 3 * t * t * (toV - v2);
+    },
+    cut(data, t, fromX, fromY, x1, y1, x2, y2, toX, toY) {
+        const o = 1 - t;
+        const ax = o * fromX + t * x1, ay = o * fromY + t * y1;
+        const mbx = o * x1 + t * x2, mby = o * y1 + t * y2;
+        const mcx = o * x2 + t * toX, mcy = o * y2 + t * toY;
+        const bx = o * ax + t * mbx, by = o * ay + t * mby;
+        const mbcx = o * mbx + t * mcx, mbcy = o * mby + t * mcy;
+        const cx = o * bx + t * mbcx, cy = o * by + t * mbcy;
+        data.push(PathCommandMap.C, ax, ay, bx, by, cx, cy);
+    }
+};
+const { getDerivative } = HighBezierHelper;
+
+const { M, L, C, Z } = PathCommandMap;
+const tempPoint = {}, tempFrom = {};
+const HighCurveHelper = {
+    transform(data, matrix) {
+        let i = 0, command;
+        const len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                case L:
+                    HighCurveHelper.transformPoints(data, matrix, i, 1);
+                    i += 3;
+                    break;
+                case C:
+                    HighCurveHelper.transformPoints(data, matrix, i, 3);
+                    i += 7;
+                    break;
+                case Z:
+                    i += 1;
+            }
+        }
+    },
+    transformPoints(data, matrix, start, pointCount) {
+        for (let i = start + 1, end = i + pointCount * 2; i < end; i += 2) {
+            tempPoint.x = data[i];
+            tempPoint.y = data[i + 1];
+            MatrixHelper.toOuterPoint(matrix, tempPoint);
+            data[i] = tempPoint.x;
+            data[i + 1] = tempPoint.y;
+        }
+    },
+    getMotionPathData(data) {
+        let total = 0, distance, segments = [];
+        let i = 0, x = 0, y = 0, toX, toY, command;
+        const len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                case L:
+                    toX = data[i + 1];
+                    toY = data[i + 2];
+                    distance = (command === L && i > 0) ? PointHelper.getDistanceFrom(x, y, toX, toY) : 0;
+                    x = toX;
+                    y = toY;
+                    i += 3;
+                    break;
+                case C:
+                    toX = data[i + 5];
+                    toY = data[i + 6];
+                    distance = HighBezierHelper.getDistance(x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], toX, toY);
+                    x = toX;
+                    y = toY;
+                    i += 7;
+                    break;
+                case Z:
+                    i += 1;
+                default:
+                    distance = 0;
+            }
+            segments.push(distance);
+            total += distance;
+        }
+        return { total, segments, data };
+    },
+    getDistancePoint(distanceData, motionDistance) {
+        const { segments, data } = distanceData;
+        motionDistance = UnitConvert.number(motionDistance, distanceData.total);
+        let total = 0, distance, to = {};
+        let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
+        const len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                case L:
+                    toX = data[i + 1];
+                    toY = data[i + 2];
+                    distance = segments[index];
+                    if (total + distance > motionDistance || !distanceData.total) {
+                        if (!i)
+                            x = toX, y = toY;
+                        tempFrom.x = x;
+                        tempFrom.y = y;
+                        to.x = toX;
+                        to.y = toY;
+                        PointHelper.getDistancePoint(tempFrom, to, motionDistance - total, true);
+                        to.rotation = PointHelper.getAngle(tempFrom, to);
+                        return to;
+                    }
+                    x = toX;
+                    y = toY;
+                    i += 3;
+                    break;
+                case C:
+                    toX = data[i + 5];
+                    toY = data[i + 6];
+                    distance = segments[index];
+                    if (total + distance > motionDistance) {
+                        const x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
+                        motionDistance -= total;
+                        BezierHelper.getPointAndSet(motionDistance / distance, x, y, x1, y1, x2, y2, toX, toY, to);
+                        BezierHelper.getPointAndSet(Math.max(0, motionDistance - 0.1) / distance, x, y, x1, y1, x2, y2, toX, toY, tempFrom);
+                        to.rotation = PointHelper.getAngle(tempFrom, to);
+                        return to;
+                    }
+                    x = toX;
+                    y = toY;
+                    i += 7;
+                    break;
+                case Z:
+                    i += 1;
+                default:
+                    distance = 0;
+            }
+            index++;
+            total += distance;
+        }
+        return to;
+    },
+    getDistancePath(distanceData, motionDistance) {
+        const { segments, data } = distanceData, path = [];
+        motionDistance = UnitConvert.number(motionDistance, distanceData.total);
+        let total = 0, distance, to = {};
+        let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
+        const len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                case L:
+                    toX = data[i + 1];
+                    toY = data[i + 2];
+                    distance = segments[index];
+                    if (total + distance > motionDistance || !distanceData.total) {
+                        if (!i)
+                            x = toX, y = toY;
+                        tempFrom.x = x;
+                        tempFrom.y = y;
+                        to.x = toX;
+                        to.y = toY;
+                        PointHelper.getDistancePoint(tempFrom, to, motionDistance - total, true);
+                        path.push(command, to.x, to.y);
+                        return path;
+                    }
+                    x = toX;
+                    y = toY;
+                    i += 3;
+                    path.push(command, x, y);
+                    break;
+                case C:
+                    const x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
+                    toX = data[i + 5];
+                    toY = data[i + 6];
+                    distance = segments[index];
+                    if (total + distance > motionDistance) {
+                        HighBezierHelper.cut(path, (motionDistance - total) / distance, x, y, x1, y1, x2, y2, toX, toY);
+                        return path;
+                    }
+                    x = toX;
+                    y = toY;
+                    i += 7;
+                    path.push(command, x1, y1, x2, y2, toX, toY);
+                    break;
+                case Z:
+                    i += 1;
+                    path.push(command);
+                default:
+                    distance = 0;
+            }
+            index++;
+            total += distance;
+        }
+        return path;
+    }
+};
+
+function motionPathType(defaultValue) {
+    return decorateLeafAttr(defaultValue, (key) => attr({
+        set(value) {
+            this.__setAttr(key, value);
+            this.__hasMotionPath = this.motionPath || !isNull(this.motion);
+            this.__layout.matrixChanged || this.__layout.matrixChange();
+        }
+    }));
+}
+
+Transition.register('motion', function (from, to, t, target) {
+    if (!from)
+        from = 0;
+    else if (typeof from === 'object')
+        from = UnitConvert.number(from, target.getMotionTotal());
+    if (!to)
+        to = 0;
+    else if (typeof to === 'object')
+        to = UnitConvert.number(to, target.getMotionTotal());
+    return Transition.number(from, to, t);
+});
+const ui = UI.prototype;
+motionPathType()(ui, 'motionPath');
+motionPathType()(ui, 'motion');
+motionPathType(true)(ui, 'motionRotation');
+ui.getMotionPathData = function () {
+    const { parent } = this;
+    if (!this.motionPath && parent) {
+        const { children } = parent;
+        for (let i = 0; i < children.length; i++) {
+            if (children[i].motionPath)
+                return children[i].getMotionPathData();
+        }
+    }
+    const data = this.__;
+    if (data.__pathForMotion)
+        return data.__pathForMotion;
+    return data.__pathForMotion = HighCurveHelper.getMotionPathData(this.getPath(true, true));
+};
+ui.getMotionPoint = function (motionDistance) {
+    const data = this.getMotionPathData();
+    const point = HighCurveHelper.getDistancePoint(data, motionDistance);
+    MatrixHelper.toOuterPoint(this.localTransform, point);
+    return point;
+};
+ui.getMotionTotal = function () {
+    return this.getMotionPathData().total;
+};
+ui.__updateMotionPath = function () {
+    const data = this.__;
+    if (this.__layout.resized && data.__pathForMotion)
+        data.__pathForMotion = undefined;
+    if (this.motionPath) {
+        let child;
+        const { children } = this.parent;
+        for (let i = 0; i < children.length; i++) {
+            child = children[i];
+            if (!isNull(child.motion))
+                updateMotion(child);
+        }
+    }
+    else {
+        updateMotion(this);
+    }
+};
+function updateMotion(leaf) {
+    const { motion, motionRotation } = leaf;
+    if (isNull(motion))
+        return;
+    if (leaf.motionPath) {
+        const data = leaf.getMotionPathData();
+        if (data.total)
+            leaf.__.__pathForRender = HighCurveHelper.getDistancePath(data, motion);
+    }
+    else {
+        let child;
+        const { children } = leaf.parent;
+        for (let i = 0; i < children.length; i++) {
+            child = children[i];
+            if (child.motionPath) {
+                const data = child.getMotionPathData();
+                if (!data.total)
+                    return;
+                const point = child.getMotionPoint(motion);
+                if (motionRotation === false)
+                    delete point.rotation;
+                else {
+                    point.rotation += child.rotation;
+                    if (typeof motionRotation === 'number')
+                        point.rotation += motionRotation;
+                }
+                leaf.set(point);
+                break;
+            }
+        }
+    }
+}
+
+export { HighBezierHelper, HighCurveHelper, motionPathType };

package/dist/motion-path.esm.min.js

@@ -0,0 +1 @@
+import{PathCommandMap as t,MatrixHelper as o,PointHelper as e,UnitConvert as n,BezierHelper as a,decorateLeafAttr as i,attr as r,isNull as s,Transition as h,UI as c}from"@leafer-ui/draw";const l=[.1488743389,.4333953941,.6794095682,.8650633666,.9739065285],u=[.2955242247,.2692667193,.2190863625,.1494513491,.0666713443],{sqrt:g}=Math,f={getDistance(t,o,e,n,a,i,r,s){let h,c,f,P,_,p,M=0;for(let D=0;D<l.length;D++)h=.5*(1+l[D]),c=.5*(1-l[D]),f=m(h,t,e,a,r),P=m(h,o,n,i,s),_=m(c,t,e,a,r),p=m(c,o,n,i,s),M+=u[D]*(g(f*f+P*P)+g(_*_+p*p));return.5*M},getDerivative(t,o,e,n,a){const i=1-t;return 3*i*i*(e-o)+6*i*t*(n-e)+3*t*t*(a-n)},cut(o,e,n,a,i,r,s,h,c,l){const u=1-e,g=u*n+e*i,f=u*a+e*r,m=u*i+e*s,P=u*r+e*h,_=u*g+e*m,p=u*f+e*P,M=u*_+e*(u*m+e*(u*s+e*c)),D=u*p+e*(u*P+e*(u*h+e*l));o.push(t.C,g,f,_,p,M,D)}},{getDerivative:m}=f,{M:P,L:_,C:p,Z:M}=t,D={},d={},b={transform(t,o){let e,n=0;const a=t.length;for(;n<a;)switch(e=t[n],e){case P:case _:b.transformPoints(t,o,n,1),n+=3;break;case p:b.transformPoints(t,o,n,3),n+=7;break;case M:n+=1}},transformPoints(t,e,n,a){for(let i=n+1,r=i+2*a;i<r;i+=2)D.x=t[i],D.y=t[i+1],o.toOuterPoint(e,D),t[i]=D.x,t[i+1]=D.y},getMotionPathData(t){let o,n,a,i,r=0,s=[],h=0,c=0,l=0;const u=t.length;for(;h<u;){switch(i=t[h],i){case P:case _:n=t[h+1],a=t[h+2],o=i===_&&h>0?e.getDistanceFrom(c,l,n,a):0,c=n,l=a,h+=3;break;case p:n=t[h+5],a=t[h+6],o=f.getDistance(c,l,t[h+1],t[h+2],t[h+3],t[h+4],n,a),c=n,l=a,h+=7;break;case M:h+=1;default:o=0}s.push(o),r+=o}return{total:r,segments:s,data:t}},getDistancePoint(t,o){const{segments:i,data:r}=t;o=n.number(o,t.total);let s,h,c,l,u=0,g={},f=0,m=0,D=0,b=0;const y=r.length;for(;f<y;){switch(l=r[f],l){case P:case _:if(h=r[f+1],c=r[f+2],s=i[m],u+s>o||!t.total)return f||(D=h,b=c),d.x=D,d.y=b,g.x=h,g.y=c,e.getDistancePoint(d,g,o-u,!0),g.rotation=e.getAngle(d,g),g;D=h,b=c,f+=3;break;case p:if(h=r[f+5],c=r[f+6],s=i[m],u+s>o){const t=r[f+1],n=r[f+2],i=r[f+3],l=r[f+4];return o-=u,a.getPointAndSet(o/s,D,b,t,n,i,l,h,c,g),a.getPointAndSet(Math.max(0,o-.1)/s,D,b,t,n,i,l,h,c,d),g.rotation=e.getAngle(d,g),g}D=h,b=c,f+=7;break;case M:f+=1;default:s=0}m++,u+=s}return g},getDistancePath(t,o){const{segments:a,data:i}=t,r=[];o=n.number(o,t.total);let s,h,c,l,u=0,g={},m=0,D=0,b=0,y=0;const x=i.length;for(;m<x;){switch(l=i[m],l){case P:case _:if(h=i[m+1],c=i[m+2],s=a[D],u+s>o||!t.total)return m||(b=h,y=c),d.x=b,d.y=y,g.x=h,g.y=c,e.getDistancePoint(d,g,o-u,!0),r.push(l,g.x,g.y),r;b=h,y=c,m+=3,r.push(l,b,y);break;case p:const n=i[m+1],x=i[m+2],k=i[m+3],F=i[m+4];if(h=i[m+5],c=i[m+6],s=a[D],u+s>o)return f.cut(r,(o-u)/s,b,y,n,x,k,F,h,c),r;b=h,y=c,m+=7,r.push(l,n,x,k,F,h,c);break;case M:m+=1,r.push(l);default:s=0}D++,u+=s}return r}};function y(t){return i(t,(t=>r({set(o){this.__setAttr(t,o),this.__hasMotionPath=this.motionPath||!s(this.motion),this.__layout.matrixChanged||this.__layout.matrixChange()}})))}h.register("motion",(function(t,o,e,a){return t?"object"==typeof t&&(t=n.number(t,a.getMotionTotal())):t=0,o?"object"==typeof o&&(o=n.number(o,a.getMotionTotal())):o=0,h.number(t,o,e)}));const x=c.prototype;function k(t){const{motion:o,motionRotation:e}=t;if(!s(o))if(t.motionPath){const e=t.getMotionPathData();e.total&&(t.__.__pathForRender=b.getDistancePath(e,o))}else{let n;const{children:a}=t.parent;for(let i=0;i<a.length;i++)if(n=a[i],n.motionPath){if(!n.getMotionPathData().total)return;const a=n.getMotionPoint(o);!1===e?delete a.rotation:(a.rotation+=n.rotation,"number"==typeof e&&(a.rotation+=e)),t.set(a);break}}}y()(x,"motionPath"),y()(x,"motion"),y(!0)(x,"motionRotation"),x.getMotionPathData=function(){const{parent:t}=this;if(!this.motionPath&&t){const{children:o}=t;for(let t=0;t<o.length;t++)if(o[t].motionPath)return o[t].getMotionPathData()}const o=this.__;return o.__pathForMotion?o.__pathForMotion:o.__pathForMotion=b.getMotionPathData(this.getPath(!0,!0))},x.getMotionPoint=function(t){const e=this.getMotionPathData(),n=b.getDistancePoint(e,t);return o.toOuterPoint(this.localTransform,n),n},x.getMotionTotal=function(){return this.getMotionPathData().total},x.__updateMotionPath=function(){const t=this.__;if(this.__layout.resized&&t.__pathForMotion&&(t.__pathForMotion=void 0),this.motionPath){let t;const{children:o}=this.parent;for(let e=0;e<o.length;e++)t=o[e],s(t.motion)||k(t)}else k(this)};export{f as HighBezierHelper,b as HighCurveHelper,y as motionPathType};