1 | (function (global, factory) {
|
2 | typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
3 | typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
4 | (global = global || self, factory(global.window = global.window || {}));
|
5 | }(this, (function (exports) { 'use strict';
|
6 |
|
7 | var _svgPathExp = /[achlmqstvz]|(-?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig,
|
8 | _scientific = /[\+\-]?\d*\.?\d+e[\+\-]?\d+/ig,
|
9 | _DEG2RAD = Math.PI / 180,
|
10 | _sin = Math.sin,
|
11 | _cos = Math.cos,
|
12 | _abs = Math.abs,
|
13 | _sqrt = Math.sqrt,
|
14 | _isNumber = function _isNumber(value) {
|
15 | return typeof value === "number";
|
16 | },
|
17 | _roundingNum = 1e5,
|
18 | _round = function _round(value) {
|
19 | return Math.round(value * _roundingNum) / _roundingNum || 0;
|
20 | };
|
21 | function transformRawPath(rawPath, a, b, c, d, tx, ty) {
|
22 | var j = rawPath.length,
|
23 | segment,
|
24 | l,
|
25 | i,
|
26 | x,
|
27 | y;
|
28 |
|
29 | while (--j > -1) {
|
30 | segment = rawPath[j];
|
31 | l = segment.length;
|
32 |
|
33 | for (i = 0; i < l; i += 2) {
|
34 | x = segment[i];
|
35 | y = segment[i + 1];
|
36 | segment[i] = x * a + y * c + tx;
|
37 | segment[i + 1] = x * b + y * d + ty;
|
38 | }
|
39 | }
|
40 |
|
41 | rawPath._dirty = 1;
|
42 | return rawPath;
|
43 | }
|
44 |
|
45 | function arcToSegment(lastX, lastY, rx, ry, angle, largeArcFlag, sweepFlag, x, y) {
|
46 | if (lastX === x && lastY === y) {
|
47 | return;
|
48 | }
|
49 |
|
50 | rx = _abs(rx);
|
51 | ry = _abs(ry);
|
52 |
|
53 | var angleRad = angle % 360 * _DEG2RAD,
|
54 | cosAngle = _cos(angleRad),
|
55 | sinAngle = _sin(angleRad),
|
56 | PI = Math.PI,
|
57 | TWOPI = PI * 2,
|
58 | dx2 = (lastX - x) / 2,
|
59 | dy2 = (lastY - y) / 2,
|
60 | x1 = cosAngle * dx2 + sinAngle * dy2,
|
61 | y1 = -sinAngle * dx2 + cosAngle * dy2,
|
62 | x1_sq = x1 * x1,
|
63 | y1_sq = y1 * y1,
|
64 | radiiCheck = x1_sq / (rx * rx) + y1_sq / (ry * ry);
|
65 |
|
66 | if (radiiCheck > 1) {
|
67 | rx = _sqrt(radiiCheck) * rx;
|
68 | ry = _sqrt(radiiCheck) * ry;
|
69 | }
|
70 |
|
71 | var rx_sq = rx * rx,
|
72 | ry_sq = ry * ry,
|
73 | sq = (rx_sq * ry_sq - rx_sq * y1_sq - ry_sq * x1_sq) / (rx_sq * y1_sq + ry_sq * x1_sq);
|
74 |
|
75 | if (sq < 0) {
|
76 | sq = 0;
|
77 | }
|
78 |
|
79 | var coef = (largeArcFlag === sweepFlag ? -1 : 1) * _sqrt(sq),
|
80 | cx1 = coef * (rx * y1 / ry),
|
81 | cy1 = coef * -(ry * x1 / rx),
|
82 | sx2 = (lastX + x) / 2,
|
83 | sy2 = (lastY + y) / 2,
|
84 | cx = sx2 + (cosAngle * cx1 - sinAngle * cy1),
|
85 | cy = sy2 + (sinAngle * cx1 + cosAngle * cy1),
|
86 | ux = (x1 - cx1) / rx,
|
87 | uy = (y1 - cy1) / ry,
|
88 | vx = (-x1 - cx1) / rx,
|
89 | vy = (-y1 - cy1) / ry,
|
90 | temp = ux * ux + uy * uy,
|
91 | angleStart = (uy < 0 ? -1 : 1) * Math.acos(ux / _sqrt(temp)),
|
92 | angleExtent = (ux * vy - uy * vx < 0 ? -1 : 1) * Math.acos((ux * vx + uy * vy) / _sqrt(temp * (vx * vx + vy * vy)));
|
93 |
|
94 | isNaN(angleExtent) && (angleExtent = PI);
|
95 |
|
96 | if (!sweepFlag && angleExtent > 0) {
|
97 | angleExtent -= TWOPI;
|
98 | } else if (sweepFlag && angleExtent < 0) {
|
99 | angleExtent += TWOPI;
|
100 | }
|
101 |
|
102 | angleStart %= TWOPI;
|
103 | angleExtent %= TWOPI;
|
104 |
|
105 | var segments = Math.ceil(_abs(angleExtent) / (TWOPI / 4)),
|
106 | rawPath = [],
|
107 | angleIncrement = angleExtent / segments,
|
108 | controlLength = 4 / 3 * _sin(angleIncrement / 2) / (1 + _cos(angleIncrement / 2)),
|
109 | ma = cosAngle * rx,
|
110 | mb = sinAngle * rx,
|
111 | mc = sinAngle * -ry,
|
112 | md = cosAngle * ry,
|
113 | i;
|
114 |
|
115 | for (i = 0; i < segments; i++) {
|
116 | angle = angleStart + i * angleIncrement;
|
117 | x1 = _cos(angle);
|
118 | y1 = _sin(angle);
|
119 | ux = _cos(angle += angleIncrement);
|
120 | uy = _sin(angle);
|
121 | rawPath.push(x1 - controlLength * y1, y1 + controlLength * x1, ux + controlLength * uy, uy - controlLength * ux, ux, uy);
|
122 | }
|
123 |
|
124 | for (i = 0; i < rawPath.length; i += 2) {
|
125 | x1 = rawPath[i];
|
126 | y1 = rawPath[i + 1];
|
127 | rawPath[i] = x1 * ma + y1 * mc + cx;
|
128 | rawPath[i + 1] = x1 * mb + y1 * md + cy;
|
129 | }
|
130 |
|
131 | rawPath[i - 2] = x;
|
132 | rawPath[i - 1] = y;
|
133 | return rawPath;
|
134 | }
|
135 |
|
136 | function stringToRawPath(d) {
|
137 | var a = (d + "").replace(_scientific, function (m) {
|
138 | var n = +m;
|
139 | return n < 0.0001 && n > -0.0001 ? 0 : n;
|
140 | }).match(_svgPathExp) || [],
|
141 | path = [],
|
142 | relativeX = 0,
|
143 | relativeY = 0,
|
144 | twoThirds = 2 / 3,
|
145 | elements = a.length,
|
146 | points = 0,
|
147 | errorMessage = "ERROR: malformed path: " + d,
|
148 | i,
|
149 | j,
|
150 | x,
|
151 | y,
|
152 | command,
|
153 | isRelative,
|
154 | segment,
|
155 | startX,
|
156 | startY,
|
157 | difX,
|
158 | difY,
|
159 | beziers,
|
160 | prevCommand,
|
161 | flag1,
|
162 | flag2,
|
163 | line = function line(sx, sy, ex, ey) {
|
164 | difX = (ex - sx) / 3;
|
165 | difY = (ey - sy) / 3;
|
166 | segment.push(sx + difX, sy + difY, ex - difX, ey - difY, ex, ey);
|
167 | };
|
168 |
|
169 | if (!d || !isNaN(a[0]) || isNaN(a[1])) {
|
170 | console.log(errorMessage);
|
171 | return path;
|
172 | }
|
173 |
|
174 | for (i = 0; i < elements; i++) {
|
175 | prevCommand = command;
|
176 |
|
177 | if (isNaN(a[i])) {
|
178 | command = a[i].toUpperCase();
|
179 | isRelative = command !== a[i];
|
180 | } else {
|
181 | i--;
|
182 | }
|
183 |
|
184 | x = +a[i + 1];
|
185 | y = +a[i + 2];
|
186 |
|
187 | if (isRelative) {
|
188 | x += relativeX;
|
189 | y += relativeY;
|
190 | }
|
191 |
|
192 | if (!i) {
|
193 | startX = x;
|
194 | startY = y;
|
195 | }
|
196 |
|
197 | if (command === "M") {
|
198 | if (segment) {
|
199 | if (segment.length < 8) {
|
200 | path.length -= 1;
|
201 | } else {
|
202 | points += segment.length;
|
203 | }
|
204 | }
|
205 |
|
206 | relativeX = startX = x;
|
207 | relativeY = startY = y;
|
208 | segment = [x, y];
|
209 | path.push(segment);
|
210 | i += 2;
|
211 | command = "L";
|
212 | } else if (command === "C") {
|
213 | if (!segment) {
|
214 | segment = [0, 0];
|
215 | }
|
216 |
|
217 | if (!isRelative) {
|
218 | relativeX = relativeY = 0;
|
219 | }
|
220 |
|
221 | segment.push(x, y, relativeX + a[i + 3] * 1, relativeY + a[i + 4] * 1, relativeX += a[i + 5] * 1, relativeY += a[i + 6] * 1);
|
222 | i += 6;
|
223 | } else if (command === "S") {
|
224 | difX = relativeX;
|
225 | difY = relativeY;
|
226 |
|
227 | if (prevCommand === "C" || prevCommand === "S") {
|
228 | difX += relativeX - segment[segment.length - 4];
|
229 | difY += relativeY - segment[segment.length - 3];
|
230 | }
|
231 |
|
232 | if (!isRelative) {
|
233 | relativeX = relativeY = 0;
|
234 | }
|
235 |
|
236 | segment.push(difX, difY, x, y, relativeX += a[i + 3] * 1, relativeY += a[i + 4] * 1);
|
237 | i += 4;
|
238 | } else if (command === "Q") {
|
239 | difX = relativeX + (x - relativeX) * twoThirds;
|
240 | difY = relativeY + (y - relativeY) * twoThirds;
|
241 |
|
242 | if (!isRelative) {
|
243 | relativeX = relativeY = 0;
|
244 | }
|
245 |
|
246 | relativeX += a[i + 3] * 1;
|
247 | relativeY += a[i + 4] * 1;
|
248 | segment.push(difX, difY, relativeX + (x - relativeX) * twoThirds, relativeY + (y - relativeY) * twoThirds, relativeX, relativeY);
|
249 | i += 4;
|
250 | } else if (command === "T") {
|
251 | difX = relativeX - segment[segment.length - 4];
|
252 | difY = relativeY - segment[segment.length - 3];
|
253 | segment.push(relativeX + difX, relativeY + difY, x + (relativeX + difX * 1.5 - x) * twoThirds, y + (relativeY + difY * 1.5 - y) * twoThirds, relativeX = x, relativeY = y);
|
254 | i += 2;
|
255 | } else if (command === "H") {
|
256 | line(relativeX, relativeY, relativeX = x, relativeY);
|
257 | i += 1;
|
258 | } else if (command === "V") {
|
259 | line(relativeX, relativeY, relativeX, relativeY = x + (isRelative ? relativeY - relativeX : 0));
|
260 | i += 1;
|
261 | } else if (command === "L" || command === "Z") {
|
262 | if (command === "Z") {
|
263 | x = startX;
|
264 | y = startY;
|
265 | segment.closed = true;
|
266 | }
|
267 |
|
268 | if (command === "L" || _abs(relativeX - x) > 0.5 || _abs(relativeY - y) > 0.5) {
|
269 | line(relativeX, relativeY, x, y);
|
270 |
|
271 | if (command === "L") {
|
272 | i += 2;
|
273 | }
|
274 | }
|
275 |
|
276 | relativeX = x;
|
277 | relativeY = y;
|
278 | } else if (command === "A") {
|
279 | flag1 = a[i + 4];
|
280 | flag2 = a[i + 5];
|
281 | difX = a[i + 6];
|
282 | difY = a[i + 7];
|
283 | j = 7;
|
284 |
|
285 | if (flag1.length > 1) {
|
286 | if (flag1.length < 3) {
|
287 | difY = difX;
|
288 | difX = flag2;
|
289 | j--;
|
290 | } else {
|
291 | difY = flag2;
|
292 | difX = flag1.substr(2);
|
293 | j -= 2;
|
294 | }
|
295 |
|
296 | flag2 = flag1.charAt(1);
|
297 | flag1 = flag1.charAt(0);
|
298 | }
|
299 |
|
300 | beziers = arcToSegment(relativeX, relativeY, +a[i + 1], +a[i + 2], +a[i + 3], +flag1, +flag2, (isRelative ? relativeX : 0) + difX * 1, (isRelative ? relativeY : 0) + difY * 1);
|
301 | i += j;
|
302 |
|
303 | if (beziers) {
|
304 | for (j = 0; j < beziers.length; j++) {
|
305 | segment.push(beziers[j]);
|
306 | }
|
307 | }
|
308 |
|
309 | relativeX = segment[segment.length - 2];
|
310 | relativeY = segment[segment.length - 1];
|
311 | } else {
|
312 | console.log(errorMessage);
|
313 | }
|
314 | }
|
315 |
|
316 | i = segment.length;
|
317 |
|
318 | if (i < 6) {
|
319 | path.pop();
|
320 | i = 0;
|
321 | } else if (segment[0] === segment[i - 2] && segment[1] === segment[i - 1]) {
|
322 | segment.closed = true;
|
323 | }
|
324 |
|
325 | path.totalPoints = points + i;
|
326 | return path;
|
327 | }
|
328 | function rawPathToString(rawPath) {
|
329 | if (_isNumber(rawPath[0])) {
|
330 | rawPath = [rawPath];
|
331 | }
|
332 |
|
333 | var result = "",
|
334 | l = rawPath.length,
|
335 | sl,
|
336 | s,
|
337 | i,
|
338 | segment;
|
339 |
|
340 | for (s = 0; s < l; s++) {
|
341 | segment = rawPath[s];
|
342 | result += "M" + _round(segment[0]) + "," + _round(segment[1]) + " C";
|
343 | sl = segment.length;
|
344 |
|
345 | for (i = 2; i < sl; i++) {
|
346 | result += _round(segment[i++]) + "," + _round(segment[i++]) + " " + _round(segment[i++]) + "," + _round(segment[i++]) + " " + _round(segment[i++]) + "," + _round(segment[i]) + " ";
|
347 | }
|
348 |
|
349 | if (segment.closed) {
|
350 | result += "z";
|
351 | }
|
352 | }
|
353 |
|
354 | return result;
|
355 | }
|
356 |
|
357 | |
358 |
|
359 |
|
360 |
|
361 |
|
362 |
|
363 |
|
364 |
|
365 |
|
366 |
|
367 | var gsap,
|
368 | _coreInitted,
|
369 | _getGSAP = function _getGSAP() {
|
370 | return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
|
371 | },
|
372 | _initCore = function _initCore() {
|
373 | gsap = _getGSAP();
|
374 |
|
375 | if (gsap) {
|
376 | gsap.registerEase("_CE", CustomEase.create);
|
377 | _coreInitted = 1;
|
378 | } else {
|
379 | console.warn("Please gsap.registerPlugin(CustomEase)");
|
380 | }
|
381 | },
|
382 | _bigNum = 1e20,
|
383 | _round$1 = function _round(value) {
|
384 | return ~~(value * 1000 + (value < 0 ? -.5 : .5)) / 1000;
|
385 | },
|
386 | _numExp = /[-+=\.]*\d+[\.e\-\+]*\d*[e\-\+]*\d*/gi,
|
387 | _needsParsingExp = /[cLlsSaAhHvVtTqQ]/g,
|
388 | _findMinimum = function _findMinimum(values) {
|
389 | var l = values.length,
|
390 | min = _bigNum,
|
391 | i;
|
392 |
|
393 | for (i = 1; i < l; i += 6) {
|
394 | +values[i] < min && (min = +values[i]);
|
395 | }
|
396 |
|
397 | return min;
|
398 | },
|
399 | _normalize = function _normalize(values, height, originY) {
|
400 | if (!originY && originY !== 0) {
|
401 | originY = Math.max(+values[values.length - 1], +values[1]);
|
402 | }
|
403 |
|
404 | var tx = +values[0] * -1,
|
405 | ty = -originY,
|
406 | l = values.length,
|
407 | sx = 1 / (+values[l - 2] + tx),
|
408 | sy = -height || (Math.abs(+values[l - 1] - +values[1]) < 0.01 * (+values[l - 2] - +values[0]) ? _findMinimum(values) + ty : +values[l - 1] + ty),
|
409 | i;
|
410 |
|
411 | if (sy) {
|
412 | sy = 1 / sy;
|
413 | } else {
|
414 | sy = -sx;
|
415 | }
|
416 |
|
417 | for (i = 0; i < l; i += 2) {
|
418 | values[i] = (+values[i] + tx) * sx;
|
419 | values[i + 1] = (+values[i + 1] + ty) * sy;
|
420 | }
|
421 | },
|
422 | _bezierToPoints = function _bezierToPoints(x1, y1, x2, y2, x3, y3, x4, y4, threshold, points, index) {
|
423 | var x12 = (x1 + x2) / 2,
|
424 | y12 = (y1 + y2) / 2,
|
425 | x23 = (x2 + x3) / 2,
|
426 | y23 = (y2 + y3) / 2,
|
427 | x34 = (x3 + x4) / 2,
|
428 | y34 = (y3 + y4) / 2,
|
429 | x123 = (x12 + x23) / 2,
|
430 | y123 = (y12 + y23) / 2,
|
431 | x234 = (x23 + x34) / 2,
|
432 | y234 = (y23 + y34) / 2,
|
433 | x1234 = (x123 + x234) / 2,
|
434 | y1234 = (y123 + y234) / 2,
|
435 | dx = x4 - x1,
|
436 | dy = y4 - y1,
|
437 | d2 = Math.abs((x2 - x4) * dy - (y2 - y4) * dx),
|
438 | d3 = Math.abs((x3 - x4) * dy - (y3 - y4) * dx),
|
439 | length;
|
440 |
|
441 | if (!points) {
|
442 | points = [{
|
443 | x: x1,
|
444 | y: y1
|
445 | }, {
|
446 | x: x4,
|
447 | y: y4
|
448 | }];
|
449 | index = 1;
|
450 | }
|
451 |
|
452 | points.splice(index || points.length - 1, 0, {
|
453 | x: x1234,
|
454 | y: y1234
|
455 | });
|
456 |
|
457 | if ((d2 + d3) * (d2 + d3) > threshold * (dx * dx + dy * dy)) {
|
458 | length = points.length;
|
459 |
|
460 | _bezierToPoints(x1, y1, x12, y12, x123, y123, x1234, y1234, threshold, points, index);
|
461 |
|
462 | _bezierToPoints(x1234, y1234, x234, y234, x34, y34, x4, y4, threshold, points, index + 1 + (points.length - length));
|
463 | }
|
464 |
|
465 | return points;
|
466 | };
|
467 |
|
468 | var CustomEase = function () {
|
469 | function CustomEase(id, data, config) {
|
470 | _coreInitted || _initCore();
|
471 | this.id = id;
|
472 | this.setData(data, config);
|
473 | }
|
474 |
|
475 | var _proto = CustomEase.prototype;
|
476 |
|
477 | _proto.setData = function setData(data, config) {
|
478 | config = config || {};
|
479 | data = data || "0,0,1,1";
|
480 | var values = data.match(_numExp),
|
481 | closest = 1,
|
482 | points = [],
|
483 | lookup = [],
|
484 | precision = config.precision || 1,
|
485 | fast = precision <= 1,
|
486 | l,
|
487 | a1,
|
488 | a2,
|
489 | i,
|
490 | inc,
|
491 | j,
|
492 | point,
|
493 | prevPoint,
|
494 | p;
|
495 | this.data = data;
|
496 |
|
497 | if (_needsParsingExp.test(data) || ~data.indexOf("M") && data.indexOf("C") < 0) {
|
498 | values = stringToRawPath(data)[0];
|
499 | }
|
500 |
|
501 | l = values.length;
|
502 |
|
503 | if (l === 4) {
|
504 | values.unshift(0, 0);
|
505 | values.push(1, 1);
|
506 | l = 8;
|
507 | } else if ((l - 2) % 6) {
|
508 | throw "Invalid CustomEase";
|
509 | }
|
510 |
|
511 | if (+values[0] !== 0 || +values[l - 2] !== 1) {
|
512 | _normalize(values, config.height, config.originY);
|
513 | }
|
514 |
|
515 | this.segment = values;
|
516 |
|
517 | for (i = 2; i < l; i += 6) {
|
518 | a1 = {
|
519 | x: +values[i - 2],
|
520 | y: +values[i - 1]
|
521 | };
|
522 | a2 = {
|
523 | x: +values[i + 4],
|
524 | y: +values[i + 5]
|
525 | };
|
526 | points.push(a1, a2);
|
527 |
|
528 | _bezierToPoints(a1.x, a1.y, +values[i], +values[i + 1], +values[i + 2], +values[i + 3], a2.x, a2.y, 1 / (precision * 200000), points, points.length - 1);
|
529 | }
|
530 |
|
531 | l = points.length;
|
532 |
|
533 | for (i = 0; i < l; i++) {
|
534 | point = points[i];
|
535 | prevPoint = points[i - 1] || point;
|
536 |
|
537 | if ((point.x > prevPoint.x || prevPoint.y !== point.y && prevPoint.x === point.x || point === prevPoint) && point.x <= 1) {
|
538 | prevPoint.cx = point.x - prevPoint.x;
|
539 | prevPoint.cy = point.y - prevPoint.y;
|
540 | prevPoint.n = point;
|
541 | prevPoint.nx = point.x;
|
542 |
|
543 | if (fast && i > 1 && Math.abs(prevPoint.cy / prevPoint.cx - points[i - 2].cy / points[i - 2].cx) > 2) {
|
544 | fast = 0;
|
545 | }
|
546 |
|
547 | if (prevPoint.cx < closest) {
|
548 | if (!prevPoint.cx) {
|
549 | prevPoint.cx = 0.001;
|
550 |
|
551 | if (i === l - 1) {
|
552 | prevPoint.x -= 0.001;
|
553 | closest = Math.min(closest, 0.001);
|
554 | fast = 0;
|
555 | }
|
556 | } else {
|
557 | closest = prevPoint.cx;
|
558 | }
|
559 | }
|
560 | } else {
|
561 | points.splice(i--, 1);
|
562 | l--;
|
563 | }
|
564 | }
|
565 |
|
566 | l = 1 / closest + 1 | 0;
|
567 | inc = 1 / l;
|
568 | j = 0;
|
569 | point = points[0];
|
570 |
|
571 | if (fast) {
|
572 | for (i = 0; i < l; i++) {
|
573 | p = i * inc;
|
574 |
|
575 | if (point.nx < p) {
|
576 | point = points[++j];
|
577 | }
|
578 |
|
579 | a1 = point.y + (p - point.x) / point.cx * point.cy;
|
580 | lookup[i] = {
|
581 | x: p,
|
582 | cx: inc,
|
583 | y: a1,
|
584 | cy: 0,
|
585 | nx: 9
|
586 | };
|
587 |
|
588 | if (i) {
|
589 | lookup[i - 1].cy = a1 - lookup[i - 1].y;
|
590 | }
|
591 | }
|
592 |
|
593 | lookup[l - 1].cy = points[points.length - 1].y - a1;
|
594 | } else {
|
595 | for (i = 0; i < l; i++) {
|
596 | if (point.nx < i * inc) {
|
597 | point = points[++j];
|
598 | }
|
599 |
|
600 | lookup[i] = point;
|
601 | }
|
602 |
|
603 | if (j < points.length - 1) {
|
604 | lookup[i - 1] = points[points.length - 2];
|
605 | }
|
606 | }
|
607 |
|
608 | this.ease = function (p) {
|
609 | var point = lookup[p * l | 0] || lookup[l - 1];
|
610 |
|
611 | if (point.nx < p) {
|
612 | point = point.n;
|
613 | }
|
614 |
|
615 | return point.y + (p - point.x) / point.cx * point.cy;
|
616 | };
|
617 |
|
618 | this.ease.custom = this;
|
619 | this.id && gsap && gsap.registerEase(this.id, this.ease);
|
620 | return this;
|
621 | };
|
622 |
|
623 | _proto.getSVGData = function getSVGData(config) {
|
624 | return CustomEase.getSVGData(this, config);
|
625 | };
|
626 |
|
627 | CustomEase.create = function create(id, data, config) {
|
628 | return new CustomEase(id, data, config).ease;
|
629 | };
|
630 |
|
631 | CustomEase.register = function register(core) {
|
632 | gsap = core;
|
633 |
|
634 | _initCore();
|
635 | };
|
636 |
|
637 | CustomEase.get = function get(id) {
|
638 | return gsap.parseEase(id);
|
639 | };
|
640 |
|
641 | CustomEase.getSVGData = function getSVGData(ease, config) {
|
642 | config = config || {};
|
643 | var width = config.width || 100,
|
644 | height = config.height || 100,
|
645 | x = config.x || 0,
|
646 | y = (config.y || 0) + height,
|
647 | e = gsap.utils.toArray(config.path)[0],
|
648 | a,
|
649 | slope,
|
650 | i,
|
651 | inc,
|
652 | tx,
|
653 | ty,
|
654 | precision,
|
655 | threshold,
|
656 | prevX,
|
657 | prevY;
|
658 |
|
659 | if (config.invert) {
|
660 | height = -height;
|
661 | y = 0;
|
662 | }
|
663 |
|
664 | if (typeof ease === "string") {
|
665 | ease = gsap.parseEase(ease);
|
666 | }
|
667 |
|
668 | if (ease.custom) {
|
669 | ease = ease.custom;
|
670 | }
|
671 |
|
672 | if (ease instanceof CustomEase) {
|
673 | a = rawPathToString(transformRawPath([ease.segment], width, 0, 0, -height, x, y));
|
674 | } else {
|
675 | a = [x, y];
|
676 | precision = Math.max(5, (config.precision || 1) * 200);
|
677 | inc = 1 / precision;
|
678 | precision += 2;
|
679 | threshold = 5 / precision;
|
680 | prevX = _round$1(x + inc * width);
|
681 | prevY = _round$1(y + ease(inc) * -height);
|
682 | slope = (prevY - y) / (prevX - x);
|
683 |
|
684 | for (i = 2; i < precision; i++) {
|
685 | tx = _round$1(x + i * inc * width);
|
686 | ty = _round$1(y + ease(i * inc) * -height);
|
687 |
|
688 | if (Math.abs((ty - prevY) / (tx - prevX) - slope) > threshold || i === precision - 1) {
|
689 | a.push(prevX, prevY);
|
690 | slope = (ty - prevY) / (tx - prevX);
|
691 | }
|
692 |
|
693 | prevX = tx;
|
694 | prevY = ty;
|
695 | }
|
696 |
|
697 | a = "M" + a.join(",");
|
698 | }
|
699 |
|
700 | e && e.setAttribute("d", a);
|
701 | return a;
|
702 | };
|
703 |
|
704 | return CustomEase;
|
705 | }();
|
706 | _getGSAP() && gsap.registerPlugin(CustomEase);
|
707 | CustomEase.version = "3.10.3";
|
708 |
|
709 | exports.CustomEase = CustomEase;
|
710 | exports.default = CustomEase;
|
711 |
|
712 | Object.defineProperty(exports, '__esModule', { value: true });
|
713 |
|
714 | })));
|