@visactor/vstory 0.0.1-alpha.0

package/es/animate/animate.d.ts

@@ -0,0 +1,13 @@
+import type { IAnimate as IVRenderAnimate, IGraphic } from '@visactor/vrender';
+import type { IContext } from '../interface/type';
+import type { ITask, TaskCb } from '../task';
+import { AbstractTask } from '../task';
+export declare class GraphicAnimate extends AbstractTask {
+    protected _animate: IVRenderAnimate;
+    prev: ITask;
+    next: ITask;
+    protected _target: IGraphic;
+    constructor(target: IGraphic);
+    runCb(cb: TaskCb): void;
+    run(context: Partial<IContext>): void;
+}

package/es/animate/animate.js

@@ -0,0 +1,12 @@
+import { AbstractTask } from "../task";
+
+export class GraphicAnimate extends AbstractTask {
+    constructor(target) {
+        super(), this._target = target, this._target && (this._animate = this._target.animate().afterAll(Array.from(this._target.animates.values())));
+    }
+    runCb(cb) {
+        this._animate && this._animate.runCb(cb);
+    }
+    run(context) {}
+}
+//# sourceMappingURL=animate.js.map

package/es/animate/animate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/animate/animate.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,MAAM,OAAO,cAAe,SAAQ,YAAY;IAQ9C,YAAY,MAAgB;QAC1B,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;SAC7F;IACH,CAAC;IAED,KAAK,CAAC,EAAU;QACd,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;SACzB;IACH,CAAC;IAGD,GAAG,CAAC,OAA0B;QAC5B,OAAO;IACT,CAAC;CACF","file":"animate.js","sourcesContent":["import type { IAnimate as IVRenderAnimate, IGraphic } from '@visactor/vrender';\nimport type { IContext } from '../interface/type';\nimport type { ITask, TaskCb } from '../task';\nimport { AbstractTask } from '../task';\n\nexport class GraphicAnimate extends AbstractTask {\n  protected _animate: IVRenderAnimate;\n\n  prev: ITask;\n  next: ITask;\n\n  protected _target: IGraphic;\n\n  constructor(target: IGraphic) {\n    super();\n    this._target = target;\n    if (this._target) {\n      this._animate = this._target.animate().afterAll(Array.from(this._target.animates.values()));\n    }\n  }\n\n  runCb(cb: TaskCb) {\n    if (this._animate) {\n      this._animate.runCb(cb);\n    }\n  }\n\n  // 覆写这个方法\n  run(context: Partial<IContext>) {\n    return;\n  }\n}\n"]}

package/es/animate/bounce.d.ts

@@ -0,0 +1,15 @@
+import { ACustomAnimate } from '@visactor/vrender';
+import type { EasingType } from '@visactor/vrender';
+export declare class Bounce extends ACustomAnimate<any> {
+    valid: boolean;
+    private dy;
+    private customEase;
+    constructor(from: any, to: any, duration: number, easing: EasingType, params: {
+        dy: number;
+        customEase?: any;
+    });
+    getEndProps(): Record<string, any>;
+    getFromProps(): void | Record<string, any>;
+    onBind(): void;
+    onUpdate(end: boolean, ratio: number, out: Record<string, any>): void;
+}

package/es/animate/bounce.js

@@ -0,0 +1,23 @@
+import { ACustomAnimate } from "@visactor/vrender";
+
+export class Bounce extends ACustomAnimate {
+    constructor(from, to, duration, easing, params) {
+        super(from, to, duration, easing, params);
+        const {dy: dy = 20, customEase: customEase} = params || {};
+        this.dy = dy, customEase && (this.customEase = customEase);
+    }
+    getEndProps() {
+        return this.to;
+    }
+    getFromProps() {
+        return this.from;
+    }
+    onBind() {
+        this.target && this.target.setAttributes(this.from);
+    }
+    onUpdate(end, ratio, out) {
+        const r = this.customEase ? this.customEase(ratio) : ratio;
+        out.dy = -this.dy * r;
+    }
+}
+//# sourceMappingURL=bounce.js.map

package/es/animate/bounce.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/animate/bounce.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGnD,MAAM,OAAO,MAAO,SAAQ,cAAmB;IAM7C,YAAY,IAAS,EAAE,EAAO,EAAE,QAAgB,EAAE,MAAkB,EAAE,MAAwC;QAC5G,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAC1C,MAAM,EAAE,EAAE,GAAG,EAAE,EAAE,UAAU,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;QAC7C,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,UAAU,EAAE;YACd,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;SAC9B;IACH,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAC,EAAE,CAAC;IACjB,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED,MAAM;QACJ,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACtD,CAAC;IAED,QAAQ,CAAC,GAAY,EAAE,KAAa,EAAE,GAAwB;QAC5D,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAC3D,GAAG,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;IACxB,CAAC;CACF","file":"bounce.js","sourcesContent":["import { ACustomAnimate } from '@visactor/vrender';\nimport type { EasingType } from '@visactor/vrender';\n\nexport class Bounce extends ACustomAnimate<any> {\n  declare valid: boolean;\n\n  private dy: number;\n  private customEase: any;\n\n  constructor(from: any, to: any, duration: number, easing: EasingType, params: { dy: number; customEase?: any }) {\n    super(from, to, duration, easing, params);\n    const { dy = 20, customEase } = params || {};\n    this.dy = dy;\n    if (customEase) {\n      this.customEase = customEase;\n    }\n  }\n\n  getEndProps(): Record<string, any> {\n    return this.to;\n  }\n\n  getFromProps(): void | Record<string, any> {\n    return this.from;\n  }\n\n  onBind(): void {\n    this.target && this.target.setAttributes(this.from);\n  }\n\n  onUpdate(end: boolean, ratio: number, out: Record<string, any>): void {\n    const r = this.customEase ? this.customEase(ratio) : ratio;\n    out.dy = -this.dy * r;\n  }\n}\n"]}

package/es/animate/highlight.d.ts

@@ -0,0 +1,5 @@
+import type { Dict } from '@visactor/vutils';
+import type { Template } from '../template/base-template';
+import type { Data, MaybeArray } from '../type/common';
+import { Action } from '../scene/action';
+export declare function highlight(template: Template, data: MaybeArray<Data>, style: Dict<any>): Action;

package/es/animate/highlight.js

@@ -0,0 +1,41 @@
+import { isArray } from "@visactor/vutils";
+
+import { getAllSeriesMarksWithoutRoot } from "../util/vchart-api";
+
+import { GraphicAnimate } from "./animate";
+
+import { Action } from "../scene/action";
+
+export function highlight(template, data, style) {
+    if (!data || !template) return null;
+    const highlight = new HighLight(template, data, style);
+    return new Action(highlight, (highlight => {
+        highlight.run();
+    }));
+}
+
+class HighLight extends GraphicAnimate {
+    constructor(target, data, style, duration) {
+        super(null), this.type = "highlight", this._duration = duration, this._dataList = isArray(data) ? data : [ data ], 
+        this._template = target, this._style = style;
+    }
+    run() {
+        if (this._dataList.length) {
+            const {_dataList: _dataList, _style: _style} = this, vchart = this._template.vchartInstance();
+            if (vchart) {
+                const marks = getAllSeriesMarksWithoutRoot(vchart);
+                marks && marks.length && (marks.forEach((mark => {
+                    mark.getProduct().encodeState("highlight", _style);
+                })), vchart.updateState({
+                    highlight: {
+                        filter: {
+                            datums: _dataList,
+                            dataKeys: void 0
+                        }
+                    }
+                }));
+            }
+        }
+    }
+}
+//# sourceMappingURL=highlight.js.map

package/es/animate/highlight.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/animate/highlight.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAG3C,OAAO,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,MAAM,UAAU,SAAS,CAAC,QAAkB,EAAE,IAAsB,EAAE,KAAgB;IACpF,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE;QACtB,OAAO,IAAI,CAAC;KACb;IACD,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IACvD,OAAO,IAAI,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE;QACvC,SAAS,CAAC,GAAG,EAAE,CAAC;IAClB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,SAAU,SAAQ,cAAc;IAQpC,YAAY,MAAgB,EAAE,IAAsB,EAAE,KAAU,EAAE,QAAiB;QACjF,KAAK,CAAC,IAAI,CAAC,CAAC;QARd,SAAI,GAAG,WAAW,CAAC;QASjB,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC/C,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC;QACxB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED,GAAG;QACD,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;YACzB,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;YACnC,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC;YAC/C,IAAI,MAAM,EAAE;gBACV,MAAM,KAAK,GAAG,4BAA4B,CAAC,MAAM,CAAC,CAAC;gBACnD,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE;oBACzB,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;wBACnB,IAAI,CAAC,UAAU,EAAE,CAAC,WAAW,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;oBACrD,CAAC,CAAC,CAAC;oBACH,MAAM,CAAC,WAAW,CAAC;wBACjB,SAAS,EAAE;4BACT,MAAM,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAS;yBAC1D;qBACF,CAAC,CAAC;iBACJ;aACF;SACF;IACH,CAAC;CACF","file":"highlight.js","sourcesContent":["import type { Dict } from '@visactor/vutils';\nimport { isArray } from '@visactor/vutils';\nimport type { Template } from '../template/base-template';\nimport type { Data, MaybeArray } from '../type/common';\nimport { getAllSeriesMarksWithoutRoot } from '../util/vchart-api';\nimport { GraphicAnimate } from './animate';\nimport { Action } from '../scene/action';\n\nexport function highlight(template: Template, data: MaybeArray<Data>, style: Dict<any>) {\n  if (!data || !template) {\n    return null;\n  }\n  const highlight = new HighLight(template, data, style);\n  return new Action(highlight, highlight => {\n    highlight.run();\n  });\n}\n\nclass HighLight extends GraphicAnimate {\n  type = 'highlight';\n\n  protected _duration: number;\n  protected _dataList: Data[];\n  protected _template: Template;\n  protected _style: any;\n\n  constructor(target: Template, data: MaybeArray<Data>, style: any, duration?: number) {\n    super(null);\n    this._duration = duration;\n    this._dataList = isArray(data) ? data : [data];\n    this._template = target;\n    this._style = style;\n  }\n\n  run() {\n    if (this._dataList.length) {\n      const { _dataList, _style } = this;\n      const vchart = this._template.vchartInstance();\n      if (vchart) {\n        const marks = getAllSeriesMarksWithoutRoot(vchart);\n        if (marks && marks.length) {\n          marks.forEach(mark => {\n            mark.getProduct().encodeState('highlight', _style);\n          });\n          vchart.updateState({\n            highlight: {\n              filter: { datums: _dataList, dataKeys: undefined } as any\n            }\n          });\n        }\n      }\n    }\n  }\n}\n"]}

package/es/animate/typewirter.d.ts

@@ -0,0 +1,14 @@
+import { ACustomAnimate } from '@visactor/vrender';
+import type { IGraphic } from '@visactor/vrender';
+export declare class TypeWriter extends ACustomAnimate<{
+    text: string;
+}> {
+    valid: boolean;
+    target: IGraphic;
+    private fromText;
+    private toText;
+    getEndProps(): Record<string, any>;
+    onBind(): void;
+    onEnd(): void;
+    onUpdate(end: boolean, ratio: number, out: Record<string, any>): void;
+}

package/es/animate/typewirter.js

@@ -0,0 +1,50 @@
+import { ACustomAnimate, createLine, getTextBounds, registerShadowRootGraphic } from "@visactor/vrender";
+
+import { isArray } from "@visactor/vutils";
+
+registerShadowRootGraphic();
+
+export class TypeWriter extends ACustomAnimate {
+    constructor() {
+        super(...arguments), this.fromText = "", this.toText = "";
+    }
+    getEndProps() {
+        return !1 === this.valid ? {} : {
+            text: this.to
+        };
+    }
+    onBind() {
+        var _a, _b, _c, _d;
+        if (this.fromText = null !== (_b = null === (_a = this.from) || void 0 === _a ? void 0 : _a.text) && void 0 !== _b ? _b : "", 
+        this.toText = null !== (_d = null === (_c = this.to) || void 0 === _c ? void 0 : _c.text) && void 0 !== _d ? _d : "", 
+        !this.toText || isArray(this.toText)) this.valid = !1; else {
+            this.toText = this.toText.toString();
+            const root = this.target.attachShadow(), fontSize = this.target.getComputedAttribute("fontSize"), line = createLine({
+                x: 0,
+                y: 0,
+                dy: -fontSize / 2,
+                points: [ {
+                    x: 0,
+                    y: 0
+                }, {
+                    x: 0,
+                    y: fontSize
+                } ],
+                stroke: "black"
+            });
+            root.add(line);
+        }
+    }
+    onEnd() {
+        this.target.detachShadow();
+    }
+    onUpdate(end, ratio, out) {
+        var _a;
+        if (!1 === this.valid) return;
+        const fromCount = this.fromText.length, toCount = this.toText.length, count = Math.ceil(fromCount + (toCount - fromCount) * ratio);
+        out.text = this.toText.substr(0, count);
+        const line = null === (_a = this.target.shadowRoot) || void 0 === _a ? void 0 : _a.at(0), endX = getTextBounds(Object.assign(Object.assign({}, this.target.attribute), out)).width() / 2 + 2;
+        line.setAttribute("x", endX);
+    }
+}
+//# sourceMappingURL=typewirter.js.map

package/es/animate/typewirter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/animate/typewirter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,aAAa,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAEzG,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,yBAAyB,EAAE,CAAC;AAC5B,MAAM,OAAO,UAAW,SAAQ,cAAgC;IAAhE;;QAIU,aAAQ,GAAG,EAAE,CAAC;QACd,WAAM,GAAG,EAAE,CAAC;IAyDtB,CAAC;IAvDC,WAAW;QACT,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,EAAE;YACxB,OAAO,EAAE,CAAC;SACX;QACD,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,EAAE;SACd,CAAC;IACJ,CAAC;IAED,MAAM;;QACJ,IAAI,CAAC,QAAQ,GAAG,MAAA,MAAA,IAAI,CAAC,IAAI,0CAAE,IAAI,mCAAI,EAAE,CAAC;QACtC,IAAI,CAAC,MAAM,GAAG,MAAA,MAAA,IAAI,CAAC,EAAE,0CAAE,IAAI,mCAAI,EAAE,CAAC;QAClC,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YACxC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;SACpB;aAAM;YACL,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACrC,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;YACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC;YAC9D,MAAM,IAAI,GAAG,UAAU,CAAC;gBACtB,CAAC,EAAE,CAAC;gBACJ,CAAC,EAAE,CAAC;gBACJ,EAAE,EAAE,CAAC,QAAQ,GAAG,CAAC;gBACjB,MAAM,EAAE;oBACN,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;oBACd,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE;iBACtB;gBACD,MAAM,EAAE,OAAO;aAChB,CAAC,CAAC;YACH,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;SAChB;IACH,CAAC;IAED,KAAK;QACH,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;QAC3B,OAAO;IACT,CAAC;IAED,QAAQ,CAAC,GAAY,EAAE,KAAa,EAAE,GAAwB;;QAC5D,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,EAAE;YACxB,OAAO;SACR;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QACvC,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,OAAO,GAAG,SAAS,CAAC,GAAG,KAAK,CAAC,CAAC;QAEnE,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAGxC,MAAM,IAAI,GAAG,MAAA,IAAI,CAAC,MAAM,CAAC,UAAU,0CAAE,EAAE,CAAC,CAAC,CAAa,CAAC;QAEvD,MAAM,IAAI,GAAG,aAAa,iCAAM,IAAI,CAAC,MAAM,CAAC,SAAS,GAAK,GAAG,EAAG,CAAC,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;QAEjF,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAC/B,CAAC;CACF","file":"typewirter.js","sourcesContent":["import { ACustomAnimate, createLine, getTextBounds, registerShadowRootGraphic } from '@visactor/vrender';\nimport type { IGraphic } from '@visactor/vrender';\nimport { isArray } from '@visactor/vutils';\nregisterShadowRootGraphic();\nexport class TypeWriter extends ACustomAnimate<{ text: string }> {\n  declare valid: boolean;\n  declare target: IGraphic;\n\n  private fromText = '';\n  private toText = '';\n\n  getEndProps(): Record<string, any> {\n    if (this.valid === false) {\n      return {};\n    }\n    return {\n      text: this.to\n    };\n  }\n\n  onBind(): void {\n    this.fromText = this.from?.text ?? '';\n    this.toText = this.to?.text ?? '';\n    if (!this.toText || isArray(this.toText)) {\n      this.valid = false;\n    } else {\n      this.toText = this.toText.toString();\n      const root = this.target.attachShadow();\n      const fontSize = this.target.getComputedAttribute('fontSize');\n      const line = createLine({\n        x: 0,\n        y: 0,\n        dy: -fontSize / 2,\n        points: [\n          { x: 0, y: 0 },\n          { x: 0, y: fontSize }\n        ],\n        stroke: 'black'\n      });\n      root.add(line);\n    }\n  }\n\n  onEnd(): void {\n    this.target.detachShadow();\n    return;\n  }\n\n  onUpdate(end: boolean, ratio: number, out: Record<string, any>): void {\n    if (this.valid === false) {\n      return;\n    }\n    // update text\n    const fromCount = this.fromText.length;\n    const toCount = this.toText.length;\n    const count = Math.ceil(fromCount + (toCount - fromCount) * ratio);\n\n    out.text = this.toText.substr(0, count);\n\n    // update line position\n    const line = this.target.shadowRoot?.at(0) as IGraphic;\n\n    const endX = getTextBounds({ ...this.target.attribute, ...out }).width() / 2 + 2;\n\n    line.setAttribute('x', endX);\n  }\n}\n"]}

package/es/animate/util/paths.d.ts

@@ -0,0 +1,31 @@
+/*!
+ * paths 3.12.5
+ * https://gsap.com
+ *
+ * Copyright 2008-2024, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license or for
+ * Club GSAP members, the agreement issued with that membership.
+ * @author: Jack Doyle, jack@greensock.com
+ */
+export declare function getRawPath(value: any): any;
+export declare function copyRawPath(rawPath: any): any;
+export declare function reverseSegment(segment: any): void;
+export declare function convertToPath(element: any, swap: any): any;
+export declare function getRotationAtProgress(rawPath: any, progress: any): number;
+export declare function sliceRawPath(rawPath: any, start: any, end: any): any;
+export declare function cacheRawPathMeasurements(rawPath: any, resolution: any): any;
+export declare function subdivideSegment(segment: any, i: any, t: any): 0 | 6;
+export declare function getPositionOnPath(rawPath: any, progress: any, includeAngle: any, point: any): any;
+export declare function transformRawPath(rawPath: any, a: any, b: any, c: any, d: any, tx: any, ty: any): any;
+export declare function stringToRawPath(d: any): any[];
+export declare function bezierToPoints(x1: any, y1: any, x2: any, y2: any, x3: any, y3: any, x4: any, y4: any, threshold: any, points: any, index: any): any;
+export declare function flatPointsToSegment(points: any, curviness?: number): any[];
+export declare function pointsToSegment(points: any, curviness: any): number[];
+export declare function simplifyPoints(points: any, tolerance: any): number[];
+export declare function getClosestData(rawPath: any, x: any, y: any, slices: any): {
+    j: number;
+    i: number;
+    t: number;
+};
+export declare function subdivideSegmentNear(x: any, y: any, segment: any, slices: any, iterations: any): number;
+export declare function rawPathToString(rawPath: any): string;

package/es/animate/util/paths.js

@@ -0,0 +1,352 @@
+/*!
+ * paths 3.12.5
+ * https://gsap.com
+ *
+ * Copyright 2008-2024, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license or for
+ * Club GSAP members, the agreement issued with that membership.
+ * @author: Jack Doyle, jack@greensock.com
+ */
+let _bestDistance, _svgPathExp = /[achlmqstvz]|(-?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/gi, _numbersExp = /(?:(-)?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/gi, _scientific = /[\+\-]?\d*\.?\d+e[\+\-]?\d+/gi, _selectorExp = /(^[#\.][a-z]|[a-y][a-z])/i, _DEG2RAD = Math.PI / 180, _RAD2DEG = 180 / Math.PI, _sin = Math.sin, _cos = Math.cos, _abs = Math.abs, _sqrt = Math.sqrt, _atan2 = Math.atan2, _largeNum = 1e8, _isString = value => "string" == typeof value, _isNumber = value => "number" == typeof value, _isUndefined = value => void 0 === value, _temp = {}, _temp2 = {}, _roundingNum = 1e5, _wrapProgress = progress => Math.round((progress + _largeNum) % 1 * _roundingNum) / _roundingNum || (progress < 0 ? 0 : 1), _round = value => Math.round(value * _roundingNum) / _roundingNum || 0, _roundPrecise = value => Math.round(1e10 * value) / 1e10 || 0, _splitSegment = (rawPath, segIndex, i, t) => {
+    let segment = rawPath[segIndex], shift = 1 === t ? 6 : subdivideSegment(segment, i, t);
+    if ((shift || !t) && shift + i + 2 < segment.length) return rawPath.splice(segIndex, 0, segment.slice(0, i + shift + 2)), 
+    segment.splice(0, i + shift), 1;
+}, _getSampleIndex = (samples, length, progress) => {
+    let l = samples.length, i = ~~(progress * l);
+    if (samples[i] > length) {
+        for (;--i && samples[i] > length; ) ;
+        i < 0 && (i = 0);
+    } else for (;samples[++i] < length && i < l; ) ;
+    return i < l ? i : l - 1;
+}, _reverseRawPath = (rawPath, skipOuter) => {
+    let i = rawPath.length;
+    for (skipOuter || rawPath.reverse(); i--; ) rawPath[i].reversed || reverseSegment(rawPath[i]);
+}, _copyMetaData = (source, copy) => (copy.totalLength = source.totalLength, source.samples ? (copy.samples = source.samples.slice(0), 
+copy.lookup = source.lookup.slice(0), copy.minLength = source.minLength, copy.resolution = source.resolution) : source.totalPoints && (copy.totalPoints = source.totalPoints), 
+copy), _appendOrMerge = (rawPath, segment) => {
+    let index = rawPath.length, prevSeg = rawPath[index - 1] || [], l = prevSeg.length;
+    index && segment[0] === prevSeg[l - 2] && segment[1] === prevSeg[l - 1] && (segment = prevSeg.concat(segment.slice(2)), 
+    index--), rawPath[index] = segment;
+};
+
+export function getRawPath(value) {
+    let rawPath, e = (value = _isString(value) && _selectorExp.test(value) && document.querySelector(value) || value).getAttribute ? value : 0;
+    return e && (value = value.getAttribute("d")) ? (e._gsPath || (e._gsPath = {}), 
+    rawPath = e._gsPath[value], rawPath && !rawPath._dirty ? rawPath : e._gsPath[value] = stringToRawPath(value)) : value ? _isString(value) ? stringToRawPath(value) : _isNumber(value[0]) ? [ value ] : value : console.warn("Expecting a <path> element or an SVG path data string");
+}
+
+export function copyRawPath(rawPath) {
+    let a = [], i = 0;
+    for (;i < rawPath.length; i++) a[i] = _copyMetaData(rawPath[i], rawPath[i].slice(0));
+    return _copyMetaData(rawPath, a);
+}
+
+export function reverseSegment(segment) {
+    let y, i = 0;
+    for (segment.reverse(); i < segment.length; i += 2) y = segment[i], segment[i] = segment[i + 1], 
+    segment[i + 1] = y;
+    segment.reversed = !segment.reversed;
+}
+
+let _createPath = (e, ignore) => {
+    let name, path = document.createElementNS("http://www.w3.org/2000/svg", "path"), attr = [].slice.call(e.attributes), i = attr.length;
+    for (ignore = "," + ignore + ","; --i > -1; ) name = attr[i].nodeName.toLowerCase(), 
+    ignore.indexOf("," + name + ",") < 0 && path.setAttributeNS(null, name, attr[i].nodeValue);
+    return path;
+}, _typeAttrs = {
+    rect: "rx,ry,x,y,width,height",
+    circle: "r,cx,cy",
+    ellipse: "rx,ry,cx,cy",
+    line: "x1,x2,y1,y2"
+}, _attrToObj = (e, attrs) => {
+    let props = attrs ? attrs.split(",") : [], obj = {}, i = props.length;
+    for (;--i > -1; ) obj[props[i]] = +e.getAttribute(props[i]) || 0;
+    return obj;
+};
+
+export function convertToPath(element, swap) {
+    let data, x, y, r, ry, path, rcirc, rycirc, points, w, h, x2, x3, x4, x5, x6, y2, y3, y4, y5, y6, attr, type = element.tagName.toLowerCase(), circ = .552284749831;
+    return "path" !== type && element.getBBox ? (path = _createPath(element, "x,y,width,height,cx,cy,rx,ry,r,x1,x2,y1,y2,points"), 
+    attr = _attrToObj(element, _typeAttrs[type]), "rect" === type ? (r = attr.rx, ry = attr.ry || r, 
+    x = attr.x, y = attr.y, w = attr.width - 2 * r, h = attr.height - 2 * ry, r || ry ? (x2 = x + r * (1 - circ), 
+    x3 = x + r, x4 = x3 + w, x5 = x4 + r * circ, x6 = x4 + r, y2 = y + ry * (1 - circ), 
+    y3 = y + ry, y4 = y3 + h, y5 = y4 + ry * circ, y6 = y4 + ry, data = "M" + x6 + "," + y3 + " V" + y4 + " C" + [ x6, y5, x5, y6, x4, y6, x4 - (x4 - x3) / 3, y6, x3 + (x4 - x3) / 3, y6, x3, y6, x2, y6, x, y5, x, y4, x, y4 - (y4 - y3) / 3, x, y3 + (y4 - y3) / 3, x, y3, x, y2, x2, y, x3, y, x3 + (x4 - x3) / 3, y, x4 - (x4 - x3) / 3, y, x4, y, x5, y, x6, y2, x6, y3 ].join(",") + "z") : data = "M" + (x + w) + "," + y + " v" + h + " h" + -w + " v" + -h + " h" + w + "z") : "circle" === type || "ellipse" === type ? ("circle" === type ? (r = ry = attr.r, 
+    rycirc = r * circ) : (r = attr.rx, ry = attr.ry, rycirc = ry * circ), x = attr.cx, 
+    y = attr.cy, rcirc = r * circ, data = "M" + (x + r) + "," + y + " C" + [ x + r, y + rycirc, x + rcirc, y + ry, x, y + ry, x - rcirc, y + ry, x - r, y + rycirc, x - r, y, x - r, y - rycirc, x - rcirc, y - ry, x, y - ry, x + rcirc, y - ry, x + r, y - rycirc, x + r, y ].join(",") + "z") : "line" === type ? data = "M" + attr.x1 + "," + attr.y1 + " L" + attr.x2 + "," + attr.y2 : "polyline" !== type && "polygon" !== type || (points = (element.getAttribute("points") + "").match(_numbersExp) || [], 
+    x = points.shift(), y = points.shift(), data = "M" + x + "," + y + " L" + points.join(","), 
+    "polygon" === type && (data += "," + x + "," + y + "z")), path.setAttribute("d", rawPathToString(path._gsRawPath = stringToRawPath(data))), 
+    swap && element.parentNode && (element.parentNode.insertBefore(path, element), element.parentNode.removeChild(element)), 
+    path) : element;
+}
+
+export function getRotationAtProgress(rawPath, progress) {
+    let d = getProgressData(rawPath, progress >= 1 ? 1 - 1e-9 : progress || 1e-9);
+    return getRotationAtBezierT(d.segment, d.i, d.t);
+}
+
+function getRotationAtBezierT(segment, i, t) {
+    let x, a = segment[i], b = segment[i + 2], c = segment[i + 4];
+    return a += (b - a) * t, b += (c - b) * t, a += (b - a) * t, x = b + (c + (segment[i + 6] - c) * t - b) * t - a, 
+    a = segment[i + 1], b = segment[i + 3], c = segment[i + 5], a += (b - a) * t, b += (c - b) * t, 
+    a += (b - a) * t, _round(_atan2(b + (c + (segment[i + 7] - c) * t - b) * t - a, x) * _RAD2DEG);
+}
+
+export function sliceRawPath(rawPath, start, end) {
+    end = _isUndefined(end) ? 1 : _roundPrecise(end) || 0, start = _roundPrecise(start) || 0;
+    let loops = Math.max(0, ~~(_abs(end - start) - 1e-8)), path = copyRawPath(rawPath);
+    if (start > end && (start = 1 - start, end = 1 - end, _reverseRawPath(path), path.totalLength = 0), 
+    start < 0 || end < 0) {
+        let offset = Math.abs(~~Math.min(start, end)) + 1;
+        start += offset, end += offset;
+    }
+    path.totalLength || cacheRawPathMeasurements(path);
+    let wrapsBehind, sShift, eShift, i, copy, totalSegments, l, j, wrap = end > 1, s = getProgressData(path, start, _temp, !0), e = getProgressData(path, end, _temp2), eSeg = e.segment, sSeg = s.segment, eSegIndex = e.segIndex, sSegIndex = s.segIndex, ei = e.i, si = s.i, sameSegment = sSegIndex === eSegIndex, sameBezier = ei === si && sameSegment;
+    if (wrap || loops) {
+        for (wrapsBehind = eSegIndex < sSegIndex || sameSegment && ei < si || sameBezier && e.t < s.t, 
+        _splitSegment(path, sSegIndex, si, s.t) && (sSegIndex++, wrapsBehind || (eSegIndex++, 
+        sameBezier ? (e.t = (e.t - s.t) / (1 - s.t), ei = 0) : sameSegment && (ei -= si))), 
+        Math.abs(1 - (end - start)) < 1e-5 ? eSegIndex = sSegIndex - 1 : !e.t && eSegIndex ? eSegIndex-- : _splitSegment(path, eSegIndex, ei, e.t) && wrapsBehind && sSegIndex++, 
+        1 === s.t && (sSegIndex = (sSegIndex + 1) % path.length), copy = [], totalSegments = path.length, 
+        l = 1 + totalSegments * loops, j = sSegIndex, l += (totalSegments - sSegIndex + eSegIndex) % totalSegments, 
+        i = 0; i < l; i++) _appendOrMerge(copy, path[j++ % totalSegments]);
+        path = copy;
+    } else if (eShift = 1 === e.t ? 6 : subdivideSegment(eSeg, ei, e.t), start !== end) for (sShift = subdivideSegment(sSeg, si, sameBezier ? s.t / e.t : s.t), 
+    sameSegment && (eShift += sShift), eSeg.splice(ei + eShift + 2), (sShift || si) && sSeg.splice(0, si + sShift), 
+    i = path.length; i--; ) (i < sSegIndex || i > eSegIndex) && path.splice(i, 1); else eSeg.angle = getRotationAtBezierT(eSeg, ei + eShift, 0), 
+    ei += eShift, s = eSeg[ei], e = eSeg[ei + 1], eSeg.length = eSeg.totalLength = 0, 
+    eSeg.totalPoints = path.totalPoints = 8, eSeg.push(s, e, s, e, s, e, s, e);
+    return path.totalLength = 0, path;
+}
+
+function measureSegment(segment, startIndex, bezierQty) {
+    startIndex = startIndex || 0, segment.samples || (segment.samples = [], segment.lookup = []);
+    let i, j, x4, x3, x2, xd, xd1, y4, y3, y2, yd, yd1, inv, t, lengthIndex, l, segLength, resolution = ~~segment.resolution || 12, inc = 1 / resolution, endIndex = bezierQty ? startIndex + 6 * bezierQty + 1 : segment.length, x1 = segment[startIndex], y1 = segment[startIndex + 1], samplesIndex = startIndex ? startIndex / 6 * resolution : 0, samples = segment.samples, lookup = segment.lookup, min = (startIndex ? segment.minLength : _largeNum) || _largeNum, prevLength = samples[samplesIndex + bezierQty * resolution - 1], length = startIndex ? samples[samplesIndex - 1] : 0;
+    for (samples.length = lookup.length = 0, j = startIndex + 2; j < endIndex; j += 6) {
+        if (x4 = segment[j + 4] - x1, x3 = segment[j + 2] - x1, x2 = segment[j] - x1, y4 = segment[j + 5] - y1, 
+        y3 = segment[j + 3] - y1, y2 = segment[j + 1] - y1, xd = xd1 = yd = yd1 = 0, _abs(x4) < .01 && _abs(y4) < .01 && _abs(x2) + _abs(y2) < .01) segment.length > 8 && (segment.splice(j, 6), 
+        j -= 6, endIndex -= 6); else for (i = 1; i <= resolution; i++) t = inc * i, inv = 1 - t, 
+        xd = xd1 - (xd1 = (t * t * x4 + 3 * inv * (t * x3 + inv * x2)) * t), yd = yd1 - (yd1 = (t * t * y4 + 3 * inv * (t * y3 + inv * y2)) * t), 
+        l = _sqrt(yd * yd + xd * xd), l < min && (min = l), length += l, samples[samplesIndex++] = length;
+        x1 += x4, y1 += y4;
+    }
+    if (prevLength) for (prevLength -= length; samplesIndex < samples.length; samplesIndex++) samples[samplesIndex] += prevLength;
+    if (samples.length && min) {
+        if (segment.totalLength = segLength = samples[samples.length - 1] || 0, segment.minLength = min, 
+        segLength / min < 9999) for (l = lengthIndex = 0, i = 0; i < segLength; i += min) lookup[l++] = samples[lengthIndex] < i ? ++lengthIndex : lengthIndex;
+    } else segment.totalLength = samples[0] = 0;
+    return startIndex ? length - samples[startIndex / 2 - 1] : length;
+}
+
+export function cacheRawPathMeasurements(rawPath, resolution) {
+    let pathLength, points, i;
+    for (i = pathLength = points = 0; i < rawPath.length; i++) rawPath[i].resolution = ~~resolution || 12, 
+    points += rawPath[i].length, pathLength += measureSegment(rawPath[i]);
+    return rawPath.totalPoints = points, rawPath.totalLength = pathLength, rawPath;
+}
+
+export function subdivideSegment(segment, i, t) {
+    if (t <= 0 || t >= 1) return 0;
+    let ax = segment[i], ay = segment[i + 1], cp1x = segment[i + 2], cp1y = segment[i + 3], cp2x = segment[i + 4], cp2y = segment[i + 5], x1a = ax + (cp1x - ax) * t, x2 = cp1x + (cp2x - cp1x) * t, y1a = ay + (cp1y - ay) * t, y2 = cp1y + (cp2y - cp1y) * t, x1 = x1a + (x2 - x1a) * t, y1 = y1a + (y2 - y1a) * t, x2a = cp2x + (segment[i + 6] - cp2x) * t, y2a = cp2y + (segment[i + 7] - cp2y) * t;
+    return x2 += (x2a - x2) * t, y2 += (y2a - y2) * t, segment.splice(i + 2, 4, _round(x1a), _round(y1a), _round(x1), _round(y1), _round(x1 + (x2 - x1) * t), _round(y1 + (y2 - y1) * t), _round(x2), _round(y2), _round(x2a), _round(y2a)), 
+    segment.samples && segment.samples.splice(i / 6 * segment.resolution | 0, 0, 0, 0, 0, 0, 0, 0), 
+    6;
+}
+
+function getProgressData(rawPath, progress, decoratee, pushToNextIfAtEnd) {
+    decoratee = decoratee || {}, rawPath.totalLength || cacheRawPathMeasurements(rawPath), 
+    (progress < 0 || progress > 1) && (progress = _wrapProgress(progress));
+    let samples, resolution, length, min, max, i, t, segIndex = 0, segment = rawPath[0];
+    if (progress) if (1 === progress) t = 1, segIndex = rawPath.length - 1, segment = rawPath[segIndex], 
+    i = segment.length - 8; else {
+        if (rawPath.length > 1) {
+            for (length = rawPath.totalLength * progress, max = i = 0; (max += rawPath[i++].totalLength) < length; ) segIndex = i;
+            segment = rawPath[segIndex], min = max - segment.totalLength, progress = (length - min) / (max - min) || 0;
+        }
+        samples = segment.samples, resolution = segment.resolution, length = segment.totalLength * progress, 
+        i = segment.lookup.length ? segment.lookup[~~(length / segment.minLength)] || 0 : _getSampleIndex(samples, length, progress), 
+        min = i ? samples[i - 1] : 0, max = samples[i], max < length && (min = max, max = samples[++i]), 
+        t = 1 / resolution * ((length - min) / (max - min) + i % resolution), i = 6 * ~~(i / resolution), 
+        pushToNextIfAtEnd && 1 === t && (i + 6 < segment.length ? (i += 6, t = 0) : segIndex + 1 < rawPath.length && (i = t = 0, 
+        segment = rawPath[++segIndex]));
+    } else t = i = segIndex = 0, segment = rawPath[0];
+    return decoratee.t = t, decoratee.i = i, decoratee.path = rawPath, decoratee.segment = segment, 
+    decoratee.segIndex = segIndex, decoratee;
+}
+
+export function getPositionOnPath(rawPath, progress, includeAngle, point) {
+    let samples, resolution, length, min, max, i, t, a, inv, segment = rawPath[0], result = point || {};
+    if ((progress < 0 || progress > 1) && (progress = _wrapProgress(progress)), segment.lookup || cacheRawPathMeasurements(rawPath), 
+    rawPath.length > 1) {
+        for (length = rawPath.totalLength * progress, max = i = 0; (max += rawPath[i++].totalLength) < length; ) segment = rawPath[i];
+        min = max - segment.totalLength, progress = (length - min) / (max - min) || 0;
+    }
+    return samples = segment.samples, resolution = segment.resolution, length = segment.totalLength * progress, 
+    i = segment.lookup.length ? segment.lookup[progress < 1 ? ~~(length / segment.minLength) : segment.lookup.length - 1] || 0 : _getSampleIndex(samples, length, progress), 
+    min = i ? samples[i - 1] : 0, max = samples[i], max < length && (min = max, max = samples[++i]), 
+    t = 1 / resolution * ((length - min) / (max - min) + i % resolution) || 0, inv = 1 - t, 
+    i = 6 * ~~(i / resolution), a = segment[i], result.x = _round((t * t * (segment[i + 6] - a) + 3 * inv * (t * (segment[i + 4] - a) + inv * (segment[i + 2] - a))) * t + a), 
+    result.y = _round((t * t * (segment[i + 7] - (a = segment[i + 1])) + 3 * inv * (t * (segment[i + 5] - a) + inv * (segment[i + 3] - a))) * t + a), 
+    includeAngle && (result.angle = segment.totalLength ? getRotationAtBezierT(segment, i, t >= 1 ? 1 - 1e-9 : t || 1e-9) : segment.angle || 0), 
+    result;
+}
+
+export function transformRawPath(rawPath, a, b, c, d, tx, ty) {
+    let segment, l, i, x, y, j = rawPath.length;
+    for (;--j > -1; ) for (segment = rawPath[j], l = segment.length, i = 0; i < l; i += 2) x = segment[i], 
+    y = segment[i + 1], segment[i] = x * a + y * c + tx, segment[i + 1] = x * b + y * d + ty;
+    return rawPath._dirty = 1, rawPath;
+}
+
+function arcToSegment(lastX, lastY, rx, ry, angle, largeArcFlag, sweepFlag, x, y) {
+    if (lastX === x && lastY === y) return;
+    rx = _abs(rx), ry = _abs(ry);
+    let angleRad = angle % 360 * _DEG2RAD, cosAngle = _cos(angleRad), sinAngle = _sin(angleRad), PI = Math.PI, TWOPI = 2 * PI, dx2 = (lastX - x) / 2, dy2 = (lastY - y) / 2, x1 = cosAngle * dx2 + sinAngle * dy2, y1 = -sinAngle * dx2 + cosAngle * dy2, x1_sq = x1 * x1, y1_sq = y1 * y1, radiiCheck = x1_sq / (rx * rx) + y1_sq / (ry * ry);
+    radiiCheck > 1 && (rx = _sqrt(radiiCheck) * rx, ry = _sqrt(radiiCheck) * ry);
+    let rx_sq = rx * rx, ry_sq = ry * ry, sq = (rx_sq * ry_sq - rx_sq * y1_sq - ry_sq * x1_sq) / (rx_sq * y1_sq + ry_sq * x1_sq);
+    sq < 0 && (sq = 0);
+    let coef = (largeArcFlag === sweepFlag ? -1 : 1) * _sqrt(sq), cx1 = coef * (rx * y1 / ry), cy1 = coef * (-ry * x1 / rx), cx = (lastX + x) / 2 + (cosAngle * cx1 - sinAngle * cy1), cy = (lastY + y) / 2 + (sinAngle * cx1 + cosAngle * cy1), ux = (x1 - cx1) / rx, uy = (y1 - cy1) / ry, vx = (-x1 - cx1) / rx, vy = (-y1 - cy1) / ry, temp = ux * ux + uy * uy, angleStart = (uy < 0 ? -1 : 1) * Math.acos(ux / _sqrt(temp)), angleExtent = (ux * vy - uy * vx < 0 ? -1 : 1) * Math.acos((ux * vx + uy * vy) / _sqrt(temp * (vx * vx + vy * vy)));
+    isNaN(angleExtent) && (angleExtent = PI), !sweepFlag && angleExtent > 0 ? angleExtent -= TWOPI : sweepFlag && angleExtent < 0 && (angleExtent += TWOPI), 
+    angleStart %= TWOPI, angleExtent %= TWOPI;
+    let i, segments = Math.ceil(_abs(angleExtent) / (TWOPI / 4)), rawPath = [], angleIncrement = angleExtent / segments, controlLength = 4 / 3 * _sin(angleIncrement / 2) / (1 + _cos(angleIncrement / 2)), ma = cosAngle * rx, mb = sinAngle * rx, mc = sinAngle * -ry, md = cosAngle * ry;
+    for (i = 0; i < segments; i++) x1 = _cos(angle = angleStart + i * angleIncrement), 
+    y1 = _sin(angle), ux = _cos(angle += angleIncrement), uy = _sin(angle), rawPath.push(x1 - controlLength * y1, y1 + controlLength * x1, ux + controlLength * uy, uy - controlLength * ux, ux, uy);
+    for (i = 0; i < rawPath.length; i += 2) x1 = rawPath[i], y1 = rawPath[i + 1], rawPath[i] = x1 * ma + y1 * mc + cx, 
+    rawPath[i + 1] = x1 * mb + y1 * md + cy;
+    return rawPath[i - 2] = x, rawPath[i - 1] = y, rawPath;
+}
+
+export function stringToRawPath(d) {
+    let i, j, x, y, command, isRelative, segment, startX, startY, difX, difY, beziers, prevCommand, flag1, flag2, a = (d + "").replace(_scientific, (m => {
+        let n = +m;
+        return n < 1e-4 && n > -1e-4 ? 0 : n;
+    })).match(_svgPathExp) || [], path = [], relativeX = 0, relativeY = 0, twoThirds = 2 / 3, elements = a.length, points = 0, errorMessage = "ERROR: malformed path: " + d, line = function(sx, sy, ex, ey) {
+        difX = (ex - sx) / 3, difY = (ey - sy) / 3, segment.push(sx + difX, sy + difY, ex - difX, ey - difY, ex, ey);
+    };
+    if (!d || !isNaN(a[0]) || isNaN(a[1])) return console.log(errorMessage), path;
+    for (i = 0; i < elements; i++) if (prevCommand = command, isNaN(a[i]) ? (command = a[i].toUpperCase(), 
+    isRelative = command !== a[i]) : i--, x = +a[i + 1], y = +a[i + 2], isRelative && (x += relativeX, 
+    y += relativeY), i || (startX = x, startY = y), "M" === command) segment && (segment.length < 8 ? path.length -= 1 : points += segment.length), 
+    relativeX = startX = x, relativeY = startY = y, segment = [ x, y ], path.push(segment), 
+    i += 2, command = "L"; else if ("C" === command) segment || (segment = [ 0, 0 ]), 
+    isRelative || (relativeX = relativeY = 0), segment.push(x, y, relativeX + 1 * a[i + 3], relativeY + 1 * a[i + 4], relativeX += 1 * a[i + 5], relativeY += 1 * a[i + 6]), 
+    i += 6; else if ("S" === command) difX = relativeX, difY = relativeY, "C" !== prevCommand && "S" !== prevCommand || (difX += relativeX - segment[segment.length - 4], 
+    difY += relativeY - segment[segment.length - 3]), isRelative || (relativeX = relativeY = 0), 
+    segment.push(difX, difY, x, y, relativeX += 1 * a[i + 3], relativeY += 1 * a[i + 4]), 
+    i += 4; else if ("Q" === command) difX = relativeX + (x - relativeX) * twoThirds, 
+    difY = relativeY + (y - relativeY) * twoThirds, isRelative || (relativeX = relativeY = 0), 
+    relativeX += 1 * a[i + 3], relativeY += 1 * a[i + 4], segment.push(difX, difY, relativeX + (x - relativeX) * twoThirds, relativeY + (y - relativeY) * twoThirds, relativeX, relativeY), 
+    i += 4; else if ("T" === command) difX = relativeX - segment[segment.length - 4], 
+    difY = relativeY - segment[segment.length - 3], segment.push(relativeX + difX, relativeY + difY, x + (relativeX + 1.5 * difX - x) * twoThirds, y + (relativeY + 1.5 * difY - y) * twoThirds, relativeX = x, relativeY = y), 
+    i += 2; else if ("H" === command) line(relativeX, relativeY, relativeX = x, relativeY), 
+    i += 1; else if ("V" === command) line(relativeX, relativeY, relativeX, relativeY = x + (isRelative ? relativeY - relativeX : 0)), 
+    i += 1; else if ("L" === command || "Z" === command) "Z" === command && (x = startX, 
+    y = startY, segment.closed = !0), ("L" === command || _abs(relativeX - x) > .5 || _abs(relativeY - y) > .5) && (line(relativeX, relativeY, x, y), 
+    "L" === command && (i += 2)), relativeX = x, relativeY = y; else if ("A" === command) {
+        if (flag1 = a[i + 4], flag2 = a[i + 5], difX = a[i + 6], difY = a[i + 7], j = 7, 
+        flag1.length > 1 && (flag1.length < 3 ? (difY = difX, difX = flag2, j--) : (difY = flag2, 
+        difX = flag1.substr(2), j -= 2), flag2 = flag1.charAt(1), flag1 = flag1.charAt(0)), 
+        beziers = arcToSegment(relativeX, relativeY, +a[i + 1], +a[i + 2], +a[i + 3], +flag1, +flag2, (isRelative ? relativeX : 0) + 1 * difX, (isRelative ? relativeY : 0) + 1 * difY), 
+        i += j, beziers) for (j = 0; j < beziers.length; j++) segment.push(beziers[j]);
+        relativeX = segment[segment.length - 2], relativeY = segment[segment.length - 1];
+    } else console.log(errorMessage);
+    return i = segment.length, i < 6 ? (path.pop(), i = 0) : segment[0] === segment[i - 2] && segment[1] === segment[i - 1] && (segment.closed = !0), 
+    path.totalPoints = points + i, path;
+}
+
+export function bezierToPoints(x1, y1, x2, y2, x3, y3, x4, y4, threshold, points, index) {
+    let length, x12 = (x1 + x2) / 2, y12 = (y1 + y2) / 2, x23 = (x2 + x3) / 2, y23 = (y2 + y3) / 2, x34 = (x3 + x4) / 2, y34 = (y3 + y4) / 2, x123 = (x12 + x23) / 2, y123 = (y12 + y23) / 2, x234 = (x23 + x34) / 2, y234 = (y23 + y34) / 2, x1234 = (x123 + x234) / 2, y1234 = (y123 + y234) / 2, dx = x4 - x1, dy = y4 - y1, d2 = _abs((x2 - x4) * dy - (y2 - y4) * dx), d3 = _abs((x3 - x4) * dy - (y3 - y4) * dx);
+    return points || (points = [ x1, y1, x4, y4 ], index = 2), points.splice(index || points.length - 2, 0, x1234, y1234), 
+    (d2 + d3) * (d2 + d3) > threshold * (dx * dx + dy * dy) && (length = points.length, 
+    bezierToPoints(x1, y1, x12, y12, x123, y123, x1234, y1234, threshold, points, index), 
+    bezierToPoints(x1234, y1234, x234, y234, x34, y34, x4, y4, threshold, points, index + 2 + (points.length - length))), 
+    points;
+}
+
+export function flatPointsToSegment(points, curviness = 1) {
+    let x = points[0], y = 0, segment = [ x, y ], i = 2;
+    for (;i < points.length; i += 2) segment.push(x, y, points[i], y = (points[i] - x) * curviness / 2, x = points[i], -y);
+    return segment;
+}
+
+export function pointsToSegment(points, curviness) {
+    _abs(points[0] - points[2]) < 1e-4 && _abs(points[1] - points[3]) < 1e-4 && (points = points.slice(2));
+    let prevX, prevY, i, dx1, dy1, r1, r2, r3, tl, mx1, mx2, mxm, my1, my2, mym, l = points.length - 2, x = +points[0], y = +points[1], nextX = +points[2], nextY = +points[3], segment = [ x, y, x, y ], dx2 = nextX - x, dy2 = nextY - y, closed = Math.abs(points[l] - x) < .001 && Math.abs(points[l + 1] - y) < .001;
+    for (closed && (points.push(nextX, nextY), nextX = x, nextY = y, x = points[l - 2], 
+    y = points[l - 1], points.unshift(x, y), l += 4), curviness = curviness || 0 === curviness ? +curviness : 1, 
+    i = 2; i < l; i += 2) prevX = x, prevY = y, x = nextX, y = nextY, nextX = +points[i + 2], 
+    nextY = +points[i + 3], x === nextX && y === nextY || (dx1 = dx2, dy1 = dy2, dx2 = nextX - x, 
+    dy2 = nextY - y, r1 = _sqrt(dx1 * dx1 + dy1 * dy1), r2 = _sqrt(dx2 * dx2 + dy2 * dy2), 
+    r3 = _sqrt((dx2 / r2 + dx1 / r1) ** 2 + (dy2 / r2 + dy1 / r1) ** 2), tl = (r1 + r2) * curviness * .25 / r3, 
+    mx1 = x - (x - prevX) * (r1 ? tl / r1 : 0), mx2 = x + (nextX - x) * (r2 ? tl / r2 : 0), 
+    mxm = x - (mx1 + ((mx2 - mx1) * (3 * r1 / (r1 + r2) + .5) / 4 || 0)), my1 = y - (y - prevY) * (r1 ? tl / r1 : 0), 
+    my2 = y + (nextY - y) * (r2 ? tl / r2 : 0), mym = y - (my1 + ((my2 - my1) * (3 * r1 / (r1 + r2) + .5) / 4 || 0)), 
+    x === prevX && y === prevY || segment.push(_round(mx1 + mxm), _round(my1 + mym), _round(x), _round(y), _round(mx2 + mxm), _round(my2 + mym)));
+    return x !== nextX || y !== nextY || segment.length < 4 ? segment.push(_round(nextX), _round(nextY), _round(nextX), _round(nextY)) : segment.length -= 2, 
+    2 === segment.length ? segment.push(x, y, x, y, x, y) : closed && (segment.splice(0, 6), 
+    segment.length = segment.length - 6), segment;
+}
+
+function pointToSegDist(x, y, x1, y1, x2, y2) {
+    let t, dx = x2 - x1, dy = y2 - y1;
+    return (dx || dy) && (t = ((x - x1) * dx + (y - y1) * dy) / (dx * dx + dy * dy), 
+    t > 1 ? (x1 = x2, y1 = y2) : t > 0 && (x1 += dx * t, y1 += dy * t)), (x - x1) ** 2 + (y - y1) ** 2;
+}
+
+function simplifyStep(points, first, last, tolerance, simplified) {
+    let index, i, d, maxSqDist = tolerance, firstX = points[first], firstY = points[first + 1], lastX = points[last], lastY = points[last + 1];
+    for (i = first + 2; i < last; i += 2) d = pointToSegDist(points[i], points[i + 1], firstX, firstY, lastX, lastY), 
+    d > maxSqDist && (index = i, maxSqDist = d);
+    maxSqDist > tolerance && (index - first > 2 && simplifyStep(points, first, index, tolerance, simplified), 
+    simplified.push(points[index], points[index + 1]), last - index > 2 && simplifyStep(points, index, last, tolerance, simplified));
+}
+
+export function simplifyPoints(points, tolerance) {
+    let i, x, y, dx, dy, result, last, prevX = parseFloat(points[0]), prevY = parseFloat(points[1]), temp = [ prevX, prevY ], l = points.length - 2;
+    for (tolerance = (tolerance || 1) ** 2, i = 2; i < l; i += 2) x = parseFloat(points[i]), 
+    y = parseFloat(points[i + 1]), dx = prevX - x, dy = prevY - y, dx * dx + dy * dy > tolerance && (temp.push(x, y), 
+    prevX = x, prevY = y);
+    return temp.push(parseFloat(points[l]), parseFloat(points[l + 1])), last = temp.length - 2, 
+    result = [ temp[0], temp[1] ], simplifyStep(temp, 0, last, tolerance, result), result.push(temp[last], temp[last + 1]), 
+    result;
+}
+
+function getClosestProgressOnBezier(iterations, px, py, start, end, slices, x0, y0, x1, y1, x2, y2, x3, y3) {
+    let x, y, d, dx, dy, inv, inc = (end - start) / slices, best = 0, t = start;
+    for (_bestDistance = _largeNum; t <= end; ) inv = 1 - t, x = inv * inv * inv * x0 + 3 * inv * inv * t * x1 + 3 * inv * t * t * x2 + t * t * t * x3, 
+    y = inv * inv * inv * y0 + 3 * inv * inv * t * y1 + 3 * inv * t * t * y2 + t * t * t * y3, 
+    dx = x - px, dy = y - py, d = dx * dx + dy * dy, d < _bestDistance && (_bestDistance = d, 
+    best = t), t += inc;
+    return iterations > 1 ? getClosestProgressOnBezier(iterations - 1, px, py, Math.max(best - inc, 0), Math.min(best + inc, 1), slices, x0, y0, x1, y1, x2, y2, x3, y3) : best;
+}
+
+export function getClosestData(rawPath, x, y, slices) {
+    let i, j, t, segment, closest = {
+        j: 0,
+        i: 0,
+        t: 0
+    }, bestDistance = _largeNum;
+    for (j = 0; j < rawPath.length; j++) for (segment = rawPath[j], i = 0; i < segment.length; i += 6) t = getClosestProgressOnBezier(1, x, y, 0, 1, slices || 20, segment[i], segment[i + 1], segment[i + 2], segment[i + 3], segment[i + 4], segment[i + 5], segment[i + 6], segment[i + 7]), 
+    bestDistance > _bestDistance && (bestDistance = _bestDistance, closest.j = j, closest.i = i, 
+    closest.t = t);
+    return closest;
+}
+
+export function subdivideSegmentNear(x, y, segment, slices, iterations) {
+    let t, i, l = segment.length, bestDistance = _largeNum, bestT = 0, bestSegmentIndex = 0;
+    for (slices = slices || 20, iterations = iterations || 3, i = 0; i < l; i += 6) t = getClosestProgressOnBezier(1, x, y, 0, 1, slices, segment[i], segment[i + 1], segment[i + 2], segment[i + 3], segment[i + 4], segment[i + 5], segment[i + 6], segment[i + 7]), 
+    bestDistance > _bestDistance && (bestDistance = _bestDistance, bestT = t, bestSegmentIndex = i);
+    return t = getClosestProgressOnBezier(iterations, x, y, bestT - .05, bestT + .05, slices, segment[bestSegmentIndex], segment[bestSegmentIndex + 1], segment[bestSegmentIndex + 2], segment[bestSegmentIndex + 3], segment[bestSegmentIndex + 4], segment[bestSegmentIndex + 5], segment[bestSegmentIndex + 6], segment[bestSegmentIndex + 7]), 
+    subdivideSegment(segment, bestSegmentIndex, t), bestSegmentIndex + 6;
+}
+
+export function rawPathToString(rawPath) {
+    _isNumber(rawPath[0]) && (rawPath = [ rawPath ]);
+    let sl, s, i, segment, result = "", l = rawPath.length;
+    for (s = 0; s < l; s++) {
+        for (segment = rawPath[s], result += "M" + _round(segment[0]) + "," + _round(segment[1]) + " C", 
+        sl = segment.length, i = 2; i < sl; i++) result += _round(segment[i++]) + "," + _round(segment[i++]) + " " + _round(segment[i++]) + "," + _round(segment[i++]) + " " + _round(segment[i++]) + "," + _round(segment[i]) + " ";
+        segment.closed && (result += "z");
+    }
+    return result;
+}
+//# sourceMappingURL=paths.js.map