https://pdfstandalone.com/webjars/common-frontend/lib/lottie_5.7.12.js

1(typeof navigator !== "undefined") && (function(root, factory) {
2    if (typeof define === "function" && define.amd) {
3        define(function() {
4            return factory(root);
5        });
6    } else if (typeof module === "object" && module.exports) {
7        module.exports = factory(root);
8    } else {
9        root.lottie = factory(root);
10        root.bodymovin = root.lottie;
11    }
12}((window || {}), function(window) {
13	/* global locationHref:writable, animationManager, subframeEnabled:writable, defaultCurveSegments:writable, roundValues,
14expressionsPlugin:writable, PropertyFactory, ShapePropertyFactory, Matrix, idPrefix:writable */
15/* exported locationHref, subframeEnabled, expressionsPlugin, idPrefix */
16
17'use strict';
18
19/* exported svgNS, locationHref, initialDefaultFrame */
20
21var svgNS = 'http://www.w3.org/2000/svg';
22
23var locationHref = '';
24
25var initialDefaultFrame = -999999;
26
27/* global createSizedArray */
28/* exported subframeEnabled, expressionsPlugin, isSafari, cachedColors, bmPow, bmSqrt, bmFloor, bmMax, bmMin, ProjectInterface,
29defaultCurveSegments, degToRads, roundCorner, bmRnd, styleDiv, BMEnterFrameEvent, BMCompleteEvent, BMCompleteLoopEvent,
30BMSegmentStartEvent, BMDestroyEvent, BMRenderFrameErrorEvent, BMConfigErrorEvent, BMAnimationConfigErrorEvent, createElementID,
31addSaturationToRGB, addBrightnessToRGB, addHueToRGB, rgbToHex */
32
33var subframeEnabled = true;
34var idPrefix = '';
35var expressionsPlugin;
36var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
37var cachedColors = {};
38var bmRnd;
39var bmPow = Math.pow;
40var bmSqrt = Math.sqrt;
41var bmFloor = Math.floor;
42var bmMax = Math.max;
43var bmMin = Math.min;
44
45var BMMath = {};
46(function () {
47  var propertyNames = ['abs', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'atan2', 'ceil', 'cbrt', 'expm1', 'clz32', 'cos', 'cosh', 'exp', 'floor', 'fround', 'hypot', 'imul', 'log', 'log1p', 'log2', 'log10', 'max', 'min', 'pow', 'random', 'round', 'sign', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc', 'E', 'LN10', 'LN2', 'LOG10E', 'LOG2E', 'PI', 'SQRT1_2', 'SQRT2'];
48  var i;
49  var len = propertyNames.length;
50  for (i = 0; i < len; i += 1) {
51    BMMath[propertyNames[i]] = Math[propertyNames[i]];
52  }
53}());
54
55function ProjectInterface() { return {}; }
56
57BMMath.random = Math.random;
58BMMath.abs = function (val) {
59  var tOfVal = typeof val;
60  if (tOfVal === 'object' && val.length) {
61    var absArr = createSizedArray(val.length);
62    var i;
63    var len = val.length;
64    for (i = 0; i < len; i += 1) {
65      absArr[i] = Math.abs(val[i]);
66    }
67    return absArr;
68  }
69  return Math.abs(val);
70};
71var defaultCurveSegments = 150;
72var degToRads = Math.PI / 180;
73var roundCorner = 0.5519;
74
75function roundValues(flag) {
76  if (flag) {
77    bmRnd = Math.round;
78  } else {
79    bmRnd = function (val) {
80      return val;
81    };
82  }
83}
84roundValues(false);
85
86function styleDiv(element) {
87  element.style.position = 'absolute';
88  element.style.top = 0;
89  element.style.left = 0;
90  element.style.display = 'block';
91  element.style.transformOrigin = '0 0';
92  element.style.webkitTransformOrigin = '0 0';
93  element.style.backfaceVisibility = 'visible';
94  element.style.webkitBackfaceVisibility = 'visible';
95  element.style.transformStyle = 'preserve-3d';
96  element.style.webkitTransformStyle = 'preserve-3d';
97  element.style.mozTransformStyle = 'preserve-3d';
98}
99
100function BMEnterFrameEvent(type, currentTime, totalTime, frameMultiplier) {
101  this.type = type;
102  this.currentTime = currentTime;
103  this.totalTime = totalTime;
104  this.direction = frameMultiplier < 0 ? -1 : 1;
105}
106
107function BMCompleteEvent(type, frameMultiplier) {
108  this.type = type;
109  this.direction = frameMultiplier < 0 ? -1 : 1;
110}
111
112function BMCompleteLoopEvent(type, totalLoops, currentLoop, frameMultiplier) {
113  this.type = type;
114  this.currentLoop = currentLoop;
115  this.totalLoops = totalLoops;
116  this.direction = frameMultiplier < 0 ? -1 : 1;
117}
118
119function BMSegmentStartEvent(type, firstFrame, totalFrames) {
120  this.type = type;
121  this.firstFrame = firstFrame;
122  this.totalFrames = totalFrames;
123}
124
125function BMDestroyEvent(type, target) {
126  this.type = type;
127  this.target = target;
128}
129
130function BMRenderFrameErrorEvent(nativeError, currentTime) {
131  this.type = 'renderFrameError';
132  this.nativeError = nativeError;
133  this.currentTime = currentTime;
134}
135
136function BMConfigErrorEvent(nativeError) {
137  this.type = 'configError';
138  this.nativeError = nativeError;
139}
140
141function BMAnimationConfigErrorEvent(type, nativeError) {
142  this.type = type;
143  this.nativeError = nativeError;
144}
145
146var createElementID = (function () {
147  var _count = 0;
148  return function createID() {
149    _count += 1;
150    return idPrefix + '__lottie_element_' + _count;
151  };
152}());
153
154function HSVtoRGB(h, s, v) {
155  var r;
156  var g;
157  var b;
158  var i;
159  var f;
160  var p;
161  var q;
162  var t;
163  i = Math.floor(h * 6);
164  f = h * 6 - i;
165  p = v * (1 - s);
166  q = v * (1 - f * s);
167  t = v * (1 - (1 - f) * s);
168  switch (i % 6) {
169    case 0: r = v; g = t; b = p; break;
170    case 1: r = q; g = v; b = p; break;
171    case 2: r = p; g = v; b = t; break;
172    case 3: r = p; g = q; b = v; break;
173    case 4: r = t; g = p; b = v; break;
174    case 5: r = v; g = p; b = q; break;
175    default: break;
176  }
177  return [r,
178    g,
179    b];
180}
181
182function RGBtoHSV(r, g, b) {
183  var max = Math.max(r, g, b);
184  var min = Math.min(r, g, b);
185  var d = max - min;
186  var h;
187  var s = (max === 0 ? 0 : d / max);

188  var v = max / 255;
189
190  switch (max) {
191    case min: h = 0; break;
192    case r: h = (g - b) + d * (g < b ? 6 : 0); h /= 6 * d; break;
193    case g: h = (b - r) + d * 2; h /= 6 * d; break;
194    case b: h = (r - g) + d * 4; h /= 6 * d; break;
195    default: break;
196  }
197
198  return [
199    h,
200    s,
201    v,
202  ];
203}
204
205function addSaturationToRGB(color, offset) {
206  var hsv = RGBtoHSV(color[0] * 255, color[1] * 255, color[2] * 255);
207  hsv[1] += offset;
208  if (hsv[1] > 1) {
209    hsv[1] = 1;
210  } else if (hsv[1] <= 0) {
211    hsv[1] = 0;
212  }
213  return HSVtoRGB(hsv[0], hsv[1], hsv[2]);
214}
215
216function addBrightnessToRGB(color, offset) {
217  var hsv = RGBtoHSV(color[0] * 255, color[1] * 255, color[2] * 255);
218  hsv[2] += offset;
219  if (hsv[2] > 1) {
220    hsv[2] = 1;
221  } else if (hsv[2] < 0) {
222    hsv[2] = 0;
223  }
224  return HSVtoRGB(hsv[0], hsv[1], hsv[2]);
225}
226
227function addHueToRGB(color, offset) {
228  var hsv = RGBtoHSV(color[0] * 255, color[1] * 255, color[2] * 255);
229  hsv[0] += offset / 360;
230  if (hsv[0] > 1) {
231    hsv[0] -= 1;
232  } else if (hsv[0] < 0) {
233    hsv[0] += 1;
234  }
235  return HSVtoRGB(hsv[0], hsv[1], hsv[2]);
236}
237
238var rgbToHex = (function () {
239  var colorMap = [];
240  var i;
241  var hex;
242  for (i = 0; i < 256; i += 1) {
243    hex = i.toString(16);
244    colorMap[i] = hex.length === 1 ? '0' + hex : hex;
245  }
246
247  return function (r, g, b) {
248    if (r < 0) {
249      r = 0;
250    }
251    if (g < 0) {
252      g = 0;
253    }
254    if (b < 0) {
255      b = 0;
256    }
257    return '#' + colorMap[r] + colorMap[g] + colorMap[b];
258  };
259}());
260
261function BaseEvent() {}
262BaseEvent.prototype = {
263  triggerEvent: function (eventName, args) {
264    if (this._cbs[eventName]) {
265      var callbacks = this._cbs[eventName];
266      for (var i = 0; i < callbacks.length; i += 1) {
267        callbacks[i](args);
268      }
269    }
270  },
271  addEventListener: function (eventName, callback) {
272    if (!this._cbs[eventName]) {
273      this._cbs[eventName] = [];
274    }
275    this._cbs[eventName].push(callback);
276
277    return function () {
278      this.removeEventListener(eventName, callback);
279    }.bind(this);
280  },
281  removeEventListener: function (eventName, callback) {
282    if (!callback) {
283      this._cbs[eventName] = null;
284    } else if (this._cbs[eventName]) {
285      var i = 0;
286      var len = this._cbs[eventName].length;
287      while (i < len) {
288        if (this._cbs[eventName][i] === callback) {
289          this._cbs[eventName].splice(i, 1);
290          i -= 1;
291          len -= 1;
292        }
293        i += 1;
294      }
295      if (!this._cbs[eventName].length) {
296        this._cbs[eventName] = null;
297      }
298    }
299  },
300};
301
302/* exported createTypedArray, createSizedArray */
303
304var createTypedArray = (function () {
305  function createRegularArray(type, len) {
306    var i = 0;
307    var arr = [];
308    var value;
309    switch (type) {
310      case 'int16':
311      case 'uint8c':
312        value = 1;
313        break;
314      default:
315        value = 1.1;
316        break;
317    }
318    for (i = 0; i < len; i += 1) {
319      arr.push(value);
320    }
321    return arr;
322  }
323  function createTypedArrayFactory(type, len) {
324    if (type === 'float32') {
325      return new Float32Array(len);
326    } if (type === 'int16') {
327      return new Int16Array(len);
328    } if (type === 'uint8c') {
329      return new Uint8ClampedArray(len);
330    }
331    return createRegularArray(type, len);
332  }
333  if (typeof Uint8ClampedArray === 'function' && typeof Float32Array === 'function') {
334    return createTypedArrayFactory;
335  }
336  return createRegularArray;
337}());
338
339function createSizedArray(len) {
340  return Array.apply(null, { length: len });
341}
342
343/* global svgNS */
344/* exported createNS */
345
346function createNS(type) {
347  // return {appendChild:function(){},setAttribute:function(){},style:{}}
348  return document.createElementNS(svgNS, type);
349}
350
351/* exported createTag */
352
353function createTag(type) {
354  // return {appendChild:function(){},setAttribute:function(){},style:{}}
355  return document.createElement(type);
356}
357
358function DynamicPropertyContainer() {}
359DynamicPropertyContainer.prototype = {
360  addDynamicProperty: function (prop) {
361    if (this.dynamicProperties.indexOf(prop) === -1) {
362      this.dynamicProperties.push(prop);
363      this.container.addDynamicProperty(this);
364      this._isAnimated = true;
365    }
366  },
367  iterateDynamicProperties: function () {
368    this._mdf = false;

369    var i;
370    var len = this.dynamicProperties.length;
371    for (i = 0; i < len; i += 1) {
372      this.dynamicProperties[i].getValue();
373      if (this.dynamicProperties[i]._mdf) {
374        this._mdf = true;
375      }
376    }
377  },
378  initDynamicPropertyContainer: function (container) {
379    this.container = container;
380    this.dynamicProperties = [];
381    this._mdf = false;
382    this._isAnimated = false;
383  },
384};
385
386/* exported getBlendMode */
387
388var getBlendMode = (function () {
389  var blendModeEnums = {
390    0: 'source-over',
391    1: 'multiply',
392    2: 'screen',
393    3: 'overlay',
394    4: 'darken',
395    5: 'lighten',
396    6: 'color-dodge',
397    7: 'color-burn',
398    8: 'hard-light',
399    9: 'soft-light',
400    10: 'difference',
401    11: 'exclusion',
402    12: 'hue',
403    13: 'saturation',
404    14: 'color',
405    15: 'luminosity',
406  };
407
408  return function (mode) {
409    return blendModeEnums[mode] || '';
410  };
411}());
412
413/* exported lineCapEnum, lineJoinEnum */
414
415var lineCapEnum = {
416  1: 'butt',
417  2: 'round',
418  3: 'square',
419};
420
421var lineJoinEnum = {
422  1: 'miter',
423  2: 'round',
424  3: 'bevel',
425};
426
427/* global createTypedArray */
428
429/*!
430 Transformation Matrix v2.0
431 (c) Epistemex 2014-2015
432 www.epistemex.com
433 By Ken Fyrstenberg
434 Contributions by leeoniya.
435 License: MIT, header required.
436 */
437
438/**
439 * 2D transformation matrix object initialized with identity matrix.
440 *
441 * The matrix can synchronize a canvas context by supplying the context
442 * as an argument, or later apply current absolute transform to an
443 * existing context.
444 *
445 * All values are handled as floating point values.
446 *
447 * @param {CanvasRenderingContext2D} [context] - Optional context to sync with Matrix
448 * @prop {number} a - scale x
449 * @prop {number} b - shear y
450 * @prop {number} c - shear x
451 * @prop {number} d - scale y
452 * @prop {number} e - translate x
453 * @prop {number} f - translate y
454 * @prop {CanvasRenderingContext2D|null} [context=null] - set or get current canvas context
455 * @constructor
456 */
457
458var Matrix = (function () {
459  var _cos = Math.cos;
460  var _sin = Math.sin;
461  var _tan = Math.tan;
462  var _rnd = Math.round;
463
464  function reset() {
465    this.props[0] = 1;
466    this.props[1] = 0;
467    this.props[2] = 0;
468    this.props[3] = 0;
469    this.props[4] = 0;
470    this.props[5] = 1;
471    this.props[6] = 0;
472    this.props[7] = 0;
473    this.props[8] = 0;
474    this.props[9] = 0;
475    this.props[10] = 1;
476    this.props[11] = 0;
477    this.props[12] = 0;
478    this.props[13] = 0;
479    this.props[14] = 0;
480    this.props[15] = 1;
481    return this;
482  }
483
484  function rotate(angle) {
485    if (angle === 0) {
486      return this;
487    }
488    var mCos = _cos(angle);
489    var mSin = _sin(angle);
490    return this._t(mCos, -mSin, 0, 0, mSin, mCos, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
491  }
492
493  function rotateX(angle) {
494    if (angle === 0) {
495      return this;
496    }
497    var mCos = _cos(angle);
498    var mSin = _sin(angle);
499    return this._t(1, 0, 0, 0, 0, mCos, -mSin, 0, 0, mSin, mCos, 0, 0, 0, 0, 1);
500  }
501
502  function rotateY(angle) {
503    if (angle === 0) {
504      return this;
505    }
506    var mCos = _cos(angle);
507    var mSin = _sin(angle);
508    return this._t(mCos, 0, mSin, 0, 0, 1, 0, 0, -mSin, 0, mCos, 0, 0, 0, 0, 1);
509  }
510
511  function rotateZ(angle) {
512    if (angle === 0) {
513      return this;
514    }
515    var mCos = _cos(angle);
516    var mSin = _sin(angle);
517    return this._t(mCos, -mSin, 0, 0, mSin, mCos, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
518  }
519
520  function shear(sx, sy) {
521    return this._t(1, sy, sx, 1, 0, 0);
522  }
523
524  function skew(ax, ay) {
525    return this.shear(_tan(ax), _tan(ay));
526  }
527
528  function skewFromAxis(ax, angle) {
529    var mCos = _cos(angle);
530    var mSin = _sin(angle);
531    return this._t(mCos, mSin, 0, 0, -mSin, mCos, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
532      ._t(1, 0, 0, 0, _tan(ax), 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
533      ._t(mCos, -mSin, 0, 0, mSin, mCos, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
534    // return this._t(mCos, mSin, -mSin, mCos, 0, 0)._t(1, 0, _tan(ax), 1, 0, 0)._t(mCos, -mSin, mSin, mCos, 0, 0);
535  }
536
537  function scale(sx, sy, sz) {
538    if (!sz && sz !== 0) {
539      sz = 1;
540    }
541    if (sx === 1 && sy === 1 && sz === 1) {
542      return this;
543    }
544    return this._t(sx, 0, 0, 0, 0, sy, 0, 0, 0, 0, sz, 0, 0, 0, 0, 1);
545  }
546
547  function setTransform(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {
548    this.props[0] = a;
549    this.props[1] = b;
550    this.props[2] = c;
551    this.props[3] = d;
552    this.props[4] = e;
553    this.props[5] = f;
554    this.props[6] = g;
555    this.props[7] = h;
556    this.props[8] = i;
557    this.props[9] = j;
558    this.props[10] = k;
559    this.props[11] = l;
560    this.props[12] = m;
561    this.props[13] = n;
562    this.props[14] = o;
563    this.props[15] = p;
564    return this;
565  }
566
567  function translate(tx, ty, tz) {
568    tz = tz || 0;
569    if (tx !== 0 || ty !== 0 || tz !== 0) {
570      return this._t(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, tx, ty, tz, 1);
571    }
572    return this;
573  }
574
575  function transform(a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2) {
576    var _p = this.props;
577
578    if (a2 === 1 && b2 === 0 && c2 === 0 && d2 === 0 && e2 === 0 && f2 === 1 && g2 === 0 && h2 === 0 && i2 === 0 && j2 === 0 && k2 === 1 && l2 === 0) {
579      // NOTE: commenting this condition because TurboFan deoptimizes code when present
580      // if(m2 !== 0 || n2 !== 0 || o2 !== 0){
581      _p[12] = _p[12] * a2 + _p[15] * m2;
582      _p[13] = _p[13] * f2 + _p[15] * n2;
583      _p[14] = _p[14] * k2 + _p[15] * o2;
584      _p[15] *= p2;
585      // }
586      this._identityCalculated = false;
587      return this;
588    }
589
590    var a1 = _p[0];
591    var b1 = _p[1];
592    var c1 = _p[2];
593    var d1 = _p[3];
594    var e1 = _p[4];
595    var f1 = _p[5];
596    var g1 = _p[6];
597    var h1 = _p[7];
598    var i1 = _p[8];
599    var j1 = _p[9];
600    var k1 = _p[10];
601    var l1 = _p[11];
602    var m1 = _p[12];
603    var n1 = _p[13];
604    var o1 = _p[14];
605    var p1 = _p[15];
606
607    /* matrix order (canvas compatible):
608         * ace
609         * bdf
610         * 001
611         */
612    _p[0] = a1 * a2 + b1 * e2 + c1 * i2 + d1 * m2;
613    _p[1] = a1 * b2 + b1 * f2 + c1 * j2 + d1 * n2;
614    _p[2] = a1 * c2 + b1 * g2 + c1 * k2 + d1 * o2;
615    _p[3] = a1 * d2 + b1 * h2 + c1 * l2 + d1 * p2;
616
617    _p[4] = e1 * a2 + f1 * e2 + g1 * i2 + h1 * m2;
618    _p[5] = e1 * b2 + f1 * f2 + g1 * j2 + h1 * n2;
619    _p[6] = e1 * c2 + f1 * g2 + g1 * k2 + h1 * o2;
620    _p[7] = e1 * d2 + f1 * h2 + g1 * l2 + h1 * p2;
621
622    _p[8] = i1 * a2 + j1 * e2 + k1 * i2 + l1 * m2;
623    _p[9] = i1 * b2 + j1 * f2 + k1 * j2 + l1 * n2;
624    _p[10] = i1 * c2 + j1 * g2 + k1 * k2 + l1 * o2;
625    _p[11] = i1 * d2 + j1 * h2 + k1 * l2 + l1 * p2;
626
627    _p[12] = m1 * a2 + n1 * e2 + o1 * i2 + p1 * m2;
628    _p[13] = m1 * b2 + n1 * f2 + o1 * j2 + p1 * n2;
629    _p[14] = m1 * c2 + n1 * g2 + o1 * k2 + p1 * o2;
630    _p[15] = m1 * d2 + n1 * h2 + o1 * l2 + p1 * p2;
631
632    this._identityCalculated = false;
633    return this;
634  }
635
636  function isIdentity() {
637    if (!this._identityCalculated) {
638      this._identity = !(this.props[0] !== 1 || this.props[1] !== 0 || this.props[2] !== 0 || this.props[3] !== 0 || this.props[4] !== 0 || this.props[5] !== 1 || this.props[6] !== 0 || this.props[7] !== 0 || this.props[8] !== 0 || this.props[9] !== 0 || this.props[10] !== 1 || this.props[11] !== 0 || this.props[12] !== 0 || this.props[13] !== 0 || this.props[14] !== 0 || this.props[15] !== 1);
639      this._identityCalculated = true;
640    }
641    return this._identity;
642  }
643
644  function equals(matr) {
645    var i = 0;
646    while (i < 16) {
647      if (matr.props[i] !== this.props[i]) {
648        return false;
649      }
650      i += 1;
651    }
652    return true;
653  }
654
655  function clone(matr) {
656    var i;
657    for (i = 0; i < 16; i += 1) {
658      matr.props[i] = this.props[i];
659    }
660    return matr;
661  }
662
663  function cloneFromProps(props) {
664    var i;
665    for (i = 0; i < 16; i += 1) {
666      this.props[i] = props[i];
667    }
668  }
669
670  function applyToPoint(x, y, z) {
671    return {
672      x: x * this.props[0] + y * this.props[4] + z * this.props[8] + this.props[12],
673      y: x * this.props[1] + y * this.props[5] + z * this.props[9] + this.props[13],
674      z: x * this.props[2] + y * this.props[6] + z * this.props[10] + this.props[14],
675    };
676    /* return {
677         x: x * me.a + y * me.c + me.e,
678         y: x * me.b + y * me.d + me.f
679         }; */
680  }
681  function applyToX(x, y, z) {
682    return x * this.props[0] + y * this.props[4] + z * this.props[8] + this.props[12];
683  }
684  function applyToY(x, y, z) {
685    return x * this.props[1] + y * this.props[5] + z * this.props[9] + this.props[13];
686  }
687  function applyToZ(x, y, z) {
688    return x * this.props[2] + y * this.props[6] + z * this.props[10] + this.props[14];
689  }
690
691  function getInverseMatrix() {
692    var determinant = this.props[0] * this.props[5] - this.props[1] * this.props[4];
693    var a = this.props[5] / determinant;
694    var b = -this.props[1] / determinant;
695    var c = -this.props[4] / determinant;
696    var d = this.props[0] / determinant;
697    var e = (this.props[4] * this.props[13] - this.props[5] * this.props[12]) / determinant;
698    var f = -(this.props[0] * this.props[13] - this.props[1] * this.props[12]) / determinant;
699    var inverseMatrix = new Matrix();
700    inverseMatrix.props[0] = a;
701    inverseMatrix.props[1] = b;
702    inverseMatrix.props[4] = c;
703    inverseMatrix.props[5] = d;
704    inverseMatrix.props[12] = e;
705    inverseMatrix.props[13] = f;
706    return inverseMatrix;
707  }
708
709  function inversePoint(pt) {
710    var inverseMatrix = this.getInverseMatrix();
711    return inverseMatrix.applyToPointArray(pt[0], pt[1], pt[2] || 0);
712  }
713
714  function inversePoints(pts) {
715    var i;
716    var len = pts.length;
717    var retPts = [];
718    for (i = 0; i < len; i += 1) {
719      retPts[i] = inversePoint(pts[i]);
720    }
721    return retPts;
722  }
723
724  function applyToTriplePoints(pt1, pt2, pt3) {
725    var arr = createTypedArray('float32', 6);
726    if (this.isIdentity()) {
727      arr[0] = pt1[0];
728      arr[1] = pt1[1];
729      arr[2] = pt2[0];
730      arr[3] = pt2[1];
731      arr[4] = pt3[0];
732      arr[5] = pt3[1];
733    } else {
734      var p0 = this.props[0];
735      var p1 = this.props[1];
736      var p4 = this.props[4];
737      var p5 = this.props[5];
738      var p12 = this.props[12];
739      var p13 = this.props[13];
740      arr[0] = pt1[0] * p0 + pt1[1] * p4 + p12;
741      arr[1] = pt1[0] * p1 + pt1[1] * p5 + p13;
742      arr[2] = pt2[0] * p0 + pt2[1] * p4 + p12;
743      arr[3] = pt2[0] * p1 + pt2[1] * p5 + p13;
744      arr[4] = pt3[0] * p0 + pt3[1] * p4 + p12;
745      arr[5] = pt3[0] * p1 + pt3[1] * p5 + p13;
746    }
747    return arr;
748  }
749
750  function applyToPointArray(x, y, z) {
751    var arr;
752    if (this.isIdentity()) {
753      arr = [x, y, z];
754    } else {
755      arr = [
756        x * this.props[0] + y * this.props[4] + z * this.props[8] + this.props[12],
757        x * this.props[1] + y * this.props[5] + z * this.props[9] + this.props[13],
758        x * this.props[2] + y * this.props[6] + z * this.props[10] + this.props[14],
759      ];
760    }
761    return arr;
762  }
763
764  function applyToPointStringified(x, y) {
765    if (this.isIdentity()) {
766      return x + ',' + y;
767    }
768    var _p = this.props;
769    return Math.round((x * _p[0] + y * _p[4] + _p[12]) * 100) / 100 + ',' + Math.round((x * _p[1] + y * _p[5] + _p[13]) * 100) / 100;
770  }
771
772  function toCSS() {
773    // Doesn't make much sense to add this optimization. If it is an identity matrix, it's very likely this will get called only once since it won't be keyframed.
774    /* if(this.isIdentity()) {
775            return '';
776        } */
777    var i = 0;
778    var props = this.props;
779    var cssValue = 'matrix3d(';
780    var v = 10000;
781    while (i < 16) {
782      cssValue += _rnd(props[i] * v) / v;
783      cssValue += i === 15 ? ')' : ',';
784      i += 1;
785    }
786    return cssValue;
787  }
788
789  function roundMatrixProperty(val) {
790    var v = 10000;
791    if ((val < 0.000001 && val > 0) || (val > -0.000001 && val < 0)) {

875(pool, math) {
876//
877// The following constants are related to IEEE 754 limits.
878//
879    var global = this,
880        width = 256,        // each RC4 output is 0 <= x < 256
881        chunks = 6,         // at least six RC4 outputs for each double
882        digits = 52,        // there are 52 significant digits in a double
883        rngname = 'random', // rngname: name for Math.random and Math.seedrandom
884        startdenom = math.pow(width, chunks),
885        significance = math.pow(2, digits),
886        overflow = significance * 2,
887        mask = width - 1,
888        nodecrypto;         // node.js crypto module, initialized at the bottom.
889
890//
891// seedrandom()
892// This is the seedrandom function described above.
893//
894    function seedrandom(seed, options, callback) {
895        var key = [];
896        options = (options === true) ? { entropy: true } : (options || {});
897
898        // Flatten the seed string or build one from local entropy if needed.
899        var shortseed = mixkey(flatten(
900            options.entropy ? [seed, tostring(pool)] :
901                (seed === null) ? autoseed() : seed, 3), key);
902
903        // Use the seed to initialize an ARC4 generator.
904        var arc4 = new ARC4(key);
905
906        // This function returns a random double in [0, 1) that contains
907        // randomness in every bit of the mantissa of the IEEE 754 value.
908        var prng = function() {
909            var n = arc4.g(chunks),             // Start with a numerator n < 2 ^ 48
910                d = startdenom,                 //   and denominator d = 2 ^ 48.
911                x = 0;                          //   and no 'extra last byte'.
912            while (n < significance) {          // Fill up all significant digits by
913                n = (n + x) * width;              //   shifting numerator and
914                d *= width;                       //   denominator and generating a
915                x = arc4.g(1);                    //   new least-significant-byte.
916            }
917            while (n >= overflow) {             // To avoid rounding up, before adding
918                n /= 2;                           //   last byte, shift everything
919                d /= 2;                           //   right using integer math until
920                x >>>= 1;                         //   we have exactly the desired bits.
921            }
922            return (n + x) / d;                 // Form the number within [0, 1).
923        };
924
925        prng.int32 = function() { return arc4.g(4) | 0; };
926        prng.quick = function() { return arc4.g(4) / 0x100000000; };
927        prng.double = prng;
928
929        // Mix the randomness into accumulated entropy.
930        mixkey(tostring(arc4.S), pool);
931
932        // Calling convention: what to return as a function of prng, seed, is_math.
933        return (options.pass || callback ||
934        function(prng, seed, is_math_call, state) {
935            if (state) {
936                // Load the arc4 state from the given state if it has an S array.
937                if (state.S) { copy(state, arc4); }
938                // Only provide the .state method if requested via options.state.
939                prng.state = function() { return copy(arc4, {}); };
940            }
941
942            // If called as a method of Math (Math.seedrandom()), mutate
943            // Math.random because that is how seedrandom.js has worked since v1.0.
944            if (is_math_call) { math[rngname] = prng; return seed; }
945
946            // Otherwise, it is a newer calling convention, so return the
947            // prng directly.
948            else return prng;
949        })(
950            prng,
951            shortseed,
952            'global' in options ? options.global : (this == math),
953            options.state);
954    }
955    math['seed' + rngname] = seedrandom;
956
957//
958// ARC4
959//
960// An ARC4 implementation.  The constructor takes a key in the form of
961// an array of at most (width) integers that should be 0 <= x < (width).
962//
963// The g(count) method returns a pseudorandom integer that concatenates
964// the next (count) outputs from ARC4.  Its return value is a number x
965// that is in the range 0 <= x < (width ^ count).
966//
967    function ARC4(key) {
968        var t, keylen = key.length,
969            me = this, i = 0, j = me.i = me.j = 0, s = me.S = [];
970
971        // The empty key [] is treated as [0].
972        if (!keylen) { key = [keylen++]; }
973
974        // Set up S using the standard key scheduling algorithm.
975        while (i < width) {
976            s[i] = i++;
977        }
978        for (i = 0; i < width; i++) {
979            s[i] = s[j = mask & (j + key[i % keylen] + (t = s[i]))];
980            s[j] = t;
981        }
982
983        // The "g" method returns the next (count) outputs as one number.
984        me.g = function(count) {
985            // Using instance members instead of closure state nearly doubles speed.
986            var t, r = 0,
987                i = me.i, j = me.j, s = me.S;
988            while (count--) {
989                t = s[i = mask & (i + 1)];
990                r = r * width + s[mask & ((s[i] = s[j = mask & (j + t)]) + (s[j] = t))];
991            }
992            me.i = i; me.j = j;
993            return r;
994            // For robust unpredictability, the function call below automatically
995            // discards an initial batch of values.  This is called RC4-drop[256].
996            // See http://google.com/search?q=rsa+fluhrer+response&btnI
997        };
998    }
999
1000//
1001// copy()
1002// Copies internal state of ARC4 to or from a plain object.
1003//
1004    function copy(f, t) {
1005        t.i = f.i;
1006        t.j = f.j;
1007        t.S = f.S.slice();
1008        return t;
1009    }
1010
1011//
1012// flatten()
1013// Converts an object tree to nested arrays of strings.
1014//
1015    function flatten(obj, depth) {
1016        var result = [], typ = (typeof obj), prop;
1017        if (depth && typ == 'object') {
1018            for (prop in obj) {
1019                try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}
1020            }
1021        }
1022        return (result.length ? result : typ == 'string' ? obj : obj + '\0');
1023    }
1024
1025//
1026// mixkey()
1027// Mixes a string seed into a key that is an array of integers, and
1028// returns a shortened string seed that is equivalent to the result key.
1029//
1030    function mixkey(seed, key) {
1031        var stringseed = seed + '', smear, j = 0;
1032        while (j < stringseed.length) {
1033            key[mask & j] =
1034                mask & ((smear ^= key[mask & j] * 19) + stringseed.charCodeAt(j++));
1035        }
1036        return tostring(key);
1037    }
1038
1039//
1040// autoseed()
1041// Returns an object for autoseeding, using window.crypto and Node crypto
1042// module if available.
1043//
1044    function autoseed() {
1045        try {
1046            if (nodecrypto) { return tostring(nodecrypto.randomBytes(width)); }
1047            var out = new Uint8Array(width);
1048            (global.crypto || global.msCrypto).getRandomValues(out);
1049            return tostring(out);
1050        } catch (e) {
1051            var browser = global.navigator,
1052                plugins = browser && browser.plugins;
1053            return [+new Date(), global, plugins, global.screen, tostring(pool)];
1054        }
1055    }
1056
1057//
1058// tostring()
1059// Converts an array of charcodes to a string
1060//
1061    function tostring(a) {
1062        return String.fromCharCode.apply(0, a);
1063    }
1064
1065//
1066// When seedrandom.js is loaded, we immediately mix a few bits
1067// from the built-in RNG into the entropy pool.  Because we do
1068// not want to interfere with deterministic PRNG state later,
1069// seedrandom will not call math.random on its own again after
1070// initialization.
1071//
1072    mixkey(math.random(), pool);
1073
1074//
1075// Nodejs and AMD support: export the implementation as a module using
1076// either convention.
1077//
1078
1079// End anonymous scope, and pass initial values.
1080}

1080)(
1081    [],     // pool: entropy pool starts empty
1082    BMMath    // math: package containing random, pow, and seedrandom
1083);
1084/* eslint-disable */
1085var BezierFactory = (function () {
1086  /**
1087     * BezierEasing - use bezier curve for transition easing function
1088     * by Gaëtan Renaudeau 2014 - 2015 – MIT License
1089     *
1090     * Credits: is based on Firefox's nsSMILKeySpline.cpp
1091     * Usage:
1092     * var spline = BezierEasing([ 0.25, 0.1, 0.25, 1.0 ])
1093     * spline.get(x) => returns the easing value | x must be in [0, 1] range
1094     *
1095     */
1096
1097  var ob = {};
1098  ob.getBezierEasing = getBezierEasing;
1099  var beziers = {};
1100
1101  function getBezierEasing(a, b, c, d, nm) {
1102    var str = nm || ('bez_' + a + '_' + b + '_' + c + '_' + d).replace(/\./g, 'p');
1103    if (beziers[str]) {
1104      return beziers[str];
1105    }
1106    var bezEasing = new BezierEasing([a, b, c, d]);
1107    beziers[str] = bezEasing;
1108    return bezEasing;
1109  }
1110
1111  // These values are established by empiricism with tests (tradeoff: performance VS precision)
1112  var NEWTON_ITERATIONS = 4;
1113  var NEWTON_MIN_SLOPE = 0.001;
1114  var SUBDIVISION_PRECISION = 0.0000001;
1115  var SUBDIVISION_MAX_ITERATIONS = 10;
1116
1117  var kSplineTableSize = 11;
1118  var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
1119
1120  var float32ArraySupported = typeof Float32Array === 'function';
1121
1122  function A(aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }
1123  function B(aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }
1124  function C(aA1) { return 3.0 * aA1; }
1125
1126  // Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
1127  function calcBezier(aT, aA1, aA2) {
1128    return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
1129  }
1130
1131  // Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
1132  function getSlope(aT, aA1, aA2) {
1133    return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
1134  }
1135
1136  function binarySubdivide(aX, aA, aB, mX1, mX2) {
1137    var currentX,
1138      currentT,
1139      i = 0;
1140    do {
1141      currentT = aA + (aB - aA) / 2.0;
1142      currentX = calcBezier(currentT, mX1, mX2) - aX;
1143      if (currentX > 0.0) {
1144        aB = currentT;
1145      } else {
1146        aA = currentT;
1147      }
1148    } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
1149    return currentT;
1150  }
1151
1152  function newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {
1153    for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
1154      var currentSlope = getSlope(aGuessT, mX1, mX2);
1155      if (currentSlope === 0.0) return aGuessT;
1156      var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
1157      aGuessT -= currentX / currentSlope;
1158    }
1159    return aGuessT;
1160  }
1161
1162  /**
1163     * points is an array of [ mX1, mY1, mX2, mY2 ]
1164     */
1165  function BezierEasing(points) {
1166    this._p = points;
1167    this._mSampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
1168    this._precomputed = false;
1169
1170    this.get = this.get.bind(this);
1171  }
1172
1173  BezierEasing.prototype = {
1174
1175    get: function (x) {
1176      var mX1 = this._p[0],
1177        mY1 = this._p[1],
1178        mX2 = this._p[2],
1179        mY2 = this._p[3];
1180      if (!this._precomputed) this._precompute();
1181      if (mX1 === mY1 && mX2 === mY2) return x; // linear
1182      // Because JavaScript number are imprecise, we should guarantee the extremes are right.
1183      if (x === 0) return 0;
1184      if (x === 1) return 1;
1185      return calcBezier(this._getTForX(x), mY1, mY2);
1186    },
1187
1188    // Private part
1189
1190    _precompute: function () {
1191      var mX1 = this._p[0],
1192        mY1 = this._p[1],
1193        mX2 = this._p[2],
1194        mY2 = this._p[3];
1195      this._precomputed = true;
1196      if (mX1 !== mY1 || mX2 !== mY2) { this._calcSampleValues(); }
1197    },
1198
1199    _calcSampleValues: function () {
1200      var mX1 = this._p[0],
1201        mX2 = this._p[2];
1202      for (var i = 0; i < kSplineTableSize; ++i) {
1203        this._mSampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
1204      }
1205    },
1206
1207    /**
1208         * getTForX chose the fastest heuristic to determine the percentage value precisely from a given X projection.
1209         */
1210    _getTForX: function (aX) {
1211      var mX1 = this._p[0],
1212        mX2 = this._p[2],
1213        mSampleValues = this._mSampleValues;
1214
1215      var intervalStart = 0.0;
1216      var currentSample = 1;
1217      var lastSample = kSplineTableSize - 1;
1218
1219      for (; currentSample !== lastSample && mSampleValues[currentSample] <= aX; ++currentSample) {
1220        intervalStart += kSampleStepSize;
1221      }
1222      --currentSample;
1223
1224      // Interpolate to provide an initial guess for t
1225      var dist = (aX - mSampleValues[currentSample]) / (mSampleValues[currentSample + 1] - mSampleValues[currentSample]);
1226      var guessForT = intervalStart + dist * kSampleStepSize;
1227
1228      var initialSlope = getSlope(guessForT, mX1, mX2);
1229      if (initialSlope >= NEWTON_MIN_SLOPE) {
1230        return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
1231      } if (initialSlope === 0.0) {
1232        return guessForT;
1233      }
1234      return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
1235    },
1236  };
1237
1238  return ob;
1239}());
1240
1241(function () {
1242  var lastTime = 0;
1243  var vendors = ['ms', 'moz', 'webkit', 'o'];
1244  for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) { // eslint-disable-line no-plusplus
1245    window.requestAnimationFrame = window[vendors[x] + 'RequestAnimationFrame'];
1246    window.cancelAnimationFrame = window[vendors[x] + 'CancelAnimationFrame'] || window[vendors[x] + 'CancelRequestAnimationFrame'];
1247  }
1248  if (!window.requestAnimationFrame) {
1249    window.requestAnimationFrame = function (callback) {
1250      var currTime = new Date().getTime();
1251      var timeToCall = Math.max(0, 16 - (currTime - lastTime));
1252      var id = setTimeout(function () {
1253        callback(currTime + timeToCall);
1254      },
1255      timeToCall);
1256      lastTime = currTime + timeToCall;
1257      return id;
1258    };
1259  }
1260  if (!window.cancelAnimationFrame) {
1261    window.cancelAnimationFrame = function (id) {
1262      clearTimeout(id);
1263    };
1264  }
1265}());
1266
1267/* exported extendPrototype, getDescriptor, createProxyFunction */
1268
1269function extendPrototype(sources, destination) {
1270  var i;
1271  var len = sources.length;
1272  var sourcePrototype;
1273  for (i = 0; i < len; i += 1) {
1274    sourcePrototype = sources[i].prototype;
1275    for (var attr in sourcePrototype) {
1276      if (Object.prototype.hasOwnProperty.call(sourcePrototype, attr)) destination.prototype[attr] = sourcePrototype[attr];
1277    }
1278  }
1279}
1280
1281function getDescriptor(object, prop) {
1282  return Object.getOwnPropertyDescriptor(object, prop);
1283}
1284
1285function createProxyFunction(prototype) {
1286  function ProxyFunction() {}
1287  ProxyFunction.prototype = prototype;
1288  return ProxyFunction;
1289}
1290
1291/* global segmentsLengthPool, defaultCurveSegments, createSizedArray, bmPow, bmSqrt, bmFloor, createTypedArray, bezierLengthPool */
1292/* exported bez */
1293
1294function bezFunction() {
1295  var math = Math;
1296
1297  function pointOnLine2D(x1, y1, x2, y2, x3, y3) {
1298    var det1 = (x1 * y2) + (y1 * x3) + (x2 * y3) - (x3 * y2) - (y3 * x1) - (x2 * y1);
1299    return det1 > -0.001 && det1 < 0.001;
1300  }
1301
1302  function pointOnLine3D(x1, y1, z1, x2, y2, z2, x3, y3, z3) {
1303    if (z1 === 0 && z2 === 0 && z3 === 0) {
1304      return pointOnLine2D(x1, y1, x2, y2, x3, y3);
1305    }
1306    var dist1 = math.sqrt(math.pow(x2 - x1, 2) + math.pow(y2 - y1, 2) + math.pow(z2 - z1, 2));
1307    var dist2 = math.sqrt(math.pow(x3 - x1, 2) + math.pow(y3 - y1, 2) + math.pow(z3 - z1, 2));
1308    var dist3 = math.sqrt(math.pow(x3 - x2, 2) + math.pow(y3 - y2, 2) + math.pow(z3 - z2, 2));
1309    var diffDist;
1310    if (dist1 > dist2) {
1311      if (dist1 > dist3) {
1312        diffDist = dist1 - dist2 - dist3;
1313      } else {
1314        diffDist = dist3 - dist2 - dist1;
1315      }
1316    } else if (dist3 > dist2) {
1317      diffDist = dist3 - dist2 - dist1;
1318    } else {
1319      diffDist = dist2 - dist1 - dist3;
1320    }
1321    return diffDist > -0.0001 && diffDist < 0.0001;
1322  }
1323
1324  var getBezierLength = (function () {
1325    return function (pt1, pt2, pt3, pt4) {
1326      var curveSegments = defaultCurveSegments;
1327      var k;
1328      var i;
1329      var len;
1330      var ptCoord;
1331      var perc;
1332      var addedLength = 0;
1333      var ptDistance;
1334      var point = [];
1335      var lastPoint = [];
1336      var lengthData = bezierLengthPool.newElement();
1337      len = pt3.length;
1338      for (k = 0; k < curveSegments; k += 1) {
1339        perc = k / (curveSegments - 1);
1340        ptDistance = 0;
1341        for (i = 0; i < len; i += 1) {
1342          ptCoord = bmPow(1 - perc, 3) * pt1[i] + 3 * bmPow(1 - perc, 2) * perc * pt3[i] + 3 * (1 - perc) * bmPow(perc, 2) * pt4[i] + bmPow(perc, 3) * pt2[i];
1343          point[i] = ptCoord;
1344          if (lastPoint[i] !== null) {
1345            ptDistance += bmPow(point[i] - lastPoint[i], 2);
1346          }
1347          lastPoint[i] = point[i];
1348        }
1349        if (ptDistance) {
1350          ptDistance = bmSqrt(ptDistance);
1351          addedLength += ptDistance;
1352        }
1353        lengthData.percents[k] = perc;
1354        lengthData.lengths[k] = addedLength;
1355      }
1356      lengthData.addedLength = addedLength;
1357      return lengthData;
1358    };
1359  }());
1360
1361  function getSegmentsLength(shapeData) {
1362    var segmentsLength = segmentsLengthPool.newElement();
1363    var closed = shapeData.c;
1364    var pathV = shapeData.v;
1365    var pathO = shapeData.o;
1366    var pathI = shapeData.i;
1367    var i;
1368    var len = shapeData._length;
1369    var lengths = segmentsLength.lengths;
1370    var totalLength = 0;
1371    for (i = 0; i < len - 1; i += 1) {
1372      lengths[i] = getBezierLength(pathV[i], pathV[i + 1], pathO[i], pathI[i + 1]);
1373      totalLength += lengths[i].addedLength;
1374    }
1375    if (closed && len) {
1376      lengths[i] = getBezierLength(pathV[i], pathV[0], pathO[i], pathI[0]);
1377      totalLength += lengths[i].addedLength;
1378    }
1379    segmentsLength.totalLength = totalLength;
1380    return segmentsLength;
1381  }
1382
1383  function BezierData(length) {
1384    this.segmentLength = 0;
1385    this.points = new Array(length);
1386  }
1387
1388  function PointData(partial, point) {
1389    this.partialLength = partial;
1390    this.point = point;
1391  }
1392
1393  var buildBezierData = (function () {
1394    var storedData = {};
1395
1396    return function (pt1, pt2, pt3, pt4) {
1397      var bezierName = (pt1[0] + '_' + pt1[1] + '_' + pt2[0] + '_' + pt2[1] + '_' + pt3[0] + '_' + pt3[1] + '_' + pt4[0] + '_' + pt4[1]).replace(/\./g, 'p');
1398      if (!storedData[bezierName]) {
1399        var curveSegments = defaultCurveSegments;
1400        var k;
1401        var i;
1402        var len;
1403        var ptCoord;
1404        var perc;
1405        var addedLength = 0;
1406        var ptDistance;
1407        var point;
1408        var lastPoint = null;
1409        if (pt1.length === 2 && (pt1[0] !== pt2[0] || pt1[1] !== pt2[1]) && pointOnLine2D(pt1[0], pt1[1], pt2[0], pt2[1], pt1[0] + pt3[0], pt1[1] + pt3[1]) && pointOnLine2D(pt1[0], pt1[1], pt2[0], pt2[1], pt2[0] + pt4[0], pt2[1] + pt4[1])) {
1410          curveSegments = 2;
1411        }
1412        var bezierData = new BezierData(curveSegments);
1413        len = pt3.length;
1414        for (k = 0; k < curveSegments; k += 1) {
1415          point = createSizedArray(len);
1416          perc = k / (curveSegments - 1);
1417          ptDistance = 0;
1418          for (i = 0; i < len; i += 1) {
1419            ptCoord = bmPow(1 - perc, 3) * pt1[i] + 3 * bmPow(1 - perc, 2) * perc * (pt1[i] + pt3[i]) + 3 * (1 - perc) * bmPow(perc, 2) * (pt2[i] + pt4[i]) + bmPow(perc, 3) * pt2[i];
1420            point[i] = ptCoord;
1421            if (lastPoint !== null) {
1422              ptDistance += bmPow(point[i] - lastPoint[i], 2);
1423            }
1424          }
1425          ptDistance = bmSqrt(ptDistance);
1426          addedLength += ptDistance;
1427          bezierData.points[k] = new PointData(ptDistance, point);
1428          lastPoint = point;
1429        }
1430        bezierData.segmentLength = addedLength;
1431        storedData[bezierName] = bezierData;
1432      }
1433      return storedData[bezierName];
1434    };
1435  }());
1436
1437  function getDistancePerc(perc, bezierData) {
1438    var percents = bezierData.percents;
1439    var lengths = bezierData.lengths;
1440    var len = percents.length;
1441    var initPos = bmFloor((len - 1) * perc);
1442    var lengthPos = perc * bezierData.addedLength;
1443    var lPerc = 0;
1444    if (initPos === len - 1 || initPos === 0 || lengthPos === lengths[initPos]) {
1445      return percents[initPos];
1446    }
1447    var dir = lengths[initPos] > lengthPos ? -1 : 1;
1448    var flag = true;
1449    while (flag) {
1450      if (lengths[initPos] <= lengthPos && lengths[initPos + 1] > lengthPos) {
1451        lPerc = (lengthPos - lengths[initPos]) / (lengths[initPos + 1] - lengths[initPos]);
1452        flag = false;
1453      } else {
1454        initPos += dir;
1455      }
1456      if (initPos < 0 || initPos >= len - 1) {
1457        // FIX for TypedArrays that don't store floating point values with enough accuracy
1458        if (initPos === len - 1) {
1459          return percents[initPos];
1460        }
1461        flag = false;
1462      }
1463    }
1464    return percents[initPos] + (percents[initPos + 1] - percents[initPos]) * lPerc;
1465  }
1466
1467  function getPointInSegment(pt1, pt2, pt3, pt4, percent, bezierData) {
1468    var t1 = getDistancePerc(percent, bezierData);
1469    var u1 = 1 - t1;
1470    var ptX = math.round((u1 * u1 * u1 * pt1[0] + (t1 * u1 * u1 + u1 * t1 * u1 + u1 * u1 * t1) * pt3[0] + (t1 * t1 * u1 + u1 * t1 * t1 + t1 * u1 * t1) * pt4[0] + t1 * t1 * t1 * pt2[0]) * 1000) / 1000;
1471    var ptY = math.round((u1 * u1 * u1 * pt1[1] + (t1 * u1 * u1 + u1 * t1 * u1 + u1 * u1 * t1) * pt3[1] + (t1 * t1 * u1 + u1 * t1 * t1 + t1 * u1 * t1) * pt4[1] + t1 * t1 * t1 * pt2[1]) * 1000) / 1000;
1472    return [ptX, ptY];
1473  }
1474
1475  var bezierSegmentPoints = createTypedArray('float32', 8);
1476
1477  function getNewSegment(pt1, pt2, pt3, pt4, startPerc, endPerc, bezierData) {
1478    if (startPerc < 0) {
1479      startPerc = 0;
1480    } else if (startPerc > 1) {
1481      startPerc = 1;
1482    }
1483    var t0 = getDistancePerc(startPerc, bezierData);
1484    endPerc = endPerc > 1 ? 1 : endPerc;
1485    var t1 = getDistancePerc(endPerc, bezierData);
1486    var i;
1487    var len = pt1.length;
1488    var u0 = 1 - t0;
1489    var u1 = 1 - t1;
1490    var u0u0u0 = u0 * u0 * u0;
1491    var t0u0u0_3 = t0 * u0 * u0 * 3; // eslint-disable-line camelcase
1492    var t0t0u0_3 = t0 * t0 * u0 * 3; // eslint-disable-line camelcase
1493    var t0t0t0 = t0 * t0 * t0;
1494    //
1495    var u0u0u1 = u0 * u0 * u1;
1496    var t0u0u1_3 = t0 * u0 * u1 + u0 * t0 * u1 + u0 * u0 * t1; // eslint-disable-line camelcase
1497    var t0t0u1_3 = t0 * t0 * u1 + u0 * t0 * t1 + t0 * u0 * t1; // eslint-disable-line camelcase
1498    var t0t0t1 = t0 * t0 * t1;
1499    //
1500    var u0u1u1 = u0 * u1 * u1;
1501    var t0u1u1_3 = t0 * u1 * u1 + u0 * t1 * u1 + u0 * u1 * t1; // eslint-disable-line camelcase
1502    var t0t1u1_3 = t0 * t1 * u1 + u0 * t1 * t1 + t0 * u1 * t1; // eslint-disable-line camelcase
1503    var t0t1t1 = t0 * t1 * t1;
1504    //
1505    var u1u1u1 = u1 * u1 * u1;
1506    var t1u1u1_3 = t1 * u1 * u1 + u1 * t1 * u1 + u1 * u1 * t1; // eslint-disable-line camelcase
1507    var t1t1u1_3 = t1 * t1 * u1 + u1 * t1 * t1 + t1 * u1 * t1; // eslint-disable-line camelcase
1508    var t1t1t1 = t1 * t1 * t1;
1509    for (i = 0; i < len; i += 1) {
1510      bezierSegmentPoints[i * 4] = math.round((u0u0u0 * pt1[i] + t0u0u0_3 * pt3[i] + t0t0u0_3 * pt4[i] + t0t0t0 * pt2[i]) * 1000) / 1000; // eslint-disable-line camelcase
1511      bezierSegmentPoints[i * 4 + 1] = math.round((u0u0u1 * pt1[i] + t0u0u1_3 * pt3[i] + t0t0u1_3 * pt4[i] + t0t0t1 * pt2[i]) * 1000) / 1000; // eslint-disable-line camelcase
1512      bezierSegmentPoints[i * 4 + 2] = math.round((u0u1u1 * pt1[i] + t0u1u1_3 * pt3[i] + t0t1u1_3 * pt4[i] + t0t1t1 * pt2[i]) * 1000) / 1000; // eslint-disable-line camelcase
1513      bezierSegmentPoints[i * 4 + 3] = math.round((u1u1u1 * pt1[i] + t1u1u1_3 * pt3[i] + t1t1u1_3 * pt4[i] + t1t1t1 * pt2[i]) * 1000) / 1000; // eslint-disable-line camelcase
1514    }
1515
1516    return bezierSegmentPoints;
1517  }
1518
1519  return {
1520    getSegmentsLength: getSegmentsLength,
1521    getNewSegment: getNewSegment,
1522    getPointInSegment: getPointInSegment,
1523    buildBezierData: buildBezierData,
1524    pointOnLine2D: pointOnLine2D,
1525    pointOnLine3D: pointOnLine3D,
1526  };
1527}
1528
1529var bez = bezFunction();
1530
1531/* exported dataManager */
1532
1533function dataFunctionManager() {
1534  // var tCanvasHelper = createTag('canvas').getContext('2d');
1535
1536  function completeLayers(layers, comps, fontManager) {
1537    var layerData;
1538    var i;
1539    var len = layers.length;
1540    var j;
1541    var jLen;
1542    var k;
1543    var kLen;
1544    for (i = 0; i < len; i += 1) {
1545      layerData = layers[i];
1546      if (('ks' in layerData) && !layerData.completed) {
1547        layerData.completed = true;
1548        if (layerData.tt) {
1549          layers[i - 1].td = layerData.tt;
1550        }
1551        if (layerData.hasMask) {
1552          var maskProps = layerData.masksProperties;
1553          jLen = maskProps.length;
1554          for (j = 0; j < jLen; j += 1) {
1555            if (maskProps[j].pt.k.i) {
1556              convertPathsToAbsoluteValues(maskProps[j].pt.k);
1557            } else {
1558              kLen = maskProps[j].pt.k.length;
1559              for (k = 0; k < kLen; k += 1) {
1560                if (maskProps[j].pt.k[k].s) {
1561                  convertPathsToAbsoluteValues(maskProps[j].pt.k[k].s[0]);
1562                }
1563                if (maskProps[j].pt.k[k].e) {
1564                  convertPathsToAbsoluteValues(maskProps[j].pt.k[k].e[0]);
1565                }
1566              }
1567            }
1568          }
1569        }
1570        if (layerData.ty === 0) {
1571          layerData.layers = findCompLayers(layerData.refId, comps);
1572          completeLayers(layerData.layers, comps, fontManager);
1573        } else if (layerData.ty === 4) {
1574          completeShapes(layerData.shapes);
1575        } else if (layerData.ty === 5) {
1576          completeText(layerData, fontManager);
1577        }
1578      }
1579    }
1580  }
1581
1582  function findCompLayers(id, comps) {
1583    var i = 0;
1584    var len = comps.length;
1585    while (i < len) {
1586      if (comps[i].id === id) {
1587        if (!comps[i].layers.__used) {
1588          comps[i].layers.__used = true;
1589          return comps[i].layers;
1590        }
1591        return JSON.parse(JSON.stringify(comps[i].layers));
1592      }
1593      i += 1;
1594    }
1595    return null;
1596  }
1597
1598  function completeShapes(arr) {
1599    var i;
1600    var len = arr.length;
1601    var j;
1602    var jLen;
1603    for (i = len - 1; i >= 0; i -= 1) {
1604      if (arr[i].ty === 'sh') {
1605        if (arr[i].ks.k.i) {
1606          convertPathsToAbsoluteValues(arr[i].ks.k);
1607        } else {
1608          jLen = arr[i].ks.k.length;
1609          for (j = 0; j < jLen; j += 1) {
1610            if (arr[i].ks.k[j].s) {
1611              convertPathsToAbsoluteValues(arr[i].ks.k[j].s[0]);
1612            }
1613            if (arr[i].ks.k[j].e) {
1614              convertPathsToAbsoluteValues(arr[i].ks.k[j].e[0]);
1615            }
1616          }
1617        }
1618      } else if (arr[i].ty === 'gr') {
1619        completeShapes(arr[i].it);
1620      }
1621    }
1622  }
1623
1624  function convertPathsToAbsoluteValues(path) {
1625    var i;
1626    var len = path.i.length;
1627    for (i = 0; i < len; i += 1) {
1628      path.i[i][0] += path.v[i][0];
1629      path.i[i][1] += path.v[i][1];
1630      path.o[i][0] += path.v[i][0];
1631      path.o[i][1] += path.v[i][1];
1632    }
1633  }
1634
1635  function checkVersion(minimum, animVersionString) {
1636    var animVersion = animVersionString ? animVersionString.split('.') : [100, 100, 100];
1637    if (minimum[0] > animVersion[0]) {
1638      return true;
1639    } if (animVersion[0] > minimum[0]) {
1640      return false;
1641    }
1642    if (minimum[1] > animVersion[1]) {
1643      return true;
1644    } if (animVersion[1] > minimum[1]) {
1645      return false;
1646    }
1647    if (minimum[2] > animVersion[2]) {
1648      return true;
1649    } if (animVersion[2] > minimum[2]) {
1650      return false;
1651    }
1652    return null;
1653  }
1654
1655  var checkText = (function () {
1656    var minimumVersion = [4, 4, 14];
1657
1658    function updateTextLayer(textLayer) {
1659      var documentData = textLayer.t.d;
1660      textLayer.t.d = {
1661        k: [
1662          {
1663            s: documentData,
1664            t: 0,
1665          },
1666        ],
1667      };
1668    }
1669
1670    function iterateLayers(layers) {
1671      var i;
1672      var len = layers.length;
1673      for (i = 0; i < len; i += 1) {
1674        if (layers[i].ty === 5) {
1675          updateTextLayer(layers[i]);
1676        }
1677      }
1678    }
1679
1680    return function (animationData) {
1681      if (checkVersion(minimumVersion, animationData.v)) {
1682        iterateLayers(animationData.layers);
1683        if (animationData.assets) {
1684          var i;
1685          var len = animationData.assets.length;
1686          for (i = 0; i < len; i += 1) {
1687            if (animationData.assets[i].layers) {
1688              iterateLayers(animationData.assets[i].layers);
1689            }
1690          }
1691        }
1692      }
1693    };
1694  }());
1695
1696  var checkChars = (function () {
1697    var minimumVersion = [4, 7, 99];
1698    return function (animationData) {
1699      if (animationData.chars && !checkVersion(minimumVersion, animationData.v)) {
1700        var i;
1701        var len = animationData.chars.length;
1702        var j;
1703        var jLen;
1704        var pathData;
1705        var paths;
1706        for (i = 0; i < len; i += 1) {
1707          if (animationData.chars[i].data && animationData.chars[i].data.shapes) {
1708            paths = animationData.chars[i].data.shapes[0].it;
1709            jLen = paths.length;
1710
1711            for (j = 0; j < jLen; j += 1) {
1712              pathData = paths[j].ks.k;
1713              if (!pathData.__converted) {
1714                convertPathsToAbsoluteValues(paths[j].ks.k);
1715                pathData.__converted = true;
1716              }
1717            }
1718          }
1719        }
1720      }
1721    };
1722  }());
1723
1724  var checkColors = (function () {
1725    var minimumVersion = [4, 1, 9];
1726
1727    function iterateShapes(shapes) {
1728      var i;
1729      var len = shapes.length;
1730      var j;
1731      var jLen;
1732      for (i = 0; i < len; i += 1) {
1733        if (shapes[i].ty === 'gr') {
1734          iterateShapes(shapes[i].it);
1735        } else if (shapes[i].ty === 'fl' || shapes[i].ty === 'st') {
1736          if (shapes[i].c.k && shapes[i].c.k[0].i) {
1737            jLen = shapes[i].c.k.length;
1738            for (j = 0; j < jLen; j += 1) {
1739              if (shapes[i].c.k[j].s) {
1740                shapes[i].c.k[j].s[0] /= 255;
1741                shapes[i].c.k[j].s[1] /= 255;
1742                shapes[i].c.k[j].s[2] /= 255;
1743                shapes[i].c.k[j].s[3] /= 255;
1744              }
1745              if (shapes[i].c.k[j].e) {
1746                shapes[i].c.k[j].e[0] /= 255;
1747                shapes[i].c.k[j].e[1] /= 255;
1748                shapes[i].c.k[j].e[2] /= 255;
1749                shapes[i].c.k[j].e[3] /= 255;
1750              }
1751            }
1752          } else {
1753            shapes[i].c.k[0] /= 255;
1754            shapes[i].c.k[1] /= 255;
1755            shapes[i].c.k[2] /= 255;
1756            shapes[i].c.k[3] /= 255;
1757          }
1758        }
1759      }
1760    }
1761
1762    function iterateLayers(layers) {
1763      var i;
1764      var len = layers.length;
1765      for (i = 0; i < len; i += 1) {
1766        if (layers[i].ty === 4) {
1767          iterateShapes(layers[i].shapes);
1768        }
1769      }
1770    }
1771
1772    return function (animationData) {
1773      if (checkVersion(minimumVersion, animationData.v)) {
1774        iterateLayers(animationData.layers);
1775        if (animationData.assets) {
1776          var i;
1777          var len = animationData.assets.length;
1778          for (i = 0; i < len; i += 1) {
1779            if (animationData.assets[i].layers) {
1780              iterateLayers(animationData.assets[i].layers);
1781            }
1782          }
1783        }
1784      }
1785    };
1786  }());
1787
1788  var checkShapes = (function () {
1789    var minimumVersion = [4, 4, 18];
1790
1791    function completeClosingShapes(arr) {
1792      var i;
1793      var len = arr.length;
1794      var j;
1795      var jLen;
1796      for (i = len - 1; i >= 0; i -= 1) {
1797        if (arr[i].ty === 'sh') {
1798          if (arr[i].ks.k.i) {
1799            arr[i].ks.k.c = arr[i].closed;
1800          } else {
1801            jLen = arr[i].ks.k.length;
1802            for (j = 0; j < jLen; j += 1) {
1803              if (arr[i].ks.k[j].s) {
1804                arr[i].ks.k[j].s[0].c = arr[i].closed;
1805              }
1806              if (arr[i].ks.k[j].e) {
1807                arr[i].ks.k[j].e[0].c = arr[i].closed;
1808              }
1809            }
1810          }
1811        } else if (arr[i].ty === 'gr') {
1812          completeClosingShapes(arr[i].it);
1813        }
1814      }
1815    }
1816
1817    function iterateLayers(layers) {
1818      var layerData;
1819      var i;
1820      var len = layers.length;
1821      var j;
1822      var jLen;
1823      var k;
1824      var kLen;
1825      for (i = 0; i < len; i += 1) {
1826        layerData = layers[i];
1827        if (layerData.hasMask) {
1828          var maskProps = layerData.masksProperties;
1829          jLen = maskProps.length;
1830          for (j = 0; j < jLen; j += 1) {
1831            if (maskProps[j].pt.k.i) {
1832              maskProps[j].pt.k.c = maskProps[j].cl;
1833            } else {
1834              kLen = maskProps[j].pt.k.length;
1835              for (k = 0; k < kLen; k += 1) {
1836                if (maskProps[j].pt.k[k].s) {
1837                  maskProps[j].pt.k[k].s[0].c = maskProps[j].cl;
1838                }
1839                if (maskProps[j].pt.k[k].e) {
1840                  maskProps[j].pt.k[k].e[0].c = maskProps[j].cl;
1841                }
1842              }
1843            }
1844          }
1845        }
1846        if (layerData.ty === 4) {
1847          completeClosingShapes(layerData.shapes);
1848        }
1849      }
1850    }
1851
1852    return function (animationData) {
1853      if (checkVersion(minimumVersion, animationData.v)) {
1854        iterateLayers(animationData.layers);
1855        if (animationData.assets) {
1856          var i;
1857          var len = animationData.assets.length;
1858          for (i = 0; i < len; i += 1) {
1859            if (animationData.assets[i].layers) {
1860              iterateLayers(animationData.assets[i].layers);
1861            }
1862          }
1863        }
1864      }
1865    };
1866  }());
1867
1868  function completeData(animationData, fontManager) {
1869    if (animationData.__complete) {
1870      return;
1871    }
1872    checkColors(animationData);
1873    checkText(animationData);
1874    checkChars(animationData);
1875    checkShapes(animationData);
1876    completeLayers(animationData.layers, animationData.assets, fontManager);
1877    animationData.__complete = true;
1878  }
1879
1880  function completeText(data) {
1881    if (data.t.a.length === 0 && !('m' in data.t.p)) {
1882      data.singleShape = true;
1883    }
1884  }
1885
1886  var moduleOb = {};
1887  moduleOb.completeData = completeData;
1888  moduleOb.checkColors = checkColors;
1889  moduleOb.checkChars = checkChars;
1890  moduleOb.checkShapes = checkShapes;
1891  moduleOb.completeLayers = completeLayers;
1892
1893  return moduleOb;
1894}
1895
1896var dataManager = dataFunctionManager();
1897
1898/* exported getFontProperties */
1899
1900function getFontProperties(fontData) {
1901  var styles = fontData.fStyle ? fontData.fStyle.split(' ') : [];
1902
1903  var fWeight = 'normal'; var
1904    fStyle = 'normal';
1905  var len = styles.length;
1906  var styleName;
1907  for (var i = 0; i < len; i += 1) {
1908    styleName = styles[i].toLowerCase();
1909    switch (styleName) {
1910      case 'italic':
1911        fStyle = 'italic';
1912        break;
1913      case 'bold':
1914        fWeight = '700';
1915        break;
1916      case 'black':
1917        fWeight = '900';
1918        break;
1919      case 'medium':
1920        fWeight = '500';
1921        break;
1922      case 'regular':
1923      case 'normal':
1924        fWeight = '400';
1925        break;
1926      case 'light':
1927      case 'thin':
1928        fWeight = '200';
1929        break;
1930      default:
1931        break;
1932    }
1933  }
1934
1935  return {
1936    style: fStyle,
1937    weight: fontData.fWeight || fWeight,
1938  };
1939}
1940
1941/* global createNS, createTag, getFontProperties */
1942/* exported FontManager */
1943
1944var FontManager = (function () {
1945  var maxWaitingTime = 5000;
1946  var emptyChar = {
1947    w: 0,
1948    size: 0,
1949    shapes: [],
1950  };
1951  var combinedCharacters = [];
1952  // Hindi characters
1953  combinedCharacters = combinedCharacters.concat([2304, 2305, 2306, 2307, 2362, 2363, 2364, 2364, 2366,
1954    2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377, 2378, 2379,
1955    2380, 2381, 2382, 2383, 2387, 2388, 2389, 2390, 2391, 2402, 2403]);
1956
1957  function trimFontOptions(font) {
1958    var familyArray = font.split(',');
1959    var i;
1960    var len = familyArray.length;
1961    var enabledFamilies = [];
1962    for (i = 0; i < len; i += 1) {
1963      if (familyArray[i] !== 'sans-serif' && familyArray[i] !== 'monospace') {
1964        enabledFamilies.push(familyArray[i]);
1965      }
1966    }
1967    return enabledFamilies.join(',');
1968  }
1969
1970  function setUpNode(font, family) {
1971    var parentNode = createTag('span');
1972    // Node is invisible to screen readers.
1973    parentNode.setAttribute('aria-hidden', true);
1974    parentNode.style.fontFamily = family;
1975    var node = createTag('span');
1976    // Characters that vary significantly among different fonts
1977    node.innerText = 'giItT1WQy@!-/#';
1978    // Visible - so we can measure it - but not on the screen
1979    parentNode.style.position = 'absolute';
1980    parentNode.style.left = '-10000px';
1981    parentNode.style.top = '-10000px';
1982    // Large font size makes even subtle changes obvious
1983    parentNode.style.fontSize = '300px';
1984    // Reset any font properties
1985    parentNode.style.fontVariant = 'normal';
1986    parentNode.style.fontStyle = 'normal';
1987    parentNode.style.fontWeight = 'normal';
1988    parentNode.style.letterSpacing = '0';
1989    parentNode.appendChild(node);
1990    document.body.appendChild(parentNode);
1991
1992    // Remember width with no applied web font
1993    var width = node.offsetWidth;
1994    node.style.fontFamily = trimFontOptions(font) + ', ' + family;
1995    return { node: node, w: width, parent: parentNode };
1996  }
1997
1998  function checkLoadedFonts() {
1999    var i;
2000    var len = this.fonts.length;
2001    var node;
2002    var w;
2003    var loadedCount = len;
2004    for (i = 0; i < len; i += 1) {
2005      if (this.fonts[i].loaded) {
2006        loadedCount -= 1;
2007      } else if (this.fonts[i].fOrigin === 'n' || this.fonts[i].origin === 0) {
2008        this.fonts[i].loaded = true;
2009      } else {
2010        node = this.fonts[i].monoCase.node;
2011        w = this.fonts[i].monoCase.w;
2012        if (node.offsetWidth !== w) {
2013          loadedCount -= 1;
2014          this.fonts[i].loaded = true;
2015        } else {
2016          node = this.fonts[i].sansCase.node;
2017          w = this.fonts[i].sansCase.w;
2018          if (node.offsetWidth !== w) {
2019            loadedCount -= 1;
2020            this.fonts[i].loaded = true;
2021          }
2022        }
2023        if (this.fonts[i].loaded) {
2024          this.fonts[i].sansCase.parent.parentNode.removeChild(this.fonts[i].sansCase.parent);
2025          this.fonts[i].monoCase.parent.parentNode.removeChild(this.fonts[i].monoCase.parent);
2026        }
2027      }
2028    }
2029
2030    if (loadedCount !== 0 && Date.now() - this.initTime < maxWaitingTime) {
2031      setTimeout(this.checkLoadedFontsBinded, 20);
2032    } else {
2033      setTimeout(this.setIsLoadedBinded, 10);
2034    }
2035  }
2036
2037  function createHelper(def, fontData) {
2038    var tHelper = createNS('text');
2039    tHelper.style.fontSize = '100px';
2040    // tHelper.style.fontFamily = fontData.fFamily;
2041
2042    var fontProps = getFontProperties(fontData);
2043    tHelper.setAttribute('font-family', fontData.fFamily);
2044    tHelper.setAttribute('font-style', fontProps.style);
2045    tHelper.setAttribute('font-weight', fontProps.weight);
2046    tHelper.textContent = '1';
2047    if (fontData.fClass) {
2048      tHelper.style.fontFamily = 'inherit';
2049      tHelper.setAttribute('class', fontData.fClass);
2050    } else {
2051      tHelper.style.fontFamily = fontData.fFamily;
2052    }
2053    def.appendChild(tHelper);
2054    var tCanvasHelper = createTag('canvas').getContext('2d');
2055    tCanvasHelper.font = fontData.fWeight + ' ' + fontData.fStyle + ' 100px ' + fontData.fFamily;
2056    // tCanvasHelper.font = ' 100px '+ fontData.fFamily;
2057    return tHelper;
2058  }
2059
2060  function addFonts(fontData, defs) {
2061    if (!fontData) {
2062      this.isLoaded = true;
2063      return;
2064    }
2065    if (this.chars) {
2066      this.isLoaded = true;
2067      this.fonts = fontData.list;
2068      return;
2069    }
2070
2071    var fontArr = fontData.list;
2072    var i;
2073    var len = fontArr.length;
2074    var _pendingFonts = len;
2075    for (i = 0; i < len; i += 1) {
2076      var shouldLoadFont = true;
2077      var loadedSelector;
2078      var j;
2079      fontArr[i].loaded = false;
2080      fontArr[i].monoCase = setUpNode(fontArr[i].fFamily, 'monospace');
2081      fontArr[i].sansCase = setUpNode(fontArr[i].fFamily, 'sans-serif');
2082      if (!fontArr[i].fPath) {
2083        fontArr[i].loaded = true;
2084        _pendingFonts -= 1;
2085      } else if (fontArr[i].fOrigin === 'p' || fontArr[i].origin === 3) {
2086        loadedSelector = document.querySelectorAll('style[f-forigin="p"][f-family="' + fontArr[i].fFamily + '"], style[f-origin="3"][f-family="' + fontArr[i].fFamily + '"]');
2087
2088        if (loadedSelector.length > 0) {
2089          shouldLoadFont = false;
2090        }
2091
2092        if (shouldLoadFont) {
2093          var s = createTag('style');
2094          s.setAttribute('f-forigin', fontArr[i].fOrigin);
2095          s.setAttribute('f-origin', fontArr[i].origin);
2096          s.setAttribute('f-family', fontArr[i].fFamily);
2097          s.type = 'text/css';
2098          s.innerText = '@font-face {font-family: ' + fontArr[i].fFamily + "; font-style: normal; src: url('" + fontArr[i].fPath + "');}";
2099          defs.appendChild(s);
2100        }
2101      } else if (fontArr[i].fOrigin === 'g' || fontArr[i].origin === 1) {
2102        loadedSelector = document.querySelectorAll('link[f-forigin="g"], link[f-origin="1"]');
2103
2104        for (j = 0; j < loadedSelector.length; j += 1) {
2105          if (loadedSelector[j].href.indexOf(fontArr[i].fPath) !== -1) {
2106            // Font is already loaded
2107            shouldLoadFont = false;
2108          }
2109        }
2110
2111        if (shouldLoadFont) {
2112          var l = createTag('link');
2113          l.setAttribute('f-forigin', fontArr[i].fOrigin);
2114          l.setAttribute('f-origin', fontArr[i].origin);
2115          l.type = 'text/css';
2116          l.rel = 'stylesheet';
2117          l.href = fontArr[i].fPath;
2118          document.body.appendChild(l);
2119        }
2120      } else if (fontArr[i].fOrigin === 't' || fontArr[i].origin === 2) {
2121        loadedSelector = document.querySelectorAll('script[f-forigin="t"], script[f-origin="2"]');
2122
2123        for (j = 0; j < loadedSelector.length; j += 1) {
2124          if (fontArr[i].fPath === loadedSelector[j].src) {
2125            // Font is already loaded
2126            shouldLoadFont = false;
2127          }
2128        }
2129
2130        if (shouldLoadFont) {
2131          var sc = createTag('link');
2132          sc.setAttribute('f-forigin', fontArr[i].fOrigin);
2133          sc.setAttribute('f-origin', fontArr[i].origin);
2134          sc.setAttribute('rel', 'stylesheet');
2135          sc.setAttribute('href', fontArr[i].fPath);
2136          defs.appendChild(sc);
2137        }
2138      }
2139      fontArr[i].helper = createHelper(defs, fontArr[i]);
2140      fontArr[i].cache = {};
2141      this.fonts.push(fontArr[i]);
2142    }
2143    if (_pendingFonts === 0) {
2144      this.isLoaded = true;
2145    } else {
2146      // On some cases even if the font is loaded, it won't load correctly when measuring text on canvas.
2147      // Adding this timeout seems to fix it
2148      setTimeout(this.checkLoadedFonts.bind(this), 100);
2149    }
2150  }
2151
2152  function addChars(chars) {
2153    if (!chars) {
2154      return;
2155    }
2156    if (!this.chars) {
2157      this.chars = [];
2158    }
2159    var i;
2160    var len = chars.length;
2161    var j;
2162    var jLen = this.chars.length;
2163    var found;
2164    for (i = 0; i < len; i += 1) {
2165      j = 0;
2166      found = false;
2167      while (j < jLen) {
2168        if (this.chars[j].style === chars[i].style && this.chars[j].fFamily === chars[i].fFamily && this.chars[j].ch === chars[i].ch) {
2169          found = true;
2170        }
2171        j += 1;
2172      }
2173      if (!found) {
2174        this.chars.push(chars[i]);
2175        jLen += 1;
2176      }
2177    }
2178  }
2179
2180  function getCharData(char, style, font) {
2181    var i = 0;
2182    var len = this.chars.length;
2183    while (i < len) {
2184      if (this.chars[i].ch === char && this.chars[i].style === style && this.chars[i].fFamily === font) {
2185        return this.chars[i];
2186      }
2187      i += 1;
2188    }
2189    if (((typeof char === 'string' && char.charCodeAt(0) !== 13) || !char)
2190            && console
2191            && console.warn // eslint-disable-line no-console
2192            && !this._warned
2193    ) {
2194      this._warned = true;
2195      console.warn('Missing character from exported characters list: ', char, style, font); // eslint-disable-line no-console
2196    }
2197    return emptyChar;
2198  }
2199
2200  function measureText(char, fontName, size) {
2201    var fontData = this.getFontByName(fontName);
2202    var index = char.charCodeAt(0);
2203    if (!fontData.cache[index + 1]) {
2204      var tHelper = fontData.helper;
2205      // Canvas version
2206      // fontData.cache[index] = tHelper.measureText(char).width / 100;
2207      // SVG version
2208      // console.log(tHelper.getBBox().width)
2209      if (char === ' ') {
2210        tHelper.textContent = '|' + char + '|';
2211        var doubleSize = tHelper.getComputedTextLength();
2212        tHelper.textContent = '||';
2213        var singleSize = tHelper.getComputedTextLength();
2214        fontData.cache[index + 1] = (doubleSize - singleSize) / 100;
2215      } else {
2216        tHelper.textContent = char;
2217        fontData.cache[index + 1] = (tHelper.getComputedTextLength()) / 100;
2218      }
2219    }
2220    return fontData.cache[index + 1] * size;
2221  }
2222
2223  function getFontByName(name) {
2224    var i = 0;
2225    var len = this.fonts.length;
2226    while (i < len) {
2227      if (this.fonts[i].fName === name) {
2228        return this.fonts[i];
2229      }
2230      i += 1;
2231    }
2232    return this.fonts[0];
2233  }
2234
2235  function getCombinedCharacterCodes() {
2236    return combinedCharacters;
2237  }
2238
2239  function setIsLoaded() {
2240    this.isLoaded = true;
2241  }
2242
2243  var Font = function () {
2244    this.fonts = [];
2245    this.chars = null;
2246    this.typekitLoaded = 0;
2247    this.isLoaded = false;
2248    this._warned = false;
2249    this.initTime = Date.now();
2250    this.setIsLoadedBinded = this.setIsLoaded.bind(this);
2251    this.checkLoadedFontsBinded = this.checkLoadedFonts.bind(this);
2252  };
2253    // TODO: for now I'm adding these methods to the Class and not the prototype. Think of a better way to implement it.
2254  Font.getCombinedCharacterCodes = getCombinedCharacterCodes;
2255
2256  var fontPrototype = {
2257    addChars: addChars,
2258    addFonts: addFonts,
2259    getCharData: getCharData,
2260    getFontByName: getFontByName,
2261    measureText: measureText,
2262    checkLoadedFonts: checkLoadedFonts,
2263    setIsLoaded: setIsLoaded,
2264  };
2265
2266  Font.prototype = fontPrototype;
2267
2268  return Font;
2269}());
2270
2271/* global initialDefaultFrame, BezierFactory, degToRads, bez, createTypedArray */
2272/* exported PropertyFactory */
2273
2274var PropertyFactory = (function () {
2275  var initFrame = initialDefaultFrame;
2276  var mathAbs = Math.abs;
2277
2278  function interpolateValue(frameNum, caching) {
2279    var offsetTime = this.offsetTime;
2280    var newValue;
2281    if (this.propType === 'multidimensional') {
2282      newValue = createTypedArray('float32', this.pv.length);
2283    }
2284    var iterationIndex = caching.lastIndex;
2285    var i = iterationIndex;
2286    var len = this.keyframes.length - 1;
2287    var flag = true;
2288    var keyData;
2289    var nextKeyData;
2290
2291    while (flag) {
2292      keyData = this.keyframes[i];
2293      nextKeyData = this.keyframes[i + 1];
2294      if (i === len - 1 && frameNum >= nextKeyData.t - offsetTime) {
2295        if (keyData.h) {
2296          keyData = nextKeyData;
2297        }
2298        iterationIndex = 0;
2299        break;
2300      }
2301      if ((nextKeyData.t - offsetTime) > frameNum) {
2302        iterationIndex = i;
2303        break;
2304      }
2305      if (i < len - 1) {
2306        i += 1;
2307      } else {
2308        iterationIndex = 0;
2309        flag = false;
2310      }
2311    }
2312
2313    var k;
2314    var kLen;
2315    var perc;
2316    var jLen;
2317    var j;
2318    var fnc;
2319    var nextKeyTime = nextKeyData.t - offsetTime;
2320    var keyTime = keyData.t - offsetTime;
2321    var endValue;
2322    if (keyData.to) {
2323      if (!keyData.bezierData) {
2324        keyData.bezierData = bez.buildBezierData(keyData.s, nextKeyData.s || keyData.e, keyData.to, keyData.ti);
2325      }
2326      var bezierData = keyData.bezierData;
2327      if (frameNum >= nextKeyTime || frameNum < keyTime) {
2328        var ind = frameNum >= nextKeyTime ? bezierData.points.length - 1 : 0;
2329        kLen = bezierData.points[ind].point.length;
2330        for (k = 0; k < kLen; k += 1) {
2331          newValue[k] = bezierData.points[ind].point[k];
2332        }
2333        // caching._lastKeyframeIndex = -1;
2334      } else {
2335        if (keyData.__fnct) {
2336          fnc = keyData.__fnct;
2337        } else {
2338          fnc = BezierFactory.getBezierEasing(keyData.o.x, keyData.o.y, keyData.i.x, keyData.i.y, keyData.n).get;
2339          keyData.__fnct = fnc;
2340        }
2341        perc = fnc((frameNum - keyTime) / (nextKeyTime - keyTime));
2342        var distanceInLine = bezierData.segmentLength * perc;
2343
2344        var segmentPerc;
2345        var addedLength = (caching.lastFrame < frameNum && caching._lastKeyframeIndex === i) ? caching._lastAddedLength : 0;
2346        j = (caching.lastFrame < frameNum && caching._lastKeyframeIndex === i) ? caching._lastPoint : 0;
2347        flag = true;
2348        jLen = bezierData.points.length;
2349        while (flag) {
2350          addedLength += bezierData.points[j].partialLength;
2351          if (distanceInLine === 0 || perc === 0 || j === bezierData.points.length - 1) {
2352            kLen = bezierData.points[j].point.length;
2353            for (k = 0; k < kLen; k += 1) {
2354              newValue[k] = bezierData.points[j].point[k];
2355            }
2356            break;
2357          } else if (distanceInLine >= addedLength && distanceInLine < addedLength + bezierData.points[j + 1].partialLength) {
2358            segmentPerc = (distanceInLine - addedLength) / bezierData.points[j + 1].partialLength;
2359            kLen = bezierData.points[j].point.length;
2360            for (k = 0; k < kLen; k += 1) {
2361              newValue[k] = bezierData.points[j].point[k] + (bezierData.points[j + 1].point[k] - bezierData.points[j].point[k]) * segmentPerc;
2362            }
2363            break;
2364          }
2365          if (j < jLen - 1) {
2366            j += 1;
2367          } else {
2368            flag = false;

2369          }
2370        }
2371        caching._lastPoint = j;
2372        caching._lastAddedLength = addedLength - bezierData.points[j].partialLength;
2373        caching._lastKeyframeIndex = i;
2374      }
2375    } else {
2376      var outX;
2377      var outY;
2378      var inX;
2379      var inY;
2380      var keyValue;
2381      len = keyData.s.length;
2382      endValue = nextKeyData.s || keyData.e;
2383      if (this.sh && keyData.h !== 1) {
2384        if (frameNum >= nextKeyTime) {
2385          newValue[0] = endValue[0];
2386          newValue[1] = endValue[1];
2387          newValue[2] = endValue[2];
2388        } else if (frameNum <= keyTime) {
2389          newValue[0] = keyData.s[0];
2390          newValue[1] = keyData.s[1];
2391          newValue[2] = keyData.s[2];
2392        } else {
2393          var quatStart = createQuaternion(keyData.s);
2394          var quatEnd = createQuaternion(endValue);
2395          var time = (frameNum - keyTime) / (nextKeyTime - keyTime);
2396          quaternionToEuler(newValue, slerp(quatStart, quatEnd, time));
2397        }
2398      } else {
2399        for (i = 0; i < len; i += 1) {
2400          if (keyData.h !== 1) {
2401            if (frameNum >= nextKeyTime) {
2402              perc = 1;
2403            } else if (frameNum < keyTime) {
2404              perc = 0;
2405            } else {
2406              if (keyData.o.x.constructor === Array) {
2407                if (!keyData.__fnct) {
2408                  keyData.__fnct = [];
2409                }
2410                if (!keyData.__fnct[i]) {
2411                  outX = (typeof keyData.o.x[i] === 'undefined') ? keyData.o.x[0] : keyData.o.x[i];
2412                  outY = (typeof keyData.o.y[i] === 'undefined') ? keyData.o.y[0] : keyData.o.y[i];
2413                  inX = (typeof keyData.i.x[i] === 'undefined') ? keyData.i.x[0] : keyData.i.x[i];
2414                  inY = (typeof keyData.i.y[i] === 'undefined') ? keyData.i.y[0] : keyData.i.y[i];
2415                  fnc = BezierFactory.getBezierEasing(outX, outY, inX, inY).get;
2416                  keyData.__fnct[i] = fnc;
2417                } else {
2418                  fnc = keyData.__fnct[i];
2419                }
2420              } else if (!keyData.__fnct) {
2421                outX = keyData.o.x;
2422                outY = keyData.o.y;
2423                inX = keyData.i.x;
2424                inY = keyData.i.y;
2425                fnc = BezierFactory.getBezierEasing(outX, outY, inX, inY).get;
2426                keyData.__fnct = fnc;
2427              } else {
2428                fnc = keyData.__fnct;
2429              }
2430              perc = fnc((frameNum - keyTime) / (nextKeyTime - keyTime));
2431            }
2432          }
2433
2434          endValue = nextKeyData.s || keyData.e;
2435          keyValue = keyData.h === 1 ? keyData.s[i] : keyData.s[i] + (endValue[i] - keyData.s[i]) * perc;
2436
2437          if (this.propType === 'multidimensional') {
2438            newValue[i] = keyValue;
2439          } else {
2440            newValue = keyValue;
2441          }
2442        }
2443      }
2444    }
2445    caching.lastIndex = iterationIndex;
2446    return newValue;
2447  }
2448
2449  // based on @Toji's https://github.com/toji/gl-matrix/
2450  function slerp(a, b, t) {
2451    var out = [];
2452    var ax = a[0];
2453    var ay = a[1];
2454    var az = a[2];
2455    var aw = a[3];
2456    var bx = b[0];
2457    var by = b[1];
2458    var bz = b[2];
2459    var bw = b[3];
2460
2461    var omega;
2462    var cosom;
2463    var sinom;
2464    var scale0;
2465    var scale1;
2466
2467    cosom = ax * bx + ay * by + az * bz + aw * bw;
2468    if (cosom < 0.0) {
2469      cosom = -cosom;
2470      bx = -bx;
2471      by = -by;
2472      bz = -bz;
2473      bw = -bw;
2474    }
2475    if ((1.0 - cosom) > 0.000001) {
2476      omega = Math.acos(cosom);
2477      sinom = Math.sin(omega);
2478      scale0 = Math.sin((1.0 - t) * omega) / sinom;
2479      scale1 = Math.sin(t * omega) / sinom;
2480    } else {
2481      scale0 = 1.0 - t;
2482      scale1 = t;
2483    }
2484    out[0] = scale0 * ax + scale1 * bx;
2485    out[1] = scale0 * ay + scale1 * by;
2486    out[2] = scale0 * az + scale1 * bz;
2487    out[3] = scale0 * aw + scale1 * bw;
2488
2489    return out;
2490  }
2491
2492  function quaternionToEuler(out, quat) {
2493    var qx = quat[0];
2494    var qy = quat[1];
2495    var qz = quat[2];
2496    var qw = quat[3];
2497    var heading = Math.atan2(2 * qy * qw - 2 * qx * qz, 1 - 2 * qy * qy - 2 * qz * qz);
2498    var attitude = Math.asin(2 * qx * qy + 2 * qz * qw);
2499    var bank = Math.atan2(2 * qx * qw - 2 * qy * qz, 1 - 2 * qx * qx - 2 * qz * qz);
2500    out[0] = heading / degToRads;
2501    out[1] = attitude / degToRads;
2502    out[2] = bank / degToRads;
2503  }
2504
2505  function createQuaternion(values) {
2506    var heading = values[0] * degToRads;
2507    var attitude = values[1] * degToRads;
2508    var bank = values[2] * degToRads;
2509    var c1 = Math.cos(heading / 2);

2510    var c2 = Math.cos(attitude / 2);
2511    var c3 = Math.cos(bank / 2);
2512    var s1 = Math.sin(heading / 2);
2513    var s2 = Math.sin(attitude / 2);
2514    var s3 = Math.sin(bank / 2);
2515    var w = c1 * c2 * c3 - s1 * s2 * s3;
2516    var x = s1 * s2 * c3 + c1 * c2 * s3;
2517    var y = s1 * c2 * c3 + c1 * s2 * s3;
2518    var z = c1 * s2 * c3 - s1 * c2 * s3;
2519
2520    return [x, y, z, w];
2521  }
2522
2523  function getValueAtCurrentTime() {
2524    var frameNum = this.comp.renderedFrame - this.offsetTime;
2525    var initTime = this.keyframes[0].t - this.offsetTime;
2526    var endTime = this.keyframes[this.keyframes.length - 1].t - this.offsetTime;
2527    if (!(frameNum === this._caching.lastFrame || (this._caching.lastFrame !== initFrame && ((this._caching.lastFrame >= endTime && frameNum >= endTime) || (this._caching.lastFrame < initTime && frameNum < initTime))))) {
2528      if (this._caching.lastFrame >= frameNum) {
2529        this._caching._lastKeyframeIndex = -1;
2530        this._caching.lastIndex = 0;
2531      }
2532
2533      var renderResult = this.interpolateValue(frameNum, this._caching);
2534      this.pv = renderResult;
2535    }
2536    this._caching.lastFrame = frameNum;
2537    return this.pv;
2538  }
2539
2540  function setVValue(val) {
2541    var multipliedValue;
2542    if (this.propType === 'unidimensional') {
2543      multipliedValue = val * this.mult;
2544      if (mathAbs(this.v - multipliedValue) > 0.00001) {
2545        this.v = multipliedValue;
2546        this._mdf = true;
2547      }
2548    } else {
2549      var i = 0;
2550      var len = this.v.length;
2551      while (i < len) {
2552        multipliedValue = val[i] * this.mult;
2553        if (mathAbs(this.v[i] - multipliedValue) > 0.00001) {
2554          this.v[i] = multipliedValue;
2555          this._mdf = true;
2556        }
2557        i += 1;
2558      }
2559    }
2560  }
2561
2562  function processEffectsSequence() {
2563    if (this.elem.globalData.frameId === this.frameId || !this.effectsSequence.length) {
2564      return;
2565    }
2566    if (this.lock) {
2567      this.setVValue(this.pv);
2568      return;
2569    }
2570    this.lock = true;
2571    this._mdf = this._isFirstFrame;
2572    var i;
2573    var len = this.effectsSequence.length;
2574    var finalValue = this.kf ? this.pv : this.data.k;
2575    for (i = 0; i < len; i += 1) {
2576      finalValue = this.effectsSequence[i](finalValue);
2577    }
2578    this.setVValue(finalValue);
2579    this._isFirstFrame = false;
2580    this.lock = false;
2581    this.frameId = this.elem.globalData.frameId;
2582  }
2583
2584  function addEffect(effectFunction) {
2585    this.effectsSequence.push(effectFunction);
2586    this.container.addDynamicProperty(this);
2587  }
2588
2589  function ValueProperty(elem, data, mult, container) {
2590    this.propType = 'unidimensional';
2591    this.mult = mult || 1;
2592    this.data = data;
2593    this.v = mult ? data.k * mult : data.k;
2594    this.pv = data.k;
2595    this._mdf = false;
2596    this.elem = elem;
2597    this.container = container;
2598    this.comp = elem.comp;
2599    this.k = false;
2600    this.kf = false;
2601    this.vel = 0;
2602    this.effectsSequence = [];
2603    this._isFirstFrame = true;
2604    this.getValue = processEffectsSequence;
2605    this.setVValue = setVValue;
2606    this.addEffect = addEffect;
2607  }
2608
2609  function MultiDimensionalProperty(elem, data, mult, container) {
2610    this.propType = 'multidimensional';
2611    this.mult = mult || 1;
2612    this.data = data;
2613    this._mdf = false;
2614    this.elem = elem;
2615    this.container = container;
2616    this.comp = elem.comp;
2617    this.k = false;
2618    this.kf = false;
2619    this.frameId = -1;
2620    var i;
2621    var len = data.k.length;
2622    this.v = createTypedArray('float32', len);
2623    this.pv = createTypedArray('float32', len);
2624    this.vel = createTypedArray('float32', len);
2625    for (i = 0; i < len; i += 1) {
2626      this.v[i] = data.k[i] * this.mult;
2627      this.pv[i] = data.k[i];
2628    }
2629    this._isFirstFrame = true;
2630    this.effectsSequence = [];
2631    this.getValue = processEffectsSequence;
2632    this.setVValue = setVValue;
2633    this.addEffect = addEffect;
2634  }
2635
2636  function KeyframedValueProperty(elem, data, mult, container) {
2637    this.propType = 'unidimensional';
2638    this.keyframes = data.k;
2639    this.offsetTime = elem.data.st;
2640    this.frameId = -1;
2641    this._caching = {
2642      lastFrame: initFrame, lastIndex: 0, value: 0, _lastKeyframeIndex: -1,
2643    };
2644    this.k = true;
2645    this.kf = true;
2646    this.data = data;
2647    this.mult = mult || 1;
2648    this.elem = elem;
2649    this.container = container;
2650    this.comp = elem.comp;
2651    this.v = initFrame;
2652    this.pv = initFrame;
2653    this._isFirstFrame = true;
2654    this.getValue = processEffectsSequence;
2655    this.setVValue = setVValue;
2656    this.interpolateValue = interpolateValue;
2657    this.effectsSequence = [getValueAtCurrentTime.bind(this)];
2658    this.addEffect = addEffect;
2659  }
2660
2661  function KeyframedMultidimensionalProperty(elem, data, mult, container) {
2662    this.propType = 'multidimensional';
2663    var i;
2664    var len = data.k.length;
2665    var s;
2666    var e;
2667    var to;
2668    var ti;
2669    for (i = 0; i < len - 1; i += 1) {
2670      if (data.k[i].to && data.k[i].s && data.k[i + 1] && data.k[i + 1].s) {
2671        s = data.k[i].s;
2672        e = data.k[i + 1].s;
2673        to = data.k[i].to;
2674        ti = data.k[i].ti;
2675        if ((s.length === 2 && !(s[0] === e[0] && s[1] === e[1]) && bez.pointOnLine2D(s[0], s[1], e[0], e[1], s[0] + to[0], s[1] + to[1]) && bez.pointOnLine2D(s[0], s[1], e[0], e[1], e[0] + ti[0], e[1] + ti[1])) || (s.length === 3 && !(s[0] === e[0] && s[1] === e[1] && s[2] === e[2]) && bez.pointOnLine3D(s[0], s[1], s[2], e[0], e[1], e[2], s[0] + to[0], s[1] + to[1], s[2] + to[2]) && bez.pointOnLine3D(s[0], s[1], s[2], e[0], e[1], e[2], e[0] + ti[0], e[1] + ti[1], e[2] + ti[2]))) {
2676          data.k[i].to = null;
2677          data.k[i].ti = null;
2678        }
2679        if (s[0] === e[0] && s[1] === e[1] && to[0] === 0 && to[1] === 0 && ti[0] === 0 && ti[1] === 0) {
2680          if (s.length === 2 || (s[2] === e[2] && to[2] === 0 && ti[2] === 0)) {
2681            data.k[i].to = null;
2682            data.k[i].ti = null;
2683          }
2684        }
2685      }
2686    }
2687    this.effectsSequence = [getValueAtCurrentTime.bind(this)];
2688    this.data = data;
2689    this.keyframes = data.k;
2690    this.offsetTime = elem.data.st;
2691    this.k = true;
2692    this.kf = true;
2693    this._isFirstFrame = true;
2694    this.mult = mult || 1;
2695    this.elem = elem;
2696    this.container = container;
2697    this.comp = elem.comp;
2698    this.getValue = processEffectsSequence;
2699    this.setVValue = setVValue;
2700    this.interpolateValue = interpolateValue;
2701    this.frameId = -1;
2702    var arrLen = data.k[0].s.length;
2703    this.v = createTypedArray('float32', arrLen);
2704    this.pv = createTypedArray('float32', arrLen);
2705    for (i = 0; i < arrLen; i += 1) {
2706      this.v[i] = initFrame;
2707      this.pv[i] = initFrame;
2708    }
2709    this._caching = { lastFrame: initFrame, lastIndex: 0, value: createTypedArray('float32', arrLen) };
2710    this.addEffect = addEffect;
2711  }
2712
2713  function getProp(elem, data, type, mult, container) {
2714    var p;
2715    if (!data.k.length) {
2716      p = new ValueProperty(elem, data, mult, container);
2717    } else if (typeof (data.k[0]) === 'number') {
2718      p = new MultiDimensionalProperty(elem, data, mult, container);
2719    } else {
2720      switch (type) {
2721        case 0:
2722          p = new KeyframedValueProperty(elem, data, mult, container);
2723          break;
2724        case 1:
2725          p = new KeyframedMultidimensionalProperty(elem, data, mult, container);
2726          break;
2727        default:
2728          break;
2729      }
2730    }
2731    if (p.effectsSequence.length) {
2732      container.addDynamicProperty(p);
2733    }
2734    return p;
2735  }
2736
2737  var ob = {
2738    getProp: getProp,
2739  };
2740  return ob;
2741}());
2742
2743/* global Matrix, degToRads, PropertyFactory, extendPrototype, DynamicPropertyContainer */
2744/* exported TransformPropertyFactory */
2745
2746var TransformPropertyFactory = (function () {
2747  var defaultVector = [0, 0];
2748
2749  function applyToMatrix(mat) {
2750    var _mdf = this._mdf;
2751    this.iterateDynamicProperties();
2752    this._mdf = this._mdf || _mdf;
2753    if (this.a) {
2754      mat.translate(-this.a.v[0], -this.a.v[1], this.a.v[2]);
2755    }
2756    if (this.s) {
2757      mat.scale(this.s.v[0], this.s.v[1], this.s.v[2]);
2758    }
2759    if (this.sk) {
2760      mat.skewFromAxis(-this.sk.v, this.sa.v);
2761    }
2762    if (this.r) {
2763      mat.rotate(-this.r.v);
2764    } else {
2765      mat.rotateZ(-this.rz.v).rotateY(this.ry.v).rotateX(this.rx.v).rotateZ(-this.or.v[2])
2766        .rotateY(this.or.v[1])
2767        .rotateX(this.or.v[0]);
2768    }
2769    if (this.data.p.s) {
2770      if (this.data.p.z) {
2771        mat.translate(this.px.v, this.py.v, -this.pz.v);
2772      } else {
2773        mat.translate(this.px.v, this.py.v, 0);
2774      }
2775    } else {
2776      mat.translate(this.p.v[0], this.p.v[1], -this.p.v[2]);
2777    }
2778  }
2779  function processKeys(forceRender) {
2780    if (this.elem.globalData.frameId === this.frameId) {
2781      return;
2782    }
2783    if (this._isDirty) {
2784      this.precalculateMatrix();
2785      this._isDirty = false;
2786    }
2787
2788    this.iterateDynamicProperties();
2789
2790    if (this._mdf || forceRender) {
2791      var frameRate;
2792      this.v.cloneFromProps(this.pre.props);
2793      if (this.appliedTransformations < 1) {
2794        this.v.translate(-this.a.v[0], -this.a.v[1], this.a.v[2]);
2795      }
2796      if (this.appliedTransformations < 2) {
2797        this.v.scale(this.s.v[0], this.s.v[1], this.s.v[2]);
2798      }
2799      if (this.sk && this.appliedTransformations < 3) {
2800        this.v.skewFromAxis(-this.sk.v, this.sa.v);
2801      }
2802      if (this.r && this.appliedTransformations < 4) {
2803        this.v.rotate(-this.r.v);
2804      } else if (!this.r && this.appliedTransformations < 4) {
2805        this.v.rotateZ(-this.rz.v).rotateY(this.ry.v).rotateX(this.rx.v).rotateZ(-this.or.v[2])
2806          .rotateY(this.or.v[1])
2807          .rotateX(this.or.v[0]);
2808      }
2809      if (this.autoOriented) {
2810        var v1;
2811        var v2;
2812        frameRate = this.elem.globalData.frameRate;
2813        if (this.p && this.p.keyframes && this.p.getValueAtTime) {
2814          if (this.p._caching.lastFrame + this.p.offsetTime <= this.p.keyframes[0].t) {
2815            v1 = this.p.getValueAtTime((this.p.keyframes[0].t + 0.01) / frameRate, 0);
2816            v2 = this.p.getValueAtTime(this.p.keyframes[0].t / frameRate, 0);
2817          } else if (this.p._caching.lastFrame + this.p.offsetTime >= this.p.keyframes[this.p.keyframes.length - 1].t) {
2818            v1 = this.p.getValueAtTime((this.p.keyframes[this.p.keyframes.length - 1].t / frameRate), 0);
2819            v2 = this.p.getValueAtTime((this.p.keyframes[this.p.keyframes.length - 1].t - 0.05) / frameRate, 0);
2820          } else {
2821            v1 = this.p.pv;
2822            v2 = this.p.getValueAtTime((this.p._caching.lastFrame + this.p.offsetTime - 0.01) / frameRate, this.p.offsetTime);
2823          }
2824        } else if (this.px && this.px.keyframes && this.py.keyframes && this.px.getValueAtTime && this.py.getValueAtTime) {
2825          v1 = [];
2826          v2 = [];
2827          var px = this.px;
2828          var py = this.py;
2829          if (px._caching.lastFrame + px.offsetTime <= px.keyframes[0].t) {
2830            v1[0] = px.getValueAtTime((px.keyframes[0].t + 0.01) / frameRate, 0);
2831            v1[1] = py.getValueAtTime((py.keyframes[0].t + 0.01) / frameRate, 0);
2832            v2[0] = px.getValueAtTime((px.keyframes[0].t) / frameRate, 0);
2833            v2[1] = py.getValueAtTime((py.keyframes[0].t) / frameRate, 0);
2834          } else if (px._caching.lastFrame + px.offsetTime >= px.keyframes[px.keyframes.length - 1].t) {
2835            v1[0] = px.getValueAtTime((px.keyframes[px.keyframes.length - 1].t / frameRate), 0);
2836            v1[1] = py.getValueAtTime((py.keyframes[py.keyframes.length - 1].t / frameRate), 0);
2837            v2[0] = px.getValueAtTime((px.keyframes[px.keyframes.length - 1].t - 0.01) / frameRate, 0);
2838            v2[1] = py.getValueAtTime((py.keyframes[py.keyframes.length - 1].t - 0.01) / frameRate, 0);
2839          } else {
2840            v1 = [px.pv, py.pv];
2841            v2[0] = px.getValueAtTime((px._caching.lastFrame + px.offsetTime - 0.01) / frameRate, px.offsetTime);
2842            v2[1] = py.getValueAtTime((py._caching.lastFrame + py.offsetTime - 0.01) / frameRate, py.offsetTime);
2843          }
2844        } else {
2845          v2 = defaultVector;
2846          v1 = v2;
2847        }
2848        this.v.rotate(-Math.atan2(v1[1] - v2[1], v1[0] - v2[0]));
2849      }
2850      if (this.data.p && this.data.p.s) {
2851        if (this.data.p.z) {
2852          this.v.translate(this.px.v, this.py.v, -this.pz.v);
2853        } else {
2854          this.v.translate(this.px.v, this.py.v, 0);
2855        }
2856      } else {
2857        this.v.translate(this.p.v[0], this.p.v[1], -this.p.v[2]);
2858      }
2859    }
2860    this.frameId = this.elem.globalData.frameId;
2861  }
2862
2863  function precalculateMatrix() {
2864    if (!this.a.k) {
2865      this.pre.translate(-this.a.v[0], -this.a.v[1], this.a.v[2]);
2866      this.appliedTransformations = 1;
2867    } else {
2868      return;
2869    }
2870    if (!this.s.effectsSequence.length) {
2871      this.pre.scale(this.s.v[0], this.s.v[1], this.s.v[2]);
2872      this.appliedTransformations = 2;
2873    } else {
2874      return;
2875    }
2876    if (this.sk) {
2877      if (!this.sk.effectsSequence.length && !this.sa.effectsSequence.length) {
2878        this.pre.skewFromAxis(-this.sk.v, this.sa.v);
2879        this.appliedTransformations = 3;
2880      } else {
2881        return;
2882      }
2883    }
2884    if (this.r) {
2885      if (!this.r.effectsSequence.length) {
2886        this.pre.rotate(-this.r.v);
2887        this.appliedTransformations = 4;
2888      }
2889    } else if (!this.rz.effectsSequence.length && !this.ry.effectsSequence.length && !this.rx.effectsSequence.length && !this.or.effectsSequence.length) {
2890      this.pre.rotateZ(-this.rz.v).rotateY(this.ry.v).rotateX(this.rx.v).rotateZ(-this.or.v[2])
2891        .rotateY(this.or.v[1])
2892        .rotateX(this.or.v[0]);
2893      this.appliedTransformations = 4;
2894    }
2895  }
2896
2897  function autoOrient() {
2898    //
2899    // var prevP = this.getValueAtTime();
2900  }
2901
2902  function addDynamicProperty(prop) {
2903    this._addDynamicProperty(prop);
2904    this.elem.addDynamicProperty(prop);
2905    this._isDirty = true;
2906  }
2907
2908  function TransformProperty(elem, data, container) {
2909    this.elem = elem;
2910    this.frameId = -1;
2911    this.propType = 'transform';
2912    this.data = data;
2913    this.v = new Matrix();
2914    // Precalculated matrix with non animated properties
2915    this.pre = new Matrix();
2916    this.appliedTransformations = 0;
2917    this.initDynamicPropertyContainer(container || elem);
2918    if (data.p && data.p.s) {
2919      this.px = PropertyFactory.getProp(elem, data.p.x, 0, 0, this);
2920      this.py = PropertyFactory.getProp(elem, data.p.y, 0, 0, this);
2921      if (data.p.z) {
2922        this.pz = PropertyFactory.getProp(elem, data.p.z, 0, 0, this);
2923      }
2924    } else {
2925      this.p = PropertyFactory.getProp(elem, data.p || { k: [0, 0, 0] }, 1, 0, this);
2926    }
2927    if (data.rx) {
2928      this.rx = PropertyFactory.getProp(elem, data.rx, 0, degToRads, this);
2929      this.ry = PropertyFactory.getProp(elem, data.ry, 0, degToRads, this);
2930      this.rz = PropertyFactory.getProp(elem, data.rz, 0, degToRads, this);
2931      if (data.or.k[0].ti) {
2932        var i;
2933        var len = data.or.k.length;
2934        for (i = 0; i < len; i += 1) {
2935          data.or.k[i].to = null;
2936          data.or.k[i].ti = null;
2937        }
2938      }
2939      this.or = PropertyFactory.getProp(elem, data.or, 1, degToRads, this);
2940      // sh Indicates it needs to be capped between -180 and 180
2941      this.or.sh = true;
2942    } else {
2943      this.r = PropertyFactory.getProp(elem, data.r || { k: 0 }, 0, degToRads, this);
2944    }
2945    if (data.sk) {
2946      this.sk = PropertyFactory.getProp(elem, data.sk, 0, degToRads, this);
2947      this.sa = PropertyFactory.getProp(elem, data.sa, 0, degToRads, this);
2948    }
2949    this.a = PropertyFactory.getProp(elem, data.a || { k: [0, 0, 0] }, 1, 0, this);
2950    this.s = PropertyFactory.getProp(elem, data.s || { k: [100, 100, 100] }, 1, 0.01, this);
2951    // Opacity is not part of the transform properties, that's why it won't use this.dynamicProperties. That way transforms won't get updated if opacity changes.
2952    if (data.o) {
2953      this.o = PropertyFactory.getProp(elem, data.o, 0, 0.01, elem);
2954    } else {
2955      this.o = { _mdf: false, v: 1 };
2956    }
2957    this._isDirty = true;
2958    if (!this.dynamicProperties.length) {
2959      this.getValue(true);
2960    }
2961  }
2962
2963  TransformProperty.prototype = {
2964    applyToMatrix: applyToMatrix,
2965    getValue: processKeys,
2966    precalculateMatrix: precalculateMatrix,
2967    autoOrient: autoOrient,
2968  };
2969
2970  extendPrototype([DynamicPropertyContainer], TransformProperty);
2971  TransformProperty.prototype.addDynamicProperty = addDynamicProperty;
2972  TransformProperty.prototype._addDynamicProperty = DynamicPropertyContainer.prototype.addDynamicProperty;
2973
2974  function getTransformProperty(elem, data, container) {
2975    return new TransformProperty(elem, data, container);
2976  }
2977
2978  return {
2979    getTransformProperty: getTransformProperty,
2980  };
2981}());
2982
2983/* global createSizedArray, createSizedArray, pointPool */
2984
2985function ShapePath() {
2986  this.c = false;