问从理论上讲，你是如何沿着路径实现动画的？

EN

function setAnimationsProgress(insTime) {
  let i = 0;
  const animations = instance.animations;
  const animationsLength = animations.length;
  while (i < animationsLength) {
    const anim = animations[i];
    const animatable = anim.animatable;
    const tweens = anim.tweens;
    const tweenLength = tweens.length - 1;
    let tween = tweens[tweenLength];
    // Only check for keyframes if there is more than one tween
    if (tweenLength) tween = filterArray(tweens, t => (insTime < t.end))[0] || tween;
    const elapsed = minMax(insTime - tween.start - tween.delay, 0, tween.duration) / tween.duration;
    const eased = isNaN(elapsed) ? 1 : tween.easing(elapsed);
    const strings = tween.to.strings;
    const round = tween.round;
    const numbers = [];
    const toNumbersLength = tween.to.numbers.length;
    let progress;
    for (let n = 0; n < toNumbersLength; n++) {
      let value;
      const toNumber = tween.to.numbers[n];
      const fromNumber = tween.from.numbers[n] || 0;
      if (!tween.isPath) {
        value = fromNumber + (eased * (toNumber - fromNumber));
      } else {
        value = getPathProgress(tween.value, eased * toNumber, tween.isPathTargetInsideSVG);
      }
      if (round) {
        if (!(tween.isColor && n > 2)) {
          value = Math.round(value * round) / round;
        }
      }
      numbers.push(value);
    }
    // Manual Array.reduce for better performances
    const stringsLength = strings.length;
    if (!stringsLength) {
      progress = numbers[0];
    } else {
      progress = strings[0];
      for (let s = 0; s < stringsLength; s++) {
        const a = strings[s];
        const b = strings[s + 1];
        const n = numbers[s];
        if (!isNaN(n)) {
          if (!b) {
            progress += n + ' ';
          } else {
            progress += n + b;
          }
        }
      }
    }
    setProgressValue[anim.type](animatable.target, anim.property, progress, animatable.transforms);
    anim.currentValue = progress;
    i++;
  }
}

function getPathProgress(path, progress, isPathTargetInsideSVG) {
  function point(offset = 0) {
    const l = progress + offset >= 1 ? progress + offset : 0;
    return path.el.getPointAtLength(l);
  }
  const svg = getParentSvg(path.el, path.svg)
  const p = point();
  const p0 = point(-1);
  const p1 = point(+1);
  const scaleX = isPathTargetInsideSVG ? 1 : svg.w / svg.vW;
  const scaleY = isPathTargetInsideSVG ? 1 : svg.h / svg.vH;
  switch (path.property) {
    case 'x': return (p.x - svg.x) * scaleX;
    case 'y': return (p.y - svg.y) * scaleY;
    case 'angle': return Math.atan2(p1.y - p0.y, p1.x - p0.x) * 180 / Math.PI;
  }
}