@lumen5/lottie-web 5.14.0

package/player/js/utils/shapes/TrimModifier.js

@@ -0,0 +1,359 @@
+import {
+  extendPrototype,
+} from '../functionExtensions';
+import PropertyFactory from '../PropertyFactory';
+import shapePool from '../pooling/shape_pool';
+import bez from '../bez';
+import {
+  ShapeModifier,
+} from './ShapeModifiers';
+import segmentsLengthPool from '../pooling/segments_length_pool';
+
+function TrimModifier() {
+}
+extendPrototype([ShapeModifier], TrimModifier);
+TrimModifier.prototype.initModifierProperties = function (elem, data) {
+  this.s = PropertyFactory.getProp(elem, data.s, 0, 0.01, this);
+  this.e = PropertyFactory.getProp(elem, data.e, 0, 0.01, this);
+  this.o = PropertyFactory.getProp(elem, data.o, 0, 0, this);
+  this.sValue = 0;
+  this.eValue = 0;
+  this.getValue = this.processKeys;
+  this.m = data.m;
+  this._isAnimated = !!this.s.effectsSequence.length || !!this.e.effectsSequence.length || !!this.o.effectsSequence.length;
+};
+
+TrimModifier.prototype.addShapeToModifier = function (shapeData) {
+  shapeData.pathsData = [];
+};
+
+TrimModifier.prototype.calculateShapeEdges = function (s, e, shapeLength, addedLength, totalModifierLength) {
+  var segments = [];
+  if (e <= 1) {
+    segments.push({
+      s: s,
+      e: e,
+    });
+  } else if (s >= 1) {
+    segments.push({
+      s: s - 1,
+      e: e - 1,
+    });
+  } else {
+    segments.push({
+      s: s,
+      e: 1,
+    });
+    segments.push({
+      s: 0,
+      e: e - 1,
+    });
+  }
+  var shapeSegments = [];
+  var i;
+  var len = segments.length;
+  var segmentOb;
+  for (i = 0; i < len; i += 1) {
+    segmentOb = segments[i];
+    if (!(segmentOb.e * totalModifierLength < addedLength || segmentOb.s * totalModifierLength > addedLength + shapeLength)) {
+      var shapeS;
+      var shapeE;
+      if (segmentOb.s * totalModifierLength <= addedLength) {
+        shapeS = 0;
+      } else {
+        shapeS = (segmentOb.s * totalModifierLength - addedLength) / shapeLength;
+      }
+      if (segmentOb.e * totalModifierLength >= addedLength + shapeLength) {
+        shapeE = 1;
+      } else {
+        shapeE = ((segmentOb.e * totalModifierLength - addedLength) / shapeLength);
+      }
+      shapeSegments.push([shapeS, shapeE]);
+    }
+  }
+  if (!shapeSegments.length) {
+    shapeSegments.push([0, 0]);
+  }
+  return shapeSegments;
+};
+
+TrimModifier.prototype.releasePathsData = function (pathsData) {
+  var i;
+  var len = pathsData.length;
+  for (i = 0; i < len; i += 1) {
+    segmentsLengthPool.release(pathsData[i]);
+  }
+  pathsData.length = 0;
+  return pathsData;
+};
+
+TrimModifier.prototype.processShapes = function (_isFirstFrame) {
+  var s;
+  var e;
+  if (this._mdf || _isFirstFrame) {
+    var o = (this.o.v % 360) / 360;
+    if (o < 0) {
+      o += 1;
+    }
+    if (this.s.v > 1) {
+      s = 1 + o;
+    } else if (this.s.v < 0) {
+      s = 0 + o;
+    } else {
+      s = this.s.v + o;
+    }
+    if (this.e.v > 1) {
+      e = 1 + o;
+    } else if (this.e.v < 0) {
+      e = 0 + o;
+    } else {
+      e = this.e.v + o;
+    }
+
+    if (s > e) {
+      var _s = s;
+      s = e;
+      e = _s;
+    }
+    s = Math.round(s * 10000) * 0.0001;
+    e = Math.round(e * 10000) * 0.0001;
+    this.sValue = s;
+    this.eValue = e;
+  } else {
+    s = this.sValue;
+    e = this.eValue;
+  }
+  var shapePaths;
+  var i;
+  var len = this.shapes.length;
+  var j;
+  var jLen;
+  var pathsData;
+  var pathData;
+  var totalShapeLength;
+  var totalModifierLength = 0;
+
+  if (e === s) {
+    for (i = 0; i < len; i += 1) {
+      this.shapes[i].localShapeCollection.releaseShapes();
+      this.shapes[i].shape._mdf = true;
+      this.shapes[i].shape.paths = this.shapes[i].localShapeCollection;
+      if (this._mdf) {
+        this.shapes[i].pathsData.length = 0;
+      }
+    }
+  } else if (!((e === 1 && s === 0) || (e === 0 && s === 1))) {
+    var segments = [];
+    var shapeData;
+    var localShapeCollection;
+    for (i = 0; i < len; i += 1) {
+      shapeData = this.shapes[i];
+      // if shape hasn't changed and trim properties haven't changed, cached previous path can be used
+      if (!shapeData.shape._mdf && !this._mdf && !_isFirstFrame && this.m !== 2) {
+        shapeData.shape.paths = shapeData.localShapeCollection;
+      } else {
+        shapePaths = shapeData.shape.paths;
+        jLen = shapePaths._length;
+        totalShapeLength = 0;
+        if (!shapeData.shape._mdf && shapeData.pathsData.length) {
+          totalShapeLength = shapeData.totalShapeLength;
+        } else {
+          pathsData = this.releasePathsData(shapeData.pathsData);
+          for (j = 0; j < jLen; j += 1) {
+            pathData = bez.getSegmentsLength(shapePaths.shapes[j]);
+            pathsData.push(pathData);
+            totalShapeLength += pathData.totalLength;
+          }
+          shapeData.totalShapeLength = totalShapeLength;
+          shapeData.pathsData = pathsData;
+        }
+
+        totalModifierLength += totalShapeLength;
+        shapeData.shape._mdf = true;
+      }
+    }
+    var shapeS = s;
+    var shapeE = e;
+    var addedLength = 0;
+    var edges;
+    for (i = len - 1; i >= 0; i -= 1) {
+      shapeData = this.shapes[i];
+      if (shapeData.shape._mdf) {
+        localShapeCollection = shapeData.localShapeCollection;
+        localShapeCollection.releaseShapes();
+        // if m === 2 means paths are trimmed individually so edges need to be found for this specific shape relative to whoel group
+        if (this.m === 2 && len > 1) {
+          edges = this.calculateShapeEdges(s, e, shapeData.totalShapeLength, addedLength, totalModifierLength);
+          addedLength += shapeData.totalShapeLength;
+        } else {
+          edges = [[shapeS, shapeE]];
+        }
+        jLen = edges.length;
+        for (j = 0; j < jLen; j += 1) {
+          shapeS = edges[j][0];
+          shapeE = edges[j][1];
+          segments.length = 0;
+          if (shapeE <= 1) {
+            segments.push({
+              s: shapeData.totalShapeLength * shapeS,
+              e: shapeData.totalShapeLength * shapeE,
+            });
+          } else if (shapeS >= 1) {
+            segments.push({
+              s: shapeData.totalShapeLength * (shapeS - 1),
+              e: shapeData.totalShapeLength * (shapeE - 1),
+            });
+          } else {
+            segments.push({
+              s: shapeData.totalShapeLength * shapeS,
+              e: shapeData.totalShapeLength,
+            });
+            segments.push({
+              s: 0,
+              e: shapeData.totalShapeLength * (shapeE - 1),
+            });
+          }
+          var newShapesData = this.addShapes(shapeData, segments[0]);
+          if (segments[0].s !== segments[0].e) {
+            if (segments.length > 1) {
+              var lastShapeInCollection = shapeData.shape.paths.shapes[shapeData.shape.paths._length - 1];
+              if (lastShapeInCollection.c) {
+                var lastShape = newShapesData.pop();
+                this.addPaths(newShapesData, localShapeCollection);
+                newShapesData = this.addShapes(shapeData, segments[1], lastShape);
+              } else {
+                this.addPaths(newShapesData, localShapeCollection);
+                newShapesData = this.addShapes(shapeData, segments[1]);
+              }
+            }
+            this.addPaths(newShapesData, localShapeCollection);
+          }
+        }
+        shapeData.shape.paths = localShapeCollection;
+      }
+    }
+  } else if (this._mdf) {
+    for (i = 0; i < len; i += 1) {
+      // Releasign Trim Cached paths data when no trim applied in case shapes are modified inbetween.
+      // Don't remove this even if it's losing cached info.
+      this.shapes[i].pathsData.length = 0;
+      this.shapes[i].shape._mdf = true;
+    }
+  }
+};
+
+TrimModifier.prototype.addPaths = function (newPaths, localShapeCollection) {
+  var i;
+  var len = newPaths.length;
+  for (i = 0; i < len; i += 1) {
+    localShapeCollection.addShape(newPaths[i]);
+  }
+};
+
+TrimModifier.prototype.addSegment = function (pt1, pt2, pt3, pt4, shapePath, pos, newShape) {
+  shapePath.setXYAt(pt2[0], pt2[1], 'o', pos);
+  shapePath.setXYAt(pt3[0], pt3[1], 'i', pos + 1);
+  if (newShape) {
+    shapePath.setXYAt(pt1[0], pt1[1], 'v', pos);
+  }
+  shapePath.setXYAt(pt4[0], pt4[1], 'v', pos + 1);
+};
+
+TrimModifier.prototype.addSegmentFromArray = function (points, shapePath, pos, newShape) {
+  shapePath.setXYAt(points[1], points[5], 'o', pos);
+  shapePath.setXYAt(points[2], points[6], 'i', pos + 1);
+  if (newShape) {
+    shapePath.setXYAt(points[0], points[4], 'v', pos);
+  }
+  shapePath.setXYAt(points[3], points[7], 'v', pos + 1);
+};
+
+TrimModifier.prototype.addShapes = function (shapeData, shapeSegment, shapePath) {
+  var pathsData = shapeData.pathsData;
+  var shapePaths = shapeData.shape.paths.shapes;
+  var i;
+  var len = shapeData.shape.paths._length;
+  var j;
+  var jLen;
+  var addedLength = 0;
+  var currentLengthData;
+  var segmentCount;
+  var lengths;
+  var segment;
+  var shapes = [];
+  var initPos;
+  var newShape = true;
+  if (!shapePath) {
+    shapePath = shapePool.newElement();
+    segmentCount = 0;
+    initPos = 0;
+  } else {
+    segmentCount = shapePath._length;
+    initPos = shapePath._length;
+  }
+  shapes.push(shapePath);
+  for (i = 0; i < len; i += 1) {
+    lengths = pathsData[i].lengths;
+    shapePath.c = shapePaths[i].c;
+    jLen = shapePaths[i].c ? lengths.length : lengths.length + 1;
+    for (j = 1; j < jLen; j += 1) {
+      currentLengthData = lengths[j - 1];
+      if (addedLength + currentLengthData.addedLength < shapeSegment.s) {
+        addedLength += currentLengthData.addedLength;
+        shapePath.c = false;
+      } else if (addedLength > shapeSegment.e) {
+        shapePath.c = false;
+        break;
+      } else {
+        if (shapeSegment.s <= addedLength && shapeSegment.e >= addedLength + currentLengthData.addedLength) {
+          this.addSegment(shapePaths[i].v[j - 1], shapePaths[i].o[j - 1], shapePaths[i].i[j], shapePaths[i].v[j], shapePath, segmentCount, newShape);
+          newShape = false;
+        } else {
+          segment = bez.getNewSegment(shapePaths[i].v[j - 1], shapePaths[i].v[j], shapePaths[i].o[j - 1], shapePaths[i].i[j], (shapeSegment.s - addedLength) / currentLengthData.addedLength, (shapeSegment.e - addedLength) / currentLengthData.addedLength, lengths[j - 1]);
+          this.addSegmentFromArray(segment, shapePath, segmentCount, newShape);
+          // this.addSegment(segment.pt1, segment.pt3, segment.pt4, segment.pt2, shapePath, segmentCount, newShape);
+          newShape = false;
+          shapePath.c = false;
+        }
+        addedLength += currentLengthData.addedLength;
+        segmentCount += 1;
+      }
+    }
+    if (shapePaths[i].c && lengths.length) {
+      currentLengthData = lengths[j - 1];
+      if (addedLength <= shapeSegment.e) {
+        var segmentLength = lengths[j - 1].addedLength;
+        if (shapeSegment.s <= addedLength && shapeSegment.e >= addedLength + segmentLength) {
+          this.addSegment(shapePaths[i].v[j - 1], shapePaths[i].o[j - 1], shapePaths[i].i[0], shapePaths[i].v[0], shapePath, segmentCount, newShape);
+          newShape = false;
+        } else {
+          segment = bez.getNewSegment(shapePaths[i].v[j - 1], shapePaths[i].v[0], shapePaths[i].o[j - 1], shapePaths[i].i[0], (shapeSegment.s - addedLength) / segmentLength, (shapeSegment.e - addedLength) / segmentLength, lengths[j - 1]);
+          this.addSegmentFromArray(segment, shapePath, segmentCount, newShape);
+          // this.addSegment(segment.pt1, segment.pt3, segment.pt4, segment.pt2, shapePath, segmentCount, newShape);
+          newShape = false;
+          shapePath.c = false;
+        }
+      } else {
+        shapePath.c = false;
+      }
+      addedLength += currentLengthData.addedLength;
+      segmentCount += 1;
+    }
+    if (shapePath._length) {
+      shapePath.setXYAt(shapePath.v[initPos][0], shapePath.v[initPos][1], 'i', initPos);
+      shapePath.setXYAt(shapePath.v[shapePath._length - 1][0], shapePath.v[shapePath._length - 1][1], 'o', shapePath._length - 1);
+    }
+    if (addedLength > shapeSegment.e) {
+      break;
+    }
+    if (i < len - 1) {
+      shapePath = shapePool.newElement();
+      newShape = true;
+      shapes.push(shapePath);
+      segmentCount = 0;
+    }
+  }
+  return shapes;
+};
+
+export default TrimModifier;

package/player/js/utils/shapes/ZigZagModifier.js

@@ -0,0 +1,174 @@
+import {
+  extendPrototype,
+} from '../functionExtensions';
+import PropertyFactory from '../PropertyFactory';
+import shapePool from '../pooling/shape_pool';
+import {
+  ShapeModifier,
+} from './ShapeModifiers';
+import { PolynomialBezier } from '../PolynomialBezier';
+
+function ZigZagModifier() {}
+extendPrototype([ShapeModifier], ZigZagModifier);
+ZigZagModifier.prototype.initModifierProperties = function (elem, data) {
+  this.getValue = this.processKeys;
+  this.amplitude = PropertyFactory.getProp(elem, data.s, 0, null, this);
+  this.frequency = PropertyFactory.getProp(elem, data.r, 0, null, this);
+  this.pointsType = PropertyFactory.getProp(elem, data.pt, 0, null, this);
+  this._isAnimated = this.amplitude.effectsSequence.length !== 0 || this.frequency.effectsSequence.length !== 0 || this.pointsType.effectsSequence.length !== 0;
+};
+
+function setPoint(outputBezier, point, angle, direction, amplitude, outAmplitude, inAmplitude) {
+  var angO = angle - Math.PI / 2;
+  var angI = angle + Math.PI / 2;
+  var px = point[0] + Math.cos(angle) * direction * amplitude;
+  var py = point[1] - Math.sin(angle) * direction * amplitude;
+
+  outputBezier.setTripleAt(
+    px,
+    py,
+    px + Math.cos(angO) * outAmplitude,
+    py - Math.sin(angO) * outAmplitude,
+    px + Math.cos(angI) * inAmplitude,
+    py - Math.sin(angI) * inAmplitude,
+    outputBezier.length()
+  );
+}
+
+function getPerpendicularVector(pt1, pt2) {
+  var vector = [
+    pt2[0] - pt1[0],
+    pt2[1] - pt1[1],
+  ];
+  var rot = -Math.PI * 0.5;
+  var rotatedVector = [
+    Math.cos(rot) * vector[0] - Math.sin(rot) * vector[1],
+    Math.sin(rot) * vector[0] + Math.cos(rot) * vector[1],
+  ];
+  return rotatedVector;
+}
+
+function getProjectingAngle(path, cur) {
+  var prevIndex = cur === 0 ? path.length() - 1 : cur - 1;
+  var nextIndex = (cur + 1) % path.length();
+  var prevPoint = path.v[prevIndex];
+  var nextPoint = path.v[nextIndex];
+  var pVector = getPerpendicularVector(prevPoint, nextPoint);
+  return Math.atan2(0, 1) - Math.atan2(pVector[1], pVector[0]);
+}
+
+function zigZagCorner(outputBezier, path, cur, amplitude, frequency, pointType, direction) {
+  var angle = getProjectingAngle(path, cur);
+  var point = path.v[cur % path._length];
+  var prevPoint = path.v[cur === 0 ? path._length - 1 : cur - 1];
+  var nextPoint = path.v[(cur + 1) % path._length];
+  var prevDist = pointType === 2
+    ? Math.sqrt(Math.pow(point[0] - prevPoint[0], 2) + Math.pow(point[1] - prevPoint[1], 2))
+    : 0;
+  var nextDist = pointType === 2
+    ? Math.sqrt(Math.pow(point[0] - nextPoint[0], 2) + Math.pow(point[1] - nextPoint[1], 2))
+    : 0;
+
+  setPoint(
+    outputBezier,
+    path.v[cur % path._length],
+    angle,
+    direction,
+    amplitude,
+    nextDist / ((frequency + 1) * 2),
+    prevDist / ((frequency + 1) * 2),
+    pointType
+  );
+}
+
+function zigZagSegment(outputBezier, segment, amplitude, frequency, pointType, direction) {
+  for (var i = 0; i < frequency; i += 1) {
+    var t = (i + 1) / (frequency + 1);
+
+    var dist = pointType === 2
+      ? Math.sqrt(Math.pow(segment.points[3][0] - segment.points[0][0], 2) + Math.pow(segment.points[3][1] - segment.points[0][1], 2))
+      : 0;
+
+    var angle = segment.normalAngle(t);
+    var point = segment.point(t);
+    setPoint(
+      outputBezier,
+      point,
+      angle,
+      direction,
+      amplitude,
+      dist / ((frequency + 1) * 2),
+      dist / ((frequency + 1) * 2),
+      pointType
+    );
+
+    direction = -direction;
+  }
+
+  return direction;
+}
+
+ZigZagModifier.prototype.processPath = function (path, amplitude, frequency, pointType) {
+  var count = path._length;
+  var clonedPath = shapePool.newElement();
+  clonedPath.c = path.c;
+
+  if (!path.c) {
+    count -= 1;
+  }
+
+  if (count === 0) return clonedPath;
+
+  var direction = -1;
+  var segment = PolynomialBezier.shapeSegment(path, 0);
+  zigZagCorner(clonedPath, path, 0, amplitude, frequency, pointType, direction);
+
+  for (var i = 0; i < count; i += 1) {
+    direction = zigZagSegment(clonedPath, segment, amplitude, frequency, pointType, -direction);
+
+    if (i === count - 1 && !path.c) {
+      segment = null;
+    } else {
+      segment = PolynomialBezier.shapeSegment(path, (i + 1) % count);
+    }
+
+    zigZagCorner(clonedPath, path, i + 1, amplitude, frequency, pointType, direction);
+  }
+
+  return clonedPath;
+};
+
+ZigZagModifier.prototype.processShapes = function (_isFirstFrame) {
+  var shapePaths;
+  var i;
+  var len = this.shapes.length;
+  var j;
+  var jLen;
+  var amplitude = this.amplitude.v;
+  var frequency = Math.max(0, Math.round(this.frequency.v));
+  var pointType = this.pointsType.v;
+
+  if (amplitude !== 0) {
+    var shapeData;
+    var localShapeCollection;
+    for (i = 0; i < len; i += 1) {
+      shapeData = this.shapes[i];
+      localShapeCollection = shapeData.localShapeCollection;
+      if (!(!shapeData.shape._mdf && !this._mdf && !_isFirstFrame)) {
+        localShapeCollection.releaseShapes();
+        shapeData.shape._mdf = true;
+        shapePaths = shapeData.shape.paths.shapes;
+        jLen = shapeData.shape.paths._length;
+        for (j = 0; j < jLen; j += 1) {
+          localShapeCollection.addShape(this.processPath(shapePaths[j], amplitude, frequency, pointType));
+        }
+      }
+      shapeData.shape.paths = shapeData.localShapeCollection;
+    }
+  }
+  if (!this.dynamicProperties.length) {
+    this._mdf = false;
+  }
+};
+
+export default ZigZagModifier;

package/player/js/utils/shapes/shapePathBuilder.js

@@ -0,0 +1,20 @@
+const buildShapeString = function (pathNodes, length, closed, mat) {
+  if (length === 0) {
+    return '';
+  }
+  var _o = pathNodes.o;
+  var _i = pathNodes.i;
+  var _v = pathNodes.v;
+  var i;
+  var shapeString = ' M' + mat.applyToPointStringified(_v[0][0], _v[0][1]);
+  for (i = 1; i < length; i += 1) {
+    shapeString += ' C' + mat.applyToPointStringified(_o[i - 1][0], _o[i - 1][1]) + ' ' + mat.applyToPointStringified(_i[i][0], _i[i][1]) + ' ' + mat.applyToPointStringified(_v[i][0], _v[i][1]);
+  }
+  if (closed && length) {
+    shapeString += ' C' + mat.applyToPointStringified(_o[i - 1][0], _o[i - 1][1]) + ' ' + mat.applyToPointStringified(_i[0][0], _i[0][1]) + ' ' + mat.applyToPointStringified(_v[0][0], _v[0][1]);
+    shapeString += 'z';
+  }
+  return shapeString;
+};
+
+export default buildShapeString;

package/player/js/utils/text/LetterProps.js

@@ -0,0 +1,60 @@
+function LetterProps(o, sw, sc, fc, m, p) {
+  this.o = o;
+  this.sw = sw;
+  this.sc = sc;
+  this.fc = fc;
+  this.m = m;
+  this.p = p;
+  this._mdf = {
+    o: true,
+    sw: !!sw,
+    sc: !!sc,
+    fc: !!fc,
+    m: true,
+    p: true,
+  };
+}
+
+LetterProps.prototype.update = function (o, sw, sc, fc, m, p) {
+  this._mdf.o = false;
+  this._mdf.sw = false;
+  this._mdf.sc = false;
+  this._mdf.fc = false;
+  this._mdf.m = false;
+  this._mdf.p = false;
+  var updated = false;
+
+  if (this.o !== o) {
+    this.o = o;
+    this._mdf.o = true;
+    updated = true;
+  }
+  if (this.sw !== sw) {
+    this.sw = sw;
+    this._mdf.sw = true;
+    updated = true;
+  }
+  if (this.sc !== sc) {
+    this.sc = sc;
+    this._mdf.sc = true;
+    updated = true;
+  }
+  if (this.fc !== fc) {
+    this.fc = fc;
+    this._mdf.fc = true;
+    updated = true;
+  }
+  if (this.m !== m) {
+    this.m = m;
+    this._mdf.m = true;
+    updated = true;
+  }
+  if (p.length && (this.p[0] !== p[0] || this.p[1] !== p[1] || this.p[4] !== p[4] || this.p[5] !== p[5] || this.p[12] !== p[12] || this.p[13] !== p[13])) {
+    this.p = p;
+    this._mdf.p = true;
+    updated = true;
+  }
+  return updated;
+};
+
+export default LetterProps;

package/player/js/utils/text/TextAnimatorDataProperty.js

@@ -0,0 +1,34 @@
+import {
+  degToRads,
+} from '../common';
+import PropertyFactory from '../PropertyFactory';
+import TextSelectorProp from './TextSelectorProperty';
+
+function TextAnimatorDataProperty(elem, animatorProps, container) {
+  var defaultData = { propType: false };
+  var getProp = PropertyFactory.getProp;
+  var textAnimatorAnimatables = animatorProps.a;
+  this.a = {
+    r: textAnimatorAnimatables.r ? getProp(elem, textAnimatorAnimatables.r, 0, degToRads, container) : defaultData,
+    rx: textAnimatorAnimatables.rx ? getProp(elem, textAnimatorAnimatables.rx, 0, degToRads, container) : defaultData,
+    ry: textAnimatorAnimatables.ry ? getProp(elem, textAnimatorAnimatables.ry, 0, degToRads, container) : defaultData,
+    sk: textAnimatorAnimatables.sk ? getProp(elem, textAnimatorAnimatables.sk, 0, degToRads, container) : defaultData,
+    sa: textAnimatorAnimatables.sa ? getProp(elem, textAnimatorAnimatables.sa, 0, degToRads, container) : defaultData,
+    s: textAnimatorAnimatables.s ? getProp(elem, textAnimatorAnimatables.s, 1, 0.01, container) : defaultData,
+    a: textAnimatorAnimatables.a ? getProp(elem, textAnimatorAnimatables.a, 1, 0, container) : defaultData,
+    o: textAnimatorAnimatables.o ? getProp(elem, textAnimatorAnimatables.o, 0, 0.01, container) : defaultData,
+    p: textAnimatorAnimatables.p ? getProp(elem, textAnimatorAnimatables.p, 1, 0, container) : defaultData,
+    sw: textAnimatorAnimatables.sw ? getProp(elem, textAnimatorAnimatables.sw, 0, 0, container) : defaultData,
+    sc: textAnimatorAnimatables.sc ? getProp(elem, textAnimatorAnimatables.sc, 1, 0, container) : defaultData,
+    fc: textAnimatorAnimatables.fc ? getProp(elem, textAnimatorAnimatables.fc, 1, 0, container) : defaultData,
+    fh: textAnimatorAnimatables.fh ? getProp(elem, textAnimatorAnimatables.fh, 0, 0, container) : defaultData,
+    fs: textAnimatorAnimatables.fs ? getProp(elem, textAnimatorAnimatables.fs, 0, 0.01, container) : defaultData,
+    fb: textAnimatorAnimatables.fb ? getProp(elem, textAnimatorAnimatables.fb, 0, 0.01, container) : defaultData,
+    t: textAnimatorAnimatables.t ? getProp(elem, textAnimatorAnimatables.t, 0, 0, container) : defaultData,
+  };
+
+  this.s = TextSelectorProp.getTextSelectorProp(elem, animatorProps.s, container);
+  this.s.t = animatorProps.s.t;
+}
+
+export default TextAnimatorDataProperty;