@lumen5/lottie-web 5.14.0

package/player/js/utils/TransformProperty.js

@@ -0,0 +1,251 @@
+import {
+  degToRads,
+} from './common';
+import {
+  extendPrototype,
+} from './functionExtensions';
+import DynamicPropertyContainer from './helpers/dynamicProperties';
+import Matrix from '../3rd_party/transformation-matrix';
+import PropertyFactory from './PropertyFactory';
+
+const TransformPropertyFactory = (function () {
+  var defaultVector = [0, 0];
+
+  function applyToMatrix(mat) {
+    var _mdf = this._mdf;
+    this.iterateDynamicProperties();
+    this._mdf = this._mdf || _mdf;
+    if (this.a) {
+      mat.translate(-this.a.v[0], -this.a.v[1], this.a.v[2]);
+    }
+    if (this.s) {
+      mat.scale(this.s.v[0], this.s.v[1], this.s.v[2]);
+    }
+    if (this.sk) {
+      mat.skewFromAxis(-this.sk.v, this.sa.v);
+    }
+    if (this.r) {
+      mat.rotate(-this.r.v);
+    } else {
+      mat.rotateZ(-this.rz.v).rotateY(this.ry.v).rotateX(this.rx.v).rotateZ(-this.or.v[2])
+        .rotateY(this.or.v[1])
+        .rotateX(this.or.v[0]);
+    }
+    if (this.data.p.s) {
+      if (this.data.p.z) {
+        mat.translate(this.px.v, this.py.v, -this.pz.v);
+      } else {
+        mat.translate(this.px.v, this.py.v, 0);
+      }
+    } else {
+      mat.translate(this.p.v[0], this.p.v[1], -this.p.v[2]);
+    }
+  }
+  function processKeys(forceRender) {
+    if (this.elem.globalData.frameId === this.frameId) {
+      return;
+    }
+    if (this._isDirty) {
+      this.precalculateMatrix();
+      this._isDirty = false;
+    }
+
+    this.iterateDynamicProperties();
+
+    if (this._mdf || forceRender) {
+      var frameRate;
+      this.v.cloneFromProps(this.pre.props);
+      if (this.appliedTransformations < 1) {
+        this.v.translate(-this.a.v[0], -this.a.v[1], this.a.v[2]);
+      }
+      if (this.appliedTransformations < 2) {
+        this.v.scale(this.s.v[0], this.s.v[1], this.s.v[2]);
+      }
+      if (this.sk && this.appliedTransformations < 3) {
+        this.v.skewFromAxis(-this.sk.v, this.sa.v);
+      }
+      if (this.r && this.appliedTransformations < 4) {
+        this.v.rotate(-this.r.v);
+      } else if (!this.r && this.appliedTransformations < 4) {
+        this.v.rotateZ(-this.rz.v).rotateY(this.ry.v).rotateX(this.rx.v).rotateZ(-this.or.v[2])
+          .rotateY(this.or.v[1])
+          .rotateX(this.or.v[0]);
+      }
+      if (this.autoOriented) {
+        var v1;
+        var v2;
+        frameRate = this.elem.globalData.frameRate;
+        if (this.p && this.p.keyframes && this.p.getValueAtTime) {
+          if (this.p._caching.lastFrame + this.p.offsetTime <= this.p.keyframes[0].t) {
+            v1 = this.p.getValueAtTime((this.p.keyframes[0].t + 0.01) / frameRate, 0);
+            v2 = this.p.getValueAtTime(this.p.keyframes[0].t / frameRate, 0);
+          } else if (this.p._caching.lastFrame + this.p.offsetTime >= this.p.keyframes[this.p.keyframes.length - 1].t) {
+            v1 = this.p.getValueAtTime((this.p.keyframes[this.p.keyframes.length - 1].t / frameRate), 0);
+            v2 = this.p.getValueAtTime((this.p.keyframes[this.p.keyframes.length - 1].t - 0.05) / frameRate, 0);
+          } else {
+            v1 = this.p.pv;
+            v2 = this.p.getValueAtTime((this.p._caching.lastFrame + this.p.offsetTime - 0.01) / frameRate, this.p.offsetTime);
+          }
+        } else if (this.px && this.px.keyframes && this.py.keyframes && this.px.getValueAtTime && this.py.getValueAtTime) {
+          v1 = [];
+          v2 = [];
+          var px = this.px;
+          var py = this.py;
+          if (px._caching.lastFrame + px.offsetTime <= px.keyframes[0].t) {
+            v1[0] = px.getValueAtTime((px.keyframes[0].t + 0.01) / frameRate, 0);
+            v1[1] = py.getValueAtTime((py.keyframes[0].t + 0.01) / frameRate, 0);
+            v2[0] = px.getValueAtTime((px.keyframes[0].t) / frameRate, 0);
+            v2[1] = py.getValueAtTime((py.keyframes[0].t) / frameRate, 0);
+          } else if (px._caching.lastFrame + px.offsetTime >= px.keyframes[px.keyframes.length - 1].t) {
+            v1[0] = px.getValueAtTime((px.keyframes[px.keyframes.length - 1].t / frameRate), 0);
+            v1[1] = py.getValueAtTime((py.keyframes[py.keyframes.length - 1].t / frameRate), 0);
+            v2[0] = px.getValueAtTime((px.keyframes[px.keyframes.length - 1].t - 0.01) / frameRate, 0);
+            v2[1] = py.getValueAtTime((py.keyframes[py.keyframes.length - 1].t - 0.01) / frameRate, 0);
+          } else {
+            v1 = [px.pv, py.pv];
+            v2[0] = px.getValueAtTime((px._caching.lastFrame + px.offsetTime - 0.01) / frameRate, px.offsetTime);
+            v2[1] = py.getValueAtTime((py._caching.lastFrame + py.offsetTime - 0.01) / frameRate, py.offsetTime);
+          }
+        } else {
+          v2 = defaultVector;
+          v1 = v2;
+        }
+        this.v.rotate(-Math.atan2(v1[1] - v2[1], v1[0] - v2[0]));
+      }
+      if (this.data.p && this.data.p.s) {
+        if (this.data.p.z) {
+          this.v.translate(this.px.v, this.py.v, -this.pz.v);
+        } else {
+          this.v.translate(this.px.v, this.py.v, 0);
+        }
+      } else {
+        this.v.translate(this.p.v[0], this.p.v[1], -this.p.v[2]);
+      }
+    }
+    this.frameId = this.elem.globalData.frameId;
+  }
+
+  function precalculateMatrix() {
+    this.appliedTransformations = 0;
+    this.pre.reset();
+
+    if (!this.a.effectsSequence.length) {
+      this.pre.translate(-this.a.v[0], -this.a.v[1], this.a.v[2]);
+      this.appliedTransformations = 1;
+    } else {
+      return;
+    }
+    if (!this.s.effectsSequence.length) {
+      this.pre.scale(this.s.v[0], this.s.v[1], this.s.v[2]);
+      this.appliedTransformations = 2;
+    } else {
+      return;
+    }
+    if (this.sk) {
+      if (!this.sk.effectsSequence.length && !this.sa.effectsSequence.length) {
+        this.pre.skewFromAxis(-this.sk.v, this.sa.v);
+        this.appliedTransformations = 3;
+      } else {
+        return;
+      }
+    }
+    if (this.r) {
+      if (!this.r.effectsSequence.length) {
+        this.pre.rotate(-this.r.v);
+        this.appliedTransformations = 4;
+      }
+    } else if (!this.rz.effectsSequence.length && !this.ry.effectsSequence.length && !this.rx.effectsSequence.length && !this.or.effectsSequence.length) {
+      this.pre.rotateZ(-this.rz.v).rotateY(this.ry.v).rotateX(this.rx.v).rotateZ(-this.or.v[2])
+        .rotateY(this.or.v[1])
+        .rotateX(this.or.v[0]);
+      this.appliedTransformations = 4;
+    }
+  }
+
+  function autoOrient() {
+    //
+    // var prevP = this.getValueAtTime();
+  }
+
+  function addDynamicProperty(prop) {
+    this._addDynamicProperty(prop);
+    this.elem.addDynamicProperty(prop);
+    this._isDirty = true;
+  }
+
+  function TransformProperty(elem, data, container) {
+    this.elem = elem;
+    this.frameId = -1;
+    this.propType = 'transform';
+    this.data = data;
+    this.v = new Matrix();
+    // Precalculated matrix with non animated properties
+    this.pre = new Matrix();
+    this.appliedTransformations = 0;
+    this.initDynamicPropertyContainer(container || elem);
+    if (data.p && data.p.s) {
+      this.px = PropertyFactory.getProp(elem, data.p.x, 0, 0, this);
+      this.py = PropertyFactory.getProp(elem, data.p.y, 0, 0, this);
+      if (data.p.z) {
+        this.pz = PropertyFactory.getProp(elem, data.p.z, 0, 0, this);
+      }
+    } else {
+      this.p = PropertyFactory.getProp(elem, data.p || { k: [0, 0, 0] }, 1, 0, this);
+    }
+    if (data.rx) {
+      this.rx = PropertyFactory.getProp(elem, data.rx, 0, degToRads, this);
+      this.ry = PropertyFactory.getProp(elem, data.ry, 0, degToRads, this);
+      this.rz = PropertyFactory.getProp(elem, data.rz, 0, degToRads, this);
+      if (data.or.k[0].ti) {
+        var i;
+        var len = data.or.k.length;
+        for (i = 0; i < len; i += 1) {
+          data.or.k[i].to = null;
+          data.or.k[i].ti = null;
+        }
+      }
+      this.or = PropertyFactory.getProp(elem, data.or, 1, degToRads, this);
+      // sh Indicates it needs to be capped between -180 and 180
+      this.or.sh = true;
+    } else {
+      this.r = PropertyFactory.getProp(elem, data.r || { k: 0 }, 0, degToRads, this);
+    }
+    if (data.sk) {
+      this.sk = PropertyFactory.getProp(elem, data.sk, 0, degToRads, this);
+      this.sa = PropertyFactory.getProp(elem, data.sa, 0, degToRads, this);
+    }
+    this.a = PropertyFactory.getProp(elem, data.a || { k: [0, 0, 0] }, 1, 0, this);
+    this.s = PropertyFactory.getProp(elem, data.s || { k: [100, 100, 100] }, 1, 0.01, this);
+    // 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.
+    if (data.o) {
+      this.o = PropertyFactory.getProp(elem, data.o, 0, 0.01, elem);
+    } else {
+      this.o = { _mdf: false, v: 1 };
+    }
+    this._isDirty = true;
+    if (!this.dynamicProperties.length) {
+      this.getValue(true);
+    }
+  }
+
+  TransformProperty.prototype = {
+    applyToMatrix: applyToMatrix,
+    getValue: processKeys,
+    precalculateMatrix: precalculateMatrix,
+    autoOrient: autoOrient,
+  };
+
+  extendPrototype([DynamicPropertyContainer], TransformProperty);
+  TransformProperty.prototype.addDynamicProperty = addDynamicProperty;
+  TransformProperty.prototype._addDynamicProperty = DynamicPropertyContainer.prototype.addDynamicProperty;
+
+  function getTransformProperty(elem, data, container) {
+    return new TransformProperty(elem, data, container);
+  }
+
+  return {
+    getTransformProperty: getTransformProperty,
+  };
+}());
+
+export default TransformPropertyFactory;

package/player/js/utils/animationFramePolyFill.js

@@ -0,0 +1,25 @@
+(function () {
+  var lastTime = 0;
+  var vendors = ['ms', 'moz', 'webkit', 'o'];
+  for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) { // eslint-disable-line no-plusplus
+    window.requestAnimationFrame = window[vendors[x] + 'RequestAnimationFrame'];
+    window.cancelAnimationFrame = window[vendors[x] + 'CancelAnimationFrame'] || window[vendors[x] + 'CancelRequestAnimationFrame'];
+  }
+  if (!window.requestAnimationFrame) {
+    window.requestAnimationFrame = function (callback) {
+      var currTime = new Date().getTime();
+      var timeToCall = Math.max(0, 16 - (currTime - lastTime));
+      var id = setTimeout(function () {
+        callback(currTime + timeToCall);
+      },
+      timeToCall);
+      lastTime = currTime + timeToCall;
+      return id;
+    };
+  }
+  if (!window.cancelAnimationFrame) {
+    window.cancelAnimationFrame = function (id) {
+      clearTimeout(id);
+    };
+  }
+}());

package/player/js/utils/asset_loader.js

@@ -0,0 +1,53 @@
+const assetLoader = (function () {
+  function formatResponse(xhr) {
+    // using typeof doubles the time of execution of this method,
+    // so if available, it's better to use the header to validate the type
+    var contentTypeHeader = xhr.getResponseHeader('content-type');
+    if (contentTypeHeader && xhr.responseType === 'json' && contentTypeHeader.indexOf('json') !== -1) {
+      return xhr.response;
+    }
+    if (xhr.response && typeof xhr.response === 'object') {
+      return xhr.response;
+    } if (xhr.response && typeof xhr.response === 'string') {
+      return JSON.parse(xhr.response);
+    } if (xhr.responseText) {
+      return JSON.parse(xhr.responseText);
+    }
+    return null;
+  }
+
+  function loadAsset(path, callback, errorCallback) {
+    var response;
+    var xhr = new XMLHttpRequest();
+    // set responseType after calling open or IE will break.
+    try {
+      // This crashes on Android WebView prior to KitKat
+      xhr.responseType = 'json';
+    } catch (err) {} // eslint-disable-line no-empty
+    xhr.onreadystatechange = function () {
+      if (xhr.readyState === 4) {
+        if (xhr.status === 200) {
+          response = formatResponse(xhr);
+          callback(response);
+        } else {
+          try {
+            response = formatResponse(xhr);
+            callback(response);
+          } catch (err) {
+            if (errorCallback) {
+              errorCallback(err);
+            }
+          }
+        }
+      }
+    };
+    // Hack to workaround banner validation
+    xhr.open(['G', 'E', 'T'].join(''), path, true);
+    xhr.send();
+  }
+  return {
+    load: loadAsset,
+  };
+}());
+
+export default assetLoader;

package/player/js/utils/asset_loader_worker_override.js

@@ -0,0 +1,3 @@
+const assetLoader = null;
+
+export default assetLoader;

package/player/js/utils/audio/AudioController.js

@@ -0,0 +1,85 @@
+// import Howl from '../../3rd_party/howler';
+
+const audioControllerFactory = (function () {
+  function AudioController(audioFactory) {
+    this.audios = [];
+    this.audioFactory = audioFactory;
+    this._volume = 1;
+    this._isMuted = false;
+  }
+
+  AudioController.prototype = {
+    addAudio: function (audio) {
+      this.audios.push(audio);
+    },
+    pause: function () {
+      var i;
+      var len = this.audios.length;
+      for (i = 0; i < len; i += 1) {
+        this.audios[i].pause();
+      }
+    },
+    resume: function () {
+      var i;
+      var len = this.audios.length;
+      for (i = 0; i < len; i += 1) {
+        this.audios[i].resume();
+      }
+    },
+    setRate: function (rateValue) {
+      var i;
+      var len = this.audios.length;
+      for (i = 0; i < len; i += 1) {
+        this.audios[i].setRate(rateValue);
+      }
+    },
+    createAudio: function (assetPath) {
+      if (this.audioFactory) {
+        return this.audioFactory(assetPath);
+      } if (window.Howl) {
+        return new window.Howl({
+          src: [assetPath],
+        });
+      }
+      return {
+        isPlaying: false,
+        play: function () { this.isPlaying = true; },
+        seek: function () { this.isPlaying = false; },
+        playing: function () {},
+        rate: function () {},
+        setVolume: function () {},
+      };
+    },
+    setAudioFactory: function (audioFactory) {
+      this.audioFactory = audioFactory;
+    },
+    setVolume: function (value) {
+      this._volume = value;
+      this._updateVolume();
+    },
+    mute: function () {
+      this._isMuted = true;
+      this._updateVolume();
+    },
+    unmute: function () {
+      this._isMuted = false;
+      this._updateVolume();
+    },
+    getVolume: function () {
+      return this._volume;
+    },
+    _updateVolume: function () {
+      var i;
+      var len = this.audios.length;
+      for (i = 0; i < len; i += 1) {
+        this.audios[i].volume(this._volume * (this._isMuted ? 0 : 1));
+      }
+    },
+  };
+
+  return function () {
+    return new AudioController();
+  };
+}());
+
+export default audioControllerFactory;

package/player/js/utils/audio/AudioElement.js

@@ -0,0 +1,6 @@
+// TODO: fix Overwrite
+function AudioElement(data) {
+  this.audioData = data;
+}
+
+export default AudioElement;

package/player/js/utils/bez.js

@@ -0,0 +1,251 @@
+import {
+  bmPow,
+  bmFloor,
+  bmSqrt,
+  getDefaultCurveSegments,
+} from './common';
+import {
+  createSizedArray,
+  createTypedArray,
+} from './helpers/arrays';
+import segmentsLengthPool from './pooling/segments_length_pool';
+import bezierLengthPool from './pooling/bezier_length_pool';
+
+function bezFunction() {
+  var math = Math;
+
+  function pointOnLine2D(x1, y1, x2, y2, x3, y3) {
+    var det1 = (x1 * y2) + (y1 * x3) + (x2 * y3) - (x3 * y2) - (y3 * x1) - (x2 * y1);
+    return det1 > -0.001 && det1 < 0.001;
+  }
+
+  function pointOnLine3D(x1, y1, z1, x2, y2, z2, x3, y3, z3) {
+    if (z1 === 0 && z2 === 0 && z3 === 0) {
+      return pointOnLine2D(x1, y1, x2, y2, x3, y3);
+    }
+    var dist1 = math.sqrt(math.pow(x2 - x1, 2) + math.pow(y2 - y1, 2) + math.pow(z2 - z1, 2));
+    var dist2 = math.sqrt(math.pow(x3 - x1, 2) + math.pow(y3 - y1, 2) + math.pow(z3 - z1, 2));
+    var dist3 = math.sqrt(math.pow(x3 - x2, 2) + math.pow(y3 - y2, 2) + math.pow(z3 - z2, 2));
+    var diffDist;
+    if (dist1 > dist2) {
+      if (dist1 > dist3) {
+        diffDist = dist1 - dist2 - dist3;
+      } else {
+        diffDist = dist3 - dist2 - dist1;
+      }
+    } else if (dist3 > dist2) {
+      diffDist = dist3 - dist2 - dist1;
+    } else {
+      diffDist = dist2 - dist1 - dist3;
+    }
+    return diffDist > -0.0001 && diffDist < 0.0001;
+  }
+
+  var getBezierLength = (function () {
+    return function (pt1, pt2, pt3, pt4) {
+      var curveSegments = getDefaultCurveSegments();
+      var k;
+      var i;
+      var len;
+      var ptCoord;
+      var perc;
+      var addedLength = 0;
+      var ptDistance;
+      var point = [];
+      var lastPoint = [];
+      var lengthData = bezierLengthPool.newElement();
+      len = pt3.length;
+      for (k = 0; k < curveSegments; k += 1) {
+        perc = k / (curveSegments - 1);
+        ptDistance = 0;
+        for (i = 0; i < len; i += 1) {
+          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];
+          point[i] = ptCoord;
+          if (lastPoint[i] !== null) {
+            ptDistance += bmPow(point[i] - lastPoint[i], 2);
+          }
+          lastPoint[i] = point[i];
+        }
+        if (ptDistance) {
+          ptDistance = bmSqrt(ptDistance);
+          addedLength += ptDistance;
+        }
+        lengthData.percents[k] = perc;
+        lengthData.lengths[k] = addedLength;
+      }
+      lengthData.addedLength = addedLength;
+      return lengthData;
+    };
+  }());
+
+  function getSegmentsLength(shapeData) {
+    var segmentsLength = segmentsLengthPool.newElement();
+    var closed = shapeData.c;
+    var pathV = shapeData.v;
+    var pathO = shapeData.o;
+    var pathI = shapeData.i;
+    var i;
+    var len = shapeData._length;
+    var lengths = segmentsLength.lengths;
+    var totalLength = 0;
+    for (i = 0; i < len - 1; i += 1) {
+      lengths[i] = getBezierLength(pathV[i], pathV[i + 1], pathO[i], pathI[i + 1]);
+      totalLength += lengths[i].addedLength;
+    }
+    if (closed && len) {
+      lengths[i] = getBezierLength(pathV[i], pathV[0], pathO[i], pathI[0]);
+      totalLength += lengths[i].addedLength;
+    }
+    segmentsLength.totalLength = totalLength;
+    return segmentsLength;
+  }
+
+  function BezierData(length) {
+    this.segmentLength = 0;
+    this.points = new Array(length);
+  }
+
+  function PointData(partial, point) {
+    this.partialLength = partial;
+    this.point = point;
+  }
+
+  var buildBezierData = (function () {
+    var storedData = {};
+
+    return function (pt1, pt2, pt3, pt4) {
+      var bezierName = (pt1[0] + '_' + pt1[1] + '_' + pt2[0] + '_' + pt2[1] + '_' + pt3[0] + '_' + pt3[1] + '_' + pt4[0] + '_' + pt4[1]).replace(/\./g, 'p');
+      if (!storedData[bezierName]) {
+        var curveSegments = getDefaultCurveSegments();
+        var k;
+        var i;
+        var len;
+        var ptCoord;
+        var perc;
+        var addedLength = 0;
+        var ptDistance;
+        var point;
+        var lastPoint = null;
+        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])) {
+          curveSegments = 2;
+        }
+        var bezierData = new BezierData(curveSegments);
+        len = pt3.length;
+        for (k = 0; k < curveSegments; k += 1) {
+          point = createSizedArray(len);
+          perc = k / (curveSegments - 1);
+          ptDistance = 0;
+          for (i = 0; i < len; i += 1) {
+            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];
+            point[i] = ptCoord;
+            if (lastPoint !== null) {
+              ptDistance += bmPow(point[i] - lastPoint[i], 2);
+            }
+          }
+          ptDistance = bmSqrt(ptDistance);
+          addedLength += ptDistance;
+          bezierData.points[k] = new PointData(ptDistance, point);
+          lastPoint = point;
+        }
+        bezierData.segmentLength = addedLength;
+        storedData[bezierName] = bezierData;
+      }
+      return storedData[bezierName];
+    };
+  }());
+
+  function getDistancePerc(perc, bezierData) {
+    var percents = bezierData.percents;
+    var lengths = bezierData.lengths;
+    var len = percents.length;
+    var initPos = bmFloor((len - 1) * perc);
+    var lengthPos = perc * bezierData.addedLength;
+    var lPerc = 0;
+    if (initPos === len - 1 || initPos === 0 || lengthPos === lengths[initPos]) {
+      return percents[initPos];
+    }
+    var dir = lengths[initPos] > lengthPos ? -1 : 1;
+    var flag = true;
+    while (flag) {
+      if (lengths[initPos] <= lengthPos && lengths[initPos + 1] > lengthPos) {
+        lPerc = (lengthPos - lengths[initPos]) / (lengths[initPos + 1] - lengths[initPos]);
+        flag = false;
+      } else {
+        initPos += dir;
+      }
+      if (initPos < 0 || initPos >= len - 1) {
+        // FIX for TypedArrays that don't store floating point values with enough accuracy
+        if (initPos === len - 1) {
+          return percents[initPos];
+        }
+        flag = false;
+      }
+    }
+    return percents[initPos] + (percents[initPos + 1] - percents[initPos]) * lPerc;
+  }
+
+  function getPointInSegment(pt1, pt2, pt3, pt4, percent, bezierData) {
+    var t1 = getDistancePerc(percent, bezierData);
+    var u1 = 1 - t1;
+    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;
+    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;
+    return [ptX, ptY];
+  }
+
+  var bezierSegmentPoints = createTypedArray('float32', 8);
+
+  function getNewSegment(pt1, pt2, pt3, pt4, startPerc, endPerc, bezierData) {
+    if (startPerc < 0) {
+      startPerc = 0;
+    } else if (startPerc > 1) {
+      startPerc = 1;
+    }
+    var t0 = getDistancePerc(startPerc, bezierData);
+    endPerc = endPerc > 1 ? 1 : endPerc;
+    var t1 = getDistancePerc(endPerc, bezierData);
+    var i;
+    var len = pt1.length;
+    var u0 = 1 - t0;
+    var u1 = 1 - t1;
+    var u0u0u0 = u0 * u0 * u0;
+    var t0u0u0_3 = t0 * u0 * u0 * 3; // eslint-disable-line camelcase
+    var t0t0u0_3 = t0 * t0 * u0 * 3; // eslint-disable-line camelcase
+    var t0t0t0 = t0 * t0 * t0;
+    //
+    var u0u0u1 = u0 * u0 * u1;
+    var t0u0u1_3 = t0 * u0 * u1 + u0 * t0 * u1 + u0 * u0 * t1; // eslint-disable-line camelcase
+    var t0t0u1_3 = t0 * t0 * u1 + u0 * t0 * t1 + t0 * u0 * t1; // eslint-disable-line camelcase
+    var t0t0t1 = t0 * t0 * t1;
+    //
+    var u0u1u1 = u0 * u1 * u1;
+    var t0u1u1_3 = t0 * u1 * u1 + u0 * t1 * u1 + u0 * u1 * t1; // eslint-disable-line camelcase
+    var t0t1u1_3 = t0 * t1 * u1 + u0 * t1 * t1 + t0 * u1 * t1; // eslint-disable-line camelcase
+    var t0t1t1 = t0 * t1 * t1;
+    //
+    var u1u1u1 = u1 * u1 * u1;
+    var t1u1u1_3 = t1 * u1 * u1 + u1 * t1 * u1 + u1 * u1 * t1; // eslint-disable-line camelcase
+    var t1t1u1_3 = t1 * t1 * u1 + u1 * t1 * t1 + t1 * u1 * t1; // eslint-disable-line camelcase
+    var t1t1t1 = t1 * t1 * t1;
+    for (i = 0; i < len; i += 1) {
+      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
+      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
+      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
+      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
+    }
+
+    return bezierSegmentPoints;
+  }
+
+  return {
+    getSegmentsLength: getSegmentsLength,
+    getNewSegment: getNewSegment,
+    getPointInSegment: getPointInSegment,
+    buildBezierData: buildBezierData,
+    pointOnLine2D: pointOnLine2D,
+    pointOnLine3D: pointOnLine3D,
+  };
+}
+
+const bez = bezFunction();
+
+export default bez;