@seed-ship/mcp-ui-solid 5.7.0 → 6.1.0

package/dist/node_modules/.pnpm/@antv_g@6.3.1/node_modules/@antv/g/dist/index.esm.cjs

@@ -0,0 +1,2345 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index_esm = require("../../../../../@antv_g-lite@2.7.0/node_modules/@antv/g-lite/dist/index.esm.cjs");
+const classCallCheck = require("../../../../../@babel_runtime@7.28.4/node_modules/@babel/runtime/helpers/esm/classCallCheck.cjs");
+const createClass = require("../../../../../@babel_runtime@7.28.4/node_modules/@babel/runtime/helpers/esm/createClass.cjs");
+const callSuper = require("../../../../../@babel_runtime@7.28.4/node_modules/@babel/runtime/helpers/esm/callSuper.cjs");
+const inherits = require("../../../../../@babel_runtime@7.28.4/node_modules/@babel/runtime/helpers/esm/inherits.cjs");
+const toConsumableArray = require("../../../../../@babel_runtime@7.28.4/node_modules/@babel/runtime/helpers/esm/toConsumableArray.cjs");
+const slicedToArray = require("../../../../../@babel_runtime@7.28.4/node_modules/@babel/runtime/helpers/esm/slicedToArray.cjs");
+const objectWithoutProperties = require("../../../../../@babel_runtime@7.28.4/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.cjs");
+require("../../../../../html2canvas@1.4.1/node_modules/html2canvas/dist/html2canvas.esm.cjs");
+const objectSpread2 = require("../../../../../@babel_runtime@7.28.4/node_modules/@babel/runtime/helpers/esm/objectSpread2.cjs");
+const defineProperty = require("../../../../../@babel_runtime@7.28.4/node_modules/@babel/runtime/helpers/esm/defineProperty.cjs");
+const superPropGet = require("../../../../../@babel_runtime@7.28.4/node_modules/@babel/runtime/helpers/esm/superPropGet.cjs");
+const isString = require("../../../../../@antv_util@3.3.11/node_modules/@antv/util/esm/lodash/is-string.cjs");
+const isNumber = require("../../../../../@antv_util@3.3.11/node_modules/@antv/util/esm/lodash/is-number.cjs");
+const isNil = require("../../../../../@antv_util@3.3.11/node_modules/@antv/util/esm/lodash/is-nil.cjs");
+const isNumberEqual = require("../../../../../@antv_util@3.3.11/node_modules/@antv/util/esm/lodash/is-number-equal.cjs");
+const clamp = require("../../../../../@antv_util@3.3.11/node_modules/@antv/util/esm/lodash/clamp.cjs");
+const quat = require("../../../../../gl-matrix@3.4.4/node_modules/gl-matrix/esm/quat.cjs");
+const mat4 = require("../../../../../gl-matrix@3.4.4/node_modules/gl-matrix/esm/mat4.cjs");
+const vec3 = require("../../../../../gl-matrix@3.4.4/node_modules/gl-matrix/esm/vec3.cjs");
+/*!
+ * @antv/g
+ * @description A core module for rendering engine implements DOM API.
+ * @version 6.3.1
+ * @date 12/24/2025, 11:55:39 AM
+ * @author AntVis
+ * @docs https://g.antv.antgroup.com/
+ */
+var AnimationEvent = /* @__PURE__ */ (function(_FederatedEvent) {
+  function AnimationEvent2(manager, target, currentTime, timelineTime) {
+    var _this;
+    classCallCheck(this, AnimationEvent2);
+    _this = callSuper(this, AnimationEvent2, [manager]);
+    _this.currentTime = currentTime;
+    _this.timelineTime = timelineTime;
+    _this.target = target;
+    _this.type = "finish";
+    _this.bubbles = false;
+    _this.currentTarget = target;
+    _this.defaultPrevented = false;
+    _this.eventPhase = _this.AT_TARGET;
+    _this.timeStamp = Date.now();
+    _this.currentTime = currentTime;
+    _this.timelineTime = timelineTime;
+    return _this;
+  }
+  inherits(AnimationEvent2, _FederatedEvent);
+  return createClass(AnimationEvent2);
+})(index_esm.FederatedEvent);
+var sequenceNumber = 0;
+var Animation = /* @__PURE__ */ (function() {
+  function Animation2(effect, timeline) {
+    var _this$effect;
+    classCallCheck(this, Animation2);
+    this.currentTimePending = false;
+    this._idle = true;
+    this._paused = false;
+    this._finishedFlag = true;
+    this._currentTime = 0;
+    this._playbackRate = 1;
+    this._inTimeline = true;
+    this.effect = effect;
+    effect.animation = this;
+    this.timeline = timeline;
+    this.id = "".concat(sequenceNumber++);
+    this._inEffect = !!this.effect.update(0);
+    this._totalDuration = Number((_this$effect = this.effect) === null || _this$effect === void 0 ? void 0 : _this$effect.getComputedTiming().endTime);
+    this._holdTime = 0;
+    this._paused = false;
+    this.oldPlayState = "idle";
+    this.updatePromises();
+  }
+  return createClass(Animation2, [{
+    key: "pending",
+    get: (
+      /**
+       * @see https://developer.mozilla.org/en-US/docs/Web/API/Animation/effect
+       */
+      /**
+       * @see https://developer.mozilla.org/en-US/docs/Web/API/Animation/timeline
+       */
+      /**
+       * @see https://developer.mozilla.org/en-US/docs/Web/API/Animation/id
+       */
+      // animation: InternalAnimation | null;
+      /**
+       * @see https://developer.mozilla.org/en-US/docs/Web/API/Animation/pending
+       */
+      function get() {
+        return this._startTime === null && !this._paused && this.playbackRate !== 0 || this.currentTimePending;
+      }
+    )
+  }, {
+    key: "playState",
+    get: function get() {
+      if (this._idle) return "idle";
+      if (this._isFinished) return "finished";
+      if (this._paused) return "paused";
+      return "running";
+    }
+    /**
+     * record previos state
+     */
+  }, {
+    key: "ready",
+    get: (
+      /**
+       * @see https://developer.mozilla.org/en-US/docs/Web/API/Animation/ready
+       * @example
+        animation.pause();
+        animation.ready.then(function() {
+          // Displays 'running'
+          alert(animation.playState);
+        });
+        animation.play();
+       */
+      function get() {
+        var _this = this;
+        if (!this.readyPromise) {
+          if (this.timeline.animationsWithPromises.indexOf(this) === -1) {
+            this.timeline.animationsWithPromises.push(this);
+          }
+          this.readyPromise = new Promise(function(resolve, reject) {
+            _this.resolveReadyPromise = function() {
+              resolve(_this);
+            };
+            _this.rejectReadyPromise = function() {
+              reject(new Error());
+            };
+          });
+          if (!this.pending) {
+            this.resolveReadyPromise();
+          }
+        }
+        return this.readyPromise;
+      }
+    )
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Animation/finished
+     * @example
+      Promise.all(
+        elem.getAnimations().map(
+          function(animation) {
+            return animation.finished
+          }
+        )
+      ).then(
+        function() {
+          return elem.remove();
+        }
+      );
+     */
+  }, {
+    key: "finished",
+    get: function get() {
+      var _this2 = this;
+      if (!this.finishedPromise) {
+        if (this.timeline.animationsWithPromises.indexOf(this) === -1) {
+          this.timeline.animationsWithPromises.push(this);
+        }
+        this.finishedPromise = new Promise(function(resolve, reject) {
+          _this2.resolveFinishedPromise = function() {
+            resolve(_this2);
+          };
+          _this2.rejectFinishedPromise = function() {
+            reject(new Error());
+          };
+        });
+        if (this.playState === "finished") {
+          this.resolveFinishedPromise();
+        }
+      }
+      return this.finishedPromise;
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Animation/onfinish
+     */
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Animation/oncancel
+     */
+    /**
+     * get called after each frame when running
+     */
+  }, {
+    key: "currentTime",
+    get: function get() {
+      this.updatePromises();
+      return this._idle || this.currentTimePending ? null : this._currentTime;
+    },
+    set: function set(newTime) {
+      newTime = Number(newTime);
+      if (isNaN(newTime)) return;
+      this.timeline.restart();
+      if (!this._paused && this._startTime !== null) {
+        var _this$timeline;
+        this._startTime = Number((_this$timeline = this.timeline) === null || _this$timeline === void 0 ? void 0 : _this$timeline.currentTime) - newTime / this.playbackRate;
+      }
+      this.currentTimePending = false;
+      if (this._currentTime === newTime) {
+        return;
+      }
+      if (this._idle) {
+        this._idle = false;
+        this._paused = true;
+      }
+      this.tickCurrentTime(newTime, true);
+      this.timeline.applyDirtiedAnimation(this);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Animation/startTime
+     */
+  }, {
+    key: "startTime",
+    get: function get() {
+      return this._startTime;
+    },
+    set: function set(newTime) {
+      if (newTime !== null) {
+        this.updatePromises();
+        newTime = Number(newTime);
+        if (isNaN(newTime)) return;
+        if (this._paused || this._idle) return;
+        this._startTime = newTime;
+        this.tickCurrentTime((Number(this.timeline.currentTime) - this._startTime) * this.playbackRate);
+        this.timeline.applyDirtiedAnimation(this);
+        this.updatePromises();
+      }
+    }
+  }, {
+    key: "playbackRate",
+    get: function get() {
+      return this._playbackRate;
+    },
+    set: function set(value) {
+      if (value === this._playbackRate) {
+        return;
+      }
+      this.updatePromises();
+      var oldCurrentTime = this.currentTime;
+      this._playbackRate = value;
+      this.startTime = null;
+      if (this.playState !== "paused" && this.playState !== "idle") {
+        this._finishedFlag = false;
+        this._idle = false;
+        this.ensureAlive();
+        this.timeline.applyDirtiedAnimation(this);
+      }
+      if (oldCurrentTime !== null) {
+        this.currentTime = oldCurrentTime;
+      }
+      this.updatePromises();
+    }
+  }, {
+    key: "_isFinished",
+    get: function get() {
+      return !this._idle && (this._playbackRate > 0 && Number(this._currentTime) >= this._totalDuration || this._playbackRate < 0 && Number(this._currentTime) <= 0);
+    }
+  }, {
+    key: "totalDuration",
+    get: function get() {
+      return this._totalDuration;
+    }
+  }, {
+    key: "_needsTick",
+    get: function get() {
+      return this.pending || this.playState === "running" || !this._finishedFlag;
+    }
+  }, {
+    key: "updatePromises",
+    value: function updatePromises() {
+      var _this$effect$target;
+      if ((_this$effect$target = this.effect.target) !== null && _this$effect$target !== void 0 && _this$effect$target.destroyed) {
+        this.readyPromise = void 0;
+        this.finishedPromise = void 0;
+        return false;
+      }
+      var oldPlayState = this.oldPlayState;
+      var newPlayState = this.pending ? "pending" : this.playState;
+      if (this.readyPromise && newPlayState !== oldPlayState) {
+        if (newPlayState === "idle") {
+          this.rejectReadyPromise();
+          this.readyPromise = void 0;
+        } else if (oldPlayState === "pending") {
+          this.resolveReadyPromise();
+        } else if (newPlayState === "pending") {
+          this.readyPromise = void 0;
+        }
+      }
+      if (this.finishedPromise && newPlayState !== oldPlayState) {
+        if (newPlayState === "idle") {
+          this.rejectFinishedPromise();
+          this.finishedPromise = void 0;
+        } else if (newPlayState === "finished") {
+          this.resolveFinishedPromise();
+        } else if (oldPlayState === "finished") {
+          this.finishedPromise = void 0;
+        }
+      }
+      this.oldPlayState = newPlayState;
+      return this.readyPromise || this.finishedPromise;
+    }
+  }, {
+    key: "play",
+    value: function play() {
+      this.updatePromises();
+      this._paused = false;
+      if (this._isFinished || this._idle) {
+        this.rewind();
+        this._startTime = null;
+      }
+      this._finishedFlag = false;
+      this._idle = false;
+      this.ensureAlive();
+      this.timeline.applyDirtiedAnimation(this);
+      if (this.timeline.animations.indexOf(this) === -1) {
+        this.timeline.animations.push(this);
+      }
+      this.updatePromises();
+    }
+  }, {
+    key: "pause",
+    value: function pause() {
+      this.updatePromises();
+      if (this.currentTime) {
+        this._holdTime = this.currentTime;
+      }
+      if (!this._isFinished && !this._paused && !this._idle) {
+        this.currentTimePending = true;
+      } else if (this._idle) {
+        this.rewind();
+        this._idle = false;
+      }
+      this._startTime = null;
+      this._paused = true;
+      this.updatePromises();
+    }
+  }, {
+    key: "finish",
+    value: function finish() {
+      this.updatePromises();
+      if (this._idle) return;
+      this.currentTime = this._playbackRate > 0 ? this._totalDuration : 0;
+      this._startTime = this._totalDuration - this.currentTime;
+      this.currentTimePending = false;
+      this.timeline.applyDirtiedAnimation(this);
+      this.updatePromises();
+    }
+  }, {
+    key: "cancel",
+    value: function cancel() {
+      var _this3 = this;
+      this.updatePromises();
+      if (!this._inEffect) return;
+      this._inEffect = false;
+      this._idle = true;
+      this._paused = false;
+      this._finishedFlag = true;
+      this._currentTime = null;
+      this._startTime = null;
+      this.effect.update(null);
+      this.timeline.applyDirtiedAnimation(this);
+      this.updatePromises();
+      if (this.oncancel) {
+        var event = new AnimationEvent(null, this, this.currentTime, null);
+        setTimeout(function() {
+          _this3.oncancel(event);
+        });
+      }
+    }
+  }, {
+    key: "reverse",
+    value: function reverse() {
+      this.updatePromises();
+      var oldCurrentTime = this.currentTime;
+      this.playbackRate *= -1;
+      this.play();
+      if (oldCurrentTime !== null) {
+        this.currentTime = oldCurrentTime;
+      }
+      this.updatePromises();
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Animation/updatePlaybackRate
+     */
+  }, {
+    key: "updatePlaybackRate",
+    value: function updatePlaybackRate(playbackRate) {
+      this.playbackRate = playbackRate;
+    }
+  }, {
+    key: "targetAnimations",
+    value: function targetAnimations() {
+      var _this$effect2;
+      var target = (_this$effect2 = this.effect) === null || _this$effect2 === void 0 ? void 0 : _this$effect2.target;
+      return target.getAnimations();
+    }
+  }, {
+    key: "markTarget",
+    value: function markTarget() {
+      var animations = this.targetAnimations();
+      if (animations.indexOf(this) === -1) {
+        animations.push(this);
+      }
+    }
+  }, {
+    key: "unmarkTarget",
+    value: function unmarkTarget() {
+      var animations = this.targetAnimations();
+      var index = animations.indexOf(this);
+      if (index !== -1) {
+        animations.splice(index, 1);
+      }
+    }
+  }, {
+    key: "tick",
+    value: function tick(timelineTime, isAnimationFrame) {
+      if (!this._idle && !this._paused) {
+        if (this._startTime === null) {
+          if (isAnimationFrame) {
+            this.startTime = timelineTime - this._currentTime / this.playbackRate;
+          }
+        } else if (!this._isFinished) {
+          this.tickCurrentTime((timelineTime - this._startTime) * this.playbackRate);
+        }
+      }
+      if (isAnimationFrame) {
+        this.currentTimePending = false;
+        this.fireEvents(timelineTime);
+      }
+    }
+  }, {
+    key: "rewind",
+    value: function rewind() {
+      if (this.playbackRate >= 0) {
+        this.currentTime = 0;
+      } else if (this._totalDuration < Infinity) {
+        this.currentTime = this._totalDuration;
+      } else {
+        throw new Error("Unable to rewind negative playback rate animation with infinite duration");
+      }
+    }
+  }, {
+    key: "persist",
+    value: function persist() {
+      throw new Error(index_esm.ERROR_MSG_METHOD_NOT_IMPLEMENTED);
+    }
+  }, {
+    key: "addEventListener",
+    value: function addEventListener(type, listener, options) {
+      throw new Error(index_esm.ERROR_MSG_METHOD_NOT_IMPLEMENTED);
+    }
+  }, {
+    key: "removeEventListener",
+    value: function removeEventListener(type, listener, options) {
+      throw new Error(index_esm.ERROR_MSG_METHOD_NOT_IMPLEMENTED);
+    }
+  }, {
+    key: "dispatchEvent",
+    value: function dispatchEvent(event) {
+      throw new Error(index_esm.ERROR_MSG_METHOD_NOT_IMPLEMENTED);
+    }
+  }, {
+    key: "commitStyles",
+    value: (
+      // replaceState: AnimationReplaceState;
+      function commitStyles() {
+        throw new Error(index_esm.ERROR_MSG_METHOD_NOT_IMPLEMENTED);
+      }
+    )
+  }, {
+    key: "ensureAlive",
+    value: function ensureAlive() {
+      if (this.playbackRate < 0 && this.currentTime === 0) {
+        var _this$effect3;
+        this._inEffect = !!((_this$effect3 = this.effect) !== null && _this$effect3 !== void 0 && _this$effect3.update(-1));
+      } else {
+        var _this$effect4;
+        this._inEffect = !!((_this$effect4 = this.effect) !== null && _this$effect4 !== void 0 && _this$effect4.update(this.currentTime));
+      }
+      if (!this._inTimeline && (this._inEffect || !this._finishedFlag)) {
+        this._inTimeline = true;
+        this.timeline.animations.push(this);
+      }
+    }
+  }, {
+    key: "tickCurrentTime",
+    value: function tickCurrentTime(newTime, ignoreLimit) {
+      if (newTime !== this._currentTime) {
+        this._currentTime = newTime;
+        if (this._isFinished && !ignoreLimit) {
+          this._currentTime = this._playbackRate > 0 ? this._totalDuration : 0;
+        }
+        this.ensureAlive();
+      }
+    }
+  }, {
+    key: "fireEvents",
+    value: function fireEvents(baseTime) {
+      var _this4 = this;
+      if (this._isFinished) {
+        if (!this._finishedFlag) {
+          if (this.onfinish) {
+            var event = new AnimationEvent(null, this, this.currentTime, baseTime);
+            setTimeout(function() {
+              if (_this4.onfinish) {
+                _this4.onfinish(event);
+              }
+            });
+          }
+          this._finishedFlag = true;
+        }
+      } else {
+        if (this.onframe && this.playState === "running") {
+          var _event = new AnimationEvent(null, this, this.currentTime, baseTime);
+          this.onframe(_event);
+        }
+        this._finishedFlag = false;
+      }
+    }
+  }]);
+})();
+var NEWTON_ITERATIONS = 4;
+var NEWTON_MIN_SLOPE = 1e-3;
+var SUBDIVISION_PRECISION = 1e-7;
+var SUBDIVISION_MAX_ITERATIONS = 10;
+var kSplineTableSize = 11;
+var kSampleStepSize = 1 / (kSplineTableSize - 1);
+var float32ArraySupported = typeof Float32Array === "function";
+var A = function A2(aA1, aA2) {
+  return 1 - 3 * aA2 + 3 * aA1;
+};
+var B = function B2(aA1, aA2) {
+  return 3 * aA2 - 6 * aA1;
+};
+var C = function C2(aA1) {
+  return 3 * aA1;
+};
+var calcBezier = function calcBezier2(aT, aA1, aA2) {
+  return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
+};
+var getSlope = function getSlope2(aT, aA1, aA2) {
+  return 3 * A(aA1, aA2) * aT * aT + 2 * B(aA1, aA2) * aT + C(aA1);
+};
+var binarySubdivide = function binarySubdivide2(aX, aA, aB, mX1, mX2) {
+  var currentX;
+  var currentT;
+  var i = 0;
+  do {
+    currentT = aA + (aB - aA) / 2;
+    currentX = calcBezier(currentT, mX1, mX2) - aX;
+    if (currentX > 0) aB = currentT;
+    else aA = currentT;
+  } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
+  return currentT;
+};
+var newtonRaphsonIterate = function newtonRaphsonIterate2(aX, aGuessT, mX1, mX2) {
+  for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
+    var currentSlope = getSlope(aGuessT, mX1, mX2);
+    if (currentSlope === 0) return aGuessT;
+    var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+    aGuessT -= currentX / currentSlope;
+  }
+  return aGuessT;
+};
+var bezier = function bezier2(mX1, mY1, mX2, mY2) {
+  if (!(mX1 >= 0 && mX1 <= 1 && mX2 >= 0 && mX2 <= 1)) throw new Error("bezier x values must be in [0, 1] range");
+  if (mX1 === mY1 && mX2 === mY2) return function(t) {
+    return t;
+  };
+  var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
+  for (var i = 0; i < kSplineTableSize; ++i) {
+    sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
+  }
+  var getTForX = function getTForX2(aX) {
+    var intervalStart = 0;
+    var currentSample = 1;
+    var lastSample = kSplineTableSize - 1;
+    for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) intervalStart += kSampleStepSize;
+    --currentSample;
+    var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
+    var guessForT = intervalStart + dist * kSampleStepSize;
+    var initialSlope = getSlope(guessForT, mX1, mX2);
+    if (initialSlope >= NEWTON_MIN_SLOPE) return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
+    if (initialSlope === 0) return guessForT;
+    return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
+  };
+  return function(t) {
+    if (t === 0 || t === 1) return t;
+    return calcBezier(getTForX(t), mY1, mY2);
+  };
+};
+var convertToDash = function convertToDash2(str) {
+  str = str.replace(/([A-Z])/g, function(letter) {
+    return "-".concat(letter.toLowerCase());
+  });
+  return str.charAt(0) === "-" ? str.substring(1) : str;
+};
+var Quad = function Quad2(t) {
+  return Math.pow(t, 2);
+};
+var Cubic = function Cubic2(t) {
+  return Math.pow(t, 3);
+};
+var Quart = function Quart2(t) {
+  return Math.pow(t, 4);
+};
+var Quint = function Quint2(t) {
+  return Math.pow(t, 5);
+};
+var Expo = function Expo2(t) {
+  return Math.pow(t, 6);
+};
+var Sine = function Sine2(t) {
+  return 1 - Math.cos(t * Math.PI / 2);
+};
+var Circ = function Circ2(t) {
+  return 1 - Math.sqrt(1 - t * t);
+};
+var Back = function Back2(t) {
+  return t * t * (3 * t - 2);
+};
+var Bounce = function Bounce2(t) {
+  var pow2;
+  var b = 4;
+  while (t < ((pow2 = Math.pow(2, --b)) - 1) / 11) {
+  }
+  return 1 / Math.pow(4, 3 - b) - 7.5625 * Math.pow((pow2 * 3 - 2) / 22 - t, 2);
+};
+var Elastic = function Elastic2(t) {
+  var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  var _params = slicedToArray(params, 2), _params$ = _params[0], amplitude = _params$ === void 0 ? 1 : _params$, _params$2 = _params[1], period = _params$2 === void 0 ? 0.5 : _params$2;
+  var a = clamp(Number(amplitude), 1, 10);
+  var p = clamp(Number(period), 0.1, 2);
+  if (t === 0 || t === 1) return t;
+  return -a * Math.pow(2, 10 * (t - 1)) * Math.sin((t - 1 - p / (Math.PI * 2) * Math.asin(1 / a)) * (Math.PI * 2) / p);
+};
+var Spring = function Spring2(t) {
+  var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  var duration = arguments.length > 2 ? arguments[2] : void 0;
+  var _params2 = slicedToArray(params, 4), _params2$ = _params2[0], mass = _params2$ === void 0 ? 1 : _params2$, _params2$2 = _params2[1], stiffness = _params2$2 === void 0 ? 100 : _params2$2, _params2$3 = _params2[2], damping = _params2$3 === void 0 ? 10 : _params2$3, _params2$4 = _params2[3], velocity = _params2$4 === void 0 ? 0 : _params2$4;
+  mass = clamp(mass, 0.1, 1e3);
+  stiffness = clamp(stiffness, 0.1, 1e3);
+  damping = clamp(damping, 0.1, 1e3);
+  velocity = clamp(velocity, 0.1, 1e3);
+  var w0 = Math.sqrt(stiffness / mass);
+  var zeta = damping / (2 * Math.sqrt(stiffness * mass));
+  var wd = zeta < 1 ? w0 * Math.sqrt(1 - zeta * zeta) : 0;
+  var a = 1;
+  var b = zeta < 1 ? (zeta * w0 + -velocity) / wd : -velocity + w0;
+  var progress = duration ? duration * t / 1e3 : t;
+  if (zeta < 1) {
+    progress = Math.exp(-progress * zeta * w0) * (a * Math.cos(wd * progress) + b * Math.sin(wd * progress));
+  } else {
+    progress = (a + b * progress) * Math.exp(-progress * w0);
+  }
+  if (t === 0 || t === 1) return t;
+  return 1 - progress;
+};
+var Steps = function Steps2(t) {
+  var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  var _ref = params, _ref2 = slicedToArray(_ref, 2), _ref2$ = _ref2[0], steps = _ref2$ === void 0 ? 10 : _ref2$, type = _ref2[1];
+  var trunc = type === "start" ? Math.ceil : Math.floor;
+  return trunc(clamp(t, 0, 1) * steps) / steps;
+};
+var Bezier = function Bezier2(t) {
+  var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  var _params3 = slicedToArray(params, 4), mX1 = _params3[0], mY1 = _params3[1], mX2 = _params3[2], mY2 = _params3[3];
+  return bezier(mX1, mY1, mX2, mY2)(t);
+};
+var easein = bezier(0.42, 0, 1, 1);
+var EaseOut = function EaseOut2(ease2) {
+  return function(t) {
+    var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+    var duration = arguments.length > 2 ? arguments[2] : void 0;
+    return 1 - ease2(1 - t, params, duration);
+  };
+};
+var EaseInOut = function EaseInOut2(ease2) {
+  return function(t) {
+    var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+    var duration = arguments.length > 2 ? arguments[2] : void 0;
+    return t < 0.5 ? ease2(t * 2, params, duration) / 2 : 1 - ease2(t * -2 + 2, params, duration) / 2;
+  };
+};
+var EaseOutIn = function EaseOutIn2(ease2) {
+  return function(t) {
+    var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+    var duration = arguments.length > 2 ? arguments[2] : void 0;
+    return t < 0.5 ? (1 - ease2(1 - t * 2, params, duration)) / 2 : (ease2(t * 2 - 1, params, duration) + 1) / 2;
+  };
+};
+var EasingFunctions = {
+  steps: Steps,
+  "step-start": function stepStart(t) {
+    return Steps(t, [1, "start"]);
+  },
+  "step-end": function stepEnd(t) {
+    return Steps(t, [1, "end"]);
+  },
+  linear: function linear(t) {
+    return t;
+  },
+  "cubic-bezier": Bezier,
+  ease: function ease(t) {
+    return Bezier(t, [0.25, 0.1, 0.25, 1]);
+  },
+  "in": easein,
+  out: EaseOut(easein),
+  "in-out": EaseInOut(easein),
+  "out-in": EaseOutIn(easein),
+  "in-quad": Quad,
+  "out-quad": EaseOut(Quad),
+  "in-out-quad": EaseInOut(Quad),
+  "out-in-quad": EaseOutIn(Quad),
+  "in-cubic": Cubic,
+  "out-cubic": EaseOut(Cubic),
+  "in-out-cubic": EaseInOut(Cubic),
+  "out-in-cubic": EaseOutIn(Cubic),
+  "in-quart": Quart,
+  "out-quart": EaseOut(Quart),
+  "in-out-quart": EaseInOut(Quart),
+  "out-in-quart": EaseOutIn(Quart),
+  "in-quint": Quint,
+  "out-quint": EaseOut(Quint),
+  "in-out-quint": EaseInOut(Quint),
+  "out-in-quint": EaseOutIn(Quint),
+  "in-expo": Expo,
+  "out-expo": EaseOut(Expo),
+  "in-out-expo": EaseInOut(Expo),
+  "out-in-expo": EaseOutIn(Expo),
+  "in-sine": Sine,
+  "out-sine": EaseOut(Sine),
+  "in-out-sine": EaseInOut(Sine),
+  "out-in-sine": EaseOutIn(Sine),
+  "in-circ": Circ,
+  "out-circ": EaseOut(Circ),
+  "in-out-circ": EaseInOut(Circ),
+  "out-in-circ": EaseOutIn(Circ),
+  "in-back": Back,
+  "out-back": EaseOut(Back),
+  "in-out-back": EaseInOut(Back),
+  "out-in-back": EaseOutIn(Back),
+  "in-bounce": Bounce,
+  "out-bounce": EaseOut(Bounce),
+  "in-out-bounce": EaseInOut(Bounce),
+  "out-in-bounce": EaseOutIn(Bounce),
+  "in-elastic": Elastic,
+  "out-elastic": EaseOut(Elastic),
+  "in-out-elastic": EaseInOut(Elastic),
+  "out-in-elastic": EaseOutIn(Elastic),
+  spring: Spring,
+  "spring-in": Spring,
+  "spring-out": EaseOut(Spring),
+  "spring-in-out": EaseInOut(Spring),
+  "spring-out-in": EaseOutIn(Spring)
+};
+var complexEasingSyntax = function complexEasingSyntax2(ease2) {
+  return convertToDash(ease2).replace(/^ease-/, "").replace(/(\(|\s).+/, "").toLowerCase().trim();
+};
+var getEasingFunction = function getEasingFunction2(ease2) {
+  return EasingFunctions[complexEasingSyntax(ease2)] || EasingFunctions.linear;
+};
+var linear2 = function linear3(x) {
+  return x;
+};
+var Start = 1;
+var Middle = 0.5;
+var End = 0;
+function step(count, pos) {
+  return function(x) {
+    if (x >= 1) {
+      return 1;
+    }
+    var stepSize = 1 / count;
+    x += pos * stepSize;
+    return x - x % stepSize;
+  };
+}
+var numberString = "\\s*(-?\\d+\\.?\\d*|-?\\.\\d+)\\s*";
+var cubicBezierRe = new RegExp("cubic-bezier\\(".concat(numberString, ",").concat(numberString, ",").concat(numberString, ",").concat(numberString, "\\)"));
+var step1Re = /steps\(\s*(\d+)\s*\)/;
+var step2Re = /steps\(\s*(\d+)\s*,\s*(start|middle|end)\s*\)/;
+function parseEasingFunction(normalizedEasing) {
+  var cubicData = cubicBezierRe.exec(normalizedEasing);
+  if (cubicData) {
+    return bezier.apply(void 0, toConsumableArray(cubicData.slice(1).map(Number)));
+  }
+  var step1Data = step1Re.exec(normalizedEasing);
+  if (step1Data) {
+    return step(Number(step1Data[1]), End);
+  }
+  var step2Data = step2Re.exec(normalizedEasing);
+  if (step2Data) {
+    return step(Number(step2Data[1]), {
+      start: Start,
+      middle: Middle,
+      end: End
+    }[step2Data[2]]);
+  }
+  return getEasingFunction(normalizedEasing);
+}
+function calculateActiveDuration(timing) {
+  return Math.abs(repeatedDuration(timing) / (timing.playbackRate || 1));
+}
+function repeatedDuration(timing) {
+  var _timing$iterations;
+  if (timing.duration === 0 || timing.iterations === 0) {
+    return 0;
+  }
+  return (timing.duration === "auto" ? 0 : Number(timing.duration)) * ((_timing$iterations = timing.iterations) !== null && _timing$iterations !== void 0 ? _timing$iterations : 1);
+}
+var PhaseNone = 0;
+var PhaseBefore = 1;
+var PhaseAfter = 2;
+var PhaseActive = 3;
+function calculatePhase(activeDuration, localTime, timing) {
+  if (localTime === null) {
+    return PhaseNone;
+  }
+  var endTime = timing.endTime;
+  if (localTime < Math.min(timing.delay, endTime)) {
+    return PhaseBefore;
+  }
+  if (localTime >= Math.min(timing.delay + activeDuration + timing.endDelay, endTime)) {
+    return PhaseAfter;
+  }
+  return PhaseActive;
+}
+function calculateActiveTime(activeDuration, fillMode, localTime, phase, delay) {
+  switch (phase) {
+    case PhaseBefore:
+      if (fillMode === "backwards" || fillMode === "both") return 0;
+      return null;
+    case PhaseActive:
+      return localTime - delay;
+    case PhaseAfter:
+      if (fillMode === "forwards" || fillMode === "both") return activeDuration;
+      return null;
+    case PhaseNone:
+      return null;
+  }
+}
+function calculateOverallProgress(iterationDuration, phase, iterations, activeTime, iterationStart) {
+  var overallProgress = iterationStart;
+  if (iterationDuration === 0) {
+    if (phase !== PhaseBefore) {
+      overallProgress += iterations;
+    }
+  } else {
+    overallProgress += activeTime / iterationDuration;
+  }
+  return overallProgress;
+}
+function calculateSimpleIterationProgress(overallProgress, iterationStart, phase, iterations, activeTime, iterationDuration) {
+  var simpleIterationProgress = overallProgress === Infinity ? iterationStart % 1 : overallProgress % 1;
+  if (simpleIterationProgress === 0 && phase === PhaseAfter && iterations !== 0 && (activeTime !== 0 || iterationDuration === 0)) {
+    simpleIterationProgress = 1;
+  }
+  return simpleIterationProgress;
+}
+function calculateCurrentIteration(phase, iterations, simpleIterationProgress, overallProgress) {
+  if (phase === PhaseAfter && iterations === Infinity) {
+    return Infinity;
+  }
+  if (simpleIterationProgress === 1) {
+    return Math.floor(overallProgress) - 1;
+  }
+  return Math.floor(overallProgress);
+}
+function calculateDirectedProgress(playbackDirection, currentIteration, simpleIterationProgress) {
+  var currentDirection = playbackDirection;
+  if (playbackDirection !== "normal" && playbackDirection !== "reverse") {
+    var d = currentIteration;
+    if (playbackDirection === "alternate-reverse") {
+      d += 1;
+    }
+    currentDirection = "normal";
+    if (d !== Infinity && d % 2 !== 0) {
+      currentDirection = "reverse";
+    }
+  }
+  if (currentDirection === "normal") {
+    return simpleIterationProgress;
+  }
+  return 1 - simpleIterationProgress;
+}
+function calculateIterationProgress(activeDuration, localTime, timing) {
+  var phase = calculatePhase(activeDuration, localTime, timing);
+  var activeTime = calculateActiveTime(activeDuration, timing.fill, localTime, phase, timing.delay);
+  if (activeTime === null) return null;
+  var duration = timing.duration === "auto" ? 0 : timing.duration;
+  var overallProgress = calculateOverallProgress(duration, phase, timing.iterations, activeTime, timing.iterationStart);
+  var simpleIterationProgress = calculateSimpleIterationProgress(overallProgress, timing.iterationStart, phase, timing.iterations, activeTime, duration);
+  var currentIteration = calculateCurrentIteration(phase, timing.iterations, simpleIterationProgress, overallProgress);
+  var directedProgress = calculateDirectedProgress(timing.direction, currentIteration, simpleIterationProgress);
+  timing.currentIteration = currentIteration;
+  timing.progress = directedProgress;
+  return timing.easingFunction(directedProgress);
+}
+function convertEffectInput(keyframes, timing, target) {
+  var propertySpecificKeyframeGroups = makePropertySpecificKeyframeGroups(keyframes, timing);
+  var interpolations = makeInterpolations(propertySpecificKeyframeGroups, target);
+  return function(target2, fraction) {
+    if (fraction !== null) {
+      interpolations.filter(function(interpolation) {
+        return fraction >= interpolation.applyFrom && fraction < interpolation.applyTo;
+      }).forEach(function(interpolation) {
+        var offsetFraction = fraction - interpolation.startOffset;
+        var localDuration = interpolation.endOffset - interpolation.startOffset;
+        var scaledLocalTime = localDuration === 0 ? 0 : offsetFraction / localDuration;
+        target2.setAttribute(
+          interpolation.property,
+          interpolation.interpolation(scaledLocalTime),
+          false,
+          false
+          // disable memoize
+        );
+      });
+    } else {
+      for (var property in propertySpecificKeyframeGroups) if (isNotReservedWord(property)) {
+        target2.setAttribute(property, null);
+      }
+    }
+  };
+}
+function isNotReservedWord(member) {
+  return member !== "offset" && member !== "easing" && member !== "composite" && member !== "computedOffset";
+}
+function makePropertySpecificKeyframeGroups(keyframes, timing) {
+  var propertySpecificKeyframeGroups = {};
+  for (var i = 0; i < keyframes.length; i++) {
+    for (var member in keyframes[i]) {
+      if (isNotReservedWord(member)) {
+        var propertySpecificKeyframe = {
+          offset: keyframes[i].offset,
+          computedOffset: keyframes[i].computedOffset,
+          easing: keyframes[i].easing,
+          easingFunction: parseEasingFunction(keyframes[i].easing) || timing.easingFunction,
+          value: keyframes[i][member]
+        };
+        propertySpecificKeyframeGroups[member] = propertySpecificKeyframeGroups[member] || [];
+        propertySpecificKeyframeGroups[member].push(propertySpecificKeyframe);
+      }
+    }
+  }
+  return propertySpecificKeyframeGroups;
+}
+function makeInterpolations(propertySpecificKeyframeGroups, target) {
+  var interpolations = [];
+  for (var groupName in propertySpecificKeyframeGroups) {
+    var keyframes = propertySpecificKeyframeGroups[groupName];
+    for (var i = 0; i < keyframes.length - 1; i++) {
+      var startIndex = i;
+      var endIndex = i + 1;
+      var startOffset = keyframes[startIndex].computedOffset;
+      var endOffset = keyframes[endIndex].computedOffset;
+      var applyFrom = startOffset;
+      var applyTo = endOffset;
+      if (i === 0) {
+        applyFrom = -Infinity;
+        if (endOffset === 0) {
+          endIndex = startIndex;
+        }
+      }
+      if (i === keyframes.length - 2) {
+        applyTo = Infinity;
+        if (startOffset === 1) {
+          startIndex = endIndex;
+        }
+      }
+      interpolations.push({
+        applyFrom,
+        applyTo,
+        startOffset: keyframes[startIndex].computedOffset,
+        endOffset: keyframes[endIndex].computedOffset,
+        easingFunction: keyframes[startIndex].easingFunction,
+        property: groupName,
+        interpolation: propertyInterpolation(groupName, keyframes[startIndex].value, keyframes[endIndex].value, target)
+      });
+    }
+  }
+  interpolations.sort(function(leftInterpolation, rightInterpolation) {
+    return leftInterpolation.startOffset - rightInterpolation.startOffset;
+  });
+  return interpolations;
+}
+var InterpolationFactory = function InterpolationFactory2(from, to, convertToString) {
+  return function(f) {
+    var interpolated = interpolate(from, to, f);
+    return isNumber(interpolated) ? interpolated : convertToString(interpolated);
+  };
+};
+function propertyInterpolation(property, left, right, target) {
+  var metadata = index_esm.propertyMetadataCache[property];
+  if (metadata && metadata.syntax && metadata["int"]) {
+    var propertyHandler = index_esm.runtime.styleValueRegistry.getPropertySyntax(metadata.syntax);
+    if (propertyHandler) {
+      var parser = propertyHandler.parser;
+      var usedLeft = parser ? parser(left, target) : left;
+      var usedRight = parser ? parser(right, target) : right;
+      var interpolationArgs = propertyHandler.mixer(usedLeft, usedRight, target);
+      if (interpolationArgs) {
+        var interp = InterpolationFactory.apply(void 0, toConsumableArray(interpolationArgs));
+        return function(t) {
+          if (t === 0) return left;
+          if (t === 1) return right;
+          return interp(t);
+        };
+      }
+    }
+  }
+  return InterpolationFactory(false, true, function(bool) {
+    return bool ? right : left;
+  });
+}
+function interpolate(from, to, f) {
+  if (typeof from === "number" && typeof to === "number") {
+    return from * (1 - f) + to * f;
+  }
+  if (typeof from === "boolean" && typeof to === "boolean" || typeof from === "string" && typeof to === "string") {
+    return f < 0.5 ? from : to;
+  }
+  if (Array.isArray(from) && Array.isArray(to)) {
+    var fromLength = from.length;
+    var toLength = to.length;
+    var length = Math.max(fromLength, toLength);
+    var r = [];
+    for (var i = 0; i < length; i++) {
+      r.push(interpolate(from[i < fromLength ? i : fromLength - 1], to[i < toLength ? i : toLength - 1], f));
+    }
+    return r;
+  }
+  throw new Error("Mismatched interpolation arguments ".concat(from, ":").concat(to));
+}
+var AnimationEffectTiming = /* @__PURE__ */ (function() {
+  function AnimationEffectTiming2() {
+    classCallCheck(this, AnimationEffectTiming2);
+    this.delay = 0;
+    this.direction = "normal";
+    this.duration = "auto";
+    this._easing = "linear";
+    this.easingFunction = linear2;
+    this.endDelay = 0;
+    this.fill = "auto";
+    this.iterationStart = 0;
+    this.iterations = 1;
+    this.currentIteration = null;
+    this.progress = null;
+  }
+  return createClass(AnimationEffectTiming2, [{
+    key: "easing",
+    get: function get() {
+      return this._easing;
+    },
+    set: function set(value) {
+      this.easingFunction = parseEasingFunction(value);
+      this._easing = value;
+    }
+  }]);
+})();
+function convertToArrayForm(effectInput) {
+  var normalizedEffectInput = [];
+  for (var property in effectInput) {
+    if (property in ["easing", "offset", "composite"]) {
+      continue;
+    }
+    var values = effectInput[property];
+    if (!Array.isArray(values)) {
+      values = [values];
+    }
+    var numKeyframes = values.length;
+    for (var i = 0; i < numKeyframes; i++) {
+      if (!normalizedEffectInput[i]) {
+        var keyframe = {};
+        if ("offset" in effectInput) {
+          keyframe.offset = Number(effectInput.offset);
+        }
+        if ("easing" in effectInput) {
+          keyframe.easing = effectInput.easing;
+        }
+        if ("composite" in effectInput) {
+          keyframe.composite = effectInput.composite;
+        }
+        normalizedEffectInput[i] = keyframe;
+      }
+      if (values[i] !== void 0 && values[i] !== null) {
+        normalizedEffectInput[i][property] = values[i];
+      }
+    }
+  }
+  normalizedEffectInput.sort(function(a, b) {
+    return (a.computedOffset || 0) - (b.computedOffset || 0);
+  });
+  return normalizedEffectInput;
+}
+function normalizeKeyframes(effectInput, timing) {
+  if (effectInput === null) {
+    return [];
+  }
+  if (!Array.isArray(effectInput)) {
+    effectInput = convertToArrayForm(effectInput);
+  }
+  var keyframes = effectInput.map(function(originalKeyframe) {
+    var keyframe = {};
+    if (timing !== null && timing !== void 0 && timing.composite) {
+      keyframe.composite = "auto";
+    }
+    for (var member in originalKeyframe) {
+      var memberValue = originalKeyframe[member];
+      if (member === "offset") {
+        if (memberValue !== null) {
+          memberValue = Number(memberValue);
+          if (!isFinite(memberValue)) throw new Error("Keyframe offsets must be numbers.");
+          if (memberValue < 0 || memberValue > 1) throw new Error("Keyframe offsets must be between 0 and 1.");
+          keyframe.computedOffset = memberValue;
+        }
+      } else if (member === "composite") {
+        if (["replace", "add", "accumulate", "auto"].indexOf(memberValue) === -1) {
+          throw new Error("".concat(memberValue, " compositing is not supported"));
+        }
+      } else ;
+      keyframe[member] = memberValue;
+    }
+    if (keyframe.offset === void 0) {
+      keyframe.offset = null;
+    }
+    if (keyframe.easing === void 0) {
+      keyframe.easing = (timing === null || timing === void 0 ? void 0 : timing.easing) || "linear";
+    }
+    if (keyframe.composite === void 0) {
+      keyframe.composite = "auto";
+    }
+    return keyframe;
+  });
+  var everyFrameHasOffset = true;
+  var previousOffset = -Infinity;
+  for (var i = 0; i < keyframes.length; i++) {
+    var offset = keyframes[i].offset;
+    if (!isNil(offset)) {
+      if (offset < previousOffset) {
+        throw new TypeError("Keyframes are not loosely sorted by offset. Sort or specify offsets.");
+      }
+      previousOffset = offset;
+    } else {
+      everyFrameHasOffset = false;
+    }
+  }
+  keyframes = keyframes.filter(function(keyframe) {
+    return Number(keyframe.offset) >= 0 && Number(keyframe.offset) <= 1;
+  });
+  function spaceKeyframes() {
+    var _keyframes$offset;
+    var _keyframes = keyframes, length = _keyframes.length;
+    keyframes[length - 1].computedOffset = Number((_keyframes$offset = keyframes[length - 1].offset) !== null && _keyframes$offset !== void 0 ? _keyframes$offset : 1);
+    if (length > 1) {
+      var _keyframes$0$offset;
+      keyframes[0].computedOffset = Number((_keyframes$0$offset = keyframes[0].offset) !== null && _keyframes$0$offset !== void 0 ? _keyframes$0$offset : 0);
+    }
+    var previousIndex = 0;
+    var previousOffset2 = Number(keyframes[0].computedOffset);
+    for (var _i = 1; _i < length; _i++) {
+      var _offset = keyframes[_i].computedOffset;
+      if (!isNil(_offset) && !isNil(previousOffset2)) {
+        for (var j = 1; j < _i - previousIndex; j++) keyframes[previousIndex + j].computedOffset = previousOffset2 + (Number(_offset) - previousOffset2) * j / (_i - previousIndex);
+        previousIndex = _i;
+        previousOffset2 = Number(_offset);
+      }
+    }
+  }
+  if (!everyFrameHasOffset) spaceKeyframes();
+  return keyframes;
+}
+var fills = "backwards|forwards|both|none".split("|");
+var directions = "reverse|alternate|alternate-reverse".split("|");
+function makeTiming(timingInput, forGroup) {
+  var timing = new AnimationEffectTiming();
+  if (typeof timingInput === "number" && !isNaN(timingInput)) {
+    timing.duration = timingInput;
+  } else if (timingInput !== void 0) {
+    Object.keys(timingInput).forEach(function(property) {
+      if (timingInput[property] !== void 0 && timingInput[property] !== null && timingInput[property] !== "auto") {
+        if (typeof timing[property] === "number" || property === "duration") {
+          if (typeof timingInput[property] !== "number" || isNaN(timingInput[property])) {
+            return;
+          }
+        }
+        if (property === "fill" && fills.indexOf(timingInput[property]) === -1) {
+          return;
+        }
+        if (property === "direction" && directions.indexOf(timingInput[property]) === -1) {
+          return;
+        }
+        timing[property] = timingInput[property];
+      }
+    });
+  }
+  return timing;
+}
+function normalizeTimingInput(timingInput, forGroup) {
+  timingInput = numericTimingToObject(timingInput !== null && timingInput !== void 0 ? timingInput : {
+    duration: "auto"
+  });
+  return makeTiming(timingInput);
+}
+function numericTimingToObject(timingInput) {
+  if (typeof timingInput === "number") {
+    if (isNaN(timingInput)) {
+      timingInput = {
+        duration: "auto"
+      };
+    } else {
+      timingInput = {
+        duration: timingInput
+      };
+    }
+  }
+  return timingInput;
+}
+var KeyframeEffect = /* @__PURE__ */ (function() {
+  function KeyframeEffect2(target, effectInput, timingInput) {
+    var _this = this;
+    classCallCheck(this, KeyframeEffect2);
+    this.composite = "replace";
+    this.iterationComposite = "replace";
+    this.target = target;
+    this.timing = normalizeTimingInput(timingInput);
+    this.timing.effect = this;
+    this.timing.activeDuration = calculateActiveDuration(this.timing);
+    this.timing.endTime = Math.max(0, this.timing.delay + this.timing.activeDuration + this.timing.endDelay);
+    this.normalizedKeyframes = normalizeKeyframes(effectInput, this.timing);
+    this.interpolations = convertEffectInput(this.normalizedKeyframes, this.timing, this.target);
+    var Proxy = index_esm.runtime.globalThis.Proxy;
+    this.computedTiming = Proxy ? new Proxy(this.timing, {
+      get: function get(target2, prop) {
+        if (prop === "duration") {
+          return target2.duration === "auto" ? 0 : target2.duration;
+        }
+        if (prop === "fill") {
+          return target2.fill === "auto" ? "none" : target2.fill;
+        }
+        if (prop === "localTime") {
+          return _this.animation && _this.animation.currentTime || null;
+        }
+        if (prop === "currentIteration") {
+          if (!_this.animation || _this.animation.playState !== "running") {
+            return null;
+          }
+          return target2.currentIteration || 0;
+        }
+        if (prop === "progress") {
+          if (!_this.animation || _this.animation.playState !== "running") {
+            return null;
+          }
+          return target2.progress || 0;
+        }
+        return target2[prop];
+      },
+      set: function set() {
+        return true;
+      }
+    }) : this.timing;
+  }
+  return createClass(KeyframeEffect2, [{
+    key: "applyInterpolations",
+    value: function applyInterpolations() {
+      this.interpolations(this.target, Number(this.timeFraction));
+    }
+  }, {
+    key: "update",
+    value: function update(localTime) {
+      if (localTime === null) {
+        return false;
+      }
+      this.timeFraction = calculateIterationProgress(this.timing.activeDuration, localTime, this.timing);
+      return this.timeFraction !== null;
+    }
+  }, {
+    key: "getKeyframes",
+    value: function getKeyframes() {
+      return this.normalizedKeyframes;
+    }
+  }, {
+    key: "setKeyframes",
+    value: function setKeyframes(keyframes) {
+      this.normalizedKeyframes = normalizeKeyframes(keyframes);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEffect/getComputedTiming
+     */
+  }, {
+    key: "getComputedTiming",
+    value: function getComputedTiming() {
+      return this.computedTiming;
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEffect/getTiming
+     */
+  }, {
+    key: "getTiming",
+    value: function getTiming() {
+      return this.timing;
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEffect/updateTiming
+     */
+  }, {
+    key: "updateTiming",
+    value: function updateTiming(timing) {
+      var _this2 = this;
+      Object.keys(timing || {}).forEach(function(name) {
+        _this2.timing[name] = timing[name];
+      });
+    }
+  }]);
+})();
+function compareAnimations(leftAnimation, rightAnimation) {
+  return Number(leftAnimation.id) - Number(rightAnimation.id);
+}
+var AnimationTimeline = /* @__PURE__ */ (function() {
+  function AnimationTimeline2(document) {
+    var _this = this;
+    classCallCheck(this, AnimationTimeline2);
+    this.animations = [];
+    this.ticking = false;
+    this.timelineTicking = false;
+    this.hasRestartedThisFrame = false;
+    this.animationsWithPromises = [];
+    this.inTick = false;
+    this.pendingEffects = [];
+    this.currentTime = null;
+    this.rafId = 0;
+    this.rafCallbacks = [];
+    this.webAnimationsNextTick = function(t) {
+      _this.currentTime = t;
+      _this.discardAnimations();
+      if (_this.animations.length === 0) {
+        _this.timelineTicking = false;
+      } else {
+        _this.requestAnimationFrame(_this.webAnimationsNextTick);
+      }
+    };
+    this.processRafCallbacks = function(t) {
+      var processing = _this.rafCallbacks;
+      _this.rafCallbacks = [];
+      if (t < Number(_this.currentTime)) t = Number(_this.currentTime);
+      _this.animations.sort(compareAnimations);
+      _this.animations = _this.tick(t, true, _this.animations)[0];
+      processing.forEach(function(entry) {
+        entry[1](t);
+      });
+      _this.applyPendingEffects();
+    };
+    this.document = document;
+  }
+  return createClass(AnimationTimeline2, [{
+    key: "getAnimations",
+    value: function getAnimations() {
+      this.discardAnimations();
+      return this.animations.slice();
+    }
+  }, {
+    key: "isTicking",
+    value: function isTicking() {
+      return this.inTick;
+    }
+  }, {
+    key: "play",
+    value: function play(target, keyframes, options) {
+      var effect = new KeyframeEffect(target, keyframes, options);
+      var animation = new Animation(effect, this);
+      this.animations.push(animation);
+      this.restartWebAnimationsNextTick();
+      animation.updatePromises();
+      animation.play();
+      animation.updatePromises();
+      return animation;
+    }
+    // RAF is supposed to be the last script to occur before frame rendering but not
+    // all browsers behave like this. This function is for synchonously updating an
+    // animation's effects whenever its state is mutated by script to work around
+    // incorrect script execution ordering by the browser.
+  }, {
+    key: "applyDirtiedAnimation",
+    value: function applyDirtiedAnimation(animation) {
+      var _this2 = this;
+      if (this.inTick) {
+        return;
+      }
+      animation.markTarget();
+      var animations = animation.targetAnimations();
+      animations.sort(compareAnimations);
+      var inactiveAnimations = this.tick(Number(this.currentTime), false, animations.slice())[1];
+      inactiveAnimations.forEach(function(animation2) {
+        var index = _this2.animations.indexOf(animation2);
+        if (index !== -1) {
+          _this2.animations.splice(index, 1);
+        }
+      });
+      this.applyPendingEffects();
+    }
+  }, {
+    key: "restart",
+    value: function restart() {
+      if (!this.ticking) {
+        this.ticking = true;
+        this.requestAnimationFrame(function() {
+        });
+        this.hasRestartedThisFrame = true;
+      }
+      return this.hasRestartedThisFrame;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.document.defaultView.cancelAnimationFrame(this.frameId);
+    }
+  }, {
+    key: "applyPendingEffects",
+    value: function applyPendingEffects() {
+      this.pendingEffects.forEach(function(effect) {
+        effect === null || effect === void 0 || effect.applyInterpolations();
+      });
+      this.pendingEffects = [];
+    }
+  }, {
+    key: "updateAnimationsPromises",
+    value: function updateAnimationsPromises() {
+      this.animationsWithPromises = this.animationsWithPromises.filter(function(animation) {
+        return animation.updatePromises();
+      });
+    }
+  }, {
+    key: "discardAnimations",
+    value: function discardAnimations() {
+      this.updateAnimationsPromises();
+      this.animations = this.animations.filter(function(animation) {
+        return animation.playState !== "finished" && animation.playState !== "idle";
+      });
+    }
+  }, {
+    key: "restartWebAnimationsNextTick",
+    value: function restartWebAnimationsNextTick() {
+      if (!this.timelineTicking) {
+        this.timelineTicking = true;
+        this.requestAnimationFrame(this.webAnimationsNextTick);
+      }
+    }
+  }, {
+    key: "rAF",
+    value: function rAF(f) {
+      var id = this.rafId++;
+      if (this.rafCallbacks.length === 0) {
+        this.frameId = this.document.defaultView.requestAnimationFrame(this.processRafCallbacks);
+      }
+      this.rafCallbacks.push([id, f]);
+      return id;
+    }
+  }, {
+    key: "requestAnimationFrame",
+    value: function requestAnimationFrame(f) {
+      var _this3 = this;
+      return this.rAF(function(x) {
+        _this3.updateAnimationsPromises();
+        f(x);
+        _this3.updateAnimationsPromises();
+      });
+    }
+  }, {
+    key: "tick",
+    value: function tick(t, isAnimationFrame, updatingAnimations) {
+      var _this4 = this, _this$pendingEffects, _this$pendingEffects2;
+      this.inTick = true;
+      this.hasRestartedThisFrame = false;
+      this.currentTime = t;
+      this.ticking = false;
+      var newPendingClears = [];
+      var newPendingEffects = [];
+      var activeAnimations = [];
+      var inactiveAnimations = [];
+      updatingAnimations.forEach(function(animation) {
+        animation.tick(t, isAnimationFrame);
+        if (!animation._inEffect) {
+          newPendingClears.push(animation.effect);
+          animation.unmarkTarget();
+        } else {
+          newPendingEffects.push(animation.effect);
+          animation.markTarget();
+        }
+        if (animation._needsTick) _this4.ticking = true;
+        var alive = animation._inEffect || animation._needsTick;
+        animation._inTimeline = alive;
+        if (alive) {
+          activeAnimations.push(animation);
+        } else {
+          inactiveAnimations.push(animation);
+        }
+      });
+      (_this$pendingEffects = this.pendingEffects).push.apply(_this$pendingEffects, newPendingClears);
+      (_this$pendingEffects2 = this.pendingEffects).push.apply(_this$pendingEffects2, newPendingEffects);
+      if (this.ticking) this.requestAnimationFrame(function() {
+      });
+      this.inTick = false;
+      return [activeAnimations, inactiveAnimations];
+    }
+  }]);
+})();
+index_esm.runtime.EasingFunction = parseEasingFunction;
+index_esm.runtime.AnimationTimeline = AnimationTimeline;
+var AdvancedCamera = /* @__PURE__ */ (function(_Camera) {
+  function AdvancedCamera2() {
+    var _this;
+    classCallCheck(this, AdvancedCamera2);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = callSuper(this, AdvancedCamera2, [].concat(args));
+    _this.landmarks = [];
+    return _this;
+  }
+  inherits(AdvancedCamera2, _Camera);
+  return createClass(AdvancedCamera2, [{
+    key: "rotate",
+    value: (
+      /**
+       * Changes the azimuth and elevation with respect to the current camera axes
+       * @param {Number} azimuth the relative azimuth
+       * @param {Number} elevation the relative elevation
+       * @param {Number} roll the relative roll
+       */
+      function rotate(azimuth, elevation, roll) {
+        this.relElevation = index_esm.getAngle(elevation);
+        this.relAzimuth = index_esm.getAngle(azimuth);
+        this.relRoll = index_esm.getAngle(roll);
+        this.elevation += this.relElevation;
+        this.azimuth += this.relAzimuth;
+        this.roll += this.relRoll;
+        if (this.type === index_esm.CameraType.EXPLORING) {
+          var rotX = quat.setAxisAngle(quat.create(), [1, 0, 0], index_esm.deg2rad((this.rotateWorld ? 1 : -1) * this.relElevation));
+          var rotY = quat.setAxisAngle(quat.create(), [0, 1, 0], index_esm.deg2rad((this.rotateWorld ? 1 : -1) * this.relAzimuth));
+          var rotZ = quat.setAxisAngle(quat.create(), [0, 0, 1], index_esm.deg2rad(this.relRoll));
+          var rotQ = quat.multiply(quat.create(), rotY, rotX);
+          rotQ = quat.multiply(quat.create(), rotQ, rotZ);
+          var rotMatrix = mat4.fromQuat(mat4.create(), rotQ);
+          mat4.translate(this.matrix, this.matrix, [0, 0, -this.distance]);
+          mat4.multiply(this.matrix, this.matrix, rotMatrix);
+          mat4.translate(this.matrix, this.matrix, [0, 0, this.distance]);
+        } else {
+          if (Math.abs(this.elevation) > 90) {
+            return this;
+          }
+          this.computeMatrix();
+        }
+        this._getAxes();
+        if (this.type === index_esm.CameraType.ORBITING || this.type === index_esm.CameraType.EXPLORING) {
+          this._getPosition();
+        } else if (this.type === index_esm.CameraType.TRACKING) {
+          this._getFocalPoint();
+        }
+        this._update();
+        return this;
+      }
+    )
+    /**
+     * 沿水平(right) & 垂直(up)平移相机
+     */
+  }, {
+    key: "pan",
+    value: function pan(tx, ty) {
+      var coords = index_esm.createVec3(tx, ty, 0);
+      var pos = vec3.clone(this.position);
+      vec3.add(pos, pos, vec3.scale(vec3.create(), this.right, coords[0]));
+      vec3.add(pos, pos, vec3.scale(vec3.create(), this.up, coords[1]));
+      this._setPosition(pos);
+      this.triggerUpdate();
+      return this;
+    }
+    /**
+     * 沿 n 轴移动，当距离视点远时移动速度较快，离视点越近速度越慢
+     */
+  }, {
+    key: "dolly",
+    value: function dolly(value) {
+      var n = this.forward;
+      var pos = vec3.clone(this.position);
+      var step2 = value * this.dollyingStep;
+      var updatedDistance = this.distance + value * this.dollyingStep;
+      step2 = Math.max(Math.min(updatedDistance, this.maxDistance), this.minDistance) - this.distance;
+      pos[0] += step2 * n[0];
+      pos[1] += step2 * n[1];
+      pos[2] += step2 * n[2];
+      this._setPosition(pos);
+      if (this.type === index_esm.CameraType.ORBITING || this.type === index_esm.CameraType.EXPLORING) {
+        this._getDistance();
+      } else if (this.type === index_esm.CameraType.TRACKING) {
+        vec3.add(this.focalPoint, pos, this.distanceVector);
+      }
+      this.triggerUpdate();
+      return this;
+    }
+  }, {
+    key: "cancelLandmarkAnimation",
+    value: function cancelLandmarkAnimation() {
+      if (this.landmarkAnimationID !== void 0) {
+        this.canvas.cancelAnimationFrame(this.landmarkAnimationID);
+      }
+    }
+  }, {
+    key: "createLandmark",
+    value: function createLandmark(name) {
+      var _position$, _position$2, _focalPoint$, _focalPoint$2;
+      var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      var _params$position = params.position, position = _params$position === void 0 ? this.position : _params$position, _params$focalPoint = params.focalPoint, focalPoint = _params$focalPoint === void 0 ? this.focalPoint : _params$focalPoint, roll = params.roll, zoom = params.zoom;
+      var camera = new index_esm.runtime.CameraContribution();
+      camera.setType(this.type, void 0);
+      camera.setPosition(position[0], (_position$ = position[1]) !== null && _position$ !== void 0 ? _position$ : this.position[1], (_position$2 = position[2]) !== null && _position$2 !== void 0 ? _position$2 : this.position[2]);
+      camera.setFocalPoint(focalPoint[0], (_focalPoint$ = focalPoint[1]) !== null && _focalPoint$ !== void 0 ? _focalPoint$ : this.focalPoint[1], (_focalPoint$2 = focalPoint[2]) !== null && _focalPoint$2 !== void 0 ? _focalPoint$2 : this.focalPoint[2]);
+      camera.setRoll(roll !== null && roll !== void 0 ? roll : this.roll);
+      camera.setZoom(zoom !== null && zoom !== void 0 ? zoom : this.zoom);
+      var landmark = {
+        name,
+        matrix: mat4.clone(camera.getWorldTransform()),
+        right: vec3.clone(camera.right),
+        up: vec3.clone(camera.up),
+        forward: vec3.clone(camera.forward),
+        position: vec3.clone(camera.getPosition()),
+        focalPoint: vec3.clone(camera.getFocalPoint()),
+        distanceVector: vec3.clone(camera.getDistanceVector()),
+        distance: camera.getDistance(),
+        dollyingStep: camera.getDollyingStep(),
+        azimuth: camera.getAzimuth(),
+        elevation: camera.getElevation(),
+        roll: camera.getRoll(),
+        relAzimuth: camera.relAzimuth,
+        relElevation: camera.relElevation,
+        relRoll: camera.relRoll,
+        zoom: camera.getZoom()
+      };
+      this.landmarks.push(landmark);
+      return landmark;
+    }
+  }, {
+    key: "gotoLandmark",
+    value: function gotoLandmark(name) {
+      var _this2 = this;
+      var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      var landmark = isString(name) ? this.landmarks.find(function(l) {
+        return l.name === name;
+      }) : name;
+      if (landmark) {
+        var _ref = isNumber(options) ? {
+          duration: options
+        } : options, _ref$easing = _ref.easing, easing = _ref$easing === void 0 ? "linear" : _ref$easing, _ref$duration = _ref.duration, duration = _ref$duration === void 0 ? 100 : _ref$duration, _ref$easingFunction = _ref.easingFunction, easingFunction = _ref$easingFunction === void 0 ? void 0 : _ref$easingFunction, _ref$onfinish = _ref.onfinish, onfinish = _ref$onfinish === void 0 ? void 0 : _ref$onfinish, _ref$onframe = _ref.onframe, onframe = _ref$onframe === void 0 ? void 0 : _ref$onframe;
+        var epsilon = 0.01;
+        this.cancelLandmarkAnimation();
+        var destPosition = landmark.position;
+        var destFocalPoint = landmark.focalPoint;
+        var destZoom = landmark.zoom;
+        var destRoll = landmark.roll;
+        var easingFunc = easingFunction || index_esm.runtime.EasingFunction(easing);
+        var timeStart;
+        var end = function end2() {
+          _this2.setFocalPoint(destFocalPoint);
+          _this2.setPosition(destPosition);
+          _this2.setRoll(destRoll);
+          _this2.setZoom(destZoom);
+          _this2.computeMatrix();
+          _this2.triggerUpdate();
+          onfinish === null || onfinish === void 0 || onfinish();
+        };
+        if (duration === 0) return end();
+        var _animate = function animate(timestamp) {
+          if (timeStart === void 0) {
+            timeStart = timestamp;
+          }
+          var elapsed = timestamp - timeStart;
+          if (elapsed >= duration) {
+            end();
+            return;
+          }
+          var t = easingFunc(elapsed / duration);
+          var interFocalPoint = vec3.create();
+          var interPosition = vec3.create();
+          var interZoom = 1;
+          var interRoll = 0;
+          vec3.lerp(interFocalPoint, _this2.focalPoint, destFocalPoint, t);
+          vec3.lerp(interPosition, _this2.position, destPosition, t);
+          interRoll = _this2.roll * (1 - t) + destRoll * t;
+          interZoom = _this2.zoom * (1 - t) + destZoom * t;
+          _this2.setFocalPoint(interFocalPoint);
+          _this2.setPosition(interPosition);
+          _this2.setRoll(interRoll);
+          _this2.setZoom(interZoom);
+          var dist = vec3.dist(interFocalPoint, destFocalPoint) + vec3.dist(interPosition, destPosition);
+          if (dist <= epsilon && destZoom === void 0 && destRoll === void 0) {
+            return end();
+          }
+          _this2.computeMatrix();
+          _this2.triggerUpdate();
+          if (elapsed < duration) {
+            onframe === null || onframe === void 0 || onframe(t);
+            _this2.landmarkAnimationID = _this2.canvas.requestAnimationFrame(_animate);
+          }
+        };
+        this.canvas.requestAnimationFrame(_animate);
+      }
+    }
+    /**
+     * Sets the camera to a distance such that the area covered by the bounding box is viewed.
+     */
+    // shot(displayObject: DisplayObject) {
+    //   const aabb = displayObject.getBounds();
+    //   if (!AABB.isEmpty(aabb)) {
+    //     this.setElevation(0);
+    //     this.setAzimuth(0);
+    //     this.setRoll(0);
+    //     const { halfExtents, center } = aabb;
+    //     const maxDim = Math.max(halfExtents[0] * 2, halfExtents[1] * 2);
+    //     const cc = center.map((c: number) => Math.round(c * 1000) / 1000) as [number, number, number];
+    //     if (maxDim !== 0) {
+    //       const d = (1.5 * maxDim) / Math.tan(this.fov * DEG_2_RAD);
+    //       this.setPosition([cc[0], cc[1], cc[2] + d]);
+    //     }
+    //     this.setFocalPoint(cc);
+    //   }
+    // }
+  }]);
+})(index_esm.Camera);
+index_esm.runtime.CameraContribution = AdvancedCamera;
+var _excluded = ["body", "startHead", "endHead", "startHeadOffset", "endHeadOffset"], _excluded2 = ["body", "startHead", "endHead", "startHeadOffset", "endHeadOffset"], _excluded3 = ["body", "startHead", "endHead", "startHeadOffset", "endHeadOffset"];
+var Arrow = /* @__PURE__ */ (function(_CustomElement) {
+  function Arrow2(config) {
+    var _this;
+    classCallCheck(this, Arrow2);
+    _this = callSuper(this, Arrow2, [objectSpread2(objectSpread2({}, config), {}, {
+      type: Arrow2.tag
+    })]);
+    var _this$attributes = _this.attributes, body = _this$attributes.body, startHead = _this$attributes.startHead, endHead = _this$attributes.endHead;
+    _this$attributes.startHeadOffset;
+    _this$attributes.endHeadOffset;
+    var rest = objectWithoutProperties(_this$attributes, _excluded);
+    if (!body) {
+      throw new Error("Arrow's body is required");
+    }
+    _this.body = body;
+    _this.appendChild(_this.body);
+    _this.handleBodyAttributeChanged(_this.body);
+    if (startHead) {
+      _this.appendArrowHead(_this.getArrowHeadType(startHead), true);
+    }
+    if (endHead) {
+      _this.appendArrowHead(_this.getArrowHeadType(endHead), false);
+    }
+    _this.applyArrowStyle(rest, [_this.body, _this.startHead, _this.endHead]);
+    return _this;
+  }
+  inherits(Arrow2, _CustomElement);
+  return createClass(Arrow2, [{
+    key: "handleBodyAttributeChanged",
+    value: function handleBodyAttributeChanged(body) {
+      var _this2 = this;
+      body.addEventListener(index_esm.ElementEvent.ATTR_MODIFIED, function(e2) {
+        var attrName = e2.attrName;
+        if (attrName === "x1" || attrName === "y1") {
+          if (_this2.startHead) {
+            _this2.transformArrowHead(_this2.startHead, true);
+          }
+        } else if (attrName === "x2" || attrName === "y2") {
+          if (_this2.endHead) {
+            _this2.transformArrowHead(_this2.endHead, false);
+          }
+        }
+      });
+    }
+  }, {
+    key: "getBody",
+    value: function getBody() {
+      return this.body;
+    }
+  }, {
+    key: "getStartHead",
+    value: function getStartHead() {
+      return this.startHead;
+    }
+  }, {
+    key: "getEndHead",
+    value: function getEndHead() {
+      return this.endHead;
+    }
+  }, {
+    key: "attributeChangedCallback",
+    value: function attributeChangedCallback(name, oldValue, newValue) {
+      if (name === "opacity" || name === "strokeOpacity" || name === "stroke" || name === "lineWidth" || name === "increasedLineWidthForHitTesting") {
+        this.applyArrowStyle(defineProperty({}, name, newValue), [this.body, this.startHead, this.endHead]);
+      } else if (name === "startHead" || name === "endHead") {
+        var isStart = name === "startHead";
+        this.destroyArrowHead(isStart);
+        if (newValue) {
+          var _this$attributes2 = this.attributes;
+          _this$attributes2.body;
+          _this$attributes2.startHead;
+          _this$attributes2.endHead;
+          _this$attributes2.startHeadOffset;
+          _this$attributes2.endHeadOffset;
+          var rest = objectWithoutProperties(_this$attributes2, _excluded2);
+          this.appendArrowHead(this.getArrowHeadType(newValue), isStart);
+          this.applyArrowStyle(rest, [isStart ? this.startHead : this.endHead]);
+        }
+      } else if (name === "body") {
+        var _this$attributes3 = this.attributes;
+        _this$attributes3.body;
+        _this$attributes3.startHead;
+        _this$attributes3.endHead;
+        _this$attributes3.startHeadOffset;
+        _this$attributes3.endHeadOffset;
+        var _rest = objectWithoutProperties(_this$attributes3, _excluded3);
+        this.body.destroy();
+        this.body = newValue;
+        this.appendChild(this.body);
+        this.applyArrowStyle(_rest, [this.body]);
+      } else if (name === "startHeadOffset") {
+        this.moveArrowHeadAlongTangent(newValue, true);
+      } else if (name === "endHeadOffset") {
+        this.moveArrowHeadAlongTangent(newValue, false);
+      }
+    }
+  }, {
+    key: "getArrowHeadType",
+    value: function getArrowHeadType(head) {
+      if (typeof head === "boolean") {
+        return "default";
+      }
+      return "custom";
+    }
+  }, {
+    key: "appendArrowHead",
+    value: function appendArrowHead(type, isStart) {
+      var head;
+      if (type === "default") {
+        head = this.createDefaultArrowHead();
+      } else {
+        head = isStart ? this.attributes.startHead : this.attributes.endHead;
+      }
+      this.transformArrowHead(head, isStart);
+      head.setAttribute("zIndex", 1);
+      if (isStart) {
+        this.startHead = head;
+      } else {
+        this.endHead = head;
+      }
+      this.appendChild(head);
+      var offset = isStart ? this.attributes.startHeadOffset : this.attributes.endHeadOffset;
+      if (offset) {
+        this.moveArrowHeadAlongTangent(offset, isStart);
+      }
+    }
+    /**
+     * transform arrow head according to arrow line
+     */
+  }, {
+    key: "transformArrowHead",
+    value: function transformArrowHead(head, isStart) {
+      var position = vec3.create();
+      var rad = 0;
+      var x1 = 0;
+      var x2 = 0;
+      var y1 = 0;
+      var y2 = 0;
+      var bodyType = this.body && this.body.nodeName;
+      if (bodyType === index_esm.Shape.LINE) {
+        var _attributes = this.body.attributes, _x1 = _attributes.x1, _x2 = _attributes.x2, _y1 = _attributes.y1, _y2 = _attributes.y2;
+        x1 = isStart ? _x2 : _x1;
+        x2 = isStart ? _x1 : _x2;
+        y1 = isStart ? _y2 : _y1;
+        y2 = isStart ? _y1 : _y2;
+      } else if (bodyType === index_esm.Shape.POLYLINE) {
+        var points = this.body.attributes.points;
+        var length = points.length;
+        x1 = isStart ? points[1][0] : points[length - 2][0];
+        y1 = isStart ? points[1][1] : points[length - 2][1];
+        x2 = isStart ? points[0][0] : points[length - 1][0];
+        y2 = isStart ? points[0][1] : points[length - 1][1];
+      } else if (bodyType === index_esm.Shape.PATH) {
+        var _this$getTangent = this.getTangent(this.body, isStart), _this$getTangent2 = slicedToArray(_this$getTangent, 2), p1 = _this$getTangent2[0], p2 = _this$getTangent2[1];
+        x1 = p1[0];
+        y1 = p1[1];
+        x2 = p2[0];
+        y2 = p2[1];
+      }
+      var x = x1 - x2;
+      var y = y1 - y2;
+      rad = Math.atan2(y, x);
+      position = vec3.fromValues(x2, y2, 0);
+      if (isStart) {
+        this.startHeadPosition = position;
+        this.startHeadRad = rad;
+      } else {
+        this.endHeadPosition = position;
+        this.endHeadRad = rad;
+      }
+      head.setLocalPosition(position);
+      head.setLocalEulerAngles(rad * 180 / Math.PI + head.getLocalEulerAngles());
+    }
+  }, {
+    key: "moveArrowHeadAlongTangent",
+    value: function moveArrowHeadAlongTangent(offset, isStart) {
+      var head = isStart ? this.startHead : this.endHead;
+      if (head) {
+        head.setLocalPosition(vec3.sub(vec3.create(), isStart ? this.startHeadPosition : this.endHeadPosition, vec3.fromValues(Math.cos(isStart ? this.startHeadRad : this.endHeadRad) * offset, Math.sin(isStart ? this.startHeadRad : this.endHeadRad) * offset, 0)));
+      }
+      if (this.body) ;
+    }
+  }, {
+    key: "destroyArrowHead",
+    value: function destroyArrowHead(isStart) {
+      if (isStart && this.startHead) {
+        this.startHead.destroy();
+        this.startHead = void 0;
+      }
+      if (!isStart && this.endHead) {
+        this.endHead.destroy();
+        this.endHead = void 0;
+      }
+    }
+  }, {
+    key: "getTangent",
+    value: function getTangent(path, isStart) {
+      return isStart ? path.getStartTangent() : path.getEndTangent();
+    }
+  }, {
+    key: "createDefaultArrowHead",
+    value: function createDefaultArrowHead() {
+      var _this$attributes4 = this.attributes, stroke = _this$attributes4.stroke, lineWidth = _this$attributes4.lineWidth;
+      var sin = Math.sin, cos = Math.cos, PI3 = Math.PI;
+      var width = 10 * cos(PI3 / 6);
+      return new index_esm.Path({
+        style: {
+          // draw an angle '<'
+          d: "M".concat(width / 2, ",").concat(10 * sin(PI3 / 6), " L-").concat(width / 2, ",0 L").concat(width / 2, ",-").concat(10 * sin(PI3 / 6)),
+          stroke,
+          lineWidth,
+          transformOrigin: "center"
+        }
+      });
+    }
+  }, {
+    key: "applyArrowStyle",
+    value: function applyArrowStyle(attributes, objects) {
+      var opacity = attributes.opacity, stroke = attributes.stroke, strokeOpacity = attributes.strokeOpacity, lineWidth = attributes.lineWidth, increasedLineWidthForHitTesting = attributes.increasedLineWidthForHitTesting;
+      objects.forEach(function(shape) {
+        if (shape) {
+          if (!isNil(opacity)) {
+            shape.style.opacity = opacity;
+          }
+          if (!isNil(stroke)) {
+            shape.style.stroke = stroke;
+          }
+          if (!isNil(strokeOpacity)) {
+            shape.style.strokeOpacity = strokeOpacity;
+          }
+          if (!isNil(lineWidth)) {
+            shape.style.lineWidth = lineWidth;
+          }
+          if (!isNil(increasedLineWidthForHitTesting)) {
+            shape.style.increasedLineWidthForHitTesting = increasedLineWidthForHitTesting;
+          }
+        }
+      });
+    }
+  }]);
+})(index_esm.CustomElement);
+Arrow.tag = "arrow";
+Arrow.PARSED_STYLE_LIST = new Set([].concat(toConsumableArray(index_esm.CustomElement.PARSED_STYLE_LIST), ["body", "startHead", "endHead", "startHeadOffset", "endHeadOffset", "stroke", "lineWidth", "opacity", "strokeOpacity"]));
+var PI = Math.PI;
+var PI2 = PI * 2;
+var mathSin = Math.sin;
+var mathCos = Math.cos;
+var mathACos = Math.acos;
+var mathATan2 = Math.atan2;
+var mathSqrt = Math.sqrt;
+var mathMax = Math.max;
+var mathMin = Math.min;
+var e = 1e-4;
+var SECTOR_CSS_PROPERTY = [{
+  name: "sr",
+  inherits: false,
+  interpolable: true,
+  syntax: index_esm.PropertySyntax.LENGTH_PERCENTAGE
+}, {
+  name: "sr0",
+  inherits: false,
+  interpolable: true,
+  syntax: index_esm.PropertySyntax.LENGTH_PERCENTAGE
+}, {
+  name: "startAngle",
+  inherits: false,
+  interpolable: true,
+  syntax: index_esm.PropertySyntax.ANGLE
+}, {
+  name: "endAngle",
+  inherits: false,
+  interpolable: true,
+  syntax: index_esm.PropertySyntax.ANGLE
+}];
+SECTOR_CSS_PROPERTY.forEach(function(property) {
+  index_esm.CSS.registerProperty(property);
+});
+var polarToCartesian = function polarToCartesian2(centerX, centerY, radius, angleInRadian) {
+  return {
+    x: centerX + radius * Math.cos(angleInRadian),
+    y: centerY + radius * Math.sin(angleInRadian)
+  };
+};
+function intersect(x0, y0, x1, y1, x2, y2, x3, y3) {
+  var dx10 = x1 - x0;
+  var dy10 = y1 - y0;
+  var dx32 = x3 - x2;
+  var dy32 = y3 - y2;
+  var t = dy32 * dx10 - dx32 * dy10;
+  if (t * t < e) {
+    return;
+  }
+  t = (dx32 * (y0 - y2) - dy32 * (x0 - x2)) / t;
+  return [x0 + t * dx10, y0 + t * dy10];
+}
+function computeCornerTangents(x0, y0, x1, y1, radius, cr, clockwise) {
+  var x01 = x0 - x1;
+  var y01 = y0 - y1;
+  var lo = cr / mathSqrt(x01 * x01 + y01 * y01);
+  var ox = lo * y01;
+  var oy = -lo * x01;
+  var x11 = x0 + ox;
+  var y11 = y0 + oy;
+  var x10 = x1 + ox;
+  var y10 = y1 + oy;
+  var x00 = (x11 + x10) / 2;
+  var y00 = (y11 + y10) / 2;
+  var dx = x10 - x11;
+  var dy = y10 - y11;
+  var d2 = dx * dx + dy * dy;
+  var r = radius - cr;
+  var s = x11 * y10 - x10 * y11;
+  var d = (dy < 0 ? -1 : 1) * mathSqrt(mathMax(0, r * r * d2 - s * s));
+  var cx0 = (s * dy - dx * d) / d2;
+  var cy0 = (-s * dx - dy * d) / d2;
+  var cx1 = (s * dy + dx * d) / d2;
+  var cy1 = (-s * dx + dy * d) / d2;
+  var dx0 = cx0 - x00;
+  var dy0 = cy0 - y00;
+  var dx1 = cx1 - x00;
+  var dy1 = cy1 - y00;
+  if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) {
+    cx0 = cx1;
+    cy0 = cy1;
+  }
+  return {
+    cx: cx0,
+    cy: cy0,
+    x0: -ox,
+    y0: -oy,
+    x1: cx0 * (radius / r - 1),
+    y1: cy0 * (radius / r - 1)
+  };
+}
+function computeArcSweep(startAngle, endAngle) {
+  endAngle = endAngle < 0 && startAngle >= 0 ? endAngle + PI2 : endAngle;
+  return endAngle - startAngle <= PI ? 0 : 1;
+}
+var Sector = /* @__PURE__ */ (function(_Path) {
+  function Sector2(config) {
+    var _this;
+    classCallCheck(this, Sector2);
+    _this = callSuper(this, Sector2, [config]);
+    _this.updatePath();
+    return _this;
+  }
+  inherits(Sector2, _Path);
+  return createClass(Sector2, [{
+    key: "setAttribute",
+    value: function setAttribute(name, value, force) {
+      superPropGet(Sector2, "setAttribute", this)([name, value, force]);
+      if (["startAngle", "endAngle", "sr", "sr0", "radius"].indexOf(name) > -1) {
+        this.updatePath();
+      }
+    }
+  }, {
+    key: "updatePath",
+    value: function updatePath() {
+      var _this$parsedStyle = this.parsedStyle, x = _this$parsedStyle.x, y = _this$parsedStyle.y, startAngle = _this$parsedStyle.startAngle, endAngle = _this$parsedStyle.endAngle, sr = _this$parsedStyle.sr, sr0 = _this$parsedStyle.sr0, radius = _this$parsedStyle.radius;
+      var path = this.createPath(x, y, startAngle ? index_esm.deg2rad(startAngle) : 0, endAngle ? index_esm.deg2rad(endAngle) : Math.PI * 2, sr || 0, sr0 || 0, radius || [0, 0, 0, 0]);
+      superPropGet(Sector2, "setAttribute", this)(["d", path]);
+    }
+  }, {
+    key: "createPath",
+    value: function createPath(x, y, startAngle, endAngle, r, r0, borderRadius) {
+      if (r <= 0) {
+        return;
+      }
+      var start = polarToCartesian(x, y, r, startAngle);
+      var end = polarToCartesian(x, y, r, endAngle);
+      var innerStart = polarToCartesian(x, y, r0, startAngle);
+      var innerEnd = polarToCartesian(x, y, r0, endAngle);
+      if (isNumberEqual(endAngle - startAngle, Math.PI * 2)) {
+        var middlePoint = polarToCartesian(x, y, r, startAngle + Math.PI);
+        var innerMiddlePoint = polarToCartesian(x, y, r0, startAngle + Math.PI);
+        var circlePathCommands = [["M", start.x, start.y], ["A", r, r, 0, 1, 1, middlePoint.x, middlePoint.y], ["A", r, r, 0, 1, 1, end.x, end.y], ["M", innerStart.x, innerStart.y]];
+        if (r0) {
+          circlePathCommands.push(["A", r0, r0, 0, 1, 0, innerMiddlePoint.x, innerMiddlePoint.y]);
+          circlePathCommands.push(["A", r0, r0, 0, 1, 0, innerEnd.x, innerEnd.y]);
+        }
+        circlePathCommands.push(["M", start.x, start.y]);
+        circlePathCommands.push(["Z"]);
+        return circlePathCommands;
+      }
+      var angle = endAngle - startAngle;
+      var xrs = r * mathCos(startAngle);
+      var yrs = r * mathSin(startAngle);
+      var xire = r0 * mathCos(endAngle);
+      var yire = r0 * mathSin(endAngle);
+      var xre = r * mathCos(endAngle);
+      var yre = r * mathSin(endAngle);
+      var xirs = r0 * mathCos(startAngle);
+      var yirs = r0 * mathSin(startAngle);
+      var _borderRadius = slicedToArray(borderRadius, 4), outStartRadius = _borderRadius[0], outEndRadius = _borderRadius[1], innerEndRadius = _borderRadius[2], innerStartRadius = _borderRadius[3];
+      var halfRadius = (r - r0) / 2;
+      var outStartBorderRadius = mathMin(halfRadius, outStartRadius);
+      var outEndBorderRadius = mathMin(halfRadius, outEndRadius);
+      var innerEndBorderRadius = mathMin(halfRadius, innerEndRadius);
+      var innerStartBorderRadius = mathMin(halfRadius, innerStartRadius);
+      var outBorderRadiusMax = mathMax(outStartBorderRadius, outEndBorderRadius);
+      var innerBorderRadiusMax = mathMax(innerEndBorderRadius, innerStartBorderRadius);
+      var limitedOutBorderRadiusMax = outBorderRadiusMax;
+      var limitedInnerBorderRadiusMax = innerBorderRadiusMax;
+      if (outBorderRadiusMax > e || innerBorderRadiusMax > e) {
+        if (angle < PI) {
+          var it = intersect(xrs, yrs, xirs, yirs, xre, yre, xire, yire);
+          if (it) {
+            var x0 = xrs - it[0];
+            var y0 = yrs - it[1];
+            var x1 = xre - it[0];
+            var y1 = yre - it[1];
+            var a = 1 / mathSin(mathACos((x0 * x1 + y0 * y1) / (mathSqrt(x0 * x0 + y0 * y0) * mathSqrt(x1 * x1 + y1 * y1))) / 2);
+            var b = mathSqrt(it[0] * it[0] + it[1] * it[1]);
+            limitedOutBorderRadiusMax = mathMin(outBorderRadiusMax, (r - b) / (a + 1));
+            limitedInnerBorderRadiusMax = mathMin(innerBorderRadiusMax, (r0 - b) / (a - 1));
+          }
+        }
+      }
+      var arcSweep = computeArcSweep(startAngle, endAngle);
+      var sectorPathCommands = [];
+      if (limitedOutBorderRadiusMax > e) {
+        var crStart = mathMin(outStartRadius, limitedOutBorderRadiusMax);
+        var crEnd = mathMin(outEndRadius, limitedOutBorderRadiusMax);
+        var ct0 = computeCornerTangents(xirs, yirs, xrs, yrs, r, crStart);
+        var ct1 = computeCornerTangents(xre, yre, xire, yire, r, crEnd);
+        sectorPathCommands.push(["M", x + ct0.cx + ct0.x0, y + ct0.cy + ct0.y0]);
+        if (limitedOutBorderRadiusMax < outBorderRadiusMax && crStart === crEnd) {
+          var outStartBorderRadiusStartAngle = mathATan2(ct0.y0, ct0.x0);
+          var outStartBorderRadiusEndAngle = mathATan2(ct1.y0, ct1.x0);
+          sectorPathCommands.push(["A", limitedOutBorderRadiusMax, limitedOutBorderRadiusMax, 0, computeArcSweep(outStartBorderRadiusStartAngle, outStartBorderRadiusEndAngle), 1, x + ct1.cx + ct1.x0, y + ct1.cy + ct1.y0]);
+        } else {
+          if (crStart > 0) {
+            var _outStartBorderRadiusStartAngle = mathATan2(ct0.y0, ct0.x0);
+            var _outStartBorderRadiusEndAngle = mathATan2(ct0.y1, ct0.x1);
+            var outStartBorderRadiusEndPoint = polarToCartesian(x, y, r, _outStartBorderRadiusEndAngle);
+            sectorPathCommands.push(["A", crStart, crStart, 0, computeArcSweep(_outStartBorderRadiusStartAngle, _outStartBorderRadiusEndAngle), 1, outStartBorderRadiusEndPoint.x, outStartBorderRadiusEndPoint.y]);
+          }
+          var outRadiusStartAngle = mathATan2(ct0.cy + ct0.y1, ct0.cx + ct0.x1);
+          var outRadiusEndAngle = mathATan2(ct1.cy + ct1.y1, ct1.cx + ct1.x1);
+          var outRadiusEndPoint = polarToCartesian(x, y, r, outRadiusEndAngle);
+          sectorPathCommands.push(["A", r, r, 0, computeArcSweep(outRadiusStartAngle, outRadiusEndAngle), 1, outRadiusEndPoint.x, outRadiusEndPoint.y]);
+          if (crEnd > 0) {
+            var outEndBorderRadiusStartAngle = mathATan2(ct1.y1, ct1.x1);
+            var outEndBorderRadiusEndAngle = mathATan2(ct1.y0, ct1.x0);
+            sectorPathCommands.push(["A", crEnd, crEnd, 0, computeArcSweep(outEndBorderRadiusStartAngle, outEndBorderRadiusEndAngle), 1, x + ct1.cx + ct1.x0, y + ct1.cy + ct1.y0]);
+          }
+        }
+      } else {
+        sectorPathCommands.push(["M", start.x, start.y]);
+        sectorPathCommands.push(["A", r, r, 0, arcSweep, 1, end.x, end.y]);
+      }
+      if (r0 < e) {
+        sectorPathCommands.push(["L", innerEnd.x, innerEnd.y]);
+      } else if (limitedInnerBorderRadiusMax > e) {
+        var _crStart = mathMin(innerStartRadius, limitedInnerBorderRadiusMax);
+        var _crEnd = mathMin(innerEndRadius, limitedInnerBorderRadiusMax);
+        var _ct = computeCornerTangents(xire, yire, 0, 0, r0 - r, _crEnd);
+        var _ct2 = computeCornerTangents(0, 0, xirs, yirs, r0 - r, _crStart);
+        sectorPathCommands.push(["L", x + _ct.cx + _ct.x0, y + _ct.cy + _ct.y0]);
+        if (limitedInnerBorderRadiusMax < innerBorderRadiusMax && _crStart === _crEnd) {
+          var innerStartBorderRadiusStartAngle = mathATan2(_ct.y0, _ct.x0);
+          var innerStartBorderRadiusEndAngle = mathATan2(_ct2.y0, _ct2.x0);
+          var innerStartBorderRadiusEndPoint = polarToCartesian(x, y, r0, innerStartBorderRadiusEndAngle);
+          sectorPathCommands.push(["A", limitedOutBorderRadiusMax, limitedOutBorderRadiusMax, 0, computeArcSweep(innerStartBorderRadiusStartAngle, innerStartBorderRadiusEndAngle), 1, innerStartBorderRadiusEndPoint.x, innerStartBorderRadiusEndPoint.y]);
+        } else {
+          if (_crEnd > 0) {
+            var _innerStartBorderRadiusStartAngle = mathATan2(_ct.y0, _ct.x0);
+            var _innerStartBorderRadiusEndAngle = mathATan2(_ct.y1, _ct.x1);
+            var _innerStartBorderRadiusEndPoint = polarToCartesian(x, y, r0 - r, _innerStartBorderRadiusEndAngle);
+            sectorPathCommands.push(["A", _crEnd, _crEnd, 0, computeArcSweep(_innerStartBorderRadiusStartAngle, _innerStartBorderRadiusEndAngle), 1, _innerStartBorderRadiusEndPoint.x, _innerStartBorderRadiusEndPoint.y]);
+          }
+          var innerRadiusStartAngle = mathATan2(_ct.cy + _ct.y1, _ct.cx + _ct.x1);
+          var innerRadiusEndAngle = mathATan2(_ct2.cy + _ct2.y1, _ct2.cx + _ct2.x1);
+          var innerRadiusEndPoint = polarToCartesian(x, y, r0, innerRadiusEndAngle);
+          sectorPathCommands.push(["A", r0, r0, 0, computeArcSweep(innerRadiusEndAngle, innerRadiusStartAngle), 0, innerRadiusEndPoint.x, innerRadiusEndPoint.y]);
+          sectorPathCommands.push(["L", innerRadiusEndPoint.x, innerRadiusEndPoint.y]);
+          if (_crStart > 0) {
+            var innerEndBorderRadiusStartAngle = mathATan2(_ct2.y1, _ct2.x1);
+            var innerEndBorderRadiusEndAngle = mathATan2(_ct2.y0, _ct2.x0);
+            sectorPathCommands.push(["A", _crStart, _crStart, 0, computeArcSweep(innerEndBorderRadiusStartAngle, innerEndBorderRadiusEndAngle), 1, x + _ct2.cx + _ct2.x0, y + _ct2.cy + _ct2.y0]);
+          }
+        }
+      } else {
+        sectorPathCommands.push(["L", innerEnd.x, innerEnd.y]);
+        sectorPathCommands.push(["A", r0, r0, 0, arcSweep, 0, innerStart.x, innerStart.y]);
+      }
+      sectorPathCommands.push(["Z"]);
+      return sectorPathCommands;
+    }
+  }]);
+})(index_esm.Path);
+Sector.PARSED_STYLE_LIST = new Set([].concat(toConsumableArray(index_esm.Path.PARSED_STYLE_LIST), ["x", "y", "sr", "sr0", "radius", "startAngle", "endAngle"]));
+exports.AABB = index_esm.AABB;
+exports.AbstractRenderer = index_esm.AbstractRenderer;
+exports.AbstractRendererPlugin = index_esm.AbstractRendererPlugin;
+exports.BUILT_IN_PROPERTIES = index_esm.BUILT_IN_PROPERTIES;
+exports.CSS = index_esm.CSS;
+exports.CSSGradientValue = index_esm.CSSGradientValue;
+exports.CSSKeywordValue = index_esm.CSSKeywordValue;
+exports.CSSRGB = index_esm.CSSRGB;
+exports.CSSStyleValue = index_esm.CSSStyleValue;
+exports.CSSUnitValue = index_esm.CSSUnitValue;
+exports.Camera = index_esm.Camera;
+exports.CameraEvent = index_esm.CameraEvent;
+exports.CameraProjectionMode = index_esm.CameraProjectionMode;
+exports.CameraTrackingMode = index_esm.CameraTrackingMode;
+exports.CameraType = index_esm.CameraType;
+exports.Canvas = index_esm.Canvas;
+exports.CanvasEvent = index_esm.CanvasEvent;
+exports.Circle = index_esm.Circle;
+exports.CircleUpdater = index_esm.CircleUpdater;
+exports.ClipSpaceNearZ = index_esm.ClipSpaceNearZ;
+exports.CustomElement = index_esm.CustomElement;
+exports.CustomElementRegistry = index_esm.CustomElementRegistry;
+exports.CustomEvent = index_esm.CustomEvent;
+exports.DefaultSceneGraphSelector = index_esm.DefaultSceneGraphSelector;
+exports.DefaultSceneGraphService = index_esm.DefaultSceneGraphService;
+exports.DisplayObject = index_esm.DisplayObject;
+exports.Document = index_esm.Document;
+exports.DomInteraction = index_esm.DomInteraction;
+exports.ERROR_MSG_METHOD_NOT_IMPLEMENTED = index_esm.ERROR_MSG_METHOD_NOT_IMPLEMENTED;
+exports.Element = index_esm.Element;
+exports.ElementEvent = index_esm.ElementEvent;
+exports.Ellipse = index_esm.Ellipse;
+exports.EllipseUpdater = index_esm.EllipseUpdater;
+exports.EventService = index_esm.EventService;
+exports.EventTarget = index_esm.EventTarget;
+exports.FederatedEvent = index_esm.FederatedEvent;
+exports.FederatedMouseEvent = index_esm.FederatedMouseEvent;
+exports.FederatedPointerEvent = index_esm.FederatedPointerEvent;
+exports.FederatedWheelEvent = index_esm.FederatedWheelEvent;
+exports.Fragment = index_esm.Fragment;
+exports.Frustum = index_esm.Frustum;
+exports.GradientType = index_esm.GradientType;
+exports.Group = index_esm.Group;
+exports.GroupUpdater = index_esm.GroupUpdater;
+exports.HTML = index_esm.HTML;
+exports.HTMLRenderer = index_esm.HTMLRenderer;
+exports.HTMLUpdater = index_esm.HTMLUpdater;
+exports.Image = index_esm.Image;
+exports.ImageLoader = index_esm.ImageLoader;
+exports.ImagePool = index_esm.ImagePool;
+exports.Line = index_esm.Line;
+exports.LineUpdater = index_esm.LineUpdater;
+exports.Mask = index_esm.Mask;
+exports.MutationEvent = index_esm.MutationEvent;
+exports.Node = index_esm.Node;
+exports.OffscreenCanvasCreator = index_esm.OffscreenCanvasCreator;
+exports.Path = index_esm.Path;
+exports.PathUpdater = index_esm.PathUpdater;
+exports.Plane = index_esm.Plane;
+exports.Point = index_esm.Point;
+exports.Polygon = index_esm.Polygon;
+exports.Polyline = index_esm.Polyline;
+exports.PolylineUpdater = index_esm.PolylineUpdater;
+exports.PropertySyntax = index_esm.PropertySyntax;
+exports.Rect = index_esm.Rect;
+exports.RectUpdater = index_esm.RectUpdater;
+exports.Rectangle = index_esm.Rectangle;
+exports.RenderReason = index_esm.RenderReason;
+exports.RenderingService = index_esm.RenderingService;
+exports.Shape = index_esm.Shape;
+exports.SortReason = index_esm.SortReason;
+exports.Strategy = index_esm.Strategy;
+exports.Text = index_esm.Text;
+exports.TextService = index_esm.TextService;
+exports.TextUpdater = index_esm.TextUpdater;
+exports.UnitType = index_esm.UnitType;
+exports.attrModifiedEvent = index_esm.attrModifiedEvent;
+exports.computeLinearGradient = index_esm.computeLinearGradient;
+exports.computeRadialGradient = index_esm.computeRadialGradient;
+exports.createVec3 = index_esm.createVec3;
+exports.decompose = index_esm.decompose;
+exports.deg2rad = index_esm.deg2rad;
+exports.destroyEvent = index_esm.destroyEvent;
+exports.findClosestClipPathTarget = index_esm.findClosestClipPathTarget;
+exports.fromRotationTranslationScale = index_esm.fromRotationTranslationScale;
+exports.getAngle = index_esm.getAngle;
+exports.getEuler = index_esm.getEuler;
+exports.getOrCalculatePathTotalLength = index_esm.getOrCalculatePathTotalLength;
+exports.insertedEvent = index_esm.insertedEvent;
+exports.isBrowser = index_esm.isBrowser;
+exports.isCSSRGB = index_esm.isCSSRGB;
+exports.isDisplayObject = index_esm.isDisplayObject;
+exports.isFillOrStrokeAffected = index_esm.isFillOrStrokeAffected;
+exports.isPattern = index_esm.isPattern;
+exports.mergeColors = index_esm.mergeColors;
+exports.parseColor = index_esm.parseColor;
+exports.parseLength = index_esm.parseLength;
+exports.parsePath = index_esm.parsePath;
+exports.parseTransform = index_esm.parseTransform;
+exports.parsedTransformToMat4 = index_esm.parsedTransformToMat4;
+exports.propertyMetadataCache = index_esm.propertyMetadataCache;
+exports.rad2deg = index_esm.rad2deg;
+exports.removedEvent = index_esm.removedEvent;
+exports.runtime = index_esm.runtime;
+exports.setDOMSize = index_esm.setDOMSize;
+exports.turn2deg = index_esm.turn2deg;
+exports.updateLocalTransform = index_esm.updateLocalTransform;
+exports.updateWorldTransform = index_esm.updateWorldTransform;
+exports.AdvancedCamera = AdvancedCamera;
+exports.Animation = Animation;
+exports.AnimationEvent = AnimationEvent;
+exports.AnimationTimeline = AnimationTimeline;
+exports.Arrow = Arrow;
+exports.EasingFunctions = EasingFunctions;
+exports.KeyframeEffect = KeyframeEffect;
+exports.Sector = Sector;
+exports.compareAnimations = compareAnimations;
+exports.makeTiming = makeTiming;
+exports.normalizeKeyframes = normalizeKeyframes;
+exports.normalizeTimingInput = normalizeTimingInput;
+exports.numericTimingToObject = numericTimingToObject;
+//# sourceMappingURL=index.esm.cjs.map