365DevNet/Tiber365
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
becarta
2025-05-16 00:17:42 +02:00
parent ea5c866137
commit bacf566ec9
6020 changed files with 1715262 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
node_modules/lottie-web/player/js/utils/BaseEvent.js generated vendored Normal file
View File

@@ -0,0 +1,42 @@
function BaseEvent() {}
BaseEvent.prototype = {
triggerEvent: function (eventName, args) {
if (this._cbs[eventName]) {
var callbacks = this._cbs[eventName];
for (var i = 0; i < callbacks.length; i += 1) {
callbacks[i](args);
}
}
},
addEventListener: function (eventName, callback) {
if (!this._cbs[eventName]) {
this._cbs[eventName] = [];
}
this._cbs[eventName].push(callback);
return function () {
this.removeEventListener(eventName, callback);
}.bind(this);
},
removeEventListener: function (eventName, callback) {
if (!callback) {
this._cbs[eventName] = null;
} else if (this._cbs[eventName]) {
var i = 0;
var len = this._cbs[eventName].length;
while (i < len) {
if (this._cbs[eventName][i] === callback) {
this._cbs[eventName].splice(i, 1);
i -= 1;
len -= 1;
}
i += 1;
}
if (!this._cbs[eventName].length) {
this._cbs[eventName] = null;
}
}
},
};
export default BaseEvent;

676
node_modules/lottie-web/player/js/utils/DataManager.js generated vendored Normal file
View File

@@ -0,0 +1,676 @@
import { getWebWorker } from '../main';
const dataManager = (function () {
var _counterId = 1;
var processes = [];
var workerFn;
var workerInstance;
var workerProxy = {
onmessage: function () {
},
postMessage: function (path) {
workerFn({
data: path,
});
},
};
var _workerSelf = {
postMessage: function (data) {
workerProxy.onmessage({
data: data,
});
},
};
function createWorker(fn) {
if (window.Worker && window.Blob && getWebWorker()) {
var blob = new Blob(['var _workerSelf = self; self.onmessage = ', fn.toString()], { type: 'text/javascript' });
// var blob = new Blob(['self.onmessage = ', fn.toString()], { type: 'text/javascript' });
var url = URL.createObjectURL(blob);
return new Worker(url);
}
workerFn = fn;
return workerProxy;
}
function setupWorker() {
if (!workerInstance) {
workerInstance = createWorker(function workerStart(e) {
function dataFunctionManager() {
function completeLayers(layers, comps) {
var layerData;
var i;
var len = layers.length;
var j;
var jLen;
var k;
var kLen;
for (i = 0; i < len; i += 1) {
layerData = layers[i];
if (('ks' in layerData) && !layerData.completed) {
layerData.completed = true;
if (layerData.hasMask) {
var maskProps = layerData.masksProperties;
jLen = maskProps.length;
for (j = 0; j < jLen; j += 1) {
if (maskProps[j].pt.k.i) {
convertPathsToAbsoluteValues(maskProps[j].pt.k);
} else {
kLen = maskProps[j].pt.k.length;
for (k = 0; k < kLen; k += 1) {
if (maskProps[j].pt.k[k].s) {
convertPathsToAbsoluteValues(maskProps[j].pt.k[k].s[0]);
}
if (maskProps[j].pt.k[k].e) {
convertPathsToAbsoluteValues(maskProps[j].pt.k[k].e[0]);
}
}
}
}
}
if (layerData.ty === 0) {
layerData.layers = findCompLayers(layerData.refId, comps);
completeLayers(layerData.layers, comps);
} else if (layerData.ty === 4) {
completeShapes(layerData.shapes);
} else if (layerData.ty === 5) {
completeText(layerData);
}
}
}
}
function completeChars(chars, assets) {
if (chars) {
var i = 0;
var len = chars.length;
for (i = 0; i < len; i += 1) {
if (chars[i].t === 1) {
// var compData = findComp(chars[i].data.refId, assets);
chars[i].data.layers = findCompLayers(chars[i].data.refId, assets);
// chars[i].data.ip = 0;
// chars[i].data.op = 99999;
// chars[i].data.st = 0;
// chars[i].data.sr = 1;
// chars[i].w = compData.w;
// chars[i].data.ks = {
// a: { k: [0, 0, 0], a: 0 },
// p: { k: [0, -compData.h, 0], a: 0 },
// r: { k: 0, a: 0 },
// s: { k: [100, 100], a: 0 },
// o: { k: 100, a: 0 },
// };
completeLayers(chars[i].data.layers, assets);
}
}
}
}
function findComp(id, comps) {
var i = 0;
var len = comps.length;
while (i < len) {
if (comps[i].id === id) {
return comps[i];
}
i += 1;
}
return null;
}
function findCompLayers(id, comps) {
var comp = findComp(id, comps);
if (comp) {
if (!comp.layers.__used) {
comp.layers.__used = true;
return comp.layers;
}
return JSON.parse(JSON.stringify(comp.layers));
}
return null;
}
function completeShapes(arr) {
var i;
var len = arr.length;
var j;
var jLen;
for (i = len - 1; i >= 0; i -= 1) {
if (arr[i].ty === 'sh') {
if (arr[i].ks.k.i) {
convertPathsToAbsoluteValues(arr[i].ks.k);
} else {
jLen = arr[i].ks.k.length;
for (j = 0; j < jLen; j += 1) {
if (arr[i].ks.k[j].s) {
convertPathsToAbsoluteValues(arr[i].ks.k[j].s[0]);
}
if (arr[i].ks.k[j].e) {
convertPathsToAbsoluteValues(arr[i].ks.k[j].e[0]);
}
}
}
} else if (arr[i].ty === 'gr') {
completeShapes(arr[i].it);
}
}
}
function convertPathsToAbsoluteValues(path) {
var i;
var len = path.i.length;
for (i = 0; i < len; i += 1) {
path.i[i][0] += path.v[i][0];
path.i[i][1] += path.v[i][1];
path.o[i][0] += path.v[i][0];
path.o[i][1] += path.v[i][1];
}
}
function checkVersion(minimum, animVersionString) {
var animVersion = animVersionString ? animVersionString.split('.') : [100, 100, 100];
if (minimum[0] > animVersion[0]) {
return true;
} if (animVersion[0] > minimum[0]) {
return false;
}
if (minimum[1] > animVersion[1]) {
return true;
} if (animVersion[1] > minimum[1]) {
return false;
}
if (minimum[2] > animVersion[2]) {
return true;
} if (animVersion[2] > minimum[2]) {
return false;
}
return null;
}
var checkText = (function () {
var minimumVersion = [4, 4, 14];
function updateTextLayer(textLayer) {
var documentData = textLayer.t.d;
textLayer.t.d = {
k: [
{
s: documentData,
t: 0,
},
],
};
}
function iterateLayers(layers) {
var i;
var len = layers.length;
for (i = 0; i < len; i += 1) {
if (layers[i].ty === 5) {
updateTextLayer(layers[i]);
}
}
}
return function (animationData) {
if (checkVersion(minimumVersion, animationData.v)) {
iterateLayers(animationData.layers);
if (animationData.assets) {
var i;
var len = animationData.assets.length;
for (i = 0; i < len; i += 1) {
if (animationData.assets[i].layers) {
iterateLayers(animationData.assets[i].layers);
}
}
}
}
};
}());
var checkChars = (function () {
var minimumVersion = [4, 7, 99];
return function (animationData) {
if (animationData.chars && !checkVersion(minimumVersion, animationData.v)) {
var i;
var len = animationData.chars.length;
for (i = 0; i < len; i += 1) {
var charData = animationData.chars[i];
if (charData.data && charData.data.shapes) {
completeShapes(charData.data.shapes);
charData.data.ip = 0;
charData.data.op = 99999;
charData.data.st = 0;
charData.data.sr = 1;
charData.data.ks = {
p: { k: [0, 0], a: 0 },
s: { k: [100, 100], a: 0 },
a: { k: [0, 0], a: 0 },
r: { k: 0, a: 0 },
o: { k: 100, a: 0 },
};
if (!animationData.chars[i].t) {
charData.data.shapes.push(
{
ty: 'no',
}
);
charData.data.shapes[0].it.push(
{
p: { k: [0, 0], a: 0 },
s: { k: [100, 100], a: 0 },
a: { k: [0, 0], a: 0 },
r: { k: 0, a: 0 },
o: { k: 100, a: 0 },
sk: { k: 0, a: 0 },
sa: { k: 0, a: 0 },
ty: 'tr',
}
);
}
}
}
}
};
}());
var checkPathProperties = (function () {
var minimumVersion = [5, 7, 15];
function updateTextLayer(textLayer) {
var pathData = textLayer.t.p;
if (typeof pathData.a === 'number') {
pathData.a = {
a: 0,
k: pathData.a,
};
}
if (typeof pathData.p === 'number') {
pathData.p = {
a: 0,
k: pathData.p,
};
}
if (typeof pathData.r === 'number') {
pathData.r = {
a: 0,
k: pathData.r,
};
}
}
function iterateLayers(layers) {
var i;
var len = layers.length;
for (i = 0; i < len; i += 1) {
if (layers[i].ty === 5) {
updateTextLayer(layers[i]);
}
}
}
return function (animationData) {
if (checkVersion(minimumVersion, animationData.v)) {
iterateLayers(animationData.layers);
if (animationData.assets) {
var i;
var len = animationData.assets.length;
for (i = 0; i < len; i += 1) {
if (animationData.assets[i].layers) {
iterateLayers(animationData.assets[i].layers);
}
}
}
}
};
}());
var checkColors = (function () {
var minimumVersion = [4, 1, 9];
function iterateShapes(shapes) {
var i;
var len = shapes.length;
var j;
var jLen;
for (i = 0; i < len; i += 1) {
if (shapes[i].ty === 'gr') {
iterateShapes(shapes[i].it);
} else if (shapes[i].ty === 'fl' || shapes[i].ty === 'st') {
if (shapes[i].c.k && shapes[i].c.k[0].i) {
jLen = shapes[i].c.k.length;
for (j = 0; j < jLen; j += 1) {
if (shapes[i].c.k[j].s) {
shapes[i].c.k[j].s[0] /= 255;
shapes[i].c.k[j].s[1] /= 255;
shapes[i].c.k[j].s[2] /= 255;
shapes[i].c.k[j].s[3] /= 255;
}
if (shapes[i].c.k[j].e) {
shapes[i].c.k[j].e[0] /= 255;
shapes[i].c.k[j].e[1] /= 255;
shapes[i].c.k[j].e[2] /= 255;
shapes[i].c.k[j].e[3] /= 255;
}
}
} else {
shapes[i].c.k[0] /= 255;
shapes[i].c.k[1] /= 255;
shapes[i].c.k[2] /= 255;
shapes[i].c.k[3] /= 255;
}
}
}
}
function iterateLayers(layers) {
var i;
var len = layers.length;
for (i = 0; i < len; i += 1) {
if (layers[i].ty === 4) {
iterateShapes(layers[i].shapes);
}
}
}
return function (animationData) {
if (checkVersion(minimumVersion, animationData.v)) {
iterateLayers(animationData.layers);
if (animationData.assets) {
var i;
var len = animationData.assets.length;
for (i = 0; i < len; i += 1) {
if (animationData.assets[i].layers) {
iterateLayers(animationData.assets[i].layers);
}
}
}
}
};
}());
var checkShapes = (function () {
var minimumVersion = [4, 4, 18];
function completeClosingShapes(arr) {
var i;
var len = arr.length;
var j;
var jLen;
for (i = len - 1; i >= 0; i -= 1) {
if (arr[i].ty === 'sh') {
if (arr[i].ks.k.i) {
arr[i].ks.k.c = arr[i].closed;
} else {
jLen = arr[i].ks.k.length;
for (j = 0; j < jLen; j += 1) {
if (arr[i].ks.k[j].s) {
arr[i].ks.k[j].s[0].c = arr[i].closed;
}
if (arr[i].ks.k[j].e) {
arr[i].ks.k[j].e[0].c = arr[i].closed;
}
}
}
} else if (arr[i].ty === 'gr') {
completeClosingShapes(arr[i].it);
}
}
}
function iterateLayers(layers) {
var layerData;
var i;
var len = layers.length;
var j;
var jLen;
var k;
var kLen;
for (i = 0; i < len; i += 1) {
layerData = layers[i];
if (layerData.hasMask) {
var maskProps = layerData.masksProperties;
jLen = maskProps.length;
for (j = 0; j < jLen; j += 1) {
if (maskProps[j].pt.k.i) {
maskProps[j].pt.k.c = maskProps[j].cl;
} else {
kLen = maskProps[j].pt.k.length;
for (k = 0; k < kLen; k += 1) {
if (maskProps[j].pt.k[k].s) {
maskProps[j].pt.k[k].s[0].c = maskProps[j].cl;
}
if (maskProps[j].pt.k[k].e) {
maskProps[j].pt.k[k].e[0].c = maskProps[j].cl;
}
}
}
}
}
if (layerData.ty === 4) {
completeClosingShapes(layerData.shapes);
}
}
}
return function (animationData) {
if (checkVersion(minimumVersion, animationData.v)) {
iterateLayers(animationData.layers);
if (animationData.assets) {
var i;
var len = animationData.assets.length;
for (i = 0; i < len; i += 1) {
if (animationData.assets[i].layers) {
iterateLayers(animationData.assets[i].layers);
}
}
}
}
};
}());
function completeData(animationData) {
if (animationData.__complete) {
return;
}
checkColors(animationData);
checkText(animationData);
checkChars(animationData);
checkPathProperties(animationData);
checkShapes(animationData);
completeLayers(animationData.layers, animationData.assets);
completeChars(animationData.chars, animationData.assets);
animationData.__complete = true;
}
function completeText(data) {
if (data.t.a.length === 0 && !('m' in data.t.p)) {
// data.singleShape = true;
}
}
var moduleOb = {};
moduleOb.completeData = completeData;
moduleOb.checkColors = checkColors;
moduleOb.checkChars = checkChars;
moduleOb.checkPathProperties = checkPathProperties;
moduleOb.checkShapes = checkShapes;
moduleOb.completeLayers = completeLayers;
return moduleOb;
}
if (!_workerSelf.dataManager) {
_workerSelf.dataManager = dataFunctionManager();
}
if (!_workerSelf.assetLoader) {
_workerSelf.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, fullPath, 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);
}
}
}
}
};
try {
// Hack to workaround banner validation
xhr.open(['G', 'E', 'T'].join(''), path, true);
} catch (error) {
// Hack to workaround banner validation
xhr.open(['G', 'E', 'T'].join(''), fullPath + '/' + path, true);
}
xhr.send();
}
return {
load: loadAsset,
};
}());
}
if (e.data.type === 'loadAnimation') {
_workerSelf.assetLoader.load(
e.data.path,
e.data.fullPath,
function (data) {
_workerSelf.dataManager.completeData(data);
_workerSelf.postMessage({
id: e.data.id,
payload: data,
status: 'success',
});
},
function () {
_workerSelf.postMessage({
id: e.data.id,
status: 'error',
});
}
);
} else if (e.data.type === 'complete') {
var animation = e.data.animation;
_workerSelf.dataManager.completeData(animation);
_workerSelf.postMessage({
id: e.data.id,
payload: animation,
status: 'success',
});
} else if (e.data.type === 'loadData') {
_workerSelf.assetLoader.load(
e.data.path,
e.data.fullPath,
function (data) {
_workerSelf.postMessage({
id: e.data.id,
payload: data,
status: 'success',
});
},
function () {
_workerSelf.postMessage({
id: e.data.id,
status: 'error',
});
}
);
}
});
workerInstance.onmessage = function (event) {
var data = event.data;
var id = data.id;
var process = processes[id];
processes[id] = null;
if (data.status === 'success') {
process.onComplete(data.payload);
} else if (process.onError) {
process.onError();
}
};
}
}
function createProcess(onComplete, onError) {
_counterId += 1;
var id = 'processId_' + _counterId;
processes[id] = {
onComplete: onComplete,
onError: onError,
};
return id;
}
function loadAnimation(path, onComplete, onError) {
setupWorker();
var processId = createProcess(onComplete, onError);
workerInstance.postMessage({
type: 'loadAnimation',
path: path,
fullPath: window.location.origin + window.location.pathname,
id: processId,
});
}
function loadData(path, onComplete, onError) {
setupWorker();
var processId = createProcess(onComplete, onError);
workerInstance.postMessage({
type: 'loadData',
path: path,
fullPath: window.location.origin + window.location.pathname,
id: processId,
});
}
function completeAnimation(anim, onComplete, onError) {
setupWorker();
var processId = createProcess(onComplete, onError);
workerInstance.postMessage({
type: 'complete',
animation: anim,
id: processId,
});
}
return {
loadAnimation: loadAnimation,
loadData: loadData,
completeAnimation: completeAnimation,
};
}());
export default dataManager;

13
node_modules/lottie-web/player/js/utils/DataManagerWorkerOverrides.js generated vendored Normal file
View File

@@ -0,0 +1,13 @@
import dataManager from './DataManager';
dataManager.completeData = function (animationData) {
if (animationData.__complete) {
return;
}
this.checkColors(animationData);
this.checkChars(animationData);
this.checkPathProperties(animationData);
this.checkShapes(animationData);
this.completeLayers(animationData.layers, animationData.assets);
animationData.__complete = true;
};

443
node_modules/lottie-web/player/js/utils/FontManager.js generated vendored Normal file
View File

@@ -0,0 +1,443 @@
import createNS from './helpers/svg_elements';
import createTag from './helpers/html_elements';
import getFontProperties from './getFontProperties';
const FontManager = (function () {
var maxWaitingTime = 5000;
var emptyChar = {
w: 0,
size: 0,
shapes: [],
data: {
shapes: [],
},
};
var combinedCharacters = [];
// Hindi characters
combinedCharacters = combinedCharacters.concat([2304, 2305, 2306, 2307, 2362, 2363, 2364, 2364, 2366,
2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377, 2378, 2379,
2380, 2381, 2382, 2383, 2387, 2388, 2389, 2390, 2391, 2402, 2403]);
var BLACK_FLAG_CODE_POINT = 127988;
var CANCEL_TAG_CODE_POINT = 917631;
var A_TAG_CODE_POINT = 917601;
var Z_TAG_CODE_POINT = 917626;
var VARIATION_SELECTOR_16_CODE_POINT = 65039;
var ZERO_WIDTH_JOINER_CODE_POINT = 8205;
var REGIONAL_CHARACTER_A_CODE_POINT = 127462;
var REGIONAL_CHARACTER_Z_CODE_POINT = 127487;
var surrogateModifiers = [
'd83cdffb',
'd83cdffc',
'd83cdffd',
'd83cdffe',
'd83cdfff',
];
function trimFontOptions(font) {
var familyArray = font.split(',');
var i;
var len = familyArray.length;
var enabledFamilies = [];
for (i = 0; i < len; i += 1) {
if (familyArray[i] !== 'sans-serif' && familyArray[i] !== 'monospace') {
enabledFamilies.push(familyArray[i]);
}
}
return enabledFamilies.join(',');
}
function setUpNode(font, family) {
var parentNode = createTag('span');
// Node is invisible to screen readers.
parentNode.setAttribute('aria-hidden', true);
parentNode.style.fontFamily = family;
var node = createTag('span');
// Characters that vary significantly among different fonts
node.innerText = 'giItT1WQy@!-/#';
// Visible - so we can measure it - but not on the screen
parentNode.style.position = 'absolute';
parentNode.style.left = '-10000px';
parentNode.style.top = '-10000px';
// Large font size makes even subtle changes obvious
parentNode.style.fontSize = '300px';
// Reset any font properties
parentNode.style.fontVariant = 'normal';
parentNode.style.fontStyle = 'normal';
parentNode.style.fontWeight = 'normal';
parentNode.style.letterSpacing = '0';
parentNode.appendChild(node);
document.body.appendChild(parentNode);
// Remember width with no applied web font
var width = node.offsetWidth;
node.style.fontFamily = trimFontOptions(font) + ', ' + family;
return { node: node, w: width, parent: parentNode };
}
function checkLoadedFonts() {
var i;
var len = this.fonts.length;
var node;
var w;
var loadedCount = len;
for (i = 0; i < len; i += 1) {
if (this.fonts[i].loaded) {
loadedCount -= 1;
} else if (this.fonts[i].fOrigin === 'n' || this.fonts[i].origin === 0) {
this.fonts[i].loaded = true;
} else {
node = this.fonts[i].monoCase.node;
w = this.fonts[i].monoCase.w;
if (node.offsetWidth !== w) {
loadedCount -= 1;
this.fonts[i].loaded = true;
} else {
node = this.fonts[i].sansCase.node;
w = this.fonts[i].sansCase.w;
if (node.offsetWidth !== w) {
loadedCount -= 1;
this.fonts[i].loaded = true;
}
}
if (this.fonts[i].loaded) {
this.fonts[i].sansCase.parent.parentNode.removeChild(this.fonts[i].sansCase.parent);
this.fonts[i].monoCase.parent.parentNode.removeChild(this.fonts[i].monoCase.parent);
}
}
}
if (loadedCount !== 0 && Date.now() - this.initTime < maxWaitingTime) {
setTimeout(this.checkLoadedFontsBinded, 20);
} else {
setTimeout(this.setIsLoadedBinded, 10);
}
}
function createHelper(fontData, def) {
var engine = (document.body && def) ? 'svg' : 'canvas';
var helper;
var fontProps = getFontProperties(fontData);
if (engine === 'svg') {
var tHelper = createNS('text');
tHelper.style.fontSize = '100px';
// tHelper.style.fontFamily = fontData.fFamily;
tHelper.setAttribute('font-family', fontData.fFamily);
tHelper.setAttribute('font-style', fontProps.style);
tHelper.setAttribute('font-weight', fontProps.weight);
tHelper.textContent = '1';
if (fontData.fClass) {
tHelper.style.fontFamily = 'inherit';
tHelper.setAttribute('class', fontData.fClass);
} else {
tHelper.style.fontFamily = fontData.fFamily;
}
def.appendChild(tHelper);
helper = tHelper;
} else {
var tCanvasHelper = new OffscreenCanvas(500, 500).getContext('2d');
tCanvasHelper.font = fontProps.style + ' ' + fontProps.weight + ' 100px ' + fontData.fFamily;
helper = tCanvasHelper;
}
function measure(text) {
if (engine === 'svg') {
helper.textContent = text;
return helper.getComputedTextLength();
}
return helper.measureText(text).width;
}
return {
measureText: measure,
};
}
function addFonts(fontData, defs) {
if (!fontData) {
this.isLoaded = true;
return;
}
if (this.chars) {
this.isLoaded = true;
this.fonts = fontData.list;
return;
}
if (!document.body) {
this.isLoaded = true;
fontData.list.forEach((data) => {
data.helper = createHelper(data);
data.cache = {};
});
this.fonts = fontData.list;
return;
}
var fontArr = fontData.list;
var i;
var len = fontArr.length;
var _pendingFonts = len;
for (i = 0; i < len; i += 1) {
var shouldLoadFont = true;
var loadedSelector;
var j;
fontArr[i].loaded = false;
fontArr[i].monoCase = setUpNode(fontArr[i].fFamily, 'monospace');
fontArr[i].sansCase = setUpNode(fontArr[i].fFamily, 'sans-serif');
if (!fontArr[i].fPath) {
fontArr[i].loaded = true;
_pendingFonts -= 1;
} else if (fontArr[i].fOrigin === 'p' || fontArr[i].origin === 3) {
loadedSelector = document.querySelectorAll('style[f-forigin="p"][f-family="' + fontArr[i].fFamily + '"], style[f-origin="3"][f-family="' + fontArr[i].fFamily + '"]');
if (loadedSelector.length > 0) {
shouldLoadFont = false;
}
if (shouldLoadFont) {
var s = createTag('style');
s.setAttribute('f-forigin', fontArr[i].fOrigin);
s.setAttribute('f-origin', fontArr[i].origin);
s.setAttribute('f-family', fontArr[i].fFamily);
s.type = 'text/css';
s.innerText = '@font-face {font-family: ' + fontArr[i].fFamily + "; font-style: normal; src: url('" + fontArr[i].fPath + "');}";
defs.appendChild(s);
}
} else if (fontArr[i].fOrigin === 'g' || fontArr[i].origin === 1) {
loadedSelector = document.querySelectorAll('link[f-forigin="g"], link[f-origin="1"]');
for (j = 0; j < loadedSelector.length; j += 1) {
if (loadedSelector[j].href.indexOf(fontArr[i].fPath) !== -1) {
// Font is already loaded
shouldLoadFont = false;
}
}
if (shouldLoadFont) {
var l = createTag('link');
l.setAttribute('f-forigin', fontArr[i].fOrigin);
l.setAttribute('f-origin', fontArr[i].origin);
l.type = 'text/css';
l.rel = 'stylesheet';
l.href = fontArr[i].fPath;
document.body.appendChild(l);
}
} else if (fontArr[i].fOrigin === 't' || fontArr[i].origin === 2) {
loadedSelector = document.querySelectorAll('script[f-forigin="t"], script[f-origin="2"]');
for (j = 0; j < loadedSelector.length; j += 1) {
if (fontArr[i].fPath === loadedSelector[j].src) {
// Font is already loaded
shouldLoadFont = false;
}
}
if (shouldLoadFont) {
var sc = createTag('link');
sc.setAttribute('f-forigin', fontArr[i].fOrigin);
sc.setAttribute('f-origin', fontArr[i].origin);
sc.setAttribute('rel', 'stylesheet');
sc.setAttribute('href', fontArr[i].fPath);
defs.appendChild(sc);
}
}
fontArr[i].helper = createHelper(fontArr[i], defs);
fontArr[i].cache = {};
this.fonts.push(fontArr[i]);
}
if (_pendingFonts === 0) {
this.isLoaded = true;
} else {
// On some cases even if the font is loaded, it won't load correctly when measuring text on canvas.
// Adding this timeout seems to fix it
setTimeout(this.checkLoadedFonts.bind(this), 100);
}
}
function addChars(chars) {
if (!chars) {
return;
}
if (!this.chars) {
this.chars = [];
}
var i;
var len = chars.length;
var j;
var jLen = this.chars.length;
var found;
for (i = 0; i < len; i += 1) {
j = 0;
found = false;
while (j < jLen) {
if (this.chars[j].style === chars[i].style && this.chars[j].fFamily === chars[i].fFamily && this.chars[j].ch === chars[i].ch) {
found = true;
}
j += 1;
}
if (!found) {
this.chars.push(chars[i]);
jLen += 1;
}
}
}
function getCharData(char, style, font) {
var i = 0;
var len = this.chars.length;
while (i < len) {
if (this.chars[i].ch === char && this.chars[i].style === style && this.chars[i].fFamily === font) {
return this.chars[i];
}
i += 1;
}
if (((typeof char === 'string' && char.charCodeAt(0) !== 13) || !char)
&& console
&& console.warn // eslint-disable-line no-console
&& !this._warned
) {
this._warned = true;
console.warn('Missing character from exported characters list: ', char, style, font); // eslint-disable-line no-console
}
return emptyChar;
}
function measureText(char, fontName, size) {
var fontData = this.getFontByName(fontName);
// Using the char instead of char.charCodeAt(0)
// to avoid collisions between equal chars
var index = char;
if (!fontData.cache[index]) {
var tHelper = fontData.helper;
if (char === ' ') {
var doubleSize = tHelper.measureText('|' + char + '|');
var singleSize = tHelper.measureText('||');
fontData.cache[index] = (doubleSize - singleSize) / 100;
} else {
fontData.cache[index] = tHelper.measureText(char) / 100;
}
}
return fontData.cache[index] * size;
}
function getFontByName(name) {
var i = 0;
var len = this.fonts.length;
while (i < len) {
if (this.fonts[i].fName === name) {
return this.fonts[i];
}
i += 1;
}
return this.fonts[0];
}
function getCodePoint(string) {
var codePoint = 0;
var first = string.charCodeAt(0);
if (first >= 0xD800 && first <= 0xDBFF) {
var second = string.charCodeAt(1);
if (second >= 0xDC00 && second <= 0xDFFF) {
codePoint = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
}
}
return codePoint;
}
// Skin tone modifiers
function isModifier(firstCharCode, secondCharCode) {
var sum = firstCharCode.toString(16) + secondCharCode.toString(16);
return surrogateModifiers.indexOf(sum) !== -1;
}
function isZeroWidthJoiner(charCode) {
return charCode === ZERO_WIDTH_JOINER_CODE_POINT;
}
// This codepoint may change the appearance of the preceding character.
// If that is a symbol, dingbat or emoji, U+FE0F forces it to be rendered
// as a colorful image as compared to a monochrome text variant.
function isVariationSelector(charCode) {
return charCode === VARIATION_SELECTOR_16_CODE_POINT;
}
// The regional indicator symbols are a set of 26 alphabetic Unicode
/// characters (A–Z) intended to be used to encode ISO 3166-1 alpha-2
// two-letter country codes in a way that allows optional special treatment.
function isRegionalCode(string) {
var codePoint = getCodePoint(string);
if (codePoint >= REGIONAL_CHARACTER_A_CODE_POINT && codePoint <= REGIONAL_CHARACTER_Z_CODE_POINT) {
return true;
}
return false;
}
// Some Emoji implementations represent combinations of
// two “regional indicator” letters as a single flag symbol.
function isFlagEmoji(string) {
return isRegionalCode(string.substr(0, 2)) && isRegionalCode(string.substr(2, 2));
}
function isCombinedCharacter(char) {
return combinedCharacters.indexOf(char) !== -1;
}
// Regional flags start with a BLACK_FLAG_CODE_POINT
// folowed by 5 chars in the TAG range
// and end with a CANCEL_TAG_CODE_POINT
function isRegionalFlag(text, index) {
var codePoint = getCodePoint(text.substr(index, 2));
if (codePoint !== BLACK_FLAG_CODE_POINT) {
return false;
}
var count = 0;
index += 2;
while (count < 5) {
codePoint = getCodePoint(text.substr(index, 2));
if (codePoint < A_TAG_CODE_POINT || codePoint > Z_TAG_CODE_POINT) {
return false;
}
count += 1;
index += 2;
}
return getCodePoint(text.substr(index, 2)) === CANCEL_TAG_CODE_POINT;
}
function setIsLoaded() {
this.isLoaded = true;
}
var Font = function () {
this.fonts = [];
this.chars = null;
this.typekitLoaded = 0;
this.isLoaded = false;
this._warned = false;
this.initTime = Date.now();
this.setIsLoadedBinded = this.setIsLoaded.bind(this);
this.checkLoadedFontsBinded = this.checkLoadedFonts.bind(this);
};
Font.isModifier = isModifier;
Font.isZeroWidthJoiner = isZeroWidthJoiner;
Font.isFlagEmoji = isFlagEmoji;
Font.isRegionalCode = isRegionalCode;
Font.isCombinedCharacter = isCombinedCharacter;
Font.isRegionalFlag = isRegionalFlag;
Font.isVariationSelector = isVariationSelector;
Font.BLACK_FLAG_CODE_POINT = BLACK_FLAG_CODE_POINT;
var fontPrototype = {
addChars: addChars,
addFonts: addFonts,
getCharData: getCharData,
getFontByName: getFontByName,
measureText: measureText,
checkLoadedFonts: checkLoadedFonts,
setIsLoaded: setIsLoaded,
};
Font.prototype = fontPrototype;
return Font;
}());
export default FontManager;

16
node_modules/lottie-web/player/js/utils/FontManagerWorkerOverride.js generated vendored Normal file
View File

@@ -0,0 +1,16 @@
import FontManager from './FontManager';
// TODO: fix overwrite
FontManager = (function () {
var Font = function () {
this.fonts = [];
this.chars = null;
this.typekitLoaded = 0;
this.isLoaded = false;
this.initTime = Date.now();
};
return Font;
}());
export default FontManager;

253
node_modules/lottie-web/player/js/utils/PolynomialBezier.js generated vendored Normal file
View File

@@ -0,0 +1,253 @@
function floatEqual(a, b) {
return Math.abs(a - b) * 100000 <= Math.min(Math.abs(a), Math.abs(b));
}
function floatZero(f) {
return Math.abs(f) <= 0.00001;
}
function lerp(p0, p1, amount) {
return p0 * (1 - amount) + p1 * amount;
}
function lerpPoint(p0, p1, amount) {
return [lerp(p0[0], p1[0], amount), lerp(p0[1], p1[1], amount)];
}
function quadRoots(a, b, c) {
// no root
if (a === 0) return [];
var s = b * b - 4 * a * c;
// Complex roots
if (s < 0) return [];
var singleRoot = -b / (2 * a);
// 1 root
if (s === 0) return [singleRoot];
var delta = Math.sqrt(s) / (2 * a);
// 2 roots
return [singleRoot - delta, singleRoot + delta];
}
function polynomialCoefficients(p0, p1, p2, p3) {
return [
-p0 + 3 * p1 - 3 * p2 + p3,
3 * p0 - 6 * p1 + 3 * p2,
-3 * p0 + 3 * p1,
p0,
];
}
function singlePoint(p) {
return new PolynomialBezier(p, p, p, p, false);
}
function PolynomialBezier(p0, p1, p2, p3, linearize) {
if (linearize && pointEqual(p0, p1)) {
p1 = lerpPoint(p0, p3, 1 / 3);
}
if (linearize && pointEqual(p2, p3)) {
p2 = lerpPoint(p0, p3, 2 / 3);
}
var coeffx = polynomialCoefficients(p0[0], p1[0], p2[0], p3[0]);
var coeffy = polynomialCoefficients(p0[1], p1[1], p2[1], p3[1]);
this.a = [coeffx[0], coeffy[0]];
this.b = [coeffx[1], coeffy[1]];
this.c = [coeffx[2], coeffy[2]];
this.d = [coeffx[3], coeffy[3]];
this.points = [p0, p1, p2, p3];
}
PolynomialBezier.prototype.point = function (t) {
return [
(((this.a[0] * t) + this.b[0]) * t + this.c[0]) * t + this.d[0],
(((this.a[1] * t) + this.b[1]) * t + this.c[1]) * t + this.d[1],
];
};
PolynomialBezier.prototype.derivative = function (t) {
return [
(3 * t * this.a[0] + 2 * this.b[0]) * t + this.c[0],
(3 * t * this.a[1] + 2 * this.b[1]) * t + this.c[1],
];
};
PolynomialBezier.prototype.tangentAngle = function (t) {
var p = this.derivative(t);
return Math.atan2(p[1], p[0]);
};
PolynomialBezier.prototype.normalAngle = function (t) {
var p = this.derivative(t);
return Math.atan2(p[0], p[1]);
};
PolynomialBezier.prototype.inflectionPoints = function () {
var denom = this.a[1] * this.b[0] - this.a[0] * this.b[1];
if (floatZero(denom)) return [];
var tcusp = (-0.5 * (this.a[1] * this.c[0] - this.a[0] * this.c[1])) / denom;
var square = tcusp * tcusp - ((1 / 3) * (this.b[1] * this.c[0] - this.b[0] * this.c[1])) / denom;
if (square < 0) return [];
var root = Math.sqrt(square);
if (floatZero(root)) {
if (root > 0 && root < 1) return [tcusp];
return [];
}
return [tcusp - root, tcusp + root].filter(function (r) { return r > 0 && r < 1; });
};
PolynomialBezier.prototype.split = function (t) {
if (t <= 0) return [singlePoint(this.points[0]), this];
if (t >= 1) return [this, singlePoint(this.points[this.points.length - 1])];
var p10 = lerpPoint(this.points[0], this.points[1], t);
var p11 = lerpPoint(this.points[1], this.points[2], t);
var p12 = lerpPoint(this.points[2], this.points[3], t);
var p20 = lerpPoint(p10, p11, t);
var p21 = lerpPoint(p11, p12, t);
var p3 = lerpPoint(p20, p21, t);
return [
new PolynomialBezier(this.points[0], p10, p20, p3, true),
new PolynomialBezier(p3, p21, p12, this.points[3], true),
];
};
function extrema(bez, comp) {
var min = bez.points[0][comp];
var max = bez.points[bez.points.length - 1][comp];
if (min > max) {
var e = max;
max = min;
min = e;
}
// Derivative roots to find min/max
var f = quadRoots(3 * bez.a[comp], 2 * bez.b[comp], bez.c[comp]);
for (var i = 0; i < f.length; i += 1) {
if (f[i] > 0 && f[i] < 1) {
var val = bez.point(f[i])[comp];
if (val < min) min = val;
else if (val > max) max = val;
}
}
return {
min: min,
max: max,
};
}
PolynomialBezier.prototype.bounds = function () {
return {
x: extrema(this, 0),
y: extrema(this, 1),
};
};
PolynomialBezier.prototype.boundingBox = function () {
var bounds = this.bounds();
return {
left: bounds.x.min,
right: bounds.x.max,
top: bounds.y.min,
bottom: bounds.y.max,
width: bounds.x.max - bounds.x.min,
height: bounds.y.max - bounds.y.min,
cx: (bounds.x.max + bounds.x.min) / 2,
cy: (bounds.y.max + bounds.y.min) / 2,
};
};
function intersectData(bez, t1, t2) {
var box = bez.boundingBox();
return {
cx: box.cx,
cy: box.cy,
width: box.width,
height: box.height,
bez: bez,
t: (t1 + t2) / 2,
t1: t1,
t2: t2,
};
}
function splitData(data) {
var split = data.bez.split(0.5);
return [
intersectData(split[0], data.t1, data.t),
intersectData(split[1], data.t, data.t2),
];
}
function boxIntersect(b1, b2) {
return Math.abs(b1.cx - b2.cx) * 2 < b1.width + b2.width
&& Math.abs(b1.cy - b2.cy) * 2 < b1.height + b2.height;
}
function intersectsImpl(d1, d2, depth, tolerance, intersections, maxRecursion) {
if (!boxIntersect(d1, d2)) return;
if (depth >= maxRecursion || (d1.width <= tolerance && d1.height <= tolerance && d2.width <= tolerance && d2.height <= tolerance)) {
intersections.push([d1.t, d2.t]);
return;
}
var d1s = splitData(d1);
var d2s = splitData(d2);
intersectsImpl(d1s[0], d2s[0], depth + 1, tolerance, intersections, maxRecursion);
intersectsImpl(d1s[0], d2s[1], depth + 1, tolerance, intersections, maxRecursion);
intersectsImpl(d1s[1], d2s[0], depth + 1, tolerance, intersections, maxRecursion);
intersectsImpl(d1s[1], d2s[1], depth + 1, tolerance, intersections, maxRecursion);
}
PolynomialBezier.prototype.intersections = function (other, tolerance, maxRecursion) {
if (tolerance === undefined) tolerance = 2;
if (maxRecursion === undefined) maxRecursion = 7;
var intersections = [];
intersectsImpl(intersectData(this, 0, 1), intersectData(other, 0, 1), 0, tolerance, intersections, maxRecursion);
return intersections;
};
PolynomialBezier.shapeSegment = function (shapePath, index) {
var nextIndex = (index + 1) % shapePath.length();
return new PolynomialBezier(shapePath.v[index], shapePath.o[index], shapePath.i[nextIndex], shapePath.v[nextIndex], true);
};
PolynomialBezier.shapeSegmentInverted = function (shapePath, index) {
var nextIndex = (index + 1) % shapePath.length();
return new PolynomialBezier(shapePath.v[nextIndex], shapePath.i[nextIndex], shapePath.o[index], shapePath.v[index], true);
};
function crossProduct(a, b) {
return [
a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0],
];
}
function lineIntersection(start1, end1, start2, end2) {
var v1 = [start1[0], start1[1], 1];
var v2 = [end1[0], end1[1], 1];
var v3 = [start2[0], start2[1], 1];
var v4 = [end2[0], end2[1], 1];
var r = crossProduct(
crossProduct(v1, v2),
crossProduct(v3, v4)
);
if (floatZero(r[2])) return null;
return [r[0] / r[2], r[1] / r[2]];
}
function polarOffset(p, angle, length) {
return [
p[0] + Math.cos(angle) * length,
p[1] - Math.sin(angle) * length,
];
}
function pointDistance(p1, p2) {
return Math.hypot(p1[0] - p2[0], p1[1] - p2[1]);
}
function pointEqual(p1, p2) {
return floatEqual(p1[0], p2[0]) && floatEqual(p1[1], p2[1]);
}
export {
PolynomialBezier,
lineIntersection,
polarOffset,
pointDistance,
pointEqual,
floatEqual,
};

489
node_modules/lottie-web/player/js/utils/PropertyFactory.js generated vendored Normal file
View File

@@ -0,0 +1,489 @@
import {
degToRads,
} from './common';
import {
createTypedArray,
} from './helpers/arrays';
import BezierFactory from '../3rd_party/BezierEaser';
import {
initialDefaultFrame,
} from '../main';
import bez from './bez';
var initFrame = initialDefaultFrame;
var mathAbs = Math.abs;
function interpolateValue(frameNum, caching) {
var offsetTime = this.offsetTime;
var newValue;
if (this.propType === 'multidimensional') {
newValue = createTypedArray('float32', this.pv.length);
}
var iterationIndex = caching.lastIndex;
var i = iterationIndex;
var len = this.keyframes.length - 1;
var flag = true;
var keyData;
var nextKeyData;
var keyframeMetadata;
while (flag) {
keyData = this.keyframes[i];
nextKeyData = this.keyframes[i + 1];
if (i === len - 1 && frameNum >= nextKeyData.t - offsetTime) {
if (keyData.h) {
keyData = nextKeyData;
}
iterationIndex = 0;
break;
}
if ((nextKeyData.t - offsetTime) > frameNum) {
iterationIndex = i;
break;
}
if (i < len - 1) {
i += 1;
} else {
iterationIndex = 0;
flag = false;
}
}
keyframeMetadata = this.keyframesMetadata[i] || {};
var k;
var kLen;
var perc;
var jLen;
var j;
var fnc;
var nextKeyTime = nextKeyData.t - offsetTime;
var keyTime = keyData.t - offsetTime;
var endValue;
if (keyData.to) {
if (!keyframeMetadata.bezierData) {
keyframeMetadata.bezierData = bez.buildBezierData(keyData.s, nextKeyData.s || keyData.e, keyData.to, keyData.ti);
}
var bezierData = keyframeMetadata.bezierData;
if (frameNum >= nextKeyTime || frameNum < keyTime) {
var ind = frameNum >= nextKeyTime ? bezierData.points.length - 1 : 0;
kLen = bezierData.points[ind].point.length;
for (k = 0; k < kLen; k += 1) {
newValue[k] = bezierData.points[ind].point[k];
}
// caching._lastKeyframeIndex = -1;
} else {
if (keyframeMetadata.__fnct) {
fnc = keyframeMetadata.__fnct;
} else {
fnc = BezierFactory.getBezierEasing(keyData.o.x, keyData.o.y, keyData.i.x, keyData.i.y, keyData.n).get;
keyframeMetadata.__fnct = fnc;
}
perc = fnc((frameNum - keyTime) / (nextKeyTime - keyTime));
var distanceInLine = bezierData.segmentLength * perc;
var segmentPerc;
var addedLength = (caching.lastFrame < frameNum && caching._lastKeyframeIndex === i) ? caching._lastAddedLength : 0;
j = (caching.lastFrame < frameNum && caching._lastKeyframeIndex === i) ? caching._lastPoint : 0;
flag = true;
jLen = bezierData.points.length;
while (flag) {
addedLength += bezierData.points[j].partialLength;
if (distanceInLine === 0 || perc === 0 || j === bezierData.points.length - 1) {
kLen = bezierData.points[j].point.length;
for (k = 0; k < kLen; k += 1) {
newValue[k] = bezierData.points[j].point[k];
}
break;
} else if (distanceInLine >= addedLength && distanceInLine < addedLength + bezierData.points[j + 1].partialLength) {
segmentPerc = (distanceInLine - addedLength) / bezierData.points[j + 1].partialLength;
kLen = bezierData.points[j].point.length;
for (k = 0; k < kLen; k += 1) {
newValue[k] = bezierData.points[j].point[k] + (bezierData.points[j + 1].point[k] - bezierData.points[j].point[k]) * segmentPerc;
}
break;
}
if (j < jLen - 1) {
j += 1;
} else {
flag = false;
}
}
caching._lastPoint = j;
caching._lastAddedLength = addedLength - bezierData.points[j].partialLength;
caching._lastKeyframeIndex = i;
}
} else {
var outX;
var outY;
var inX;
var inY;
var keyValue;
len = keyData.s.length;
endValue = nextKeyData.s || keyData.e;
if (this.sh && keyData.h !== 1) {
if (frameNum >= nextKeyTime) {
newValue[0] = endValue[0];
newValue[1] = endValue[1];
newValue[2] = endValue[2];
} else if (frameNum <= keyTime) {
newValue[0] = keyData.s[0];
newValue[1] = keyData.s[1];
newValue[2] = keyData.s[2];
} else {
var quatStart = createQuaternion(keyData.s);
var quatEnd = createQuaternion(endValue);
var time = (frameNum - keyTime) / (nextKeyTime - keyTime);
quaternionToEuler(newValue, slerp(quatStart, quatEnd, time));
}
} else {
for (i = 0; i < len; i += 1) {
if (keyData.h !== 1) {
if (frameNum >= nextKeyTime) {
perc = 1;
} else if (frameNum < keyTime) {
perc = 0;
} else {
if (keyData.o.x.constructor === Array) {
if (!keyframeMetadata.__fnct) {
keyframeMetadata.__fnct = [];
}
if (!keyframeMetadata.__fnct[i]) {
outX = keyData.o.x[i] === undefined ? keyData.o.x[0] : keyData.o.x[i];
outY = keyData.o.y[i] === undefined ? keyData.o.y[0] : keyData.o.y[i];
inX = keyData.i.x[i] === undefined ? keyData.i.x[0] : keyData.i.x[i];
inY = keyData.i.y[i] === undefined ? keyData.i.y[0] : keyData.i.y[i];
fnc = BezierFactory.getBezierEasing(outX, outY, inX, inY).get;
keyframeMetadata.__fnct[i] = fnc;
} else {
fnc = keyframeMetadata.__fnct[i];
}
} else if (!keyframeMetadata.__fnct) {
outX = keyData.o.x;
outY = keyData.o.y;
inX = keyData.i.x;
inY = keyData.i.y;
fnc = BezierFactory.getBezierEasing(outX, outY, inX, inY).get;
keyData.keyframeMetadata = fnc;
} else {
fnc = keyframeMetadata.__fnct;
}
perc = fnc((frameNum - keyTime) / (nextKeyTime - keyTime));
}
}
endValue = nextKeyData.s || keyData.e;
keyValue = keyData.h === 1 ? keyData.s[i] : keyData.s[i] + (endValue[i] - keyData.s[i]) * perc;
if (this.propType === 'multidimensional') {
newValue[i] = keyValue;
} else {
newValue = keyValue;
}
}
}
}
caching.lastIndex = iterationIndex;
return newValue;
}
// based on @Toji's https://github.com/toji/gl-matrix/
function slerp(a, b, t) {
var out = [];
var ax = a[0];
var ay = a[1];
var az = a[2];
var aw = a[3];
var bx = b[0];
var by = b[1];
var bz = b[2];
var bw = b[3];
var omega;
var cosom;
var sinom;
var scale0;
var scale1;
cosom = ax * bx + ay * by + az * bz + aw * bw;
if (cosom < 0.0) {
cosom = -cosom;
bx = -bx;
by = -by;
bz = -bz;
bw = -bw;
}
if ((1.0 - cosom) > 0.000001) {
omega = Math.acos(cosom);
sinom = Math.sin(omega);
scale0 = Math.sin((1.0 - t) * omega) / sinom;
scale1 = Math.sin(t * omega) / sinom;
} else {
scale0 = 1.0 - t;
scale1 = t;
}
out[0] = scale0 * ax + scale1 * bx;
out[1] = scale0 * ay + scale1 * by;
out[2] = scale0 * az + scale1 * bz;
out[3] = scale0 * aw + scale1 * bw;
return out;
}
function quaternionToEuler(out, quat) {
var qx = quat[0];
var qy = quat[1];
var qz = quat[2];
var qw = quat[3];
var heading = Math.atan2(2 * qy * qw - 2 * qx * qz, 1 - 2 * qy * qy - 2 * qz * qz);
var attitude = Math.asin(2 * qx * qy + 2 * qz * qw);
var bank = Math.atan2(2 * qx * qw - 2 * qy * qz, 1 - 2 * qx * qx - 2 * qz * qz);
out[0] = heading / degToRads;
out[1] = attitude / degToRads;
out[2] = bank / degToRads;
}
function createQuaternion(values) {
var heading = values[0] * degToRads;
var attitude = values[1] * degToRads;
var bank = values[2] * degToRads;
var c1 = Math.cos(heading / 2);
var c2 = Math.cos(attitude / 2);
var c3 = Math.cos(bank / 2);
var s1 = Math.sin(heading / 2);
var s2 = Math.sin(attitude / 2);
var s3 = Math.sin(bank / 2);
var w = c1 * c2 * c3 - s1 * s2 * s3;
var x = s1 * s2 * c3 + c1 * c2 * s3;
var y = s1 * c2 * c3 + c1 * s2 * s3;
var z = c1 * s2 * c3 - s1 * c2 * s3;
return [x, y, z, w];
}
function getValueAtCurrentTime() {
var frameNum = this.comp.renderedFrame - this.offsetTime;
var initTime = this.keyframes[0].t - this.offsetTime;
var endTime = this.keyframes[this.keyframes.length - 1].t - this.offsetTime;
if (!(frameNum === this._caching.lastFrame || (this._caching.lastFrame !== initFrame && ((this._caching.lastFrame >= endTime && frameNum >= endTime) || (this._caching.lastFrame < initTime && frameNum < initTime))))) {
if (this._caching.lastFrame >= frameNum) {
this._caching._lastKeyframeIndex = -1;
this._caching.lastIndex = 0;
}
var renderResult = this.interpolateValue(frameNum, this._caching);
this.pv = renderResult;
}
this._caching.lastFrame = frameNum;
return this.pv;
}
function setVValue(val) {
var multipliedValue;
if (this.propType === 'unidimensional') {
multipliedValue = val * this.mult;
if (mathAbs(this.v - multipliedValue) > 0.00001) {
this.v = multipliedValue;
this._mdf = true;
}
} else {
var i = 0;
var len = this.v.length;
while (i < len) {
multipliedValue = val[i] * this.mult;
if (mathAbs(this.v[i] - multipliedValue) > 0.00001) {
this.v[i] = multipliedValue;
this._mdf = true;
}
i += 1;
}
}
}
function processEffectsSequence() {
if (this.elem.globalData.frameId === this.frameId || !this.effectsSequence.length) {
return;
}
if (this.lock) {
this.setVValue(this.pv);
return;
}
this.lock = true;
this._mdf = this._isFirstFrame;
var i;
var len = this.effectsSequence.length;
var finalValue = this.kf ? this.pv : this.data.k;
for (i = 0; i < len; i += 1) {
finalValue = this.effectsSequence[i](finalValue);
}
this.setVValue(finalValue);
this._isFirstFrame = false;
this.lock = false;
this.frameId = this.elem.globalData.frameId;
}
function addEffect(effectFunction) {
this.effectsSequence.push(effectFunction);
this.container.addDynamicProperty(this);
}
function ValueProperty(elem, data, mult, container) {
this.propType = 'unidimensional';
this.mult = mult || 1;
this.data = data;
this.v = mult ? data.k * mult : data.k;
this.pv = data.k;
this._mdf = false;
this.elem = elem;
this.container = container;
this.comp = elem.comp;
this.k = false;
this.kf = false;
this.vel = 0;
this.effectsSequence = [];
this._isFirstFrame = true;
this.getValue = processEffectsSequence;
this.setVValue = setVValue;
this.addEffect = addEffect;
}
function MultiDimensionalProperty(elem, data, mult, container) {
this.propType = 'multidimensional';
this.mult = mult || 1;
this.data = data;
this._mdf = false;
this.elem = elem;
this.container = container;
this.comp = elem.comp;
this.k = false;
this.kf = false;
this.frameId = -1;
var i;
var len = data.k.length;
this.v = createTypedArray('float32', len);
this.pv = createTypedArray('float32', len);
this.vel = createTypedArray('float32', len);
for (i = 0; i < len; i += 1) {
this.v[i] = data.k[i] * this.mult;
this.pv[i] = data.k[i];
}
this._isFirstFrame = true;
this.effectsSequence = [];
this.getValue = processEffectsSequence;
this.setVValue = setVValue;
this.addEffect = addEffect;
}
function KeyframedValueProperty(elem, data, mult, container) {
this.propType = 'unidimensional';
this.keyframes = data.k;
this.keyframesMetadata = [];
this.offsetTime = elem.data.st;
this.frameId = -1;
this._caching = {
lastFrame: initFrame, lastIndex: 0, value: 0, _lastKeyframeIndex: -1,
};
this.k = true;
this.kf = true;
this.data = data;
this.mult = mult || 1;
this.elem = elem;
this.container = container;
this.comp = elem.comp;
this.v = initFrame;
this.pv = initFrame;
this._isFirstFrame = true;
this.getValue = processEffectsSequence;
this.setVValue = setVValue;
this.interpolateValue = interpolateValue;
this.effectsSequence = [getValueAtCurrentTime.bind(this)];
this.addEffect = addEffect;
}
function KeyframedMultidimensionalProperty(elem, data, mult, container) {
this.propType = 'multidimensional';
var i;
var len = data.k.length;
var s;
var e;
var to;
var ti;
for (i = 0; i < len - 1; i += 1) {
if (data.k[i].to && data.k[i].s && data.k[i + 1] && data.k[i + 1].s) {
s = data.k[i].s;
e = data.k[i + 1].s;
to = data.k[i].to;
ti = data.k[i].ti;
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]))) {
data.k[i].to = null;
data.k[i].ti = null;
}
if (s[0] === e[0] && s[1] === e[1] && to[0] === 0 && to[1] === 0 && ti[0] === 0 && ti[1] === 0) {
if (s.length === 2 || (s[2] === e[2] && to[2] === 0 && ti[2] === 0)) {
data.k[i].to = null;
data.k[i].ti = null;
}
}
}
}
this.effectsSequence = [getValueAtCurrentTime.bind(this)];
this.data = data;
this.keyframes = data.k;
this.keyframesMetadata = [];
this.offsetTime = elem.data.st;
this.k = true;
this.kf = true;
this._isFirstFrame = true;
this.mult = mult || 1;
this.elem = elem;
this.container = container;
this.comp = elem.comp;
this.getValue = processEffectsSequence;
this.setVValue = setVValue;
this.interpolateValue = interpolateValue;
this.frameId = -1;
var arrLen = data.k[0].s.length;
this.v = createTypedArray('float32', arrLen);
this.pv = createTypedArray('float32', arrLen);
for (i = 0; i < arrLen; i += 1) {
this.v[i] = initFrame;
this.pv[i] = initFrame;
}
this._caching = { lastFrame: initFrame, lastIndex: 0, value: createTypedArray('float32', arrLen) };
this.addEffect = addEffect;
}
const PropertyFactory = (function () {
function getProp(elem, data, type, mult, container) {
if (data.sid) {
data = elem.globalData.slotManager.getProp(data);
}
var p;
if (!data.k.length) {
p = new ValueProperty(elem, data, mult, container);
} else if (typeof (data.k[0]) === 'number') {
p = new MultiDimensionalProperty(elem, data, mult, container);
} else {
switch (type) {
case 0:
p = new KeyframedValueProperty(elem, data, mult, container);
break;
case 1:
p = new KeyframedMultidimensionalProperty(elem, data, mult, container);
break;
default:
break;
}
}
if (p.effectsSequence.length) {
container.addDynamicProperty(p);
}
return p;
}
var ob = {
getProp: getProp,
};
return ob;
}());
export default PropertyFactory;

17
node_modules/lottie-web/player/js/utils/SlotManager.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
function SlotManager(animationData) {
this.animationData = animationData;
}
SlotManager.prototype.getProp = function (data) {
if (this.animationData.slots
&& this.animationData.slots[data.sid]
) {
return Object.assign(data, this.animationData.slots[data.sid].p);
}
return data;
};
function slotFactory(animationData) {
return new SlotManager(animationData);
}
export default slotFactory;

251
node_modules/lottie-web/player/js/utils/TransformProperty.js generated vendored Normal file
View File

@@ -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;

25
node_modules/lottie-web/player/js/utils/animationFramePolyFill.js generated vendored Normal file
View File

@@ -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);
};
}
}());

53
node_modules/lottie-web/player/js/utils/asset_loader.js generated vendored Normal file
View File

@@ -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;

3
node_modules/lottie-web/player/js/utils/asset_loader_worker_override.js generated vendored Normal file
View File

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

85
node_modules/lottie-web/player/js/utils/audio/AudioController.js generated vendored Normal file
View File

@@ -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;

6
node_modules/lottie-web/player/js/utils/audio/AudioElement.js generated vendored Normal file
View File

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

251
node_modules/lottie-web/player/js/utils/bez.js generated vendored Normal file
View File

@@ -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;

280
node_modules/lottie-web/player/js/utils/common.js generated vendored Normal file
View File

@@ -0,0 +1,280 @@
import {
createSizedArray,
} from './helpers/arrays';
let subframeEnabled = true;
let expressionsPlugin = null;
let expressionsInterfaces = null;
let idPrefix = '';
const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
let _shouldRoundValues = false;
const bmPow = Math.pow;
const bmSqrt = Math.sqrt;
const bmFloor = Math.floor;
const bmMax = Math.max;
const bmMin = Math.min;
const BMMath = {};
(function () {
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'];
var i;
var len = propertyNames.length;
for (i = 0; i < len; i += 1) {
BMMath[propertyNames[i]] = Math[propertyNames[i]];
}
}());
function ProjectInterface() { return {}; }
BMMath.random = Math.random;
BMMath.abs = function (val) {
var tOfVal = typeof val;
if (tOfVal === 'object' && val.length) {
var absArr = createSizedArray(val.length);
var i;
var len = val.length;
for (i = 0; i < len; i += 1) {
absArr[i] = Math.abs(val[i]);
}
return absArr;
}
return Math.abs(val);
};
let defaultCurveSegments = 150;
const degToRads = Math.PI / 180;
const roundCorner = 0.5519;
function roundValues(flag) {
_shouldRoundValues = !!flag;
}
function bmRnd(value) {
if (_shouldRoundValues) {
return Math.round(value);
}
return value;
}
function styleDiv(element) {
element.style.position = 'absolute';
element.style.top = 0;
element.style.left = 0;
element.style.display = 'block';
element.style.transformOrigin = '0 0';
element.style.webkitTransformOrigin = '0 0';
element.style.backfaceVisibility = 'visible';
element.style.webkitBackfaceVisibility = 'visible';
element.style.transformStyle = 'preserve-3d';
element.style.webkitTransformStyle = 'preserve-3d';
element.style.mozTransformStyle = 'preserve-3d';
}
function BMEnterFrameEvent(type, currentTime, totalTime, frameMultiplier) {
this.type = type;
this.currentTime = currentTime;
this.totalTime = totalTime;
this.direction = frameMultiplier < 0 ? -1 : 1;
}
function BMCompleteEvent(type, frameMultiplier) {
this.type = type;
this.direction = frameMultiplier < 0 ? -1 : 1;
}
function BMCompleteLoopEvent(type, totalLoops, currentLoop, frameMultiplier) {
this.type = type;
this.currentLoop = currentLoop;
this.totalLoops = totalLoops;
this.direction = frameMultiplier < 0 ? -1 : 1;
}
function BMSegmentStartEvent(type, firstFrame, totalFrames) {
this.type = type;
this.firstFrame = firstFrame;
this.totalFrames = totalFrames;
}
function BMDestroyEvent(type, target) {
this.type = type;
this.target = target;
}
function BMRenderFrameErrorEvent(nativeError, currentTime) {
this.type = 'renderFrameError';
this.nativeError = nativeError;
this.currentTime = currentTime;
}
function BMConfigErrorEvent(nativeError) {
this.type = 'configError';
this.nativeError = nativeError;
}
function BMAnimationConfigErrorEvent(type, nativeError) {
this.type = type;
this.nativeError = nativeError;
}
const createElementID = (function () {
var _count = 0;
return function createID() {
_count += 1;
return idPrefix + '__lottie_element_' + _count;
};
}());
function HSVtoRGB(h, s, v) {
var r;
var g;
var b;
var i;
var f;
var p;
var q;
var t;
i = Math.floor(h * 6);
f = h * 6 - i;
p = v * (1 - s);
q = v * (1 - f * s);
t = v * (1 - (1 - f) * s);
switch (i % 6) {
case 0: r = v; g = t; b = p; break;
case 1: r = q; g = v; b = p; break;
case 2: r = p; g = v; b = t; break;
case 3: r = p; g = q; b = v; break;
case 4: r = t; g = p; b = v; break;
case 5: r = v; g = p; b = q; break;
default: break;
}
return [r,
g,
b];
}
function RGBtoHSV(r, g, b) {
var max = Math.max(r, g, b);
var min = Math.min(r, g, b);
var d = max - min;
var h;
var s = (max === 0 ? 0 : d / max);
var v = max / 255;
switch (max) {
case min: h = 0; break;
case r: h = (g - b) + d * (g < b ? 6 : 0); h /= 6 * d; break;
case g: h = (b - r) + d * 2; h /= 6 * d; break;
case b: h = (r - g) + d * 4; h /= 6 * d; break;
default: break;
}
return [
h,
s,
v,
];
}
function addSaturationToRGB(color, offset) {
var hsv = RGBtoHSV(color[0] * 255, color[1] * 255, color[2] * 255);
hsv[1] += offset;
if (hsv[1] > 1) {
hsv[1] = 1;
} else if (hsv[1] <= 0) {
hsv[1] = 0;
}
return HSVtoRGB(hsv[0], hsv[1], hsv[2]);
}
function addBrightnessToRGB(color, offset) {
var hsv = RGBtoHSV(color[0] * 255, color[1] * 255, color[2] * 255);
hsv[2] += offset;
if (hsv[2] > 1) {
hsv[2] = 1;
} else if (hsv[2] < 0) {
hsv[2] = 0;
}
return HSVtoRGB(hsv[0], hsv[1], hsv[2]);
}
function addHueToRGB(color, offset) {
var hsv = RGBtoHSV(color[0] * 255, color[1] * 255, color[2] * 255);
hsv[0] += offset / 360;
if (hsv[0] > 1) {
hsv[0] -= 1;
} else if (hsv[0] < 0) {
hsv[0] += 1;
}
return HSVtoRGB(hsv[0], hsv[1], hsv[2]);
}
const rgbToHex = (function () {
var colorMap = [];
var i;
var hex;
for (i = 0; i < 256; i += 1) {
hex = i.toString(16);
colorMap[i] = hex.length === 1 ? '0' + hex : hex;
}
return function (r, g, b) {
if (r < 0) {
r = 0;
}
if (g < 0) {
g = 0;
}
if (b < 0) {
b = 0;
}
return '#' + colorMap[r] + colorMap[g] + colorMap[b];
};
}());
const setSubframeEnabled = (flag) => { subframeEnabled = !!flag; };
const getSubframeEnabled = () => subframeEnabled;
const setExpressionsPlugin = (value) => { expressionsPlugin = value; };
const getExpressionsPlugin = () => expressionsPlugin;
const setExpressionInterfaces = (value) => { expressionsInterfaces = value; };
const getExpressionInterfaces = () => expressionsInterfaces;
const setDefaultCurveSegments = (value) => { defaultCurveSegments = value; };
const getDefaultCurveSegments = () => defaultCurveSegments;
const setIdPrefix = (value) => { idPrefix = value; };
const getIdPrefix = () => idPrefix;
export {
setSubframeEnabled,
getSubframeEnabled,
setExpressionsPlugin,
getExpressionsPlugin,
setExpressionInterfaces,
getExpressionInterfaces,
setDefaultCurveSegments,
getDefaultCurveSegments,
isSafari,
bmPow,
bmSqrt,
bmFloor,
bmMax,
bmMin,
degToRads,
roundCorner,
styleDiv,
bmRnd,
roundValues,
BMEnterFrameEvent,
BMCompleteEvent,
BMCompleteLoopEvent,
BMSegmentStartEvent,
BMDestroyEvent,
BMRenderFrameErrorEvent,
BMConfigErrorEvent,
BMAnimationConfigErrorEvent,
createElementID,
addSaturationToRGB,
addBrightnessToRGB,
addHueToRGB,
rgbToHex,
setIdPrefix,
getIdPrefix,
BMMath,
ProjectInterface,
};

28
node_modules/lottie-web/player/js/utils/expressions/CompInterface.js generated vendored Normal file
View File

@@ -0,0 +1,28 @@
const CompExpressionInterface = (function () {
return function (comp) {
function _thisLayerFunction(name) {
var i = 0;
var len = comp.layers.length;
while (i < len) {
if (comp.layers[i].nm === name || comp.layers[i].ind === name) {
return comp.elements[i].layerInterface;
}
i += 1;
}
return null;
// return {active:false};
}
Object.defineProperty(_thisLayerFunction, '_name', { value: comp.data.nm });
_thisLayerFunction.layer = _thisLayerFunction;
_thisLayerFunction.pixelAspect = 1;
_thisLayerFunction.height = comp.data.h || comp.globalData.compSize.h;
_thisLayerFunction.width = comp.data.w || comp.globalData.compSize.w;
_thisLayerFunction.pixelAspect = 1;
_thisLayerFunction.frameDuration = 1 / comp.globalData.frameRate;
_thisLayerFunction.displayStartTime = 0;
_thisLayerFunction.numLayers = comp.layers.length;
return _thisLayerFunction;
};
}());
export default CompExpressionInterface;

111
node_modules/lottie-web/player/js/utils/expressions/EffectInterface.js generated vendored Normal file
View File

@@ -0,0 +1,111 @@
import ExpressionPropertyInterface from './ExpressionValueFactory';
import propertyGroupFactory from './PropertyGroupFactory';
import PropertyInterface from './PropertyInterface';
const EffectsExpressionInterface = (function () {
var ob = {
createEffectsInterface: createEffectsInterface,
};
function createEffectsInterface(elem, propertyGroup) {
if (elem.effectsManager) {
var effectElements = [];
var effectsData = elem.data.ef;
var i;
var len = elem.effectsManager.effectElements.length;
for (i = 0; i < len; i += 1) {
effectElements.push(createGroupInterface(effectsData[i], elem.effectsManager.effectElements[i], propertyGroup, elem));
}
var effects = elem.data.ef || [];
var groupInterface = function (name) {
i = 0;
len = effects.length;
while (i < len) {
if (name === effects[i].nm || name === effects[i].mn || name === effects[i].ix) {
return effectElements[i];
}
i += 1;
}
return null;
};
Object.defineProperty(groupInterface, 'numProperties', {
get: function () {
return effects.length;
},
});
return groupInterface;
}
return null;
}
function createGroupInterface(data, elements, propertyGroup, elem) {
function groupInterface(name) {
var effects = data.ef;
var i = 0;
var len = effects.length;
while (i < len) {
if (name === effects[i].nm || name === effects[i].mn || name === effects[i].ix) {
if (effects[i].ty === 5) {
return effectElements[i];
}
return effectElements[i]();
}
i += 1;
}
throw new Error();
}
var _propertyGroup = propertyGroupFactory(groupInterface, propertyGroup);
var effectElements = [];
var i;
var len = data.ef.length;
for (i = 0; i < len; i += 1) {
if (data.ef[i].ty === 5) {
effectElements.push(createGroupInterface(data.ef[i], elements.effectElements[i], elements.effectElements[i].propertyGroup, elem));
} else {
effectElements.push(createValueInterface(elements.effectElements[i], data.ef[i].ty, elem, _propertyGroup));
}
}
if (data.mn === 'ADBE Color Control') {
Object.defineProperty(groupInterface, 'color', {
get: function () {
return effectElements[0]();
},
});
}
Object.defineProperties(groupInterface, {
numProperties: {
get: function () {
return data.np;
},
},
_name: { value: data.nm },
propertyGroup: { value: _propertyGroup },
});
groupInterface.enabled = data.en !== 0;
groupInterface.active = groupInterface.enabled;
return groupInterface;
}
function createValueInterface(element, type, elem, propertyGroup) {
var expressionProperty = ExpressionPropertyInterface(element.p);
function interfaceFunction() {
if (type === 10) {
return elem.comp.compInterface(element.p.v);
}
return expressionProperty();
}
if (element.p.setGroupProperty) {
element.p.setGroupProperty(PropertyInterface('', propertyGroup));
}
return interfaceFunction;
}
return ob;
}());
export default EffectsExpressionInterface;

751
node_modules/lottie-web/player/js/utils/expressions/ExpressionManager.js generated vendored Normal file
View File

@@ -0,0 +1,751 @@
/* eslint-disable camelcase */
import {
degToRads,
BMMath,
} from '../common';
import {
createTypedArray,
} from '../helpers/arrays';
import BezierFactory from '../../3rd_party/BezierEaser';
import shapePool from '../pooling/shape_pool';
import seedrandom from '../../3rd_party/seedrandom';
import propTypes from '../helpers/propTypes';
const ExpressionManager = (function () {
'use strict';
var ob = {};
var Math = BMMath;
var window = null;
var document = null;
var XMLHttpRequest = null;
var fetch = null;
var frames = null;
var _lottieGlobal = {};
seedrandom(BMMath);
function resetFrame() {
_lottieGlobal = {};
}
function $bm_isInstanceOfArray(arr) {
return arr.constructor === Array || arr.constructor === Float32Array;
}
function isNumerable(tOfV, v) {
return tOfV === 'number' || v instanceof Number || tOfV === 'boolean' || tOfV === 'string';
}
function $bm_neg(a) {
var tOfA = typeof a;
if (tOfA === 'number' || a instanceof Number || tOfA === 'boolean') {
return -a;
}
if ($bm_isInstanceOfArray(a)) {
var i;
var lenA = a.length;
var retArr = [];
for (i = 0; i < lenA; i += 1) {
retArr[i] = -a[i];
}
return retArr;
}
if (a.propType) {
return a.v;
}
return -a;
}
var easeInBez = BezierFactory.getBezierEasing(0.333, 0, 0.833, 0.833, 'easeIn').get;
var easeOutBez = BezierFactory.getBezierEasing(0.167, 0.167, 0.667, 1, 'easeOut').get;
var easeInOutBez = BezierFactory.getBezierEasing(0.33, 0, 0.667, 1, 'easeInOut').get;
function sum(a, b) {
var tOfA = typeof a;
var tOfB = typeof b;
if ((isNumerable(tOfA, a) && isNumerable(tOfB, b)) || tOfA === 'string' || tOfB === 'string') {
return a + b;
}
if ($bm_isInstanceOfArray(a) && isNumerable(tOfB, b)) {
a = a.slice(0);
a[0] += b;
return a;
}
if (isNumerable(tOfA, a) && $bm_isInstanceOfArray(b)) {
b = b.slice(0);
b[0] = a + b[0];
return b;
}
if ($bm_isInstanceOfArray(a) && $bm_isInstanceOfArray(b)) {
var i = 0;
var lenA = a.length;
var lenB = b.length;
var retArr = [];
while (i < lenA || i < lenB) {
if ((typeof a[i] === 'number' || a[i] instanceof Number) && (typeof b[i] === 'number' || b[i] instanceof Number)) {
retArr[i] = a[i] + b[i];
} else {
retArr[i] = b[i] === undefined ? a[i] : a[i] || b[i];
}
i += 1;
}
return retArr;
}
return 0;
}
var add = sum;
function sub(a, b) {
var tOfA = typeof a;
var tOfB = typeof b;
if (isNumerable(tOfA, a) && isNumerable(tOfB, b)) {
if (tOfA === 'string') {
a = parseInt(a, 10);
}
if (tOfB === 'string') {
b = parseInt(b, 10);
}
return a - b;
}
if ($bm_isInstanceOfArray(a) && isNumerable(tOfB, b)) {
a = a.slice(0);
a[0] -= b;
return a;
}
if (isNumerable(tOfA, a) && $bm_isInstanceOfArray(b)) {
b = b.slice(0);
b[0] = a - b[0];
return b;
}
if ($bm_isInstanceOfArray(a) && $bm_isInstanceOfArray(b)) {
var i = 0;
var lenA = a.length;
var lenB = b.length;
var retArr = [];
while (i < lenA || i < lenB) {
if ((typeof a[i] === 'number' || a[i] instanceof Number) && (typeof b[i] === 'number' || b[i] instanceof Number)) {
retArr[i] = a[i] - b[i];
} else {
retArr[i] = b[i] === undefined ? a[i] : a[i] || b[i];
}
i += 1;
}
return retArr;
}
return 0;
}
function mul(a, b) {
var tOfA = typeof a;
var tOfB = typeof b;
var arr;
if (isNumerable(tOfA, a) && isNumerable(tOfB, b)) {
return a * b;
}
var i;
var len;
if ($bm_isInstanceOfArray(a) && isNumerable(tOfB, b)) {
len = a.length;
arr = createTypedArray('float32', len);
for (i = 0; i < len; i += 1) {
arr[i] = a[i] * b;
}
return arr;
}
if (isNumerable(tOfA, a) && $bm_isInstanceOfArray(b)) {
len = b.length;
arr = createTypedArray('float32', len);
for (i = 0; i < len; i += 1) {
arr[i] = a * b[i];
}
return arr;
}
return 0;
}
function div(a, b) {
var tOfA = typeof a;
var tOfB = typeof b;
var arr;
if (isNumerable(tOfA, a) && isNumerable(tOfB, b)) {
return a / b;
}
var i;
var len;
if ($bm_isInstanceOfArray(a) && isNumerable(tOfB, b)) {
len = a.length;
arr = createTypedArray('float32', len);
for (i = 0; i < len; i += 1) {
arr[i] = a[i] / b;
}
return arr;
}
if (isNumerable(tOfA, a) && $bm_isInstanceOfArray(b)) {
len = b.length;
arr = createTypedArray('float32', len);
for (i = 0; i < len; i += 1) {
arr[i] = a / b[i];
}
return arr;
}
return 0;
}
function mod(a, b) {
if (typeof a === 'string') {
a = parseInt(a, 10);
}
if (typeof b === 'string') {
b = parseInt(b, 10);
}
return a % b;
}
var $bm_sum = sum;
var $bm_sub = sub;
var $bm_mul = mul;
var $bm_div = div;
var $bm_mod = mod;
function clamp(num, min, max) {
if (min > max) {
var mm = max;
max = min;
min = mm;
}
return Math.min(Math.max(num, min), max);
}
function radiansToDegrees(val) {
return val / degToRads;
}
var radians_to_degrees = radiansToDegrees;
function degreesToRadians(val) {
return val * degToRads;
}
var degrees_to_radians = radiansToDegrees;
var helperLengthArray = [0, 0, 0, 0, 0, 0];
function length(arr1, arr2) {
if (typeof arr1 === 'number' || arr1 instanceof Number) {
arr2 = arr2 || 0;
return Math.abs(arr1 - arr2);
}
if (!arr2) {
arr2 = helperLengthArray;
}
var i;
var len = Math.min(arr1.length, arr2.length);
var addedLength = 0;
for (i = 0; i < len; i += 1) {
addedLength += Math.pow(arr2[i] - arr1[i], 2);
}
return Math.sqrt(addedLength);
}
function normalize(vec) {
return div(vec, length(vec));
}
function rgbToHsl(val) {
var r = val[0]; var g = val[1]; var b = val[2];
var max = Math.max(r, g, b);
var min = Math.min(r, g, b);
var h;
var s;
var l = (max + min) / 2;
if (max === min) {
h = 0; // achromatic
s = 0; // achromatic
} else {
var d = max - min;
s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
switch (max) {
case r: h = (g - b) / d + (g < b ? 6 : 0); break;
case g: h = (b - r) / d + 2; break;
case b: h = (r - g) / d + 4; break;
default: break;
}
h /= 6;
}
return [h, s, l, val[3]];
}
function hue2rgb(p, q, t) {
if (t < 0) t += 1;
if (t > 1) t -= 1;
if (t < 1 / 6) return p + (q - p) * 6 * t;
if (t < 1 / 2) return q;
if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
return p;
}
function hslToRgb(val) {
var h = val[0];
var s = val[1];
var l = val[2];
var r;
var g;
var b;
if (s === 0) {
r = l; // achromatic
b = l; // achromatic
g = l; // achromatic
} else {
var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
var p = 2 * l - q;
r = hue2rgb(p, q, h + 1 / 3);
g = hue2rgb(p, q, h);
b = hue2rgb(p, q, h - 1 / 3);
}
return [r, g, b, val[3]];
}
function linear(t, tMin, tMax, value1, value2) {
if (value1 === undefined || value2 === undefined) {
value1 = tMin;
value2 = tMax;
tMin = 0;
tMax = 1;
}
if (tMax < tMin) {
var _tMin = tMax;
tMax = tMin;
tMin = _tMin;
}
if (t <= tMin) {
return value1;
} if (t >= tMax) {
return value2;
}
var perc = tMax === tMin ? 0 : (t - tMin) / (tMax - tMin);
if (!value1.length) {
return value1 + (value2 - value1) * perc;
}
var i;
var len = value1.length;
var arr = createTypedArray('float32', len);
for (i = 0; i < len; i += 1) {
arr[i] = value1[i] + (value2[i] - value1[i]) * perc;
}
return arr;
}
function random(min, max) {
if (max === undefined) {
if (min === undefined) {
min = 0;
max = 1;
} else {
max = min;
min = undefined;
}
}
if (max.length) {
var i;
var len = max.length;
if (!min) {
min = createTypedArray('float32', len);
}
var arr = createTypedArray('float32', len);
var rnd = BMMath.random();
for (i = 0; i < len; i += 1) {
arr[i] = min[i] + rnd * (max[i] - min[i]);
}
return arr;
}
if (min === undefined) {
min = 0;
}
var rndm = BMMath.random();
return min + rndm * (max - min);
}
function createPath(points, inTangents, outTangents, closed) {
var i;
var len = points.length;
var path = shapePool.newElement();
path.setPathData(!!closed, len);
var arrPlaceholder = [0, 0];
var inVertexPoint;
var outVertexPoint;
for (i = 0; i < len; i += 1) {
inVertexPoint = (inTangents && inTangents[i]) ? inTangents[i] : arrPlaceholder;
outVertexPoint = (outTangents && outTangents[i]) ? outTangents[i] : arrPlaceholder;
path.setTripleAt(points[i][0], points[i][1], outVertexPoint[0] + points[i][0], outVertexPoint[1] + points[i][1], inVertexPoint[0] + points[i][0], inVertexPoint[1] + points[i][1], i, true);
}
return path;
}
function initiateExpression(elem, data, property) {
// Bail out if we don't want expressions
function noOp(_value) {
return _value;
}
if (!elem.globalData.renderConfig.runExpressions) {
return noOp;
}
var val = data.x;
var needsVelocity = /velocity(?![\w\d])/.test(val);
var _needsRandom = val.indexOf('random') !== -1;
var elemType = elem.data.ty;
var transform;
var $bm_transform;
var content;
var effect;
var thisProperty = property;
thisProperty.valueAtTime = thisProperty.getValueAtTime;
Object.defineProperty(thisProperty, 'value', {
get: function () {
return thisProperty.v;
},
});
elem.comp.frameDuration = 1 / elem.comp.globalData.frameRate;
elem.comp.displayStartTime = 0;
var inPoint = elem.data.ip / elem.comp.globalData.frameRate;
var outPoint = elem.data.op / elem.comp.globalData.frameRate;
var width = elem.data.sw ? elem.data.sw : 0;
var height = elem.data.sh ? elem.data.sh : 0;
var name = elem.data.nm;
var loopIn;
var loop_in;
var loopOut;
var loop_out;
var smooth;
var toWorld;
var fromWorld;
var fromComp;
var toComp;
var fromCompToSurface;
var position;
var rotation;
var anchorPoint;
var scale;
var thisLayer;
var thisComp;
var mask;
var valueAtTime;
var velocityAtTime;
var scoped_bm_rt;
// val = val.replace(/(\\?"|')((http)(s)?(:\/))?\/.*?(\\?"|')/g, "\"\""); // deter potential network calls
var expression_function = eval('[function _expression_function(){' + val + ';scoped_bm_rt=$bm_rt}]')[0]; // eslint-disable-line no-eval
var numKeys = property.kf ? data.k.length : 0;
var active = !this.data || this.data.hd !== true;
var wiggle = function wiggle(freq, amp) {
var iWiggle;
var j;
var lenWiggle = this.pv.length ? this.pv.length : 1;
var addedAmps = createTypedArray('float32', lenWiggle);
freq = 5;
var iterations = Math.floor(time * freq);
iWiggle = 0;
j = 0;
while (iWiggle < iterations) {
// var rnd = BMMath.random();
for (j = 0; j < lenWiggle; j += 1) {
addedAmps[j] += -amp + amp * 2 * BMMath.random();
// addedAmps[j] += -amp + amp*2*rnd;
}
iWiggle += 1;
}
// var rnd2 = BMMath.random();
var periods = time * freq;
var perc = periods - Math.floor(periods);
var arr = createTypedArray('float32', lenWiggle);
if (lenWiggle > 1) {
for (j = 0; j < lenWiggle; j += 1) {
arr[j] = this.pv[j] + addedAmps[j] + (-amp + amp * 2 * BMMath.random()) * perc;
// arr[j] = this.pv[j] + addedAmps[j] + (-amp + amp*2*rnd)*perc;
// arr[i] = this.pv[i] + addedAmp + amp1*perc + amp2*(1-perc);
}
return arr;
}
return this.pv + addedAmps[0] + (-amp + amp * 2 * BMMath.random()) * perc;
}.bind(this);
if (thisProperty.loopIn) {
loopIn = thisProperty.loopIn.bind(thisProperty);
loop_in = loopIn;
}
if (thisProperty.loopOut) {
loopOut = thisProperty.loopOut.bind(thisProperty);
loop_out = loopOut;
}
if (thisProperty.smooth) {
smooth = thisProperty.smooth.bind(thisProperty);
}
function loopInDuration(type, duration) {
return loopIn(type, duration, true);
}
function loopOutDuration(type, duration) {
return loopOut(type, duration, true);
}
if (this.getValueAtTime) {
valueAtTime = this.getValueAtTime.bind(this);
}
if (this.getVelocityAtTime) {
velocityAtTime = this.getVelocityAtTime.bind(this);
}
var comp = elem.comp.globalData.projectInterface.bind(elem.comp.globalData.projectInterface);
function lookAt(elem1, elem2) {
var fVec = [elem2[0] - elem1[0], elem2[1] - elem1[1], elem2[2] - elem1[2]];
var pitch = Math.atan2(fVec[0], Math.sqrt(fVec[1] * fVec[1] + fVec[2] * fVec[2])) / degToRads;
var yaw = -Math.atan2(fVec[1], fVec[2]) / degToRads;
return [yaw, pitch, 0];
}
function easeOut(t, tMin, tMax, val1, val2) {
return applyEase(easeOutBez, t, tMin, tMax, val1, val2);
}
function easeIn(t, tMin, tMax, val1, val2) {
return applyEase(easeInBez, t, tMin, tMax, val1, val2);
}
function ease(t, tMin, tMax, val1, val2) {
return applyEase(easeInOutBez, t, tMin, tMax, val1, val2);
}
function applyEase(fn, t, tMin, tMax, val1, val2) {
if (val1 === undefined) {
val1 = tMin;
val2 = tMax;
} else {
t = (t - tMin) / (tMax - tMin);
}
if (t > 1) {
t = 1;
} else if (t < 0) {
t = 0;
}
var mult = fn(t);
if ($bm_isInstanceOfArray(val1)) {
var iKey;
var lenKey = val1.length;
var arr = createTypedArray('float32', lenKey);
for (iKey = 0; iKey < lenKey; iKey += 1) {
arr[iKey] = (val2[iKey] - val1[iKey]) * mult + val1[iKey];
}
return arr;
}
return (val2 - val1) * mult + val1;
}
function nearestKey(time) {
var iKey;
var lenKey = data.k.length;
var index;
var keyTime;
if (!data.k.length || typeof (data.k[0]) === 'number') {
index = 0;
keyTime = 0;
} else {
index = -1;
time *= elem.comp.globalData.frameRate;
if (time < data.k[0].t) {
index = 1;
keyTime = data.k[0].t;
} else {
for (iKey = 0; iKey < lenKey - 1; iKey += 1) {
if (time === data.k[iKey].t) {
index = iKey + 1;
keyTime = data.k[iKey].t;
break;
} else if (time > data.k[iKey].t && time < data.k[iKey + 1].t) {
if (time - data.k[iKey].t > data.k[iKey + 1].t - time) {
index = iKey + 2;
keyTime = data.k[iKey + 1].t;
} else {
index = iKey + 1;
keyTime = data.k[iKey].t;
}
break;
}
}
if (index === -1) {
index = iKey + 1;
keyTime = data.k[iKey].t;
}
}
}
var obKey = {};
obKey.index = index;
obKey.time = keyTime / elem.comp.globalData.frameRate;
return obKey;
}
function key(ind) {
var obKey;
var iKey;
var lenKey;
if (!data.k.length || typeof (data.k[0]) === 'number') {
throw new Error('The property has no keyframe at index ' + ind);
}
ind -= 1;
obKey = {
time: data.k[ind].t / elem.comp.globalData.frameRate,
value: [],
};
var arr = Object.prototype.hasOwnProperty.call(data.k[ind], 's') ? data.k[ind].s : data.k[ind - 1].e;
lenKey = arr.length;
for (iKey = 0; iKey < lenKey; iKey += 1) {
obKey[iKey] = arr[iKey];
obKey.value[iKey] = arr[iKey];
}
return obKey;
}
function framesToTime(fr, fps) {
if (!fps) {
fps = elem.comp.globalData.frameRate;
}
return fr / fps;
}
function timeToFrames(t, fps) {
if (!t && t !== 0) {
t = time;
}
if (!fps) {
fps = elem.comp.globalData.frameRate;
}
return t * fps;
}
function seedRandom(seed) {
BMMath.seedrandom(randSeed + seed);
}
function sourceRectAtTime() {
return elem.sourceRectAtTime();
}
function substring(init, end) {
if (typeof value === 'string') {
if (end === undefined) {
return value.substring(init);
}
return value.substring(init, end);
}
return '';
}
function substr(init, end) {
if (typeof value === 'string') {
if (end === undefined) {
return value.substr(init);
}
return value.substr(init, end);
}
return '';
}
function posterizeTime(framesPerSecond) {
time = framesPerSecond === 0 ? 0 : Math.floor(time * framesPerSecond) / framesPerSecond;
value = valueAtTime(time);
}
var time;
var velocity;
var value;
var text;
var textIndex;
var textTotal;
var selectorValue;
var index = elem.data.ind;
var hasParent = !!(elem.hierarchy && elem.hierarchy.length);
var parent;
var randSeed = Math.floor(Math.random() * 1000000);
var globalData = elem.globalData;
function executeExpression(_value) {
// globalData.pushExpression();
value = _value;
if (this.frameExpressionId === elem.globalData.frameId && this.propType !== 'textSelector') {
return value;
}
if (this.propType === 'textSelector') {
textIndex = this.textIndex;
textTotal = this.textTotal;
selectorValue = this.selectorValue;
}
if (!thisLayer) {
text = elem.layerInterface.text;
thisLayer = elem.layerInterface;
thisComp = elem.comp.compInterface;
toWorld = thisLayer.toWorld.bind(thisLayer);
fromWorld = thisLayer.fromWorld.bind(thisLayer);
fromComp = thisLayer.fromComp.bind(thisLayer);
toComp = thisLayer.toComp.bind(thisLayer);
mask = thisLayer.mask ? thisLayer.mask.bind(thisLayer) : null;
fromCompToSurface = fromComp;
}
if (!transform) {
transform = elem.layerInterface('ADBE Transform Group');
$bm_transform = transform;
if (transform) {
anchorPoint = transform.anchorPoint;
/* position = transform.position;
rotation = transform.rotation;
scale = transform.scale; */
}
}
if (elemType === 4 && !content) {
content = thisLayer('ADBE Root Vectors Group');
}
if (!effect) {
effect = thisLayer(4);
}
hasParent = !!(elem.hierarchy && elem.hierarchy.length);
if (hasParent && !parent) {
parent = elem.hierarchy[0].layerInterface;
}
time = this.comp.renderedFrame / this.comp.globalData.frameRate;
if (_needsRandom) {
seedRandom(randSeed + time);
}
if (needsVelocity) {
velocity = velocityAtTime(time);
}
expression_function();
this.frameExpressionId = elem.globalData.frameId;
// TODO: Check if it's possible to return on ShapeInterface the .v value
// Changed this to a ternary operation because Rollup failed compiling it correctly
scoped_bm_rt = scoped_bm_rt.propType === propTypes.SHAPE
? scoped_bm_rt.v
: scoped_bm_rt;
return scoped_bm_rt;
}
// Bundlers will see these as dead code and unless we reference them
executeExpression.__preventDeadCodeRemoval = [$bm_transform, anchorPoint, time, velocity, inPoint, outPoint, width, height, name, loop_in, loop_out, smooth, toComp, fromCompToSurface, toWorld, fromWorld, mask, position, rotation, scale, thisComp, numKeys, active, wiggle, loopInDuration, loopOutDuration, comp, lookAt, easeOut, easeIn, ease, nearestKey, key, text, textIndex, textTotal, selectorValue, framesToTime, timeToFrames, sourceRectAtTime, substring, substr, posterizeTime, index, globalData];
return executeExpression;
}
ob.initiateExpression = initiateExpression;
ob.__preventDeadCodeRemoval = [window, document, XMLHttpRequest, fetch, frames, $bm_neg, add, $bm_sum, $bm_sub, $bm_mul, $bm_div, $bm_mod, clamp, radians_to_degrees, degreesToRadians, degrees_to_radians, normalize, rgbToHsl, hslToRgb, linear, random, createPath, _lottieGlobal];
ob.resetFrame = resetFrame;
return ob;
}());
export default ExpressionManager;

463
node_modules/lottie-web/player/js/utils/expressions/ExpressionPropertyDecorator.js generated vendored Normal file
View File

@@ -0,0 +1,463 @@
import {
extendPrototype,
} from '../functionExtensions';
import {
createSizedArray,
createTypedArray,
} from '../helpers/arrays';
import ShapePropertyFactory from '../shapes/ShapeProperty';
import PropertyFactory from '../PropertyFactory';
import shapePool from '../pooling/shape_pool';
import {
initialDefaultFrame,
} from '../../main';
import bez from '../bez';
import Matrix from '../../3rd_party/transformation-matrix';
import TransformPropertyFactory from '../TransformProperty';
import expressionHelpers from './expressionHelpers';
import ExpressionManager from './ExpressionManager';
function addPropertyDecorator() {
function loopOut(type, duration, durationFlag) {
if (!this.k || !this.keyframes) {
return this.pv;
}
type = type ? type.toLowerCase() : '';
var currentFrame = this.comp.renderedFrame;
var keyframes = this.keyframes;
var lastKeyFrame = keyframes[keyframes.length - 1].t;
if (currentFrame <= lastKeyFrame) {
return this.pv;
}
var cycleDuration;
var firstKeyFrame;
if (!durationFlag) {
if (!duration || duration > keyframes.length - 1) {
duration = keyframes.length - 1;
}
firstKeyFrame = keyframes[keyframes.length - 1 - duration].t;
cycleDuration = lastKeyFrame - firstKeyFrame;
} else {
if (!duration) {
cycleDuration = Math.max(0, lastKeyFrame - this.elem.data.ip);
} else {
cycleDuration = Math.abs(lastKeyFrame - this.elem.comp.globalData.frameRate * duration);
}
firstKeyFrame = lastKeyFrame - cycleDuration;
}
var i;
var len;
var ret;
if (type === 'pingpong') {
var iterations = Math.floor((currentFrame - firstKeyFrame) / cycleDuration);
if (iterations % 2 !== 0) {
return this.getValueAtTime(((cycleDuration - (currentFrame - firstKeyFrame) % cycleDuration + firstKeyFrame)) / this.comp.globalData.frameRate, 0); // eslint-disable-line
}
} else if (type === 'offset') {
var initV = this.getValueAtTime(firstKeyFrame / this.comp.globalData.frameRate, 0);
var endV = this.getValueAtTime(lastKeyFrame / this.comp.globalData.frameRate, 0);
var current = this.getValueAtTime(((currentFrame - firstKeyFrame) % cycleDuration + firstKeyFrame) / this.comp.globalData.frameRate, 0); // eslint-disable-line
var repeats = Math.floor((currentFrame - firstKeyFrame) / cycleDuration);
if (this.pv.length) {
ret = new Array(initV.length);
len = ret.length;
for (i = 0; i < len; i += 1) {
ret[i] = (endV[i] - initV[i]) * repeats + current[i];
}
return ret;
}
return (endV - initV) * repeats + current;
} else if (type === 'continue') {
var lastValue = this.getValueAtTime(lastKeyFrame / this.comp.globalData.frameRate, 0);
var nextLastValue = this.getValueAtTime((lastKeyFrame - 0.001) / this.comp.globalData.frameRate, 0);
if (this.pv.length) {
ret = new Array(lastValue.length);
len = ret.length;
for (i = 0; i < len; i += 1) {
ret[i] = lastValue[i] + (lastValue[i] - nextLastValue[i]) * ((currentFrame - lastKeyFrame) / this.comp.globalData.frameRate) / 0.0005; // eslint-disable-line
}
return ret;
}
return lastValue + (lastValue - nextLastValue) * (((currentFrame - lastKeyFrame)) / 0.001);
}
return this.getValueAtTime((((currentFrame - firstKeyFrame) % cycleDuration + firstKeyFrame)) / this.comp.globalData.frameRate, 0); // eslint-disable-line
}
function loopIn(type, duration, durationFlag) {
if (!this.k) {
return this.pv;
}
type = type ? type.toLowerCase() : '';
var currentFrame = this.comp.renderedFrame;
var keyframes = this.keyframes;
var firstKeyFrame = keyframes[0].t;
if (currentFrame >= firstKeyFrame) {
return this.pv;
}
var cycleDuration;
var lastKeyFrame;
if (!durationFlag) {
if (!duration || duration > keyframes.length - 1) {
duration = keyframes.length - 1;
}
lastKeyFrame = keyframes[duration].t;
cycleDuration = lastKeyFrame - firstKeyFrame;
} else {
if (!duration) {
cycleDuration = Math.max(0, this.elem.data.op - firstKeyFrame);
} else {
cycleDuration = Math.abs(this.elem.comp.globalData.frameRate * duration);
}
lastKeyFrame = firstKeyFrame + cycleDuration;
}
var i;
var len;
var ret;
if (type === 'pingpong') {
var iterations = Math.floor((firstKeyFrame - currentFrame) / cycleDuration);
if (iterations % 2 === 0) {
return this.getValueAtTime((((firstKeyFrame - currentFrame) % cycleDuration + firstKeyFrame)) / this.comp.globalData.frameRate, 0); // eslint-disable-line
}
} else if (type === 'offset') {
var initV = this.getValueAtTime(firstKeyFrame / this.comp.globalData.frameRate, 0);
var endV = this.getValueAtTime(lastKeyFrame / this.comp.globalData.frameRate, 0);
var current = this.getValueAtTime((cycleDuration - ((firstKeyFrame - currentFrame) % cycleDuration) + firstKeyFrame) / this.comp.globalData.frameRate, 0);
var repeats = Math.floor((firstKeyFrame - currentFrame) / cycleDuration) + 1;
if (this.pv.length) {
ret = new Array(initV.length);
len = ret.length;
for (i = 0; i < len; i += 1) {
ret[i] = current[i] - (endV[i] - initV[i]) * repeats;
}
return ret;
}
return current - (endV - initV) * repeats;
} else if (type === 'continue') {
var firstValue = this.getValueAtTime(firstKeyFrame / this.comp.globalData.frameRate, 0);
var nextFirstValue = this.getValueAtTime((firstKeyFrame + 0.001) / this.comp.globalData.frameRate, 0);
if (this.pv.length) {
ret = new Array(firstValue.length);
len = ret.length;
for (i = 0; i < len; i += 1) {
ret[i] = firstValue[i] + ((firstValue[i] - nextFirstValue[i]) * (firstKeyFrame - currentFrame)) / 0.001;
}
return ret;
}
return firstValue + ((firstValue - nextFirstValue) * (firstKeyFrame - currentFrame)) / 0.001;
}
return this.getValueAtTime(((cycleDuration - ((firstKeyFrame - currentFrame) % cycleDuration + firstKeyFrame))) / this.comp.globalData.frameRate, 0); // eslint-disable-line
}
function smooth(width, samples) {
if (!this.k) {
return this.pv;
}
width = (width || 0.4) * 0.5;
samples = Math.floor(samples || 5);
if (samples <= 1) {
return this.pv;
}
var currentTime = this.comp.renderedFrame / this.comp.globalData.frameRate;
var initFrame = currentTime - width;
var endFrame = currentTime + width;
var sampleFrequency = samples > 1 ? (endFrame - initFrame) / (samples - 1) : 1;
var i = 0;
var j = 0;
var value;
if (this.pv.length) {
value = createTypedArray('float32', this.pv.length);
} else {
value = 0;
}
var sampleValue;
while (i < samples) {
sampleValue = this.getValueAtTime(initFrame + i * sampleFrequency);
if (this.pv.length) {
for (j = 0; j < this.pv.length; j += 1) {
value[j] += sampleValue[j];
}
} else {
value += sampleValue;
}
i += 1;
}
if (this.pv.length) {
for (j = 0; j < this.pv.length; j += 1) {
value[j] /= samples;
}
} else {
value /= samples;
}
return value;
}
function getTransformValueAtTime(time) {
if (!this._transformCachingAtTime) {
this._transformCachingAtTime = {
v: new Matrix(),
};
}
/// /
var matrix = this._transformCachingAtTime.v;
matrix.cloneFromProps(this.pre.props);
if (this.appliedTransformations < 1) {
var anchor = this.a.getValueAtTime(time);
matrix.translate(
-anchor[0] * this.a.mult,
-anchor[1] * this.a.mult,
anchor[2] * this.a.mult
);
}
if (this.appliedTransformations < 2) {
var scale = this.s.getValueAtTime(time);
matrix.scale(
scale[0] * this.s.mult,
scale[1] * this.s.mult,
scale[2] * this.s.mult
);
}
if (this.sk && this.appliedTransformations < 3) {
var skew = this.sk.getValueAtTime(time);
var skewAxis = this.sa.getValueAtTime(time);
matrix.skewFromAxis(-skew * this.sk.mult, skewAxis * this.sa.mult);
}
if (this.r && this.appliedTransformations < 4) {
var rotation = this.r.getValueAtTime(time);
matrix.rotate(-rotation * this.r.mult);
} else if (!this.r && this.appliedTransformations < 4) {
var rotationZ = this.rz.getValueAtTime(time);
var rotationY = this.ry.getValueAtTime(time);
var rotationX = this.rx.getValueAtTime(time);
var orientation = this.or.getValueAtTime(time);
matrix.rotateZ(-rotationZ * this.rz.mult)
.rotateY(rotationY * this.ry.mult)
.rotateX(rotationX * this.rx.mult)
.rotateZ(-orientation[2] * this.or.mult)
.rotateY(orientation[1] * this.or.mult)
.rotateX(orientation[0] * this.or.mult);
}
if (this.data.p && this.data.p.s) {
var positionX = this.px.getValueAtTime(time);
var positionY = this.py.getValueAtTime(time);
if (this.data.p.z) {
var positionZ = this.pz.getValueAtTime(time);
matrix.translate(
positionX * this.px.mult,
positionY * this.py.mult,
-positionZ * this.pz.mult
);
} else {
matrix.translate(positionX * this.px.mult, positionY * this.py.mult, 0);
}
} else {
var position = this.p.getValueAtTime(time);
matrix.translate(
position[0] * this.p.mult,
position[1] * this.p.mult,
-position[2] * this.p.mult
);
}
return matrix;
/// /
}
function getTransformStaticValueAtTime() {
return this.v.clone(new Matrix());
}
var getTransformProperty = TransformPropertyFactory.getTransformProperty;
TransformPropertyFactory.getTransformProperty = function (elem, data, container) {
var prop = getTransformProperty(elem, data, container);
if (prop.dynamicProperties.length) {
prop.getValueAtTime = getTransformValueAtTime.bind(prop);
} else {
prop.getValueAtTime = getTransformStaticValueAtTime.bind(prop);
}
prop.setGroupProperty = expressionHelpers.setGroupProperty;
return prop;
};
var propertyGetProp = PropertyFactory.getProp;
PropertyFactory.getProp = function (elem, data, type, mult, container) {
var prop = propertyGetProp(elem, data, type, mult, container);
// prop.getVelocityAtTime = getVelocityAtTime;
// prop.loopOut = loopOut;
// prop.loopIn = loopIn;
if (prop.kf) {
prop.getValueAtTime = expressionHelpers.getValueAtTime.bind(prop);
} else {
prop.getValueAtTime = expressionHelpers.getStaticValueAtTime.bind(prop);
}
prop.setGroupProperty = expressionHelpers.setGroupProperty;
prop.loopOut = loopOut;
prop.loopIn = loopIn;
prop.smooth = smooth;
prop.getVelocityAtTime = expressionHelpers.getVelocityAtTime.bind(prop);
prop.getSpeedAtTime = expressionHelpers.getSpeedAtTime.bind(prop);
prop.numKeys = data.a === 1 ? data.k.length : 0;
prop.propertyIndex = data.ix;
var value = 0;
if (type !== 0) {
value = createTypedArray('float32', data.a === 1 ? data.k[0].s.length : data.k.length);
}
prop._cachingAtTime = {
lastFrame: initialDefaultFrame,
lastIndex: 0,
value: value,
};
expressionHelpers.searchExpressions(elem, data, prop);
if (prop.k) {
container.addDynamicProperty(prop);
}
return prop;
};
function getShapeValueAtTime(frameNum) {
// For now this caching object is created only when needed instead of creating it when the shape is initialized.
if (!this._cachingAtTime) {
this._cachingAtTime = {
shapeValue: shapePool.clone(this.pv),
lastIndex: 0,
lastTime: initialDefaultFrame,
};
}
frameNum *= this.elem.globalData.frameRate;
frameNum -= this.offsetTime;
if (frameNum !== this._cachingAtTime.lastTime) {
this._cachingAtTime.lastIndex = this._cachingAtTime.lastTime < frameNum ? this._caching.lastIndex : 0;
this._cachingAtTime.lastTime = frameNum;
this.interpolateShape(frameNum, this._cachingAtTime.shapeValue, this._cachingAtTime);
}
return this._cachingAtTime.shapeValue;
}
var ShapePropertyConstructorFunction = ShapePropertyFactory.getConstructorFunction();
var KeyframedShapePropertyConstructorFunction = ShapePropertyFactory.getKeyframedConstructorFunction();
function ShapeExpressions() {}
ShapeExpressions.prototype = {
vertices: function (prop, time) {
if (this.k) {
this.getValue();
}
var shapePath = this.v;
if (time !== undefined) {
shapePath = this.getValueAtTime(time, 0);
}
var i;
var len = shapePath._length;
var vertices = shapePath[prop];
var points = shapePath.v;
var arr = createSizedArray(len);
for (i = 0; i < len; i += 1) {
if (prop === 'i' || prop === 'o') {
arr[i] = [vertices[i][0] - points[i][0], vertices[i][1] - points[i][1]];
} else {
arr[i] = [vertices[i][0], vertices[i][1]];
}
}
return arr;
},
points: function (time) {
return this.vertices('v', time);
},
inTangents: function (time) {
return this.vertices('i', time);
},
outTangents: function (time) {
return this.vertices('o', time);
},
isClosed: function () {
return this.v.c;
},
pointOnPath: function (perc, time) {
var shapePath = this.v;
if (time !== undefined) {
shapePath = this.getValueAtTime(time, 0);
}
if (!this._segmentsLength) {
this._segmentsLength = bez.getSegmentsLength(shapePath);
}
var segmentsLength = this._segmentsLength;
var lengths = segmentsLength.lengths;
var lengthPos = segmentsLength.totalLength * perc;
var i = 0;
var len = lengths.length;
var accumulatedLength = 0;
var pt;
while (i < len) {
if (accumulatedLength + lengths[i].addedLength > lengthPos) {
var initIndex = i;
var endIndex = (shapePath.c && i === len - 1) ? 0 : i + 1;
var segmentPerc = (lengthPos - accumulatedLength) / lengths[i].addedLength;
pt = bez.getPointInSegment(shapePath.v[initIndex], shapePath.v[endIndex], shapePath.o[initIndex], shapePath.i[endIndex], segmentPerc, lengths[i]);
break;
} else {
accumulatedLength += lengths[i].addedLength;
}
i += 1;
}
if (!pt) {
pt = shapePath.c ? [shapePath.v[0][0], shapePath.v[0][1]] : [shapePath.v[shapePath._length - 1][0], shapePath.v[shapePath._length - 1][1]];
}
return pt;
},
vectorOnPath: function (perc, time, vectorType) {
// perc doesn't use triple equality because it can be a Number object as well as a primitive.
if (perc == 1) { // eslint-disable-line eqeqeq
perc = this.v.c;
} else if (perc == 0) { // eslint-disable-line eqeqeq
perc = 0.999;
}
var pt1 = this.pointOnPath(perc, time);
var pt2 = this.pointOnPath(perc + 0.001, time);
var xLength = pt2[0] - pt1[0];
var yLength = pt2[1] - pt1[1];
var magnitude = Math.sqrt(Math.pow(xLength, 2) + Math.pow(yLength, 2));
if (magnitude === 0) {
return [0, 0];
}
var unitVector = vectorType === 'tangent' ? [xLength / magnitude, yLength / magnitude] : [-yLength / magnitude, xLength / magnitude];
return unitVector;
},
tangentOnPath: function (perc, time) {
return this.vectorOnPath(perc, time, 'tangent');
},
normalOnPath: function (perc, time) {
return this.vectorOnPath(perc, time, 'normal');
},
setGroupProperty: expressionHelpers.setGroupProperty,
getValueAtTime: expressionHelpers.getStaticValueAtTime,
};
extendPrototype([ShapeExpressions], ShapePropertyConstructorFunction);
extendPrototype([ShapeExpressions], KeyframedShapePropertyConstructorFunction);
KeyframedShapePropertyConstructorFunction.prototype.getValueAtTime = getShapeValueAtTime;
KeyframedShapePropertyConstructorFunction.prototype.initiateExpression = ExpressionManager.initiateExpression;
var propertyGetShapeProp = ShapePropertyFactory.getShapeProp;
ShapePropertyFactory.getShapeProp = function (elem, data, type, arr, trims) {
var prop = propertyGetShapeProp(elem, data, type, arr, trims);
prop.propertyIndex = data.ix;
prop.lock = false;
if (type === 3) {
expressionHelpers.searchExpressions(elem, data.pt, prop);
} else if (type === 4) {
expressionHelpers.searchExpressions(elem, data.ks, prop);
}
if (prop.k) {
elem.addDynamicProperty(prop);
}
return prop;
};
}
function initialize() {
addPropertyDecorator();
}
export default initialize;

40
node_modules/lottie-web/player/js/utils/expressions/ExpressionTextPropertyDecorator.js generated vendored Normal file
View File

@@ -0,0 +1,40 @@
import TextProperty from '../text/TextProperty';
import ExpressionManager from './ExpressionManager';
function addDecorator() {
function searchExpressions() {
if (this.data.d.x) {
this.calculateExpression = ExpressionManager.initiateExpression.bind(this)(this.elem, this.data.d, this);
this.addEffect(this.getExpressionValue.bind(this));
return true;
}
return null;
}
TextProperty.prototype.getExpressionValue = function (currentValue, text) {
var newValue = this.calculateExpression(text);
if (currentValue.t !== newValue) {
var newData = {};
this.copyData(newData, currentValue);
newData.t = newValue.toString();
newData.__complete = false;
return newData;
}
return currentValue;
};
TextProperty.prototype.searchProperty = function () {
var isKeyframed = this.searchKeyframes();
var hasExpressions = this.searchExpressions();
this.kf = isKeyframed || hasExpressions;
return this.kf;
};
TextProperty.prototype.searchExpressions = searchExpressions;
}
function initialize() {
addDecorator();
}
export default initialize;

61
node_modules/lottie-web/player/js/utils/expressions/ExpressionValue.js generated vendored Normal file
View File

@@ -0,0 +1,61 @@
import {
createTypedArray,
} from '../helpers/arrays';
function ExpressionValue(elementProp, mult, type) {
mult = mult || 1;
var expressionValue;
if (elementProp.k) {
elementProp.getValue();
}
var i;
var len;
var arrValue;
var val;
if (type) {
if (type === 'color') {
len = 4;
expressionValue = createTypedArray('float32', len);
arrValue = createTypedArray('float32', len);
for (i = 0; i < len; i += 1) {
arrValue[i] = (i < 3) ? elementProp.v[i] * mult : 1;
expressionValue[i] = arrValue[i];
}
expressionValue.value = arrValue;
}
} else if (elementProp.propType === 'unidimensional') {
val = elementProp.v * mult;
expressionValue = new Number(val); // eslint-disable-line no-new-wrappers
expressionValue.value = val;
} else {
len = elementProp.pv.length;
expressionValue = createTypedArray('float32', len);
arrValue = createTypedArray('float32', len);
for (i = 0; i < len; i += 1) {
arrValue[i] = elementProp.v[i] * mult;
expressionValue[i] = arrValue[i];
}
expressionValue.value = arrValue;
}
expressionValue.numKeys = elementProp.keyframes ? elementProp.keyframes.length : 0;
expressionValue.key = function (pos) {
if (!expressionValue.numKeys) {
return 0;
}
return elementProp.keyframes[pos - 1].t;
};
expressionValue.valueAtTime = elementProp.getValueAtTime;
expressionValue.speedAtTime = elementProp.getSpeedAtTime;
expressionValue.velocityAtTime = elementProp.getVelocityAtTime;
expressionValue.propertyGroup = elementProp.propertyGroup;
Object.defineProperty(expressionValue, 'velocity', {
get: function () {
return elementProp.getVelocityAtTime(elementProp.comp.currentFrame);
},
});
return expressionValue;
}
export default ExpressionValue;

101
node_modules/lottie-web/player/js/utils/expressions/ExpressionValueFactory.js generated vendored Normal file
View File

@@ -0,0 +1,101 @@
import {
createTypedArray,
} from '../helpers/arrays';
const ExpressionPropertyInterface = (function () {
var defaultUnidimensionalValue = { pv: 0, v: 0, mult: 1 };
var defaultMultidimensionalValue = { pv: [0, 0, 0], v: [0, 0, 0], mult: 1 };
function completeProperty(expressionValue, property, type) {
Object.defineProperty(expressionValue, 'velocity', {
get: function () {
return property.getVelocityAtTime(property.comp.currentFrame);
},
});
expressionValue.numKeys = property.keyframes ? property.keyframes.length : 0;
expressionValue.key = function (pos) {
if (!expressionValue.numKeys) {
return 0;
}
var value = '';
if ('s' in property.keyframes[pos - 1]) {
value = property.keyframes[pos - 1].s;
} else if ('e' in property.keyframes[pos - 2]) {
value = property.keyframes[pos - 2].e;
} else {
value = property.keyframes[pos - 2].s;
}
var valueProp = type === 'unidimensional' ? new Number(value) : Object.assign({}, value); // eslint-disable-line no-new-wrappers
valueProp.time = property.keyframes[pos - 1].t / property.elem.comp.globalData.frameRate;
valueProp.value = type === 'unidimensional' ? value[0] : value;
return valueProp;
};
expressionValue.valueAtTime = property.getValueAtTime;
expressionValue.speedAtTime = property.getSpeedAtTime;
expressionValue.velocityAtTime = property.getVelocityAtTime;
expressionValue.propertyGroup = property.propertyGroup;
}
function UnidimensionalPropertyInterface(property) {
if (!property || !('pv' in property)) {
property = defaultUnidimensionalValue;
}
var mult = 1 / property.mult;
var val = property.pv * mult;
var expressionValue = new Number(val); // eslint-disable-line no-new-wrappers
expressionValue.value = val;
completeProperty(expressionValue, property, 'unidimensional');
return function () {
if (property.k) {
property.getValue();
}
val = property.v * mult;
if (expressionValue.value !== val) {
expressionValue = new Number(val); // eslint-disable-line no-new-wrappers
expressionValue.value = val;
completeProperty(expressionValue, property, 'unidimensional');
}
return expressionValue;
};
}
function MultidimensionalPropertyInterface(property) {
if (!property || !('pv' in property)) {
property = defaultMultidimensionalValue;
}
var mult = 1 / property.mult;
var len = (property.data && property.data.l) || property.pv.length;
var expressionValue = createTypedArray('float32', len);
var arrValue = createTypedArray('float32', len);
expressionValue.value = arrValue;
completeProperty(expressionValue, property, 'multidimensional');
return function () {
if (property.k) {
property.getValue();
}
for (var i = 0; i < len; i += 1) {
arrValue[i] = property.v[i] * mult;
expressionValue[i] = arrValue[i];
}
return expressionValue;
};
}
// TODO: try to avoid using this getter
function defaultGetter() {
return defaultUnidimensionalValue;
}
return function (property) {
if (!property) {
return defaultGetter;
} if (property.propType === 'unidimensional') {
return UnidimensionalPropertyInterface(property);
}
return MultidimensionalPropertyInterface(property);
};
}());
export default ExpressionPropertyInterface;

48
node_modules/lottie-web/player/js/utils/expressions/Expressions.js generated vendored Normal file
View File

@@ -0,0 +1,48 @@
import CompExpressionInterface from './CompInterface';
import ExpressionManager from './ExpressionManager';
const Expressions = (function () {
var ob = {};
ob.initExpressions = initExpressions;
ob.resetFrame = ExpressionManager.resetFrame;
function initExpressions(animation) {
var stackCount = 0;
var registers = [];
function pushExpression() {
stackCount += 1;
}
function popExpression() {
stackCount -= 1;
if (stackCount === 0) {
releaseInstances();
}
}
function registerExpressionProperty(expression) {
if (registers.indexOf(expression) === -1) {
registers.push(expression);
}
}
function releaseInstances() {
var i;
var len = registers.length;
for (i = 0; i < len; i += 1) {
registers[i].release();
}
registers.length = 0;
}
animation.renderer.compInterface = CompExpressionInterface(animation.renderer);
animation.renderer.globalData.projectInterface.registerComposition(animation.renderer);
animation.renderer.globalData.pushExpression = pushExpression;
animation.renderer.globalData.popExpression = popExpression;
animation.renderer.globalData.registerExpressionProperty = registerExpressionProperty;
}
return ob;
}());
export default Expressions;

60
node_modules/lottie-web/player/js/utils/expressions/FootageInterface.js generated vendored Normal file
View File

@@ -0,0 +1,60 @@
const FootageInterface = (function () {
var outlineInterfaceFactory = (function (elem) {
var currentPropertyName = '';
var currentProperty = elem.getFootageData();
function init() {
currentPropertyName = '';
currentProperty = elem.getFootageData();
return searchProperty;
}
function searchProperty(value) {
if (currentProperty[value]) {
currentPropertyName = value;
currentProperty = currentProperty[value];
if (typeof currentProperty === 'object') {
return searchProperty;
}
return currentProperty;
}
var propertyNameIndex = value.indexOf(currentPropertyName);
if (propertyNameIndex !== -1) {
var index = parseInt(value.substr(propertyNameIndex + currentPropertyName.length), 10);
currentProperty = currentProperty[index];
if (typeof currentProperty === 'object') {
return searchProperty;
}
return currentProperty;
}
return '';
}
return init;
});
var dataInterfaceFactory = function (elem) {
function interfaceFunction(value) {
if (value === 'Outline') {
return interfaceFunction.outlineInterface();
}
return null;
}
interfaceFunction._name = 'Outline';
interfaceFunction.outlineInterface = outlineInterfaceFactory(elem);
return interfaceFunction;
};
return function (elem) {
function _interfaceFunction(value) {
if (value === 'Data') {
return _interfaceFunction.dataInterface;
}
return null;
}
_interfaceFunction._name = 'Data';
_interfaceFunction.dataInterface = dataInterfaceFactory(elem);
return _interfaceFunction;
};
}());
export default FootageInterface;

21
node_modules/lottie-web/player/js/utils/expressions/InterfacesProvider.js generated vendored Normal file
View File

@@ -0,0 +1,21 @@
import LayerExpressionInterface from './LayerInterface';
import EffectsExpressionInterface from './EffectInterface';
import CompExpressionInterface from './CompInterface';
import ShapeExpressionInterface from './ShapeInterface';
import TextExpressionInterface from './TextInterface';
import FootageInterface from './FootageInterface';
var interfaces = {
layer: LayerExpressionInterface,
effects: EffectsExpressionInterface,
comp: CompExpressionInterface,
shape: ShapeExpressionInterface,
text: TextExpressionInterface,
footage: FootageInterface,
};
function getInterface(type) {
return interfaces[type] || null;
}
export default getInterface;

179
node_modules/lottie-web/player/js/utils/expressions/LayerInterface.js generated vendored Normal file
View File

@@ -0,0 +1,179 @@
import {
getDescriptor,
} from '../functionExtensions';
import Matrix from '../../3rd_party/transformation-matrix';
import MaskManagerInterface from './MaskInterface';
import TransformExpressionInterface from './TransformInterface';
const LayerExpressionInterface = (function () {
function getMatrix(time) {
var toWorldMat = new Matrix();
if (time !== undefined) {
var propMatrix = this._elem.finalTransform.mProp.getValueAtTime(time);
propMatrix.clone(toWorldMat);
} else {
var transformMat = this._elem.finalTransform.mProp;
transformMat.applyToMatrix(toWorldMat);
}
return toWorldMat;
}
function toWorldVec(arr, time) {
var toWorldMat = this.getMatrix(time);
toWorldMat.props[12] = 0;
toWorldMat.props[13] = 0;
toWorldMat.props[14] = 0;
return this.applyPoint(toWorldMat, arr);
}
function toWorld(arr, time) {
var toWorldMat = this.getMatrix(time);
return this.applyPoint(toWorldMat, arr);
}
function fromWorldVec(arr, time) {
var toWorldMat = this.getMatrix(time);
toWorldMat.props[12] = 0;
toWorldMat.props[13] = 0;
toWorldMat.props[14] = 0;
return this.invertPoint(toWorldMat, arr);
}
function fromWorld(arr, time) {
var toWorldMat = this.getMatrix(time);
return this.invertPoint(toWorldMat, arr);
}
function applyPoint(matrix, arr) {
if (this._elem.hierarchy && this._elem.hierarchy.length) {
var i;
var len = this._elem.hierarchy.length;
for (i = 0; i < len; i += 1) {
this._elem.hierarchy[i].finalTransform.mProp.applyToMatrix(matrix);
}
}
return matrix.applyToPointArray(arr[0], arr[1], arr[2] || 0);
}
function invertPoint(matrix, arr) {
if (this._elem.hierarchy && this._elem.hierarchy.length) {
var i;
var len = this._elem.hierarchy.length;
for (i = 0; i < len; i += 1) {
this._elem.hierarchy[i].finalTransform.mProp.applyToMatrix(matrix);
}
}
return matrix.inversePoint(arr);
}
function fromComp(arr) {
var toWorldMat = new Matrix();
toWorldMat.reset();
this._elem.finalTransform.mProp.applyToMatrix(toWorldMat);
if (this._elem.hierarchy && this._elem.hierarchy.length) {
var i;
var len = this._elem.hierarchy.length;
for (i = 0; i < len; i += 1) {
this._elem.hierarchy[i].finalTransform.mProp.applyToMatrix(toWorldMat);
}
return toWorldMat.inversePoint(arr);
}
return toWorldMat.inversePoint(arr);
}
function sampleImage() {
return [1, 1, 1, 1];
}
return function (elem) {
var transformInterface;
function _registerMaskInterface(maskManager) {
_thisLayerFunction.mask = new MaskManagerInterface(maskManager, elem);
}
function _registerEffectsInterface(effects) {
_thisLayerFunction.effect = effects;
}
function _thisLayerFunction(name) {
switch (name) {
case 'ADBE Root Vectors Group':
case 'Contents':
case 2:
return _thisLayerFunction.shapeInterface;
case 1:
case 6:
case 'Transform':
case 'transform':
case 'ADBE Transform Group':
return transformInterface;
case 4:
case 'ADBE Effect Parade':
case 'effects':
case 'Effects':
return _thisLayerFunction.effect;
case 'ADBE Text Properties':
return _thisLayerFunction.textInterface;
default:
return null;
}
}
_thisLayerFunction.getMatrix = getMatrix;
_thisLayerFunction.invertPoint = invertPoint;
_thisLayerFunction.applyPoint = applyPoint;
_thisLayerFunction.toWorld = toWorld;
_thisLayerFunction.toWorldVec = toWorldVec;
_thisLayerFunction.fromWorld = fromWorld;
_thisLayerFunction.fromWorldVec = fromWorldVec;
_thisLayerFunction.toComp = toWorld;
_thisLayerFunction.fromComp = fromComp;
_thisLayerFunction.sampleImage = sampleImage;
_thisLayerFunction.sourceRectAtTime = elem.sourceRectAtTime.bind(elem);
_thisLayerFunction._elem = elem;
transformInterface = TransformExpressionInterface(elem.finalTransform.mProp);
var anchorPointDescriptor = getDescriptor(transformInterface, 'anchorPoint');
Object.defineProperties(_thisLayerFunction, {
hasParent: {
get: function () {
return elem.hierarchy.length;
},
},
parent: {
get: function () {
return elem.hierarchy[0].layerInterface;
},
},
rotation: getDescriptor(transformInterface, 'rotation'),
scale: getDescriptor(transformInterface, 'scale'),
position: getDescriptor(transformInterface, 'position'),
opacity: getDescriptor(transformInterface, 'opacity'),
anchorPoint: anchorPointDescriptor,
anchor_point: anchorPointDescriptor,
transform: {
get: function () {
return transformInterface;
},
},
active: {
get: function () {
return elem.isInRange;
},
},
});
_thisLayerFunction.startTime = elem.data.st;
_thisLayerFunction.index = elem.data.ind;
_thisLayerFunction.source = elem.data.refId;
_thisLayerFunction.height = elem.data.ty === 0 ? elem.data.h : 100;
_thisLayerFunction.width = elem.data.ty === 0 ? elem.data.w : 100;
_thisLayerFunction.inPoint = elem.data.ip / elem.comp.globalData.frameRate;
_thisLayerFunction.outPoint = elem.data.op / elem.comp.globalData.frameRate;
_thisLayerFunction._name = elem.data.nm;
_thisLayerFunction.registerMaskInterface = _registerMaskInterface;
_thisLayerFunction.registerEffectsInterface = _registerEffectsInterface;
return _thisLayerFunction;
};
}());
export default LayerExpressionInterface;

50
node_modules/lottie-web/player/js/utils/expressions/MaskInterface.js generated vendored Normal file
View File

@@ -0,0 +1,50 @@
import {
createSizedArray,
} from '../helpers/arrays';
const MaskManagerInterface = (function () {
function MaskInterface(mask, data) {
this._mask = mask;
this._data = data;
}
Object.defineProperty(MaskInterface.prototype, 'maskPath', {
get: function () {
if (this._mask.prop.k) {
this._mask.prop.getValue();
}
return this._mask.prop;
},
});
Object.defineProperty(MaskInterface.prototype, 'maskOpacity', {
get: function () {
if (this._mask.op.k) {
this._mask.op.getValue();
}
return this._mask.op.v * 100;
},
});
var MaskManager = function (maskManager) {
var _masksInterfaces = createSizedArray(maskManager.viewData.length);
var i;
var len = maskManager.viewData.length;
for (i = 0; i < len; i += 1) {
_masksInterfaces[i] = new MaskInterface(maskManager.viewData[i], maskManager.masksProperties[i]);
}
var maskFunction = function (name) {
i = 0;
while (i < len) {
if (maskManager.masksProperties[i].nm === name) {
return _masksInterfaces[i];
}
i += 1;
}
return null;
};
return maskFunction;
};
return MaskManager;
}());
export default MaskManagerInterface;

31
node_modules/lottie-web/player/js/utils/expressions/ProjectInterface.js generated vendored Normal file
View File

@@ -0,0 +1,31 @@
const ProjectInterface = (function () {
function registerComposition(comp) {
this.compositions.push(comp);
}
return function () {
function _thisProjectFunction(name) {
var i = 0;
var len = this.compositions.length;
while (i < len) {
if (this.compositions[i].data && this.compositions[i].data.nm === name) {
if (this.compositions[i].prepareFrame && this.compositions[i].data.xt) {
this.compositions[i].prepareFrame(this.currentFrame);
}
return this.compositions[i].compInterface;
}
i += 1;
}
return null;
}
_thisProjectFunction.compositions = [];
_thisProjectFunction.currentFrame = 0;
_thisProjectFunction.registerComposition = registerComposition;
return _thisProjectFunction;
};
}());
export default ProjectInterface;

13
node_modules/lottie-web/player/js/utils/expressions/PropertyGroupFactory.js generated vendored Normal file
View File

@@ -0,0 +1,13 @@
const propertyGroupFactory = (function () {
return function (interfaceFunction, parentPropertyGroup) {
return function (val) {
val = val === undefined ? 1 : val;
if (val <= 0) {
return interfaceFunction;
}
return parentPropertyGroup(val - 1);
};
};
}());
export default propertyGroupFactory;

19
node_modules/lottie-web/player/js/utils/expressions/PropertyInterface.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
const PropertyInterface = (function () {
return function (propertyName, propertyGroup) {
var interfaceFunction = {
_name: propertyName,
};
function _propertyGroup(val) {
val = val === undefined ? 1 : val;
if (val <= 0) {
return interfaceFunction;
}
return propertyGroup(val - 1);
}
return _propertyGroup;
};
}());
export default PropertyInterface;

543
node_modules/lottie-web/player/js/utils/expressions/ShapeInterface.js generated vendored Normal file
View File

@@ -0,0 +1,543 @@
import ExpressionPropertyInterface from './ExpressionValueFactory';
import propertyGroupFactory from './PropertyGroupFactory';
import PropertyInterface from './PropertyInterface';
import ShapePathInterface from './shapes/ShapePathInterface';
const ShapeExpressionInterface = (function () {
function iterateElements(shapes, view, propertyGroup) {
var arr = [];
var i;
var len = shapes ? shapes.length : 0;
for (i = 0; i < len; i += 1) {
if (shapes[i].ty === 'gr') {
arr.push(groupInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === 'fl') {
arr.push(fillInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === 'st') {
arr.push(strokeInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === 'tm') {
arr.push(trimInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === 'tr') {
// arr.push(transformInterfaceFactory(shapes[i],view[i],propertyGroup));
} else if (shapes[i].ty === 'el') {
arr.push(ellipseInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === 'sr') {
arr.push(starInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === 'sh') {
arr.push(ShapePathInterface(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === 'rc') {
arr.push(rectInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === 'rd') {
arr.push(roundedInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === 'rp') {
arr.push(repeaterInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === 'gf') {
arr.push(gradientFillInterfaceFactory(shapes[i], view[i], propertyGroup));
} else {
arr.push(defaultInterfaceFactory(shapes[i], view[i], propertyGroup));
}
}
return arr;
}
function contentsInterfaceFactory(shape, view, propertyGroup) {
var interfaces;
var interfaceFunction = function _interfaceFunction(value) {
var i = 0;
var len = interfaces.length;
while (i < len) {
if (interfaces[i]._name === value || interfaces[i].mn === value || interfaces[i].propertyIndex === value || interfaces[i].ix === value || interfaces[i].ind === value) {
return interfaces[i];
}
i += 1;
}
if (typeof value === 'number') {
return interfaces[value - 1];
}
return null;
};
interfaceFunction.propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
interfaces = iterateElements(shape.it, view.it, interfaceFunction.propertyGroup);
interfaceFunction.numProperties = interfaces.length;
var transformInterface = transformInterfaceFactory(shape.it[shape.it.length - 1], view.it[view.it.length - 1], interfaceFunction.propertyGroup);
interfaceFunction.transform = transformInterface;
interfaceFunction.propertyIndex = shape.cix;
interfaceFunction._name = shape.nm;
return interfaceFunction;
}
function groupInterfaceFactory(shape, view, propertyGroup) {
var interfaceFunction = function _interfaceFunction(value) {
switch (value) {
case 'ADBE Vectors Group':
case 'Contents':
case 2:
return interfaceFunction.content;
// Not necessary for now. Keeping them here in case a new case appears
// case 'ADBE Vector Transform Group':
// case 3:
default:
return interfaceFunction.transform;
}
};
interfaceFunction.propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
var content = contentsInterfaceFactory(shape, view, interfaceFunction.propertyGroup);
var transformInterface = transformInterfaceFactory(shape.it[shape.it.length - 1], view.it[view.it.length - 1], interfaceFunction.propertyGroup);
interfaceFunction.content = content;
interfaceFunction.transform = transformInterface;
Object.defineProperty(interfaceFunction, '_name', {
get: function () {
return shape.nm;
},
});
// interfaceFunction.content = interfaceFunction;
interfaceFunction.numProperties = shape.np;
interfaceFunction.propertyIndex = shape.ix;
interfaceFunction.nm = shape.nm;
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
function fillInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(val) {
if (val === 'Color' || val === 'color') {
return interfaceFunction.color;
} if (val === 'Opacity' || val === 'opacity') {
return interfaceFunction.opacity;
}
return null;
}
Object.defineProperties(interfaceFunction, {
color: {
get: ExpressionPropertyInterface(view.c),
},
opacity: {
get: ExpressionPropertyInterface(view.o),
},
_name: { value: shape.nm },
mn: { value: shape.mn },
});
view.c.setGroupProperty(PropertyInterface('Color', propertyGroup));
view.o.setGroupProperty(PropertyInterface('Opacity', propertyGroup));
return interfaceFunction;
}
function gradientFillInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(val) {
if (val === 'Start Point' || val === 'start point') {
return interfaceFunction.startPoint;
}
if (val === 'End Point' || val === 'end point') {
return interfaceFunction.endPoint;
}
if (val === 'Opacity' || val === 'opacity') {
return interfaceFunction.opacity;
}
return null;
}
Object.defineProperties(interfaceFunction, {
startPoint: {
get: ExpressionPropertyInterface(view.s),
},
endPoint: {
get: ExpressionPropertyInterface(view.e),
},
opacity: {
get: ExpressionPropertyInterface(view.o),
},
type: {
get: function () {
return 'a';
},
},
_name: { value: shape.nm },
mn: { value: shape.mn },
});
view.s.setGroupProperty(PropertyInterface('Start Point', propertyGroup));
view.e.setGroupProperty(PropertyInterface('End Point', propertyGroup));
view.o.setGroupProperty(PropertyInterface('Opacity', propertyGroup));
return interfaceFunction;
}
function defaultInterfaceFactory() {
function interfaceFunction() {
return null;
}
return interfaceFunction;
}
function strokeInterfaceFactory(shape, view, propertyGroup) {
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
var _dashPropertyGroup = propertyGroupFactory(dashOb, _propertyGroup);
function addPropertyToDashOb(i) {
Object.defineProperty(dashOb, shape.d[i].nm, {
get: ExpressionPropertyInterface(view.d.dataProps[i].p),
});
}
var i;
var len = shape.d ? shape.d.length : 0;
var dashOb = {};
for (i = 0; i < len; i += 1) {
addPropertyToDashOb(i);
view.d.dataProps[i].p.setGroupProperty(_dashPropertyGroup);
}
function interfaceFunction(val) {
if (val === 'Color' || val === 'color') {
return interfaceFunction.color;
} if (val === 'Opacity' || val === 'opacity') {
return interfaceFunction.opacity;
} if (val === 'Stroke Width' || val === 'stroke width') {
return interfaceFunction.strokeWidth;
}
return null;
}
Object.defineProperties(interfaceFunction, {
color: {
get: ExpressionPropertyInterface(view.c),
},
opacity: {
get: ExpressionPropertyInterface(view.o),
},
strokeWidth: {
get: ExpressionPropertyInterface(view.w),
},
dash: {
get: function () {
return dashOb;
},
},
_name: { value: shape.nm },
mn: { value: shape.mn },
});
view.c.setGroupProperty(PropertyInterface('Color', _propertyGroup));
view.o.setGroupProperty(PropertyInterface('Opacity', _propertyGroup));
view.w.setGroupProperty(PropertyInterface('Stroke Width', _propertyGroup));
return interfaceFunction;
}
function trimInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(val) {
if (val === shape.e.ix || val === 'End' || val === 'end') {
return interfaceFunction.end;
}
if (val === shape.s.ix) {
return interfaceFunction.start;
}
if (val === shape.o.ix) {
return interfaceFunction.offset;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
interfaceFunction.propertyIndex = shape.ix;
view.s.setGroupProperty(PropertyInterface('Start', _propertyGroup));
view.e.setGroupProperty(PropertyInterface('End', _propertyGroup));
view.o.setGroupProperty(PropertyInterface('Offset', _propertyGroup));
interfaceFunction.propertyIndex = shape.ix;
interfaceFunction.propertyGroup = propertyGroup;
Object.defineProperties(interfaceFunction, {
start: {
get: ExpressionPropertyInterface(view.s),
},
end: {
get: ExpressionPropertyInterface(view.e),
},
offset: {
get: ExpressionPropertyInterface(view.o),
},
_name: { value: shape.nm },
});
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
function transformInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(value) {
if (shape.a.ix === value || value === 'Anchor Point') {
return interfaceFunction.anchorPoint;
}
if (shape.o.ix === value || value === 'Opacity') {
return interfaceFunction.opacity;
}
if (shape.p.ix === value || value === 'Position') {
return interfaceFunction.position;
}
if (shape.r.ix === value || value === 'Rotation' || value === 'ADBE Vector Rotation') {
return interfaceFunction.rotation;
}
if (shape.s.ix === value || value === 'Scale') {
return interfaceFunction.scale;
}
if ((shape.sk && shape.sk.ix === value) || value === 'Skew') {
return interfaceFunction.skew;
}
if ((shape.sa && shape.sa.ix === value) || value === 'Skew Axis') {
return interfaceFunction.skewAxis;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
view.transform.mProps.o.setGroupProperty(PropertyInterface('Opacity', _propertyGroup));
view.transform.mProps.p.setGroupProperty(PropertyInterface('Position', _propertyGroup));
view.transform.mProps.a.setGroupProperty(PropertyInterface('Anchor Point', _propertyGroup));
view.transform.mProps.s.setGroupProperty(PropertyInterface('Scale', _propertyGroup));
view.transform.mProps.r.setGroupProperty(PropertyInterface('Rotation', _propertyGroup));
if (view.transform.mProps.sk) {
view.transform.mProps.sk.setGroupProperty(PropertyInterface('Skew', _propertyGroup));
view.transform.mProps.sa.setGroupProperty(PropertyInterface('Skew Angle', _propertyGroup));
}
view.transform.op.setGroupProperty(PropertyInterface('Opacity', _propertyGroup));
Object.defineProperties(interfaceFunction, {
opacity: {
get: ExpressionPropertyInterface(view.transform.mProps.o),
},
position: {
get: ExpressionPropertyInterface(view.transform.mProps.p),
},
anchorPoint: {
get: ExpressionPropertyInterface(view.transform.mProps.a),
},
scale: {
get: ExpressionPropertyInterface(view.transform.mProps.s),
},
rotation: {
get: ExpressionPropertyInterface(view.transform.mProps.r),
},
skew: {
get: ExpressionPropertyInterface(view.transform.mProps.sk),
},
skewAxis: {
get: ExpressionPropertyInterface(view.transform.mProps.sa),
},
_name: { value: shape.nm },
});
interfaceFunction.ty = 'tr';
interfaceFunction.mn = shape.mn;
interfaceFunction.propertyGroup = propertyGroup;
return interfaceFunction;
}
function ellipseInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(value) {
if (shape.p.ix === value) {
return interfaceFunction.position;
}
if (shape.s.ix === value) {
return interfaceFunction.size;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
interfaceFunction.propertyIndex = shape.ix;
var prop = view.sh.ty === 'tm' ? view.sh.prop : view.sh;
prop.s.setGroupProperty(PropertyInterface('Size', _propertyGroup));
prop.p.setGroupProperty(PropertyInterface('Position', _propertyGroup));
Object.defineProperties(interfaceFunction, {
size: {
get: ExpressionPropertyInterface(prop.s),
},
position: {
get: ExpressionPropertyInterface(prop.p),
},
_name: { value: shape.nm },
});
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
function starInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(value) {
if (shape.p.ix === value) {
return interfaceFunction.position;
}
if (shape.r.ix === value) {
return interfaceFunction.rotation;
}
if (shape.pt.ix === value) {
return interfaceFunction.points;
}
if (shape.or.ix === value || value === 'ADBE Vector Star Outer Radius') {
return interfaceFunction.outerRadius;
}
if (shape.os.ix === value) {
return interfaceFunction.outerRoundness;
}
if (shape.ir && (shape.ir.ix === value || value === 'ADBE Vector Star Inner Radius')) {
return interfaceFunction.innerRadius;
}
if (shape.is && shape.is.ix === value) {
return interfaceFunction.innerRoundness;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
var prop = view.sh.ty === 'tm' ? view.sh.prop : view.sh;
interfaceFunction.propertyIndex = shape.ix;
prop.or.setGroupProperty(PropertyInterface('Outer Radius', _propertyGroup));
prop.os.setGroupProperty(PropertyInterface('Outer Roundness', _propertyGroup));
prop.pt.setGroupProperty(PropertyInterface('Points', _propertyGroup));
prop.p.setGroupProperty(PropertyInterface('Position', _propertyGroup));
prop.r.setGroupProperty(PropertyInterface('Rotation', _propertyGroup));
if (shape.ir) {
prop.ir.setGroupProperty(PropertyInterface('Inner Radius', _propertyGroup));
prop.is.setGroupProperty(PropertyInterface('Inner Roundness', _propertyGroup));
}
Object.defineProperties(interfaceFunction, {
position: {
get: ExpressionPropertyInterface(prop.p),
},
rotation: {
get: ExpressionPropertyInterface(prop.r),
},
points: {
get: ExpressionPropertyInterface(prop.pt),
},
outerRadius: {
get: ExpressionPropertyInterface(prop.or),
},
outerRoundness: {
get: ExpressionPropertyInterface(prop.os),
},
innerRadius: {
get: ExpressionPropertyInterface(prop.ir),
},
innerRoundness: {
get: ExpressionPropertyInterface(prop.is),
},
_name: { value: shape.nm },
});
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
function rectInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(value) {
if (shape.p.ix === value) {
return interfaceFunction.position;
}
if (shape.r.ix === value) {
return interfaceFunction.roundness;
}
if (shape.s.ix === value || value === 'Size' || value === 'ADBE Vector Rect Size') {
return interfaceFunction.size;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
var prop = view.sh.ty === 'tm' ? view.sh.prop : view.sh;
interfaceFunction.propertyIndex = shape.ix;
prop.p.setGroupProperty(PropertyInterface('Position', _propertyGroup));
prop.s.setGroupProperty(PropertyInterface('Size', _propertyGroup));
prop.r.setGroupProperty(PropertyInterface('Rotation', _propertyGroup));
Object.defineProperties(interfaceFunction, {
position: {
get: ExpressionPropertyInterface(prop.p),
},
roundness: {
get: ExpressionPropertyInterface(prop.r),
},
size: {
get: ExpressionPropertyInterface(prop.s),
},
_name: { value: shape.nm },
});
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
function roundedInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(value) {
if (shape.r.ix === value || value === 'Round Corners 1') {
return interfaceFunction.radius;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
var prop = view;
interfaceFunction.propertyIndex = shape.ix;
prop.rd.setGroupProperty(PropertyInterface('Radius', _propertyGroup));
Object.defineProperties(interfaceFunction, {
radius: {
get: ExpressionPropertyInterface(prop.rd),
},
_name: { value: shape.nm },
});
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
function repeaterInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(value) {
if (shape.c.ix === value || value === 'Copies') {
return interfaceFunction.copies;
} if (shape.o.ix === value || value === 'Offset') {
return interfaceFunction.offset;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
var prop = view;
interfaceFunction.propertyIndex = shape.ix;
prop.c.setGroupProperty(PropertyInterface('Copies', _propertyGroup));
prop.o.setGroupProperty(PropertyInterface('Offset', _propertyGroup));
Object.defineProperties(interfaceFunction, {
copies: {
get: ExpressionPropertyInterface(prop.c),
},
offset: {
get: ExpressionPropertyInterface(prop.o),
},
_name: { value: shape.nm },
});
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
return function (shapes, view, propertyGroup) {
var interfaces;
function _interfaceFunction(value) {
if (typeof value === 'number') {
value = value === undefined ? 1 : value;
if (value === 0) {
return propertyGroup;
}
return interfaces[value - 1];
}
var i = 0;
var len = interfaces.length;
while (i < len) {
if (interfaces[i]._name === value) {
return interfaces[i];
}
i += 1;
}
return null;
}
function parentGroupWrapper() {
return propertyGroup;
}
_interfaceFunction.propertyGroup = propertyGroupFactory(_interfaceFunction, parentGroupWrapper);
interfaces = iterateElements(shapes, view, _interfaceFunction.propertyGroup);
_interfaceFunction.numProperties = interfaces.length;
_interfaceFunction._name = 'Contents';
return _interfaceFunction;
};
}());
export default ShapeExpressionInterface;

35
node_modules/lottie-web/player/js/utils/expressions/TextInterface.js generated vendored Normal file
View File

@@ -0,0 +1,35 @@
const TextExpressionInterface = (function () {
return function (elem) {
var _sourceText;
function _thisLayerFunction(name) {
switch (name) {
case 'ADBE Text Document':
return _thisLayerFunction.sourceText;
default:
return null;
}
}
Object.defineProperty(_thisLayerFunction, 'sourceText', {
get: function () {
elem.textProperty.getValue();
var stringValue = elem.textProperty.currentData.t;
if (!_sourceText || stringValue !== _sourceText.value) {
_sourceText = new String(stringValue); // eslint-disable-line no-new-wrappers
// If stringValue is an empty string, eval returns undefined, so it has to be returned as a String primitive
_sourceText.value = stringValue || new String(stringValue); // eslint-disable-line no-new-wrappers
Object.defineProperty(_sourceText, 'style', {
get: function () {
return {
fillColor: elem.textProperty.currentData.fc,
};
},
});
}
return _sourceText;
},
});
return _thisLayerFunction;
};
}());
export default TextExpressionInterface;

44
node_modules/lottie-web/player/js/utils/expressions/TextSelectorPropertyDecorator.js generated vendored Normal file
View File

@@ -0,0 +1,44 @@
import ExpressionManager from './ExpressionManager';
import expressionHelpers from './expressionHelpers';
import TextSelectorProp from '../text/TextSelectorProperty';
const TextExpressionSelectorPropFactory = (function () { // eslint-disable-line no-unused-vars
function getValueProxy(index, total) {
this.textIndex = index + 1;
this.textTotal = total;
this.v = this.getValue() * this.mult;
return this.v;
}
return function (elem, data) {
this.pv = 1;
this.comp = elem.comp;
this.elem = elem;
this.mult = 0.01;
this.propType = 'textSelector';
this.textTotal = data.totalChars;
this.selectorValue = 100;
this.lastValue = [1, 1, 1];
this.k = true;
this.x = true;
this.getValue = ExpressionManager.initiateExpression.bind(this)(elem, data, this);
this.getMult = getValueProxy;
this.getVelocityAtTime = expressionHelpers.getVelocityAtTime;
if (this.kf) {
this.getValueAtTime = expressionHelpers.getValueAtTime.bind(this);
} else {
this.getValueAtTime = expressionHelpers.getStaticValueAtTime.bind(this);
}
this.setGroupProperty = expressionHelpers.setGroupProperty;
};
}());
var propertyGetTextProp = TextSelectorProp.getTextSelectorProp;
TextSelectorProp.getTextSelectorProp = function (elem, data, arr) {
if (data.t === 1) {
return new TextExpressionSelectorPropFactory(elem, data, arr); // eslint-disable-line no-undef
}
return propertyGetTextProp(elem, data, arr);
};
export default TextExpressionSelectorPropFactory;

126
node_modules/lottie-web/player/js/utils/expressions/TransformInterface.js generated vendored Normal file
View File

@@ -0,0 +1,126 @@
import ExpressionPropertyInterface from './ExpressionValueFactory';
const TransformExpressionInterface = (function () {
return function (transform) {
function _thisFunction(name) {
switch (name) {
case 'scale':
case 'Scale':
case 'ADBE Scale':
case 6:
return _thisFunction.scale;
case 'rotation':
case 'Rotation':
case 'ADBE Rotation':
case 'ADBE Rotate Z':
case 10:
return _thisFunction.rotation;
case 'ADBE Rotate X':
return _thisFunction.xRotation;
case 'ADBE Rotate Y':
return _thisFunction.yRotation;
case 'position':
case 'Position':
case 'ADBE Position':
case 2:
return _thisFunction.position;
case 'ADBE Position_0':
return _thisFunction.xPosition;
case 'ADBE Position_1':
return _thisFunction.yPosition;
case 'ADBE Position_2':
return _thisFunction.zPosition;
case 'anchorPoint':
case 'AnchorPoint':
case 'Anchor Point':
case 'ADBE AnchorPoint':
case 1:
return _thisFunction.anchorPoint;
case 'opacity':
case 'Opacity':
case 11:
return _thisFunction.opacity;
default:
return null;
}
}
Object.defineProperty(_thisFunction, 'rotation', {
get: ExpressionPropertyInterface(transform.r || transform.rz),
});
Object.defineProperty(_thisFunction, 'zRotation', {
get: ExpressionPropertyInterface(transform.rz || transform.r),
});
Object.defineProperty(_thisFunction, 'xRotation', {
get: ExpressionPropertyInterface(transform.rx),
});
Object.defineProperty(_thisFunction, 'yRotation', {
get: ExpressionPropertyInterface(transform.ry),
});
Object.defineProperty(_thisFunction, 'scale', {
get: ExpressionPropertyInterface(transform.s),
});
var _px;
var _py;
var _pz;
var _transformFactory;
if (transform.p) {
_transformFactory = ExpressionPropertyInterface(transform.p);
} else {
_px = ExpressionPropertyInterface(transform.px);
_py = ExpressionPropertyInterface(transform.py);
if (transform.pz) {
_pz = ExpressionPropertyInterface(transform.pz);
}
}
Object.defineProperty(_thisFunction, 'position', {
get: function () {
if (transform.p) {
return _transformFactory();
}
return [
_px(),
_py(),
_pz ? _pz() : 0];
},
});
Object.defineProperty(_thisFunction, 'xPosition', {
get: ExpressionPropertyInterface(transform.px),
});
Object.defineProperty(_thisFunction, 'yPosition', {
get: ExpressionPropertyInterface(transform.py),
});
Object.defineProperty(_thisFunction, 'zPosition', {
get: ExpressionPropertyInterface(transform.pz),
});
Object.defineProperty(_thisFunction, 'anchorPoint', {
get: ExpressionPropertyInterface(transform.a),
});
Object.defineProperty(_thisFunction, 'opacity', {
get: ExpressionPropertyInterface(transform.o),
});
Object.defineProperty(_thisFunction, 'skew', {
get: ExpressionPropertyInterface(transform.sk),
});
Object.defineProperty(_thisFunction, 'skewAxis', {
get: ExpressionPropertyInterface(transform.sa),
});
Object.defineProperty(_thisFunction, 'orientation', {
get: ExpressionPropertyInterface(transform.or),
});
return _thisFunction;
};
}());
export default TransformExpressionInterface;

86
node_modules/lottie-web/player/js/utils/expressions/expressionHelpers.js generated vendored Normal file
View File

@@ -0,0 +1,86 @@
import {
createTypedArray,
} from '../helpers/arrays';
import ExpressionManager from './ExpressionManager';
const expressionHelpers = (function () {
function searchExpressions(elem, data, prop) {
if (data.x) {
prop.k = true;
prop.x = true;
prop.initiateExpression = ExpressionManager.initiateExpression;
prop.effectsSequence.push(prop.initiateExpression(elem, data, prop).bind(prop));
}
}
function getValueAtTime(frameNum) {
frameNum *= this.elem.globalData.frameRate;
frameNum -= this.offsetTime;
if (frameNum !== this._cachingAtTime.lastFrame) {
this._cachingAtTime.lastIndex = this._cachingAtTime.lastFrame < frameNum ? this._cachingAtTime.lastIndex : 0;
this._cachingAtTime.value = this.interpolateValue(frameNum, this._cachingAtTime);
this._cachingAtTime.lastFrame = frameNum;
}
return this._cachingAtTime.value;
}
function getSpeedAtTime(frameNum) {
var delta = -0.01;
var v1 = this.getValueAtTime(frameNum);
var v2 = this.getValueAtTime(frameNum + delta);
var speed = 0;
if (v1.length) {
var i;
for (i = 0; i < v1.length; i += 1) {
speed += Math.pow(v2[i] - v1[i], 2);
}
speed = Math.sqrt(speed) * 100;
} else {
speed = 0;
}
return speed;
}
function getVelocityAtTime(frameNum) {
if (this.vel !== undefined) {
return this.vel;
}
var delta = -0.001;
// frameNum += this.elem.data.st;
var v1 = this.getValueAtTime(frameNum);
var v2 = this.getValueAtTime(frameNum + delta);
var velocity;
if (v1.length) {
velocity = createTypedArray('float32', v1.length);
var i;
for (i = 0; i < v1.length; i += 1) {
// removing frameRate
// if needed, don't add it here
// velocity[i] = this.elem.globalData.frameRate*((v2[i] - v1[i])/delta);
velocity[i] = (v2[i] - v1[i]) / delta;
}
} else {
velocity = (v2 - v1) / delta;
}
return velocity;
}
function getStaticValueAtTime() {
return this.pv;
}
function setGroupProperty(propertyGroup) {
this.propertyGroup = propertyGroup;
}
return {
searchExpressions: searchExpressions,
getSpeedAtTime: getSpeedAtTime,
getVelocityAtTime: getVelocityAtTime,
getValueAtTime: getValueAtTime,
getStaticValueAtTime: getStaticValueAtTime,
setGroupProperty: setGroupProperty,
};
}());
export default expressionHelpers;

47
node_modules/lottie-web/player/js/utils/expressions/shapes/ShapePathInterface.js generated vendored Normal file
View File

@@ -0,0 +1,47 @@
import propertyGroupFactory from '../PropertyGroupFactory';
import PropertyInterface from '../PropertyInterface';
const ShapePathInterface = (
function () {
return function pathInterfaceFactory(shape, view, propertyGroup) {
var prop = view.sh;
function interfaceFunction(val) {
if (val === 'Shape' || val === 'shape' || val === 'Path' || val === 'path' || val === 'ADBE Vector Shape' || val === 2) {
return interfaceFunction.path;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
prop.setGroupProperty(PropertyInterface('Path', _propertyGroup));
Object.defineProperties(interfaceFunction, {
path: {
get: function () {
if (prop.k) {
prop.getValue();
}
return prop;
},
},
shape: {
get: function () {
if (prop.k) {
prop.getValue();
}
return prop;
},
},
_name: { value: shape.nm },
ix: { value: shape.ix },
propertyIndex: { value: shape.ix },
mn: { value: shape.mn },
propertyGroup: { value: propertyGroup },
});
return interfaceFunction;
};
}()
);
export default ShapePathInterface;

16
node_modules/lottie-web/player/js/utils/featureSupport.js generated vendored Normal file
View File

@@ -0,0 +1,16 @@
const featureSupport = (function () {
var ob = {
maskType: true,
svgLumaHidden: true,
offscreenCanvas: typeof OffscreenCanvas !== 'undefined',
};
if (/MSIE 10/i.test(navigator.userAgent) || /MSIE 9/i.test(navigator.userAgent) || /rv:11.0/i.test(navigator.userAgent) || /Edge\/\d./i.test(navigator.userAgent)) {
ob.maskType = false;
}
if (/firefox/i.test(navigator.userAgent)) {
ob.svgLumaHidden = false;
}
return ob;
}());
export default featureSupport;

32
node_modules/lottie-web/player/js/utils/filters.js generated vendored Normal file
View File

@@ -0,0 +1,32 @@
import createNS from './helpers/svg_elements';
const filtersFactory = (function () {
var ob = {};
ob.createFilter = createFilter;
ob.createAlphaToLuminanceFilter = createAlphaToLuminanceFilter;
function createFilter(filId, skipCoordinates) {
var fil = createNS('filter');
fil.setAttribute('id', filId);
if (skipCoordinates !== true) {
fil.setAttribute('filterUnits', 'objectBoundingBox');
fil.setAttribute('x', '0%');
fil.setAttribute('y', '0%');
fil.setAttribute('width', '100%');
fil.setAttribute('height', '100%');
}
return fil;
}
function createAlphaToLuminanceFilter() {
var feColorMatrix = createNS('feColorMatrix');
feColorMatrix.setAttribute('type', 'matrix');
feColorMatrix.setAttribute('color-interpolation-filters', 'sRGB');
feColorMatrix.setAttribute('values', '0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 1');
return feColorMatrix;
}
return ob;
}());
export default filtersFactory;

27
node_modules/lottie-web/player/js/utils/functionExtensions.js generated vendored Normal file
View File

@@ -0,0 +1,27 @@
function extendPrototype(sources, destination) {
var i;
var len = sources.length;
var sourcePrototype;
for (i = 0; i < len; i += 1) {
sourcePrototype = sources[i].prototype;
for (var attr in sourcePrototype) {
if (Object.prototype.hasOwnProperty.call(sourcePrototype, attr)) destination.prototype[attr] = sourcePrototype[attr];
}
}
}
function getDescriptor(object, prop) {
return Object.getOwnPropertyDescriptor(object, prop);
}
function createProxyFunction(prototype) {
function ProxyFunction() {}
ProxyFunction.prototype = prototype;
return ProxyFunction;
}
export {
extendPrototype,
getDescriptor,
createProxyFunction,
};

42
node_modules/lottie-web/player/js/utils/getFontProperties.js generated vendored Normal file
View File

@@ -0,0 +1,42 @@
function getFontProperties(fontData) {
var styles = fontData.fStyle ? fontData.fStyle.split(' ') : [];
var fWeight = 'normal'; var
fStyle = 'normal';
var len = styles.length;
var styleName;
for (var i = 0; i < len; i += 1) {
styleName = styles[i].toLowerCase();
switch (styleName) {
case 'italic':
fStyle = 'italic';
break;
case 'bold':
fWeight = '700';
break;
case 'black':
fWeight = '900';
break;
case 'medium':
fWeight = '500';
break;
case 'regular':
case 'normal':
fWeight = '400';
break;
case 'light':
case 'thin':
fWeight = '200';
break;
default:
break;
}
}
return {
style: fStyle,
weight: fontData.fWeight || fWeight,
};
}
export default getFontProperties;

43
node_modules/lottie-web/player/js/utils/helpers/arrays.js generated vendored Normal file
View File

@@ -0,0 +1,43 @@
const createTypedArray = (function () {
function createRegularArray(type, len) {
var i = 0;
var arr = [];
var value;
switch (type) {
case 'int16':
case 'uint8c':
value = 1;
break;
default:
value = 1.1;
break;
}
for (i = 0; i < len; i += 1) {
arr.push(value);
}
return arr;
}
function createTypedArrayFactory(type, len) {
if (type === 'float32') {
return new Float32Array(len);
} if (type === 'int16') {
return new Int16Array(len);
} if (type === 'uint8c') {
return new Uint8ClampedArray(len);
}
return createRegularArray(type, len);
}
if (typeof Uint8ClampedArray === 'function' && typeof Float32Array === 'function') {
return createTypedArrayFactory;
}
return createRegularArray;
}());
function createSizedArray(len) {
return Array.apply(null, { length: len });
}
export {
createTypedArray,
createSizedArray,
};

96
node_modules/lottie-web/player/js/utils/helpers/assetManager.js generated vendored Normal file
View File

@@ -0,0 +1,96 @@
import createTag from './html_elements';
import createNS from './svg_elements';
import featureSupport from '../featureSupport';
var lumaLoader = (function () {
var id = '__lottie_element_luma_buffer';
var lumaBuffer = null;
var lumaBufferCtx = null;
var svg = null;
// This alternate solution has a slight delay before the filter is applied, resulting in a flicker on the first frame.
// Keeping this here for reference, and in the future, if offscreen canvas supports url filters, this can be used.
// For now, neither of them work for offscreen canvas, so canvas workers can't support the luma track matte mask.
// Naming it solution 2 to mark the extra comment lines.
/*
var svgString = [
'<svg xmlns="http://www.w3.org/2000/svg">',
'<filter id="' + id + '">',
'<feColorMatrix type="matrix" color-interpolation-filters="sRGB" values="',
'0.3, 0.3, 0.3, 0, 0, ',
'0.3, 0.3, 0.3, 0, 0, ',
'0.3, 0.3, 0.3, 0, 0, ',
'0.3, 0.3, 0.3, 0, 0',
'"/>',
'</filter>',
'</svg>',
].join('');
var blob = new Blob([svgString], { type: 'image/svg+xml' });
var url = URL.createObjectURL(blob);
*/
function createLumaSvgFilter() {
var _svg = createNS('svg');
var fil = createNS('filter');
var matrix = createNS('feColorMatrix');
fil.setAttribute('id', id);
matrix.setAttribute('type', 'matrix');
matrix.setAttribute('color-interpolation-filters', 'sRGB');
matrix.setAttribute('values', '0.3, 0.3, 0.3, 0, 0, 0.3, 0.3, 0.3, 0, 0, 0.3, 0.3, 0.3, 0, 0, 0.3, 0.3, 0.3, 0, 0');
fil.appendChild(matrix);
_svg.appendChild(fil);
_svg.setAttribute('id', id + '_svg');
if (featureSupport.svgLumaHidden) {
_svg.style.display = 'none';
}
return _svg;
}
function loadLuma() {
if (!lumaBuffer) {
svg = createLumaSvgFilter();
document.body.appendChild(svg);
lumaBuffer = createTag('canvas');
lumaBufferCtx = lumaBuffer.getContext('2d');
// lumaBufferCtx.filter = `url('${url}#__lottie_element_luma_buffer')`; // part of solution 2
lumaBufferCtx.filter = 'url(#' + id + ')';
lumaBufferCtx.fillStyle = 'rgba(0,0,0,0)';
lumaBufferCtx.fillRect(0, 0, 1, 1);
}
}
function getLuma(canvas) {
if (!lumaBuffer) {
loadLuma();
}
lumaBuffer.width = canvas.width;
lumaBuffer.height = canvas.height;
// lumaBufferCtx.filter = `url('${url}#__lottie_element_luma_buffer')`; // part of solution 2
lumaBufferCtx.filter = 'url(#' + id + ')';
return lumaBuffer;
}
return {
load: loadLuma,
get: getLuma,
};
});
function createCanvas(width, height) {
if (featureSupport.offscreenCanvas) {
return new OffscreenCanvas(width, height);
}
var canvas = createTag('canvas');
canvas.width = width;
canvas.height = height;
return canvas;
}
const assetLoader = (function () {
return {
loadLumaCanvas: lumaLoader.load,
getLumaCanvas: lumaLoader.get,
createCanvas: createCanvas,
};
}());
export default assetLoader;

26
node_modules/lottie-web/player/js/utils/helpers/blendModes.js generated vendored Normal file
View File

@@ -0,0 +1,26 @@
const getBlendMode = (function () {
var blendModeEnums = {
0: 'source-over',
1: 'multiply',
2: 'screen',
3: 'overlay',
4: 'darken',
5: 'lighten',
6: 'color-dodge',
7: 'color-burn',
8: 'hard-light',
9: 'soft-light',
10: 'difference',
11: 'exclusion',
12: 'hue',
13: 'saturation',
14: 'color',
15: 'luminosity',
};
return function (mode) {
return blendModeEnums[mode] || '';
};
}());
export default getBlendMode;

29
node_modules/lottie-web/player/js/utils/helpers/dynamicProperties.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
function DynamicPropertyContainer() {}
DynamicPropertyContainer.prototype = {
addDynamicProperty: function (prop) {
if (this.dynamicProperties.indexOf(prop) === -1) {
this.dynamicProperties.push(prop);
this.container.addDynamicProperty(this);
this._isAnimated = true;
}
},
iterateDynamicProperties: function () {
this._mdf = false;
var i;
var len = this.dynamicProperties.length;
for (i = 0; i < len; i += 1) {
this.dynamicProperties[i].getValue();
if (this.dynamicProperties[i]._mdf) {
this._mdf = true;
}
}
},
initDynamicPropertyContainer: function (container) {
this.container = container;
this.dynamicProperties = [];
this._mdf = false;
this._isAnimated = false;
},
};
export default DynamicPropertyContainer;

3
node_modules/lottie-web/player/js/utils/helpers/effectTypes.js generated vendored Normal file
View File

@@ -0,0 +1,3 @@
export default {
TRANSFORM_EFFECT: 'transformEFfect',
};

6
node_modules/lottie-web/player/js/utils/helpers/html_elements.js generated vendored Normal file
View File

@@ -0,0 +1,6 @@
function createTag(type) {
// return {appendChild:function(){},setAttribute:function(){},style:{}}
return document.createElement(type);
}
export default createTag;

3
node_modules/lottie-web/player/js/utils/helpers/propTypes.js generated vendored Normal file
View File

@@ -0,0 +1,3 @@
export default {
SHAPE: 'shape',
};

16
node_modules/lottie-web/player/js/utils/helpers/shapeEnums.js generated vendored Normal file
View File

@@ -0,0 +1,16 @@
const lineCapEnum = {
1: 'butt',
2: 'round',
3: 'square',
};
const lineJoinEnum = {
1: 'miter',
2: 'round',
3: 'bevel',
};
export {
lineCapEnum,
lineJoinEnum,
};

8
node_modules/lottie-web/player/js/utils/helpers/svg_elements.js generated vendored Normal file
View File

@@ -0,0 +1,8 @@
import { svgNS } from '../../main';
function createNS(type) {
// return {appendChild:function(){},setAttribute:function(){},style:{}}
return document.createElementNS(svgNS, type);
}
export default createNS;

213
node_modules/lottie-web/player/js/utils/imagePreloader.js generated vendored Normal file
View File

@@ -0,0 +1,213 @@
import { isSafari } from './common';
import createNS from './helpers/svg_elements';
import dataManager from './DataManager';
import createTag from './helpers/html_elements';
const ImagePreloader = (function () {
var proxyImage = (function () {
var canvas = createTag('canvas');
canvas.width = 1;
canvas.height = 1;
var ctx = canvas.getContext('2d');
ctx.fillStyle = 'rgba(0,0,0,0)';
ctx.fillRect(0, 0, 1, 1);
return canvas;
}());
function imageLoaded() {
this.loadedAssets += 1;
if (this.loadedAssets === this.totalImages && this.loadedFootagesCount === this.totalFootages) {
if (this.imagesLoadedCb) {
this.imagesLoadedCb(null);
}
}
}
function footageLoaded() {
this.loadedFootagesCount += 1;
if (this.loadedAssets === this.totalImages && this.loadedFootagesCount === this.totalFootages) {
if (this.imagesLoadedCb) {
this.imagesLoadedCb(null);
}
}
}
function getAssetsPath(assetData, assetsPath, originalPath) {
var path = '';
if (assetData.e) {
path = assetData.p;
} else if (assetsPath) {
var imagePath = assetData.p;
if (imagePath.indexOf('images/') !== -1) {
imagePath = imagePath.split('/')[1];
}
path = assetsPath + imagePath;
} else {
path = originalPath;
path += assetData.u ? assetData.u : '';
path += assetData.p;
}
return path;
}
function testImageLoaded(img) {
var _count = 0;
var intervalId = setInterval(function () {
var box = img.getBBox();
if (box.width || _count > 500) {
this._imageLoaded();
clearInterval(intervalId);
}
_count += 1;
}.bind(this), 50);
}
function createImageData(assetData) {
var path = getAssetsPath(assetData, this.assetsPath, this.path);
var img = createNS('image');
if (isSafari) {
this.testImageLoaded(img);
} else {
img.addEventListener('load', this._imageLoaded, false);
}
img.addEventListener('error', function () {
ob.img = proxyImage;
this._imageLoaded();
}.bind(this), false);
img.setAttributeNS('http://www.w3.org/1999/xlink', 'href', path);
if (this._elementHelper.append) {
this._elementHelper.append(img);
} else {
this._elementHelper.appendChild(img);
}
var ob = {
img: img,
assetData: assetData,
};
return ob;
}
function createImgData(assetData) {
var path = getAssetsPath(assetData, this.assetsPath, this.path);
var img = createTag('img');
img.crossOrigin = 'anonymous';
img.addEventListener('load', this._imageLoaded, false);
img.addEventListener('error', function () {
ob.img = proxyImage;
this._imageLoaded();
}.bind(this), false);
img.src = path;
var ob = {
img: img,
assetData: assetData,
};
return ob;
}
function createFootageData(data) {
var ob = {
assetData: data,
};
var path = getAssetsPath(data, this.assetsPath, this.path);
dataManager.loadData(path, function (footageData) {
ob.img = footageData;
this._footageLoaded();
}.bind(this), function () {
ob.img = {};
this._footageLoaded();
}.bind(this));
return ob;
}
function loadAssets(assets, cb) {
this.imagesLoadedCb = cb;
var i;
var len = assets.length;
for (i = 0; i < len; i += 1) {
if (!assets[i].layers) {
if (!assets[i].t || assets[i].t === 'seq') {
this.totalImages += 1;
this.images.push(this._createImageData(assets[i]));
} else if (assets[i].t === 3) {
this.totalFootages += 1;
this.images.push(this.createFootageData(assets[i]));
}
}
}
}
function setPath(path) {
this.path = path || '';
}
function setAssetsPath(path) {
this.assetsPath = path || '';
}
function getAsset(assetData) {
var i = 0;
var len = this.images.length;
while (i < len) {
if (this.images[i].assetData === assetData) {
return this.images[i].img;
}
i += 1;
}
return null;
}
function destroy() {
this.imagesLoadedCb = null;
this.images.length = 0;
}
function loadedImages() {
return this.totalImages === this.loadedAssets;
}
function loadedFootages() {
return this.totalFootages === this.loadedFootagesCount;
}
function setCacheType(type, elementHelper) {
if (type === 'svg') {
this._elementHelper = elementHelper;
this._createImageData = this.createImageData.bind(this);
} else {
this._createImageData = this.createImgData.bind(this);
}
}
function ImagePreloaderFactory() {
this._imageLoaded = imageLoaded.bind(this);
this._footageLoaded = footageLoaded.bind(this);
this.testImageLoaded = testImageLoaded.bind(this);
this.createFootageData = createFootageData.bind(this);
this.assetsPath = '';
this.path = '';
this.totalImages = 0;
this.totalFootages = 0;
this.loadedAssets = 0;
this.loadedFootagesCount = 0;
this.imagesLoadedCb = null;
this.images = [];
}
ImagePreloaderFactory.prototype = {
loadAssets: loadAssets,
setAssetsPath: setAssetsPath,
setPath: setPath,
loadedImages: loadedImages,
loadedFootages: loadedFootages,
destroy: destroy,
getAsset: getAsset,
createImgData: createImgData,
createImageData: createImageData,
imageLoaded: imageLoaded,
footageLoaded: footageLoaded,
setCacheType: setCacheType,
};
return ImagePreloaderFactory;
}());
export default ImagePreloader;

3
node_modules/lottie-web/player/js/utils/imagePreloaderWorkerOverride.js generated vendored Normal file
View File

@@ -0,0 +1,3 @@
const ImagePreloader = function () {};
export default ImagePreloader;

47
node_modules/lottie-web/player/js/utils/markers/markerParser.js generated vendored Normal file
View File

@@ -0,0 +1,47 @@
const markerParser = (
function () {
function parsePayloadLines(payload) {
var lines = payload.split('\r\n');
var keys = {};
var line;
var keysCount = 0;
for (var i = 0; i < lines.length; i += 1) {
line = lines[i].split(':');
if (line.length === 2) {
keys[line[0]] = line[1].trim();
keysCount += 1;
}
}
if (keysCount === 0) {
throw new Error();
}
return keys;
}
return function (_markers) {
var markers = [];
for (var i = 0; i < _markers.length; i += 1) {
var _marker = _markers[i];
var markerData = {
time: _marker.tm,
duration: _marker.dr,
};
try {
markerData.payload = JSON.parse(_markers[i].cm);
} catch (_) {
try {
markerData.payload = parsePayloadLines(_markers[i].cm);
} catch (__) {
markerData.payload = {
name: _markers[i].cm,
};
}
}
markers.push(markerData);
}
return markers;
};
}());
export default markerParser;

20
node_modules/lottie-web/player/js/utils/pooling/bezier_length_pool.js generated vendored Normal file
View File

@@ -0,0 +1,20 @@
import {
getDefaultCurveSegments,
} from '../common';
import {
createTypedArray,
} from '../helpers/arrays';
import poolFactory from './pool_factory';
const bezierLengthPool = (function () {
function create() {
return {
addedLength: 0,
percents: createTypedArray('float32', getDefaultCurveSegments()),
lengths: createTypedArray('float32', getDefaultCurveSegments()),
};
}
return poolFactory(8, create);
}());
export default bezierLengthPool;

13
node_modules/lottie-web/player/js/utils/pooling/point_pool.js generated vendored Normal file
View File

@@ -0,0 +1,13 @@
import {
createTypedArray,
} from '../helpers/arrays';
import poolFactory from './pool_factory';
const pointPool = (function () {
function create() {
return createTypedArray('float32', 2);
}
return poolFactory(8, create);
}());
export default pointPool;

44
node_modules/lottie-web/player/js/utils/pooling/pool_factory.js generated vendored Normal file
View File

@@ -0,0 +1,44 @@
import {
createSizedArray,
} from '../helpers/arrays';
import pooling from './pooling';
const poolFactory = (function () {
return function (initialLength, _create, _release) {
var _length = 0;
var _maxLength = initialLength;
var pool = createSizedArray(_maxLength);
var ob = {
newElement: newElement,
release: release,
};
function newElement() {
var element;
if (_length) {
_length -= 1;
element = pool[_length];
} else {
element = _create();
}
return element;
}
function release(element) {
if (_length === _maxLength) {
pool = pooling.double(pool);
_maxLength *= 2;
}
if (_release) {
_release(element);
}
pool[_length] = element;
_length += 1;
}
return ob;
};
}());
export default poolFactory;

15
node_modules/lottie-web/player/js/utils/pooling/pooling.js generated vendored Normal file
View File

@@ -0,0 +1,15 @@
import {
createSizedArray,
} from '../helpers/arrays';
const pooling = (function () {
function double(arr) {
return arr.concat(createSizedArray(arr.length));
}
return {
double: double,
};
}());
export default pooling;

24
node_modules/lottie-web/player/js/utils/pooling/segments_length_pool.js generated vendored Normal file
View File

@@ -0,0 +1,24 @@
import bezierLengthPool from './bezier_length_pool';
import poolFactory from './pool_factory';
const segmentsLengthPool = (function () {
function create() {
return {
lengths: [],
totalLength: 0,
};
}
function release(element) {
var i;
var len = element.lengths.length;
for (i = 0; i < len; i += 1) {
bezierLengthPool.release(element.lengths[i]);
}
element.lengths.length = 0;
}
return poolFactory(8, create, release);
}());
export default segmentsLengthPool;

48
node_modules/lottie-web/player/js/utils/pooling/shapeCollection_pool.js generated vendored Normal file
View File

@@ -0,0 +1,48 @@
import {
createSizedArray,
} from '../helpers/arrays';
import shapePool from './shape_pool';
import pooling from './pooling';
import ShapeCollection from '../shapes/ShapeCollection';
const shapeCollectionPool = (function () {
var ob = {
newShapeCollection: newShapeCollection,
release: release,
};
var _length = 0;
var _maxLength = 4;
var pool = createSizedArray(_maxLength);
function newShapeCollection() {
var shapeCollection;
if (_length) {
_length -= 1;
shapeCollection = pool[_length];
} else {
shapeCollection = new ShapeCollection();
}
return shapeCollection;
}
function release(shapeCollection) {
var i;
var len = shapeCollection._length;
for (i = 0; i < len; i += 1) {
shapePool.release(shapeCollection.shapes[i]);
}
shapeCollection._length = 0;
if (_length === _maxLength) {
pool = pooling.double(pool);
_maxLength *= 2;
}
pool[_length] = shapeCollection;
_length += 1;
}
return ob;
}());
export default shapeCollectionPool;

44
node_modules/lottie-web/player/js/utils/pooling/shape_pool.js generated vendored Normal file
View File

@@ -0,0 +1,44 @@
import poolFactory from './pool_factory';
import pointPool from './point_pool';
import ShapePath from '../shapes/ShapePath';
const shapePool = (function () {
function create() {
return new ShapePath();
}
function release(shapePath) {
var len = shapePath._length;
var i;
for (i = 0; i < len; i += 1) {
pointPool.release(shapePath.v[i]);
pointPool.release(shapePath.i[i]);
pointPool.release(shapePath.o[i]);
shapePath.v[i] = null;
shapePath.i[i] = null;
shapePath.o[i] = null;
}
shapePath._length = 0;
shapePath.c = false;
}
function clone(shape) {
var cloned = factory.newElement();
var i;
var len = shape._length === undefined ? shape.v.length : shape._length;
cloned.setLength(len);
cloned.c = shape.c;
for (i = 0; i < len; i += 1) {
cloned.setTripleAt(shape.v[i][0], shape.v[i][1], shape.o[i][0], shape.o[i][1], shape.i[i][0], shape.i[i][1], i);
}
return cloned;
}
var factory = poolFactory(4, create, release);
factory.clone = clone;
return factory;
}());
export default shapePool;

63
node_modules/lottie-web/player/js/utils/shapes/DashProperty.js generated vendored Normal file
View File

@@ -0,0 +1,63 @@
import {
extendPrototype,
} from '../functionExtensions';
import DynamicPropertyContainer from '../helpers/dynamicProperties';
import {
createSizedArray,
createTypedArray,
} from '../helpers/arrays';
import PropertyFactory from '../PropertyFactory';
function DashProperty(elem, data, renderer, container) {
this.elem = elem;
this.frameId = -1;
this.dataProps = createSizedArray(data.length);
this.renderer = renderer;
this.k = false;
this.dashStr = '';
this.dashArray = createTypedArray('float32', data.length ? data.length - 1 : 0);
this.dashoffset = createTypedArray('float32', 1);
this.initDynamicPropertyContainer(container);
var i;
var len = data.length || 0;
var prop;
for (i = 0; i < len; i += 1) {
prop = PropertyFactory.getProp(elem, data[i].v, 0, 0, this);
this.k = prop.k || this.k;
this.dataProps[i] = { n: data[i].n, p: prop };
}
if (!this.k) {
this.getValue(true);
}
this._isAnimated = this.k;
}
DashProperty.prototype.getValue = function (forceRender) {
if (this.elem.globalData.frameId === this.frameId && !forceRender) {
return;
}
this.frameId = this.elem.globalData.frameId;
this.iterateDynamicProperties();
this._mdf = this._mdf || forceRender;
if (this._mdf) {
var i = 0;
var len = this.dataProps.length;
if (this.renderer === 'svg') {
this.dashStr = '';
}
for (i = 0; i < len; i += 1) {
if (this.dataProps[i].n !== 'o') {
if (this.renderer === 'svg') {
this.dashStr += ' ' + this.dataProps[i].p.v;
} else {
this.dashArray[i] = this.dataProps[i].p.v;
}
} else {
this.dashoffset[0] = this.dataProps[i].p.v;
}
}
}
};
extendPrototype([DynamicPropertyContainer], DashProperty);
export default DashProperty;

93
node_modules/lottie-web/player/js/utils/shapes/GradientProperty.js generated vendored Normal file
View File

@@ -0,0 +1,93 @@
import {
extendPrototype,
} from '../functionExtensions';
import DynamicPropertyContainer from '../helpers/dynamicProperties';
import {
createTypedArray,
} from '../helpers/arrays';
import PropertyFactory from '../PropertyFactory';
function GradientProperty(elem, data, container) {
this.data = data;
this.c = createTypedArray('uint8c', data.p * 4);
var cLength = data.k.k[0].s ? (data.k.k[0].s.length - data.p * 4) : data.k.k.length - data.p * 4;
this.o = createTypedArray('float32', cLength);
this._cmdf = false;
this._omdf = false;
this._collapsable = this.checkCollapsable();
this._hasOpacity = cLength;
this.initDynamicPropertyContainer(container);
this.prop = PropertyFactory.getProp(elem, data.k, 1, null, this);
this.k = this.prop.k;
this.getValue(true);
}
GradientProperty.prototype.comparePoints = function (values, points) {
var i = 0;
var len = this.o.length / 2;
var diff;
while (i < len) {
diff = Math.abs(values[i * 4] - values[points * 4 + i * 2]);
if (diff > 0.01) {
return false;
}
i += 1;
}
return true;
};
GradientProperty.prototype.checkCollapsable = function () {
if (this.o.length / 2 !== this.c.length / 4) {
return false;
}
if (this.data.k.k[0].s) {
var i = 0;
var len = this.data.k.k.length;
while (i < len) {
if (!this.comparePoints(this.data.k.k[i].s, this.data.p)) {
return false;
}
i += 1;
}
} else if (!this.comparePoints(this.data.k.k, this.data.p)) {
return false;
}
return true;
};
GradientProperty.prototype.getValue = function (forceRender) {
this.prop.getValue();
this._mdf = false;
this._cmdf = false;
this._omdf = false;
if (this.prop._mdf || forceRender) {
var i;
var len = this.data.p * 4;
var mult;
var val;
for (i = 0; i < len; i += 1) {
mult = i % 4 === 0 ? 100 : 255;
val = Math.round(this.prop.v[i] * mult);
if (this.c[i] !== val) {
this.c[i] = val;
this._cmdf = !forceRender;
}
}
if (this.o.length) {
len = this.prop.v.length;
for (i = this.data.p * 4; i < len; i += 1) {
mult = i % 2 === 0 ? 100 : 1;
val = i % 2 === 0 ? Math.round(this.prop.v[i] * 100) : this.prop.v[i];
if (this.o[i - this.data.p * 4] !== val) {
this.o[i - this.data.p * 4] = val;
this._omdf = !forceRender;
}
}
}
this._mdf = !forceRender;
}
};
extendPrototype([DynamicPropertyContainer], GradientProperty);
export default GradientProperty;

222
node_modules/lottie-web/player/js/utils/shapes/MouseModifier.js generated vendored Normal file
View File

@@ -0,0 +1,222 @@
import {
extendPrototype,
} from '../functionExtensions';
import {
ShapeModifiers,
ShapeModifier,
} from './ShapeModifiers';
function MouseModifier() {}
extendPrototype([ShapeModifier], MouseModifier);
MouseModifier.prototype.processKeys = function (forceRender) {
if (this.elem.globalData.frameId === this.frameId && !forceRender) {
return;
}
this._mdf = true;
};
MouseModifier.prototype.addShapeToModifier = function () {
this.positions.push([]);
};
MouseModifier.prototype.processPath = function (path, mouseCoords, positions) {
var i;
var len = path.v.length;
var vValues = [];
var oValues = [];
var iValues = [];
var theta;
var x;
var y;
/// / OPTION A
for (i = 0; i < len; i += 1) {
if (!positions.v[i]) {
positions.v[i] = [path.v[i][0], path.v[i][1]];
positions.o[i] = [path.o[i][0], path.o[i][1]];
positions.i[i] = [path.i[i][0], path.i[i][1]];
positions.distV[i] = 0;
positions.distO[i] = 0;
positions.distI[i] = 0;
}
theta = Math.atan2(
path.v[i][1] - mouseCoords[1],
path.v[i][0] - mouseCoords[0]
);
x = mouseCoords[0] - positions.v[i][0];
y = mouseCoords[1] - positions.v[i][1];
var distance = Math.sqrt((x * x) + (y * y));
positions.distV[i] += (distance - positions.distV[i]) * this.data.dc;
positions.v[i][0] = (Math.cos(theta) * Math.max(0, this.data.maxDist - positions.distV[i])) / 2 + (path.v[i][0]);
positions.v[i][1] = (Math.sin(theta) * Math.max(0, this.data.maxDist - positions.distV[i])) / 2 + (path.v[i][1]);
theta = Math.atan2(
path.o[i][1] - mouseCoords[1],
path.o[i][0] - mouseCoords[0]
);
x = mouseCoords[0] - positions.o[i][0];
y = mouseCoords[1] - positions.o[i][1];
distance = Math.sqrt((x * x) + (y * y));
positions.distO[i] += (distance - positions.distO[i]) * this.data.dc;
positions.o[i][0] = (Math.cos(theta) * Math.max(0, this.data.maxDist - positions.distO[i])) / 2 + (path.o[i][0]);
positions.o[i][1] = (Math.sin(theta) * Math.max(0, this.data.maxDist - positions.distO[i])) / 2 + (path.o[i][1]);
theta = Math.atan2(
path.i[i][1] - mouseCoords[1],
path.i[i][0] - mouseCoords[0]
);
x = mouseCoords[0] - positions.i[i][0];
y = mouseCoords[1] - positions.i[i][1];
distance = Math.sqrt((x * x) + (y * y));
positions.distI[i] += (distance - positions.distI[i]) * this.data.dc;
positions.i[i][0] = (Math.cos(theta) * Math.max(0, this.data.maxDist - positions.distI[i])) / 2 + (path.i[i][0]);
positions.i[i][1] = (Math.sin(theta) * Math.max(0, this.data.maxDist - positions.distI[i])) / 2 + (path.i[i][1]);
/// //OPTION 1
vValues.push(positions.v[i]);
oValues.push(positions.o[i]);
iValues.push(positions.i[i]);
/// //OPTION 2
// vValues.push(positions.v[i]);
// iValues.push([path.i[i][0]+(positions.v[i][0]-path.v[i][0]),path.i[i][1]+(positions.v[i][1]-path.v[i][1])]);
// oValues.push([path.o[i][0]+(positions.v[i][0]-path.v[i][0]),path.o[i][1]+(positions.v[i][1]-path.v[i][1])]);
/// //OPTION 3
// vValues.push(positions.v[i]);
// iValues.push(path.i[i]);
// oValues.push(path.o[i]);
/// //OPTION 4
// vValues.push(path.v[i]);
// oValues.push(positions.o[i]);
// iValues.push(positions.i[i]);
}
/// / OPTION B
/* for(i=0;i<len;i+=1){
if(!positions.v[i]){
positions.v[i] = [path.v[i][0],path.v[i][1]];
positions.o[i] = [path.o[i][0],path.o[i][1]];
positions.i[i] = [path.i[i][0],path.i[i][1]];
positions.distV[i] = 0;
}
theta = Math.atan2(
positions.v[i][1] - mouseCoords[1],
positions.v[i][0] - mouseCoords[0]
);
x = mouseCoords[0] - positions.v[i][0];
y = mouseCoords[1] - positions.v[i][1];
var distance = this.data.ss * this.data.mx / Math.sqrt( (x * x) + (y * y) );
positions.v[i][0] += Math.cos(theta) * distance + (path.v[i][0] - positions.v[i][0]) * this.data.dc;
positions.v[i][1] += Math.sin(theta) * distance + (path.v[i][1] - positions.v[i][1]) * this.data.dc;
theta = Math.atan2(
positions.o[i][1] - mouseCoords[1],
positions.o[i][0] - mouseCoords[0]
);
x = mouseCoords[0] - positions.o[i][0];
y = mouseCoords[1] - positions.o[i][1];
var distance = this.data.ss * this.data.mx / Math.sqrt( (x * x) + (y * y) );
positions.o[i][0] += Math.cos(theta) * distance + (path.o[i][0] - positions.o[i][0]) * this.data.dc;
positions.o[i][1] += Math.sin(theta) * distance + (path.o[i][1] - positions.o[i][1]) * this.data.dc;
theta = Math.atan2(
positions.i[i][1] - mouseCoords[1],
positions.i[i][0] - mouseCoords[0]
);
x = mouseCoords[0] - positions.i[i][0];
y = mouseCoords[1] - positions.i[i][1];
var distance = this.data.ss * this.data.mx / Math.sqrt( (x * x) + (y * y) );
positions.i[i][0] += Math.cos(theta) * distance + (path.i[i][0] - positions.i[i][0]) * this.data.dc;
positions.i[i][1] += Math.sin(theta) * distance + (path.i[i][1] - positions.i[i][1]) * this.data.dc;
/////OPTION 1
//vValues.push(positions.v[i]);
// oValues.push(positions.o[i]);
// iValues.push(positions.i[i]);
/////OPTION 2
//vValues.push(positions.v[i]);
// iValues.push([path.i[i][0]+(positions.v[i][0]-path.v[i][0]),path.i[i][1]+(positions.v[i][1]-path.v[i][1])]);
// oValues.push([path.o[i][0]+(positions.v[i][0]-path.v[i][0]),path.o[i][1]+(positions.v[i][1]-path.v[i][1])]);
/////OPTION 3
//vValues.push(positions.v[i]);
//iValues.push(path.i[i]);
//oValues.push(path.o[i]);
/////OPTION 4
//vValues.push(path.v[i]);
// oValues.push(positions.o[i]);
// iValues.push(positions.i[i]);
} */
return {
v: vValues,
o: oValues,
i: iValues,
c: path.c,
};
};
MouseModifier.prototype.processShapes = function () {
var mouseX = this.elem.globalData.mouseX;
var mouseY = this.elem.globalData.mouseY;
var shapePaths;
var i;
var len = this.shapes.length;
var j;
var jLen;
if (mouseX) {
var localMouseCoords = this.elem.globalToLocal([mouseX, mouseY, 0]);
var shapeData;
var newPaths = [];
for (i = 0; i < len; i += 1) {
shapeData = this.shapes[i];
if (!shapeData.shape._mdf && !this._mdf) {
shapeData.shape.paths = shapeData.last;
} else {
shapeData.shape._mdf = true;
shapePaths = shapeData.shape.paths;
jLen = shapePaths.length;
for (j = 0; j < jLen; j += 1) {
if (!this.positions[i][j]) {
this.positions[i][j] = {
v: [],
o: [],
i: [],
distV: [],
distO: [],
distI: [],
};
}
newPaths.push(this.processPath(shapePaths[j], localMouseCoords, this.positions[i][j]));
}
shapeData.shape.paths = newPaths;
shapeData.last = newPaths;
}
}
}
};
MouseModifier.prototype.initModifierProperties = function (elem, data) {
this.getValue = this.processKeys;
this.data = data;
this.positions = [];
};
ShapeModifiers.registerModifier('ms', MouseModifier);
export default MouseModifier;

306
node_modules/lottie-web/player/js/utils/shapes/OffsetPathModifier.js generated vendored Normal file
View File

@@ -0,0 +1,306 @@
import {
roundCorner,
} from '../common';
import {
extendPrototype,
} from '../functionExtensions';
import PropertyFactory from '../PropertyFactory';
import shapePool from '../pooling/shape_pool';
import {
ShapeModifier,
} from './ShapeModifiers';
import {
PolynomialBezier,
polarOffset,
lineIntersection,
pointDistance,
pointEqual,
floatEqual,
} from '../PolynomialBezier';
function linearOffset(p1, p2, amount) {
var angle = Math.atan2(p2[0] - p1[0], p2[1] - p1[1]);
return [
polarOffset(p1, angle, amount),
polarOffset(p2, angle, amount),
];
}
function offsetSegment(segment, amount) {
var p0; var p1a; var p1b; var p2b; var p2a; var
p3;
var e;
e = linearOffset(segment.points[0], segment.points[1], amount);
p0 = e[0];
p1a = e[1];
e = linearOffset(segment.points[1], segment.points[2], amount);
p1b = e[0];
p2b = e[1];
e = linearOffset(segment.points[2], segment.points[3], amount);
p2a = e[0];
p3 = e[1];
var p1 = lineIntersection(p0, p1a, p1b, p2b);
if (p1 === null) p1 = p1a;
var p2 = lineIntersection(p2a, p3, p1b, p2b);
if (p2 === null) p2 = p2a;
return new PolynomialBezier(p0, p1, p2, p3);
}
function joinLines(outputBezier, seg1, seg2, lineJoin, miterLimit) {
var p0 = seg1.points[3];
var p1 = seg2.points[0];
// Bevel
if (lineJoin === 3) return p0;
// Connected, they don't need a joint
if (pointEqual(p0, p1)) return p0;
// Round
if (lineJoin === 2) {
var angleOut = -seg1.tangentAngle(1);
var angleIn = -seg2.tangentAngle(0) + Math.PI;
var center = lineIntersection(
p0,
polarOffset(p0, angleOut + Math.PI / 2, 100),
p1,
polarOffset(p1, angleOut + Math.PI / 2, 100)
);
var radius = center ? pointDistance(center, p0) : pointDistance(p0, p1) / 2;
var tan = polarOffset(p0, angleOut, 2 * radius * roundCorner);
outputBezier.setXYAt(tan[0], tan[1], 'o', outputBezier.length() - 1);
tan = polarOffset(p1, angleIn, 2 * radius * roundCorner);
outputBezier.setTripleAt(p1[0], p1[1], p1[0], p1[1], tan[0], tan[1], outputBezier.length());
return p1;
}
// Miter
var t0 = pointEqual(p0, seg1.points[2]) ? seg1.points[0] : seg1.points[2];
var t1 = pointEqual(p1, seg2.points[1]) ? seg2.points[3] : seg2.points[1];
var intersection = lineIntersection(t0, p0, p1, t1);
if (intersection && pointDistance(intersection, p0) < miterLimit) {
outputBezier.setTripleAt(
intersection[0],
intersection[1],
intersection[0],
intersection[1],
intersection[0],
intersection[1],
outputBezier.length()
);
return intersection;
}
return p0;
}
function getIntersection(a, b) {
const intersect = a.intersections(b);
if (intersect.length && floatEqual(intersect[0][0], 1)) intersect.shift();
if (intersect.length) return intersect[0];
return null;
}
function pruneSegmentIntersection(a, b) {
var outa = a.slice();
var outb = b.slice();
var intersect = getIntersection(a[a.length - 1], b[0]);
if (intersect) {
outa[a.length - 1] = a[a.length - 1].split(intersect[0])[0];
outb[0] = b[0].split(intersect[1])[1];
}
if (a.length > 1 && b.length > 1) {
intersect = getIntersection(a[0], b[b.length - 1]);
if (intersect) {
return [
[a[0].split(intersect[0])[0]],
[b[b.length - 1].split(intersect[1])[1]],
];
}
}
return [outa, outb];
}
function pruneIntersections(segments) {
var e;
for (var i = 1; i < segments.length; i += 1) {
e = pruneSegmentIntersection(segments[i - 1], segments[i]);
segments[i - 1] = e[0];
segments[i] = e[1];
}
if (segments.length > 1) {
e = pruneSegmentIntersection(segments[segments.length - 1], segments[0]);
segments[segments.length - 1] = e[0];
segments[0] = e[1];
}
return segments;
}
function offsetSegmentSplit(segment, amount) {
/*
We split each bezier segment into smaller pieces based
on inflection points, this ensures the control point
polygon is convex.
(A cubic bezier can have none, one, or two inflection points)
*/
var flex = segment.inflectionPoints();
var left;
var right;
var split;
var mid;
if (flex.length === 0) {
return [offsetSegment(segment, amount)];
}
if (flex.length === 1 || floatEqual(flex[1], 1)) {
split = segment.split(flex[0]);
left = split[0];
right = split[1];
return [
offsetSegment(left, amount),
offsetSegment(right, amount),
];
}
split = segment.split(flex[0]);
left = split[0];
var t = (flex[1] - flex[0]) / (1 - flex[0]);
split = split[1].split(t);
mid = split[0];
right = split[1];
return [
offsetSegment(left, amount),
offsetSegment(mid, amount),
offsetSegment(right, amount),
];
}
function OffsetPathModifier() {}
extendPrototype([ShapeModifier], OffsetPathModifier);
OffsetPathModifier.prototype.initModifierProperties = function (elem, data) {
this.getValue = this.processKeys;
this.amount = PropertyFactory.getProp(elem, data.a, 0, null, this);
this.miterLimit = PropertyFactory.getProp(elem, data.ml, 0, null, this);
this.lineJoin = data.lj;
this._isAnimated = this.amount.effectsSequence.length !== 0;
};
OffsetPathModifier.prototype.processPath = function (inputBezier, amount, lineJoin, miterLimit) {
var outputBezier = shapePool.newElement();
outputBezier.c = inputBezier.c;
var count = inputBezier.length();
if (!inputBezier.c) {
count -= 1;
}
var i; var j; var segment;
var multiSegments = [];
for (i = 0; i < count; i += 1) {
segment = PolynomialBezier.shapeSegment(inputBezier, i);
multiSegments.push(offsetSegmentSplit(segment, amount));
}
if (!inputBezier.c) {
for (i = count - 1; i >= 0; i -= 1) {
segment = PolynomialBezier.shapeSegmentInverted(inputBezier, i);
multiSegments.push(offsetSegmentSplit(segment, amount));
}
}
multiSegments = pruneIntersections(multiSegments);
// Add bezier segments to the output and apply line joints
var lastPoint = null;
var lastSeg = null;
for (i = 0; i < multiSegments.length; i += 1) {
var multiSegment = multiSegments[i];
if (lastSeg) lastPoint = joinLines(outputBezier, lastSeg, multiSegment[0], lineJoin, miterLimit);
lastSeg = multiSegment[multiSegment.length - 1];
for (j = 0; j < multiSegment.length; j += 1) {
segment = multiSegment[j];
if (lastPoint && pointEqual(segment.points[0], lastPoint)) {
outputBezier.setXYAt(segment.points[1][0], segment.points[1][1], 'o', outputBezier.length() - 1);
} else {
outputBezier.setTripleAt(
segment.points[0][0],
segment.points[0][1],
segment.points[1][0],
segment.points[1][1],
segment.points[0][0],
segment.points[0][1],
outputBezier.length()
);
}
outputBezier.setTripleAt(
segment.points[3][0],
segment.points[3][1],
segment.points[3][0],
segment.points[3][1],
segment.points[2][0],
segment.points[2][1],
outputBezier.length()
);
lastPoint = segment.points[3];
}
}
if (multiSegments.length) joinLines(outputBezier, lastSeg, multiSegments[0][0], lineJoin, miterLimit);
return outputBezier;
};
OffsetPathModifier.prototype.processShapes = function (_isFirstFrame) {
var shapePaths;
var i;
var len = this.shapes.length;
var j;
var jLen;
var amount = this.amount.v;
var miterLimit = this.miterLimit.v;
var lineJoin = this.lineJoin;
if (amount !== 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], amount, lineJoin, miterLimit));
}
}
shapeData.shape.paths = shapeData.localShapeCollection;
}
}
if (!this.dynamicProperties.length) {
this._mdf = false;
}
};
export default OffsetPathModifier;

80
node_modules/lottie-web/player/js/utils/shapes/PuckerAndBloatModifier.js generated vendored Normal file
View File

@@ -0,0 +1,80 @@
import {
extendPrototype,
} from '../functionExtensions';
import PropertyFactory from '../PropertyFactory';
import shapePool from '../pooling/shape_pool';
import {
ShapeModifier,
} from './ShapeModifiers';
function PuckerAndBloatModifier() {}
extendPrototype([ShapeModifier], PuckerAndBloatModifier);
PuckerAndBloatModifier.prototype.initModifierProperties = function (elem, data) {
this.getValue = this.processKeys;
this.amount = PropertyFactory.getProp(elem, data.a, 0, null, this);
this._isAnimated = !!this.amount.effectsSequence.length;
};
PuckerAndBloatModifier.prototype.processPath = function (path, amount) {
var percent = amount / 100;
var centerPoint = [0, 0];
var pathLength = path._length;
var i = 0;
for (i = 0; i < pathLength; i += 1) {
centerPoint[0] += path.v[i][0];
centerPoint[1] += path.v[i][1];
}
centerPoint[0] /= pathLength;
centerPoint[1] /= pathLength;
var clonedPath = shapePool.newElement();
clonedPath.c = path.c;
var vX;
var vY;
var oX;
var oY;
var iX;
var iY;
for (i = 0; i < pathLength; i += 1) {
vX = path.v[i][0] + (centerPoint[0] - path.v[i][0]) * percent;
vY = path.v[i][1] + (centerPoint[1] - path.v[i][1]) * percent;
oX = path.o[i][0] + (centerPoint[0] - path.o[i][0]) * -percent;
oY = path.o[i][1] + (centerPoint[1] - path.o[i][1]) * -percent;
iX = path.i[i][0] + (centerPoint[0] - path.i[i][0]) * -percent;
iY = path.i[i][1] + (centerPoint[1] - path.i[i][1]) * -percent;
clonedPath.setTripleAt(vX, vY, oX, oY, iX, iY, i);
}
return clonedPath;
};
PuckerAndBloatModifier.prototype.processShapes = function (_isFirstFrame) {
var shapePaths;
var i;
var len = this.shapes.length;
var j;
var jLen;
var amount = this.amount.v;
if (amount !== 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], amount));
}
}
shapeData.shape.paths = shapeData.localShapeCollection;
}
}
if (!this.dynamicProperties.length) {
this._mdf = false;
}
};
export default PuckerAndBloatModifier;

232
node_modules/lottie-web/player/js/utils/shapes/RepeaterModifier.js generated vendored Normal file
View File

@@ -0,0 +1,232 @@
import {
extendPrototype,
} from '../functionExtensions';
import PropertyFactory from '../PropertyFactory';
import Matrix from '../../3rd_party/transformation-matrix';
import TransformPropertyFactory from '../TransformProperty';
import {
ShapeModifier,
} from './ShapeModifiers';
function RepeaterModifier() {}
extendPrototype([ShapeModifier], RepeaterModifier);
RepeaterModifier.prototype.initModifierProperties = function (elem, data) {
this.getValue = this.processKeys;
this.c = PropertyFactory.getProp(elem, data.c, 0, null, this);
this.o = PropertyFactory.getProp(elem, data.o, 0, null, this);
this.tr = TransformPropertyFactory.getTransformProperty(elem, data.tr, this);
this.so = PropertyFactory.getProp(elem, data.tr.so, 0, 0.01, this);
this.eo = PropertyFactory.getProp(elem, data.tr.eo, 0, 0.01, this);
this.data = data;
if (!this.dynamicProperties.length) {
this.getValue(true);
}
this._isAnimated = !!this.dynamicProperties.length;
this.pMatrix = new Matrix();
this.rMatrix = new Matrix();
this.sMatrix = new Matrix();
this.tMatrix = new Matrix();
this.matrix = new Matrix();
};
RepeaterModifier.prototype.applyTransforms = function (pMatrix, rMatrix, sMatrix, transform, perc, inv) {
var dir = inv ? -1 : 1;
var scaleX = transform.s.v[0] + (1 - transform.s.v[0]) * (1 - perc);
var scaleY = transform.s.v[1] + (1 - transform.s.v[1]) * (1 - perc);
pMatrix.translate(transform.p.v[0] * dir * perc, transform.p.v[1] * dir * perc, transform.p.v[2]);
rMatrix.translate(-transform.a.v[0], -transform.a.v[1], transform.a.v[2]);
rMatrix.rotate(-transform.r.v * dir * perc);
rMatrix.translate(transform.a.v[0], transform.a.v[1], transform.a.v[2]);
sMatrix.translate(-transform.a.v[0], -transform.a.v[1], transform.a.v[2]);
sMatrix.scale(inv ? 1 / scaleX : scaleX, inv ? 1 / scaleY : scaleY);
sMatrix.translate(transform.a.v[0], transform.a.v[1], transform.a.v[2]);
};
RepeaterModifier.prototype.init = function (elem, arr, pos, elemsData) {
this.elem = elem;
this.arr = arr;
this.pos = pos;
this.elemsData = elemsData;
this._currentCopies = 0;
this._elements = [];
this._groups = [];
this.frameId = -1;
this.initDynamicPropertyContainer(elem);
this.initModifierProperties(elem, arr[pos]);
while (pos > 0) {
pos -= 1;
// this._elements.unshift(arr.splice(pos,1)[0]);
this._elements.unshift(arr[pos]);
}
if (this.dynamicProperties.length) {
this.k = true;
} else {
this.getValue(true);
}
};
RepeaterModifier.prototype.resetElements = function (elements) {
var i;
var len = elements.length;
for (i = 0; i < len; i += 1) {
elements[i]._processed = false;
if (elements[i].ty === 'gr') {
this.resetElements(elements[i].it);
}
}
};
RepeaterModifier.prototype.cloneElements = function (elements) {
var newElements = JSON.parse(JSON.stringify(elements));
this.resetElements(newElements);
return newElements;
};
RepeaterModifier.prototype.changeGroupRender = function (elements, renderFlag) {
var i;
var len = elements.length;
for (i = 0; i < len; i += 1) {
elements[i]._render = renderFlag;
if (elements[i].ty === 'gr') {
this.changeGroupRender(elements[i].it, renderFlag);
}
}
};
RepeaterModifier.prototype.processShapes = function (_isFirstFrame) {
var items;
var itemsTransform;
var i;
var dir;
var cont;
var hasReloaded = false;
if (this._mdf || _isFirstFrame) {
var copies = Math.ceil(this.c.v);
if (this._groups.length < copies) {
while (this._groups.length < copies) {
var group = {
it: this.cloneElements(this._elements),
ty: 'gr',
};
group.it.push({
a: { a: 0, ix: 1, k: [0, 0] }, nm: 'Transform', o: { a: 0, ix: 7, k: 100 }, p: { a: 0, ix: 2, k: [0, 0] }, r: { a: 1, ix: 6, k: [{ s: 0, e: 0, t: 0 }, { s: 0, e: 0, t: 1 }] }, s: { a: 0, ix: 3, k: [100, 100] }, sa: { a: 0, ix: 5, k: 0 }, sk: { a: 0, ix: 4, k: 0 }, ty: 'tr',
});
this.arr.splice(0, 0, group);
this._groups.splice(0, 0, group);
this._currentCopies += 1;
}
this.elem.reloadShapes();
hasReloaded = true;
}
cont = 0;
var renderFlag;
for (i = 0; i <= this._groups.length - 1; i += 1) {
renderFlag = cont < copies;
this._groups[i]._render = renderFlag;
this.changeGroupRender(this._groups[i].it, renderFlag);
if (!renderFlag) {
var elems = this.elemsData[i].it;
var transformData = elems[elems.length - 1];
if (transformData.transform.op.v !== 0) {
transformData.transform.op._mdf = true;
transformData.transform.op.v = 0;
} else {
transformData.transform.op._mdf = false;
}
}
cont += 1;
}
this._currentCopies = copies;
/// /
var offset = this.o.v;
var offsetModulo = offset % 1;
var roundOffset = offset > 0 ? Math.floor(offset) : Math.ceil(offset);
var pProps = this.pMatrix.props;
var rProps = this.rMatrix.props;
var sProps = this.sMatrix.props;
this.pMatrix.reset();
this.rMatrix.reset();
this.sMatrix.reset();
this.tMatrix.reset();
this.matrix.reset();
var iteration = 0;
if (offset > 0) {
while (iteration < roundOffset) {
this.applyTransforms(this.pMatrix, this.rMatrix, this.sMatrix, this.tr, 1, false);
iteration += 1;
}
if (offsetModulo) {
this.applyTransforms(this.pMatrix, this.rMatrix, this.sMatrix, this.tr, offsetModulo, false);
iteration += offsetModulo;
}
} else if (offset < 0) {
while (iteration > roundOffset) {
this.applyTransforms(this.pMatrix, this.rMatrix, this.sMatrix, this.tr, 1, true);
iteration -= 1;
}
if (offsetModulo) {
this.applyTransforms(this.pMatrix, this.rMatrix, this.sMatrix, this.tr, -offsetModulo, true);
iteration -= offsetModulo;
}
}
i = this.data.m === 1 ? 0 : this._currentCopies - 1;
dir = this.data.m === 1 ? 1 : -1;
cont = this._currentCopies;
var j;
var jLen;
while (cont) {
items = this.elemsData[i].it;
itemsTransform = items[items.length - 1].transform.mProps.v.props;
jLen = itemsTransform.length;
items[items.length - 1].transform.mProps._mdf = true;
items[items.length - 1].transform.op._mdf = true;
items[items.length - 1].transform.op.v = this._currentCopies === 1
? this.so.v
: this.so.v + (this.eo.v - this.so.v) * (i / (this._currentCopies - 1));
if (iteration !== 0) {
if ((i !== 0 && dir === 1) || (i !== this._currentCopies - 1 && dir === -1)) {
this.applyTransforms(this.pMatrix, this.rMatrix, this.sMatrix, this.tr, 1, false);
}
this.matrix.transform(rProps[0], rProps[1], rProps[2], rProps[3], rProps[4], rProps[5], rProps[6], rProps[7], rProps[8], rProps[9], rProps[10], rProps[11], rProps[12], rProps[13], rProps[14], rProps[15]);
this.matrix.transform(sProps[0], sProps[1], sProps[2], sProps[3], sProps[4], sProps[5], sProps[6], sProps[7], sProps[8], sProps[9], sProps[10], sProps[11], sProps[12], sProps[13], sProps[14], sProps[15]);
this.matrix.transform(pProps[0], pProps[1], pProps[2], pProps[3], pProps[4], pProps[5], pProps[6], pProps[7], pProps[8], pProps[9], pProps[10], pProps[11], pProps[12], pProps[13], pProps[14], pProps[15]);
for (j = 0; j < jLen; j += 1) {
itemsTransform[j] = this.matrix.props[j];
}
this.matrix.reset();
} else {
this.matrix.reset();
for (j = 0; j < jLen; j += 1) {
itemsTransform[j] = this.matrix.props[j];
}
}
iteration += 1;
cont -= 1;
i += dir;
}
} else {
cont = this._currentCopies;
i = 0;
dir = 1;
while (cont) {
items = this.elemsData[i].it;
itemsTransform = items[items.length - 1].transform.mProps.v.props;
items[items.length - 1].transform.mProps._mdf = false;
items[items.length - 1].transform.op._mdf = false;
cont -= 1;
i += dir;
}
}
return hasReloaded;
};
RepeaterModifier.prototype.addShape = function () {};
export default RepeaterModifier;

122
node_modules/lottie-web/player/js/utils/shapes/RoundCornersModifier.js generated vendored Normal file
View File

@@ -0,0 +1,122 @@
import {
roundCorner,
} from '../common';
import {
extendPrototype,
} from '../functionExtensions';
import PropertyFactory from '../PropertyFactory';
import shapePool from '../pooling/shape_pool';
import {
ShapeModifier,
} from './ShapeModifiers';
function RoundCornersModifier() {}
extendPrototype([ShapeModifier], RoundCornersModifier);
RoundCornersModifier.prototype.initModifierProperties = function (elem, data) {
this.getValue = this.processKeys;
this.rd = PropertyFactory.getProp(elem, data.r, 0, null, this);
this._isAnimated = !!this.rd.effectsSequence.length;
};
RoundCornersModifier.prototype.processPath = function (path, round) {
var clonedPath = shapePool.newElement();
clonedPath.c = path.c;
var i;
var len = path._length;
var currentV;
var currentI;
var currentO;
var closerV;
var distance;
var newPosPerc;
var index = 0;
var vX;
var vY;
var oX;
var oY;
var iX;
var iY;
for (i = 0; i < len; i += 1) {
currentV = path.v[i];
currentO = path.o[i];
currentI = path.i[i];
if (currentV[0] === currentO[0] && currentV[1] === currentO[1] && currentV[0] === currentI[0] && currentV[1] === currentI[1]) {
if ((i === 0 || i === len - 1) && !path.c) {
clonedPath.setTripleAt(currentV[0], currentV[1], currentO[0], currentO[1], currentI[0], currentI[1], index);
/* clonedPath.v[index] = currentV;
clonedPath.o[index] = currentO;
clonedPath.i[index] = currentI; */
index += 1;
} else {
if (i === 0) {
closerV = path.v[len - 1];
} else {
closerV = path.v[i - 1];
}
distance = Math.sqrt(Math.pow(currentV[0] - closerV[0], 2) + Math.pow(currentV[1] - closerV[1], 2));
newPosPerc = distance ? Math.min(distance / 2, round) / distance : 0;
iX = currentV[0] + (closerV[0] - currentV[0]) * newPosPerc;
vX = iX;
iY = currentV[1] - (currentV[1] - closerV[1]) * newPosPerc;
vY = iY;
oX = vX - (vX - currentV[0]) * roundCorner;
oY = vY - (vY - currentV[1]) * roundCorner;
clonedPath.setTripleAt(vX, vY, oX, oY, iX, iY, index);
index += 1;
if (i === len - 1) {
closerV = path.v[0];
} else {
closerV = path.v[i + 1];
}
distance = Math.sqrt(Math.pow(currentV[0] - closerV[0], 2) + Math.pow(currentV[1] - closerV[1], 2));
newPosPerc = distance ? Math.min(distance / 2, round) / distance : 0;
oX = currentV[0] + (closerV[0] - currentV[0]) * newPosPerc;
vX = oX;
oY = currentV[1] + (closerV[1] - currentV[1]) * newPosPerc;
vY = oY;
iX = vX - (vX - currentV[0]) * roundCorner;
iY = vY - (vY - currentV[1]) * roundCorner;
clonedPath.setTripleAt(vX, vY, oX, oY, iX, iY, index);
index += 1;
}
} else {
clonedPath.setTripleAt(path.v[i][0], path.v[i][1], path.o[i][0], path.o[i][1], path.i[i][0], path.i[i][1], index);
index += 1;
}
}
return clonedPath;
};
RoundCornersModifier.prototype.processShapes = function (_isFirstFrame) {
var shapePaths;
var i;
var len = this.shapes.length;
var j;
var jLen;
var rd = this.rd.v;
if (rd !== 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], rd));
}
}
shapeData.shape.paths = shapeData.localShapeCollection;
}
}
if (!this.dynamicProperties.length) {
this._mdf = false;
}
};
export default RoundCornersModifier;

29
node_modules/lottie-web/player/js/utils/shapes/ShapeCollection.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
import {
createSizedArray,
} from '../helpers/arrays';
import shapePool from '../pooling/shape_pool';
function ShapeCollection() {
this._length = 0;
this._maxLength = 4;
this.shapes = createSizedArray(this._maxLength);
}
ShapeCollection.prototype.addShape = function (shapeData) {
if (this._length === this._maxLength) {
this.shapes = this.shapes.concat(createSizedArray(this._maxLength));
this._maxLength *= 2;
}
this.shapes[this._length] = shapeData;
this._length += 1;
};
ShapeCollection.prototype.releaseShapes = function () {
var i;
for (i = 0; i < this._length; i += 1) {
shapePool.release(this.shapes[i]);
}
this._length = 0;
};
export default ShapeCollection;

71
node_modules/lottie-web/player/js/utils/shapes/ShapeModifiers.js generated vendored Normal file
View File

@@ -0,0 +1,71 @@
import {
extendPrototype,
} from '../functionExtensions';
import DynamicPropertyContainer from '../helpers/dynamicProperties';
import {
initialDefaultFrame,
} from '../../main';
import shapeCollectionPool from '../pooling/shapeCollection_pool';
const ShapeModifiers = (function () {
var ob = {};
var modifiers = {};
ob.registerModifier = registerModifier;
ob.getModifier = getModifier;
function registerModifier(nm, factory) {
if (!modifiers[nm]) {
modifiers[nm] = factory;
}
}
function getModifier(nm, elem, data) {
return new modifiers[nm](elem, data);
}
return ob;
}());
function ShapeModifier() {}
ShapeModifier.prototype.initModifierProperties = function () {};
ShapeModifier.prototype.addShapeToModifier = function () {};
ShapeModifier.prototype.addShape = function (data) {
if (!this.closed) {
// Adding shape to dynamic properties. It covers the case where a shape has no effects applied, to reset it's _mdf state on every tick.
data.sh.container.addDynamicProperty(data.sh);
var shapeData = { shape: data.sh, data: data, localShapeCollection: shapeCollectionPool.newShapeCollection() };
this.shapes.push(shapeData);
this.addShapeToModifier(shapeData);
if (this._isAnimated) {
data.setAsAnimated();
}
}
};
ShapeModifier.prototype.init = function (elem, data) {
this.shapes = [];
this.elem = elem;
this.initDynamicPropertyContainer(elem);
this.initModifierProperties(elem, data);
this.frameId = initialDefaultFrame;
this.closed = false;
this.k = false;
if (this.dynamicProperties.length) {
this.k = true;
} else {
this.getValue(true);
}
};
ShapeModifier.prototype.processKeys = function () {
if (this.elem.globalData.frameId === this.frameId) {
return;
}
this.frameId = this.elem.globalData.frameId;
this.iterateDynamicProperties();
};
extendPrototype([DynamicPropertyContainer], ShapeModifier);
export {
ShapeModifiers,
ShapeModifier,
};

100
node_modules/lottie-web/player/js/utils/shapes/ShapePath.js generated vendored Normal file
View File

@@ -0,0 +1,100 @@
import {
createSizedArray,
} from '../helpers/arrays';
import pointPool from '../pooling/point_pool';
function ShapePath() {
this.c = false;
this._length = 0;
this._maxLength = 8;
this.v = createSizedArray(this._maxLength);
this.o = createSizedArray(this._maxLength);
this.i = createSizedArray(this._maxLength);
}
ShapePath.prototype.setPathData = function (closed, len) {
this.c = closed;
this.setLength(len);
var i = 0;
while (i < len) {
this.v[i] = pointPool.newElement();
this.o[i] = pointPool.newElement();
this.i[i] = pointPool.newElement();
i += 1;
}
};
ShapePath.prototype.setLength = function (len) {
while (this._maxLength < len) {
this.doubleArrayLength();
}
this._length = len;
};
ShapePath.prototype.doubleArrayLength = function () {
this.v = this.v.concat(createSizedArray(this._maxLength));
this.i = this.i.concat(createSizedArray(this._maxLength));
this.o = this.o.concat(createSizedArray(this._maxLength));
this._maxLength *= 2;
};
ShapePath.prototype.setXYAt = function (x, y, type, pos, replace) {
var arr;
this._length = Math.max(this._length, pos + 1);
if (this._length >= this._maxLength) {
this.doubleArrayLength();
}
switch (type) {
case 'v':
arr = this.v;
break;
case 'i':
arr = this.i;
break;
case 'o':
arr = this.o;
break;
default:
arr = [];
break;
}
if (!arr[pos] || (arr[pos] && !replace)) {
arr[pos] = pointPool.newElement();
}
arr[pos][0] = x;
arr[pos][1] = y;
};
ShapePath.prototype.setTripleAt = function (vX, vY, oX, oY, iX, iY, pos, replace) {
this.setXYAt(vX, vY, 'v', pos, replace);
this.setXYAt(oX, oY, 'o', pos, replace);
this.setXYAt(iX, iY, 'i', pos, replace);
};
ShapePath.prototype.reverse = function () {
var newPath = new ShapePath();
newPath.setPathData(this.c, this._length);
var vertices = this.v;
var outPoints = this.o;
var inPoints = this.i;
var init = 0;
if (this.c) {
newPath.setTripleAt(vertices[0][0], vertices[0][1], inPoints[0][0], inPoints[0][1], outPoints[0][0], outPoints[0][1], 0, false);
init = 1;
}
var cnt = this._length - 1;
var len = this._length;
var i;
for (i = init; i < len; i += 1) {
newPath.setTripleAt(vertices[cnt][0], vertices[cnt][1], inPoints[cnt][0], inPoints[cnt][1], outPoints[cnt][0], outPoints[cnt][1], i, false);
cnt -= 1;
}
return newPath;
};
ShapePath.prototype.length = function () {
return this._length;
};
export default ShapePath;

546
node_modules/lottie-web/player/js/utils/shapes/ShapeProperty.js generated vendored Normal file
View File

@@ -0,0 +1,546 @@
import {
degToRads,
roundCorner,
bmMin,
} from '../common';
import {
extendPrototype,
} from '../functionExtensions';
import DynamicPropertyContainer from '../helpers/dynamicProperties';
import PropertyFactory from '../PropertyFactory';
import BezierFactory from '../../3rd_party/BezierEaser';
import shapePool from '../pooling/shape_pool';
import shapeCollectionPool from '../pooling/shapeCollection_pool';
const ShapePropertyFactory = (function () {
var initFrame = -999999;
function interpolateShape(frameNum, previousValue, caching) {
var iterationIndex = caching.lastIndex;
var keyPropS;
var keyPropE;
var isHold;
var j;
var k;
var jLen;
var kLen;
var perc;
var vertexValue;
var kf = this.keyframes;
if (frameNum < kf[0].t - this.offsetTime) {
keyPropS = kf[0].s[0];
isHold = true;
iterationIndex = 0;
} else if (frameNum >= kf[kf.length - 1].t - this.offsetTime) {
keyPropS = kf[kf.length - 1].s ? kf[kf.length - 1].s[0] : kf[kf.length - 2].e[0];
/* if(kf[kf.length - 1].s){
keyPropS = kf[kf.length - 1].s[0];
}else{
keyPropS = kf[kf.length - 2].e[0];
} */
isHold = true;
} else {
var i = iterationIndex;
var len = kf.length - 1;
var flag = true;
var keyData;
var nextKeyData;
var keyframeMetadata;
while (flag) {
keyData = kf[i];
nextKeyData = kf[i + 1];
if ((nextKeyData.t - this.offsetTime) > frameNum) {
break;
}
if (i < len - 1) {
i += 1;
} else {
flag = false;
}
}
keyframeMetadata = this.keyframesMetadata[i] || {};
isHold = keyData.h === 1;
iterationIndex = i;
if (!isHold) {
if (frameNum >= nextKeyData.t - this.offsetTime) {
perc = 1;
} else if (frameNum < keyData.t - this.offsetTime) {
perc = 0;
} else {
var fnc;
if (keyframeMetadata.__fnct) {
fnc = keyframeMetadata.__fnct;
} else {
fnc = BezierFactory.getBezierEasing(keyData.o.x, keyData.o.y, keyData.i.x, keyData.i.y).get;
keyframeMetadata.__fnct = fnc;
}
perc = fnc((frameNum - (keyData.t - this.offsetTime)) / ((nextKeyData.t - this.offsetTime) - (keyData.t - this.offsetTime)));
}
keyPropE = nextKeyData.s ? nextKeyData.s[0] : keyData.e[0];
}
keyPropS = keyData.s[0];
}
jLen = previousValue._length;
kLen = keyPropS.i[0].length;
caching.lastIndex = iterationIndex;
for (j = 0; j < jLen; j += 1) {
for (k = 0; k < kLen; k += 1) {
vertexValue = isHold ? keyPropS.i[j][k] : keyPropS.i[j][k] + (keyPropE.i[j][k] - keyPropS.i[j][k]) * perc;
previousValue.i[j][k] = vertexValue;
vertexValue = isHold ? keyPropS.o[j][k] : keyPropS.o[j][k] + (keyPropE.o[j][k] - keyPropS.o[j][k]) * perc;
previousValue.o[j][k] = vertexValue;
vertexValue = isHold ? keyPropS.v[j][k] : keyPropS.v[j][k] + (keyPropE.v[j][k] - keyPropS.v[j][k]) * perc;
previousValue.v[j][k] = vertexValue;
}
}
}
function interpolateShapeCurrentTime() {
var frameNum = this.comp.renderedFrame - this.offsetTime;
var initTime = this.keyframes[0].t - this.offsetTime;
var endTime = this.keyframes[this.keyframes.length - 1].t - this.offsetTime;
var lastFrame = this._caching.lastFrame;
if (!(lastFrame !== initFrame && ((lastFrame < initTime && frameNum < initTime) || (lastFrame > endTime && frameNum > endTime)))) {
/// /
this._caching.lastIndex = lastFrame < frameNum ? this._caching.lastIndex : 0;
this.interpolateShape(frameNum, this.pv, this._caching);
/// /
}
this._caching.lastFrame = frameNum;
return this.pv;
}
function resetShape() {
this.paths = this.localShapeCollection;
}
function shapesEqual(shape1, shape2) {
if (shape1._length !== shape2._length || shape1.c !== shape2.c) {
return false;
}
var i;
var len = shape1._length;
for (i = 0; i < len; i += 1) {
if (shape1.v[i][0] !== shape2.v[i][0]
|| shape1.v[i][1] !== shape2.v[i][1]
|| shape1.o[i][0] !== shape2.o[i][0]
|| shape1.o[i][1] !== shape2.o[i][1]
|| shape1.i[i][0] !== shape2.i[i][0]
|| shape1.i[i][1] !== shape2.i[i][1]) {
return false;
}
}
return true;
}
function setVValue(newPath) {
if (!shapesEqual(this.v, newPath)) {
this.v = shapePool.clone(newPath);
this.localShapeCollection.releaseShapes();
this.localShapeCollection.addShape(this.v);
this._mdf = true;
this.paths = this.localShapeCollection;
}
}
function processEffectsSequence() {
if (this.elem.globalData.frameId === this.frameId) {
return;
} if (!this.effectsSequence.length) {
this._mdf = false;
return;
}
if (this.lock) {
this.setVValue(this.pv);
return;
}
this.lock = true;
this._mdf = false;
var finalValue;
if (this.kf) {
finalValue = this.pv;
} else if (this.data.ks) {
finalValue = this.data.ks.k;
} else {
finalValue = this.data.pt.k;
}
var i;
var len = this.effectsSequence.length;
for (i = 0; i < len; i += 1) {
finalValue = this.effectsSequence[i](finalValue);
}
this.setVValue(finalValue);
this.lock = false;
this.frameId = this.elem.globalData.frameId;
}
function ShapeProperty(elem, data, type) {
this.propType = 'shape';
this.comp = elem.comp;
this.container = elem;
this.elem = elem;
this.data = data;
this.k = false;
this.kf = false;
this._mdf = false;
var pathData = type === 3 ? data.pt.k : data.ks.k;
this.v = shapePool.clone(pathData);
this.pv = shapePool.clone(this.v);
this.localShapeCollection = shapeCollectionPool.newShapeCollection();
this.paths = this.localShapeCollection;
this.paths.addShape(this.v);
this.reset = resetShape;
this.effectsSequence = [];
}
function addEffect(effectFunction) {
this.effectsSequence.push(effectFunction);
this.container.addDynamicProperty(this);
}
ShapeProperty.prototype.interpolateShape = interpolateShape;
ShapeProperty.prototype.getValue = processEffectsSequence;
ShapeProperty.prototype.setVValue = setVValue;
ShapeProperty.prototype.addEffect = addEffect;
function KeyframedShapeProperty(elem, data, type) {
this.propType = 'shape';
this.comp = elem.comp;
this.elem = elem;
this.container = elem;
this.offsetTime = elem.data.st;
this.keyframes = type === 3 ? data.pt.k : data.ks.k;
this.keyframesMetadata = [];
this.k = true;
this.kf = true;
var len = this.keyframes[0].s[0].i.length;
this.v = shapePool.newElement();
this.v.setPathData(this.keyframes[0].s[0].c, len);
this.pv = shapePool.clone(this.v);
this.localShapeCollection = shapeCollectionPool.newShapeCollection();
this.paths = this.localShapeCollection;
this.paths.addShape(this.v);
this.lastFrame = initFrame;
this.reset = resetShape;
this._caching = { lastFrame: initFrame, lastIndex: 0 };
this.effectsSequence = [interpolateShapeCurrentTime.bind(this)];
}
KeyframedShapeProperty.prototype.getValue = processEffectsSequence;
KeyframedShapeProperty.prototype.interpolateShape = interpolateShape;
KeyframedShapeProperty.prototype.setVValue = setVValue;
KeyframedShapeProperty.prototype.addEffect = addEffect;
var EllShapeProperty = (function () {
var cPoint = roundCorner;
function EllShapePropertyFactory(elem, data) {
this.v = shapePool.newElement();
this.v.setPathData(true, 4);
this.localShapeCollection = shapeCollectionPool.newShapeCollection();
this.paths = this.localShapeCollection;
this.localShapeCollection.addShape(this.v);
this.d = data.d;
this.elem = elem;
this.comp = elem.comp;
this.frameId = -1;
this.initDynamicPropertyContainer(elem);
this.p = PropertyFactory.getProp(elem, data.p, 1, 0, this);
this.s = PropertyFactory.getProp(elem, data.s, 1, 0, this);
if (this.dynamicProperties.length) {
this.k = true;
} else {
this.k = false;
this.convertEllToPath();
}
}
EllShapePropertyFactory.prototype = {
reset: resetShape,
getValue: function () {
if (this.elem.globalData.frameId === this.frameId) {
return;
}
this.frameId = this.elem.globalData.frameId;
this.iterateDynamicProperties();
if (this._mdf) {
this.convertEllToPath();
}
},
convertEllToPath: function () {
var p0 = this.p.v[0];
var p1 = this.p.v[1];
var s0 = this.s.v[0] / 2;
var s1 = this.s.v[1] / 2;
var _cw = this.d !== 3;
var _v = this.v;
_v.v[0][0] = p0;
_v.v[0][1] = p1 - s1;
_v.v[1][0] = _cw ? p0 + s0 : p0 - s0;
_v.v[1][1] = p1;
_v.v[2][0] = p0;
_v.v[2][1] = p1 + s1;
_v.v[3][0] = _cw ? p0 - s0 : p0 + s0;
_v.v[3][1] = p1;
_v.i[0][0] = _cw ? p0 - s0 * cPoint : p0 + s0 * cPoint;
_v.i[0][1] = p1 - s1;
_v.i[1][0] = _cw ? p0 + s0 : p0 - s0;
_v.i[1][1] = p1 - s1 * cPoint;
_v.i[2][0] = _cw ? p0 + s0 * cPoint : p0 - s0 * cPoint;
_v.i[2][1] = p1 + s1;
_v.i[3][0] = _cw ? p0 - s0 : p0 + s0;
_v.i[3][1] = p1 + s1 * cPoint;
_v.o[0][0] = _cw ? p0 + s0 * cPoint : p0 - s0 * cPoint;
_v.o[0][1] = p1 - s1;
_v.o[1][0] = _cw ? p0 + s0 : p0 - s0;
_v.o[1][1] = p1 + s1 * cPoint;
_v.o[2][0] = _cw ? p0 - s0 * cPoint : p0 + s0 * cPoint;
_v.o[2][1] = p1 + s1;
_v.o[3][0] = _cw ? p0 - s0 : p0 + s0;
_v.o[3][1] = p1 - s1 * cPoint;
},
};
extendPrototype([DynamicPropertyContainer], EllShapePropertyFactory);
return EllShapePropertyFactory;
}());
var StarShapeProperty = (function () {
function StarShapePropertyFactory(elem, data) {
this.v = shapePool.newElement();
this.v.setPathData(true, 0);
this.elem = elem;
this.comp = elem.comp;
this.data = data;
this.frameId = -1;
this.d = data.d;
this.initDynamicPropertyContainer(elem);
if (data.sy === 1) {
this.ir = PropertyFactory.getProp(elem, data.ir, 0, 0, this);
this.is = PropertyFactory.getProp(elem, data.is, 0, 0.01, this);
this.convertToPath = this.convertStarToPath;
} else {
this.convertToPath = this.convertPolygonToPath;
}
this.pt = PropertyFactory.getProp(elem, data.pt, 0, 0, this);
this.p = PropertyFactory.getProp(elem, data.p, 1, 0, this);
this.r = PropertyFactory.getProp(elem, data.r, 0, degToRads, this);
this.or = PropertyFactory.getProp(elem, data.or, 0, 0, this);
this.os = PropertyFactory.getProp(elem, data.os, 0, 0.01, this);
this.localShapeCollection = shapeCollectionPool.newShapeCollection();
this.localShapeCollection.addShape(this.v);
this.paths = this.localShapeCollection;
if (this.dynamicProperties.length) {
this.k = true;
} else {
this.k = false;
this.convertToPath();
}
}
StarShapePropertyFactory.prototype = {
reset: resetShape,
getValue: function () {
if (this.elem.globalData.frameId === this.frameId) {
return;
}
this.frameId = this.elem.globalData.frameId;
this.iterateDynamicProperties();
if (this._mdf) {
this.convertToPath();
}
},
convertStarToPath: function () {
var numPts = Math.floor(this.pt.v) * 2;
var angle = (Math.PI * 2) / numPts;
/* this.v.v.length = numPts;
this.v.i.length = numPts;
this.v.o.length = numPts; */
var longFlag = true;
var longRad = this.or.v;
var shortRad = this.ir.v;
var longRound = this.os.v;
var shortRound = this.is.v;
var longPerimSegment = (2 * Math.PI * longRad) / (numPts * 2);
var shortPerimSegment = (2 * Math.PI * shortRad) / (numPts * 2);
var i;
var rad;
var roundness;
var perimSegment;
var currentAng = -Math.PI / 2;
currentAng += this.r.v;
var dir = this.data.d === 3 ? -1 : 1;
this.v._length = 0;
for (i = 0; i < numPts; i += 1) {
rad = longFlag ? longRad : shortRad;
roundness = longFlag ? longRound : shortRound;
perimSegment = longFlag ? longPerimSegment : shortPerimSegment;
var x = rad * Math.cos(currentAng);
var y = rad * Math.sin(currentAng);
var ox = x === 0 && y === 0 ? 0 : y / Math.sqrt(x * x + y * y);
var oy = x === 0 && y === 0 ? 0 : -x / Math.sqrt(x * x + y * y);
x += +this.p.v[0];
y += +this.p.v[1];
this.v.setTripleAt(x, y, x - ox * perimSegment * roundness * dir, y - oy * perimSegment * roundness * dir, x + ox * perimSegment * roundness * dir, y + oy * perimSegment * roundness * dir, i, true);
/* this.v.v[i] = [x,y];
this.v.i[i] = [x+ox*perimSegment*roundness*dir,y+oy*perimSegment*roundness*dir];
this.v.o[i] = [x-ox*perimSegment*roundness*dir,y-oy*perimSegment*roundness*dir];
this.v._length = numPts; */
longFlag = !longFlag;
currentAng += angle * dir;
}
},
convertPolygonToPath: function () {
var numPts = Math.floor(this.pt.v);
var angle = (Math.PI * 2) / numPts;
var rad = this.or.v;
var roundness = this.os.v;
var perimSegment = (2 * Math.PI * rad) / (numPts * 4);
var i;
var currentAng = -Math.PI * 0.5;
var dir = this.data.d === 3 ? -1 : 1;
currentAng += this.r.v;
this.v._length = 0;
for (i = 0; i < numPts; i += 1) {
var x = rad * Math.cos(currentAng);
var y = rad * Math.sin(currentAng);
var ox = x === 0 && y === 0 ? 0 : y / Math.sqrt(x * x + y * y);
var oy = x === 0 && y === 0 ? 0 : -x / Math.sqrt(x * x + y * y);
x += +this.p.v[0];
y += +this.p.v[1];
this.v.setTripleAt(x, y, x - ox * perimSegment * roundness * dir, y - oy * perimSegment * roundness * dir, x + ox * perimSegment * roundness * dir, y + oy * perimSegment * roundness * dir, i, true);
currentAng += angle * dir;
}
this.paths.length = 0;
this.paths[0] = this.v;
},
};
extendPrototype([DynamicPropertyContainer], StarShapePropertyFactory);
return StarShapePropertyFactory;
}());
var RectShapeProperty = (function () {
function RectShapePropertyFactory(elem, data) {
this.v = shapePool.newElement();
this.v.c = true;
this.localShapeCollection = shapeCollectionPool.newShapeCollection();
this.localShapeCollection.addShape(this.v);
this.paths = this.localShapeCollection;
this.elem = elem;
this.comp = elem.comp;
this.frameId = -1;
this.d = data.d;
this.initDynamicPropertyContainer(elem);
this.p = PropertyFactory.getProp(elem, data.p, 1, 0, this);
this.s = PropertyFactory.getProp(elem, data.s, 1, 0, this);
this.r = PropertyFactory.getProp(elem, data.r, 0, 0, this);
if (this.dynamicProperties.length) {
this.k = true;
} else {
this.k = false;
this.convertRectToPath();
}
}
RectShapePropertyFactory.prototype = {
convertRectToPath: function () {
var p0 = this.p.v[0];
var p1 = this.p.v[1];
var v0 = this.s.v[0] / 2;
var v1 = this.s.v[1] / 2;
var round = bmMin(v0, v1, this.r.v);
var cPoint = round * (1 - roundCorner);
this.v._length = 0;
if (this.d === 2 || this.d === 1) {
this.v.setTripleAt(p0 + v0, p1 - v1 + round, p0 + v0, p1 - v1 + round, p0 + v0, p1 - v1 + cPoint, 0, true);
this.v.setTripleAt(p0 + v0, p1 + v1 - round, p0 + v0, p1 + v1 - cPoint, p0 + v0, p1 + v1 - round, 1, true);
if (round !== 0) {
this.v.setTripleAt(p0 + v0 - round, p1 + v1, p0 + v0 - round, p1 + v1, p0 + v0 - cPoint, p1 + v1, 2, true);
this.v.setTripleAt(p0 - v0 + round, p1 + v1, p0 - v0 + cPoint, p1 + v1, p0 - v0 + round, p1 + v1, 3, true);
this.v.setTripleAt(p0 - v0, p1 + v1 - round, p0 - v0, p1 + v1 - round, p0 - v0, p1 + v1 - cPoint, 4, true);
this.v.setTripleAt(p0 - v0, p1 - v1 + round, p0 - v0, p1 - v1 + cPoint, p0 - v0, p1 - v1 + round, 5, true);
this.v.setTripleAt(p0 - v0 + round, p1 - v1, p0 - v0 + round, p1 - v1, p0 - v0 + cPoint, p1 - v1, 6, true);
this.v.setTripleAt(p0 + v0 - round, p1 - v1, p0 + v0 - cPoint, p1 - v1, p0 + v0 - round, p1 - v1, 7, true);
} else {
this.v.setTripleAt(p0 - v0, p1 + v1, p0 - v0 + cPoint, p1 + v1, p0 - v0, p1 + v1, 2);
this.v.setTripleAt(p0 - v0, p1 - v1, p0 - v0, p1 - v1 + cPoint, p0 - v0, p1 - v1, 3);
}
} else {
this.v.setTripleAt(p0 + v0, p1 - v1 + round, p0 + v0, p1 - v1 + cPoint, p0 + v0, p1 - v1 + round, 0, true);
if (round !== 0) {
this.v.setTripleAt(p0 + v0 - round, p1 - v1, p0 + v0 - round, p1 - v1, p0 + v0 - cPoint, p1 - v1, 1, true);
this.v.setTripleAt(p0 - v0 + round, p1 - v1, p0 - v0 + cPoint, p1 - v1, p0 - v0 + round, p1 - v1, 2, true);
this.v.setTripleAt(p0 - v0, p1 - v1 + round, p0 - v0, p1 - v1 + round, p0 - v0, p1 - v1 + cPoint, 3, true);
this.v.setTripleAt(p0 - v0, p1 + v1 - round, p0 - v0, p1 + v1 - cPoint, p0 - v0, p1 + v1 - round, 4, true);
this.v.setTripleAt(p0 - v0 + round, p1 + v1, p0 - v0 + round, p1 + v1, p0 - v0 + cPoint, p1 + v1, 5, true);
this.v.setTripleAt(p0 + v0 - round, p1 + v1, p0 + v0 - cPoint, p1 + v1, p0 + v0 - round, p1 + v1, 6, true);
this.v.setTripleAt(p0 + v0, p1 + v1 - round, p0 + v0, p1 + v1 - round, p0 + v0, p1 + v1 - cPoint, 7, true);
} else {
this.v.setTripleAt(p0 - v0, p1 - v1, p0 - v0 + cPoint, p1 - v1, p0 - v0, p1 - v1, 1, true);
this.v.setTripleAt(p0 - v0, p1 + v1, p0 - v0, p1 + v1 - cPoint, p0 - v0, p1 + v1, 2, true);
this.v.setTripleAt(p0 + v0, p1 + v1, p0 + v0 - cPoint, p1 + v1, p0 + v0, p1 + v1, 3, true);
}
}
},
getValue: function () {
if (this.elem.globalData.frameId === this.frameId) {
return;
}
this.frameId = this.elem.globalData.frameId;
this.iterateDynamicProperties();
if (this._mdf) {
this.convertRectToPath();
}
},
reset: resetShape,
};
extendPrototype([DynamicPropertyContainer], RectShapePropertyFactory);
return RectShapePropertyFactory;
}());
function getShapeProp(elem, data, type) {
var prop;
if (type === 3 || type === 4) {
var dataProp = type === 3 ? data.pt : data.ks;
var keys = dataProp.k;
if (keys.length) {
prop = new KeyframedShapeProperty(elem, data, type);
} else {
prop = new ShapeProperty(elem, data, type);
}
} else if (type === 5) {
prop = new RectShapeProperty(elem, data);
} else if (type === 6) {
prop = new EllShapeProperty(elem, data);
} else if (type === 7) {
prop = new StarShapeProperty(elem, data);
}
if (prop.k) {
elem.addDynamicProperty(prop);
}
return prop;
}
function getConstructorFunction() {
return ShapeProperty;
}
function getKeyframedConstructorFunction() {
return KeyframedShapeProperty;
}
var ob = {};
ob.getShapeProp = getShapeProp;
ob.getConstructorFunction = getConstructorFunction;
ob.getKeyframedConstructorFunction = getKeyframedConstructorFunction;
return ob;
}());
export default ShapePropertyFactory;

359
node_modules/lottie-web/player/js/utils/shapes/TrimModifier.js generated vendored Normal file
View File

@@ -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;

174
node_modules/lottie-web/player/js/utils/shapes/ZigZagModifier.js generated vendored Normal file
View File

@@ -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;

20
node_modules/lottie-web/player/js/utils/shapes/shapePathBuilder.js generated vendored Normal file
View File

@@ -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;

60
node_modules/lottie-web/player/js/utils/text/LetterProps.js generated vendored Normal file
View File

@@ -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;

34
node_modules/lottie-web/player/js/utils/text/TextAnimatorDataProperty.js generated vendored Normal file
View File

@@ -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;

610
node_modules/lottie-web/player/js/utils/text/TextAnimatorProperty.js generated vendored Normal file
View File

@@ -0,0 +1,610 @@
import {
addSaturationToRGB,
addBrightnessToRGB,
addHueToRGB,
} from '../common';
import {
extendPrototype,
} from '../functionExtensions';
import DynamicPropertyContainer from '../helpers/dynamicProperties';
import {
createSizedArray,
} from '../helpers/arrays';
import PropertyFactory from '../PropertyFactory';
import bez from '../bez';
import Matrix from '../../3rd_party/transformation-matrix';
import TextAnimatorDataProperty from './TextAnimatorDataProperty';
import LetterProps from './LetterProps';
function TextAnimatorProperty(textData, renderType, elem) {
this._isFirstFrame = true;
this._hasMaskedPath = false;
this._frameId = -1;
this._textData = textData;
this._renderType = renderType;
this._elem = elem;
this._animatorsData = createSizedArray(this._textData.a.length);
this._pathData = {};
this._moreOptions = {
alignment: {},
};
this.renderedLetters = [];
this.lettersChangedFlag = false;
this.initDynamicPropertyContainer(elem);
}
TextAnimatorProperty.prototype.searchProperties = function () {
var i;
var len = this._textData.a.length;
var animatorProps;
var getProp = PropertyFactory.getProp;
for (i = 0; i < len; i += 1) {
animatorProps = this._textData.a[i];
this._animatorsData[i] = new TextAnimatorDataProperty(this._elem, animatorProps, this);
}
if (this._textData.p && 'm' in this._textData.p) {
this._pathData = {
a: getProp(this._elem, this._textData.p.a, 0, 0, this),
f: getProp(this._elem, this._textData.p.f, 0, 0, this),
l: getProp(this._elem, this._textData.p.l, 0, 0, this),
r: getProp(this._elem, this._textData.p.r, 0, 0, this),
p: getProp(this._elem, this._textData.p.p, 0, 0, this),
m: this._elem.maskManager.getMaskProperty(this._textData.p.m),
};
this._hasMaskedPath = true;
} else {
this._hasMaskedPath = false;
}
this._moreOptions.alignment = getProp(this._elem, this._textData.m.a, 1, 0, this);
};
TextAnimatorProperty.prototype.getMeasures = function (documentData, lettersChangedFlag) {
this.lettersChangedFlag = lettersChangedFlag;
if (!this._mdf && !this._isFirstFrame && !lettersChangedFlag && (!this._hasMaskedPath || !this._pathData.m._mdf)) {
return;
}
this._isFirstFrame = false;
var alignment = this._moreOptions.alignment.v;
var animators = this._animatorsData;
var textData = this._textData;
var matrixHelper = this.mHelper;
var renderType = this._renderType;
var renderedLettersCount = this.renderedLetters.length;
var xPos;
var yPos;
var i;
var len;
var letters = documentData.l;
var pathInfo;
var currentLength;
var currentPoint;
var segmentLength;
var flag;
var pointInd;
var segmentInd;
var prevPoint;
var points;
var segments;
var partialLength;
var totalLength;
var perc;
var tanAngle;
var mask;
if (this._hasMaskedPath) {
mask = this._pathData.m;
if (!this._pathData.n || this._pathData._mdf) {
var paths = mask.v;
if (this._pathData.r.v) {
paths = paths.reverse();
}
// TODO: release bezier data cached from previous pathInfo: this._pathData.pi
pathInfo = {
tLength: 0,
segments: [],
};
len = paths._length - 1;
var bezierData;
totalLength = 0;
for (i = 0; i < len; i += 1) {
bezierData = bez.buildBezierData(paths.v[i],
paths.v[i + 1],
[paths.o[i][0] - paths.v[i][0], paths.o[i][1] - paths.v[i][1]],
[paths.i[i + 1][0] - paths.v[i + 1][0], paths.i[i + 1][1] - paths.v[i + 1][1]]);
pathInfo.tLength += bezierData.segmentLength;
pathInfo.segments.push(bezierData);
totalLength += bezierData.segmentLength;
}
i = len;
if (mask.v.c) {
bezierData = bez.buildBezierData(paths.v[i],
paths.v[0],
[paths.o[i][0] - paths.v[i][0], paths.o[i][1] - paths.v[i][1]],
[paths.i[0][0] - paths.v[0][0], paths.i[0][1] - paths.v[0][1]]);
pathInfo.tLength += bezierData.segmentLength;
pathInfo.segments.push(bezierData);
totalLength += bezierData.segmentLength;
}
this._pathData.pi = pathInfo;
}
pathInfo = this._pathData.pi;
currentLength = this._pathData.f.v;
segmentInd = 0;
pointInd = 1;
segmentLength = 0;
flag = true;
segments = pathInfo.segments;
if (currentLength < 0 && mask.v.c) {
if (pathInfo.tLength < Math.abs(currentLength)) {
currentLength = -Math.abs(currentLength) % pathInfo.tLength;
}
segmentInd = segments.length - 1;
points = segments[segmentInd].points;
pointInd = points.length - 1;
while (currentLength < 0) {
currentLength += points[pointInd].partialLength;
pointInd -= 1;
if (pointInd < 0) {
segmentInd -= 1;
points = segments[segmentInd].points;
pointInd = points.length - 1;
}
}
}
points = segments[segmentInd].points;
prevPoint = points[pointInd - 1];
currentPoint = points[pointInd];
partialLength = currentPoint.partialLength;
}
len = letters.length;
xPos = 0;
yPos = 0;
var yOff = documentData.finalSize * 1.2 * 0.714;
var firstLine = true;
var animatorProps;
var animatorSelector;
var j;
var jLen;
var letterValue;
jLen = animators.length;
var mult;
var ind = -1;
var offf;
var xPathPos;
var yPathPos;
var initPathPos = currentLength;
var initSegmentInd = segmentInd;
var initPointInd = pointInd;
var currentLine = -1;
var elemOpacity;
var sc;
var sw;
var fc;
var k;
var letterSw;
var letterSc;
var letterFc;
var letterM = '';
var letterP = this.defaultPropsArray;
var letterO;
//
if (documentData.j === 2 || documentData.j === 1) {
var animatorJustifyOffset = 0;
var animatorFirstCharOffset = 0;
var justifyOffsetMult = documentData.j === 2 ? -0.5 : -1;
var lastIndex = 0;
var isNewLine = true;
for (i = 0; i < len; i += 1) {
if (letters[i].n) {
if (animatorJustifyOffset) {
animatorJustifyOffset += animatorFirstCharOffset;
}
while (lastIndex < i) {
letters[lastIndex].animatorJustifyOffset = animatorJustifyOffset;
lastIndex += 1;
}
animatorJustifyOffset = 0;
isNewLine = true;
} else {
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
if (animatorProps.t.propType) {
if (isNewLine && documentData.j === 2) {
animatorFirstCharOffset += animatorProps.t.v * justifyOffsetMult;
}
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (mult.length) {
animatorJustifyOffset += animatorProps.t.v * mult[0] * justifyOffsetMult;
} else {
animatorJustifyOffset += animatorProps.t.v * mult * justifyOffsetMult;
}
}
}
isNewLine = false;
}
}
if (animatorJustifyOffset) {
animatorJustifyOffset += animatorFirstCharOffset;
}
while (lastIndex < i) {
letters[lastIndex].animatorJustifyOffset = animatorJustifyOffset;
lastIndex += 1;
}
}
//
for (i = 0; i < len; i += 1) {
matrixHelper.reset();
elemOpacity = 1;
if (letters[i].n) {
xPos = 0;
yPos += documentData.yOffset;
yPos += firstLine ? 1 : 0;
currentLength = initPathPos;
firstLine = false;
if (this._hasMaskedPath) {
segmentInd = initSegmentInd;
pointInd = initPointInd;
points = segments[segmentInd].points;
prevPoint = points[pointInd - 1];
currentPoint = points[pointInd];
partialLength = currentPoint.partialLength;
segmentLength = 0;
}
letterM = '';
letterFc = '';
letterSw = '';
letterO = '';
letterP = this.defaultPropsArray;
} else {
if (this._hasMaskedPath) {
if (currentLine !== letters[i].line) {
switch (documentData.j) {
case 1:
currentLength += totalLength - documentData.lineWidths[letters[i].line];
break;
case 2:
currentLength += (totalLength - documentData.lineWidths[letters[i].line]) / 2;
break;
default:
break;
}
currentLine = letters[i].line;
}
if (ind !== letters[i].ind) {
if (letters[ind]) {
currentLength += letters[ind].extra;
}
currentLength += letters[i].an / 2;
ind = letters[i].ind;
}
currentLength += (alignment[0] * letters[i].an) * 0.005;
var animatorOffset = 0;
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
if (animatorProps.p.propType) {
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (mult.length) {
animatorOffset += animatorProps.p.v[0] * mult[0];
} else {
animatorOffset += animatorProps.p.v[0] * mult;
}
}
if (animatorProps.a.propType) {
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (mult.length) {
animatorOffset += animatorProps.a.v[0] * mult[0];
} else {
animatorOffset += animatorProps.a.v[0] * mult;
}
}
}
flag = true;
// Force alignment only works with a single line for now
if (this._pathData.a.v) {
currentLength = letters[0].an * 0.5 + ((totalLength - this._pathData.f.v - letters[0].an * 0.5 - letters[letters.length - 1].an * 0.5) * ind) / (len - 1);
currentLength += this._pathData.f.v;
}
while (flag) {
if (segmentLength + partialLength >= currentLength + animatorOffset || !points) {
perc = (currentLength + animatorOffset - segmentLength) / currentPoint.partialLength;
xPathPos = prevPoint.point[0] + (currentPoint.point[0] - prevPoint.point[0]) * perc;
yPathPos = prevPoint.point[1] + (currentPoint.point[1] - prevPoint.point[1]) * perc;
matrixHelper.translate((-alignment[0] * letters[i].an) * 0.005, -(alignment[1] * yOff) * 0.01);
flag = false;
} else if (points) {
segmentLength += currentPoint.partialLength;
pointInd += 1;
if (pointInd >= points.length) {
pointInd = 0;
segmentInd += 1;
if (!segments[segmentInd]) {
if (mask.v.c) {
pointInd = 0;
segmentInd = 0;
points = segments[segmentInd].points;
} else {
segmentLength -= currentPoint.partialLength;
points = null;
}
} else {
points = segments[segmentInd].points;
}
}
if (points) {
prevPoint = currentPoint;
currentPoint = points[pointInd];
partialLength = currentPoint.partialLength;
}
}
}
offf = letters[i].an / 2 - letters[i].add;
matrixHelper.translate(-offf, 0, 0);
} else {
offf = letters[i].an / 2 - letters[i].add;
matrixHelper.translate(-offf, 0, 0);
// Grouping alignment
matrixHelper.translate((-alignment[0] * letters[i].an) * 0.005, (-alignment[1] * yOff) * 0.01, 0);
}
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
if (animatorProps.t.propType) {
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
// This condition is to prevent applying tracking to first character in each line. Might be better to use a boolean "isNewLine"
if (xPos !== 0 || documentData.j !== 0) {
if (this._hasMaskedPath) {
if (mult.length) {
currentLength += animatorProps.t.v * mult[0];
} else {
currentLength += animatorProps.t.v * mult;
}
} else if (mult.length) {
xPos += animatorProps.t.v * mult[0];
} else {
xPos += animatorProps.t.v * mult;
}
}
}
}
if (documentData.strokeWidthAnim) {
sw = documentData.sw || 0;
}
if (documentData.strokeColorAnim) {
if (documentData.sc) {
sc = [documentData.sc[0], documentData.sc[1], documentData.sc[2]];
} else {
sc = [0, 0, 0];
}
}
if (documentData.fillColorAnim && documentData.fc) {
fc = [documentData.fc[0], documentData.fc[1], documentData.fc[2]];
}
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
if (animatorProps.a.propType) {
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (mult.length) {
matrixHelper.translate(-animatorProps.a.v[0] * mult[0], -animatorProps.a.v[1] * mult[1], animatorProps.a.v[2] * mult[2]);
} else {
matrixHelper.translate(-animatorProps.a.v[0] * mult, -animatorProps.a.v[1] * mult, animatorProps.a.v[2] * mult);
}
}
}
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
if (animatorProps.s.propType) {
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (mult.length) {
matrixHelper.scale(1 + ((animatorProps.s.v[0] - 1) * mult[0]), 1 + ((animatorProps.s.v[1] - 1) * mult[1]), 1);
} else {
matrixHelper.scale(1 + ((animatorProps.s.v[0] - 1) * mult), 1 + ((animatorProps.s.v[1] - 1) * mult), 1);
}
}
}
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (animatorProps.sk.propType) {
if (mult.length) {
matrixHelper.skewFromAxis(-animatorProps.sk.v * mult[0], animatorProps.sa.v * mult[1]);
} else {
matrixHelper.skewFromAxis(-animatorProps.sk.v * mult, animatorProps.sa.v * mult);
}
}
if (animatorProps.r.propType) {
if (mult.length) {
matrixHelper.rotateZ(-animatorProps.r.v * mult[2]);
} else {
matrixHelper.rotateZ(-animatorProps.r.v * mult);
}
}
if (animatorProps.ry.propType) {
if (mult.length) {
matrixHelper.rotateY(animatorProps.ry.v * mult[1]);
} else {
matrixHelper.rotateY(animatorProps.ry.v * mult);
}
}
if (animatorProps.rx.propType) {
if (mult.length) {
matrixHelper.rotateX(animatorProps.rx.v * mult[0]);
} else {
matrixHelper.rotateX(animatorProps.rx.v * mult);
}
}
if (animatorProps.o.propType) {
if (mult.length) {
elemOpacity += ((animatorProps.o.v) * mult[0] - elemOpacity) * mult[0];
} else {
elemOpacity += ((animatorProps.o.v) * mult - elemOpacity) * mult;
}
}
if (documentData.strokeWidthAnim && animatorProps.sw.propType) {
if (mult.length) {
sw += animatorProps.sw.v * mult[0];
} else {
sw += animatorProps.sw.v * mult;
}
}
if (documentData.strokeColorAnim && animatorProps.sc.propType) {
for (k = 0; k < 3; k += 1) {
if (mult.length) {
sc[k] += (animatorProps.sc.v[k] - sc[k]) * mult[0];
} else {
sc[k] += (animatorProps.sc.v[k] - sc[k]) * mult;
}
}
}
if (documentData.fillColorAnim && documentData.fc) {
if (animatorProps.fc.propType) {
for (k = 0; k < 3; k += 1) {
if (mult.length) {
fc[k] += (animatorProps.fc.v[k] - fc[k]) * mult[0];
} else {
fc[k] += (animatorProps.fc.v[k] - fc[k]) * mult;
}
}
}
if (animatorProps.fh.propType) {
if (mult.length) {
fc = addHueToRGB(fc, animatorProps.fh.v * mult[0]);
} else {
fc = addHueToRGB(fc, animatorProps.fh.v * mult);
}
}
if (animatorProps.fs.propType) {
if (mult.length) {
fc = addSaturationToRGB(fc, animatorProps.fs.v * mult[0]);
} else {
fc = addSaturationToRGB(fc, animatorProps.fs.v * mult);
}
}
if (animatorProps.fb.propType) {
if (mult.length) {
fc = addBrightnessToRGB(fc, animatorProps.fb.v * mult[0]);
} else {
fc = addBrightnessToRGB(fc, animatorProps.fb.v * mult);
}
}
}
}
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
if (animatorProps.p.propType) {
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (this._hasMaskedPath) {
if (mult.length) {
matrixHelper.translate(0, animatorProps.p.v[1] * mult[0], -animatorProps.p.v[2] * mult[1]);
} else {
matrixHelper.translate(0, animatorProps.p.v[1] * mult, -animatorProps.p.v[2] * mult);
}
} else if (mult.length) {
matrixHelper.translate(animatorProps.p.v[0] * mult[0], animatorProps.p.v[1] * mult[1], -animatorProps.p.v[2] * mult[2]);
} else {
matrixHelper.translate(animatorProps.p.v[0] * mult, animatorProps.p.v[1] * mult, -animatorProps.p.v[2] * mult);
}
}
}
if (documentData.strokeWidthAnim) {
letterSw = sw < 0 ? 0 : sw;
}
if (documentData.strokeColorAnim) {
letterSc = 'rgb(' + Math.round(sc[0] * 255) + ',' + Math.round(sc[1] * 255) + ',' + Math.round(sc[2] * 255) + ')';
}
if (documentData.fillColorAnim && documentData.fc) {
letterFc = 'rgb(' + Math.round(fc[0] * 255) + ',' + Math.round(fc[1] * 255) + ',' + Math.round(fc[2] * 255) + ')';
}
if (this._hasMaskedPath) {
matrixHelper.translate(0, -documentData.ls);
matrixHelper.translate(0, (alignment[1] * yOff) * 0.01 + yPos, 0);
if (this._pathData.p.v) {
tanAngle = (currentPoint.point[1] - prevPoint.point[1]) / (currentPoint.point[0] - prevPoint.point[0]);
var rot = (Math.atan(tanAngle) * 180) / Math.PI;
if (currentPoint.point[0] < prevPoint.point[0]) {
rot += 180;
}
matrixHelper.rotate((-rot * Math.PI) / 180);
}
matrixHelper.translate(xPathPos, yPathPos, 0);
currentLength -= (alignment[0] * letters[i].an) * 0.005;
if (letters[i + 1] && ind !== letters[i + 1].ind) {
currentLength += letters[i].an / 2;
currentLength += (documentData.tr * 0.001) * documentData.finalSize;
}
} else {
matrixHelper.translate(xPos, yPos, 0);
if (documentData.ps) {
// matrixHelper.translate(documentData.ps[0],documentData.ps[1],0);
matrixHelper.translate(documentData.ps[0], documentData.ps[1] + documentData.ascent, 0);
}
switch (documentData.j) {
case 1:
matrixHelper.translate(letters[i].animatorJustifyOffset + documentData.justifyOffset + (documentData.boxWidth - documentData.lineWidths[letters[i].line]), 0, 0);
break;
case 2:
matrixHelper.translate(letters[i].animatorJustifyOffset + documentData.justifyOffset + (documentData.boxWidth - documentData.lineWidths[letters[i].line]) / 2, 0, 0);
break;
default:
break;
}
matrixHelper.translate(0, -documentData.ls);
matrixHelper.translate(offf, 0, 0);
matrixHelper.translate((alignment[0] * letters[i].an) * 0.005, (alignment[1] * yOff) * 0.01, 0);
xPos += letters[i].l + (documentData.tr * 0.001) * documentData.finalSize;
}
if (renderType === 'html') {
letterM = matrixHelper.toCSS();
} else if (renderType === 'svg') {
letterM = matrixHelper.to2dCSS();
} else {
letterP = [matrixHelper.props[0], matrixHelper.props[1], matrixHelper.props[2], matrixHelper.props[3], matrixHelper.props[4], matrixHelper.props[5], matrixHelper.props[6], matrixHelper.props[7], matrixHelper.props[8], matrixHelper.props[9], matrixHelper.props[10], matrixHelper.props[11], matrixHelper.props[12], matrixHelper.props[13], matrixHelper.props[14], matrixHelper.props[15]];
}
letterO = elemOpacity;
}
if (renderedLettersCount <= i) {
letterValue = new LetterProps(letterO, letterSw, letterSc, letterFc, letterM, letterP);
this.renderedLetters.push(letterValue);
renderedLettersCount += 1;
this.lettersChangedFlag = true;
} else {
letterValue = this.renderedLetters[i];
this.lettersChangedFlag = letterValue.update(letterO, letterSw, letterSc, letterFc, letterM, letterP) || this.lettersChangedFlag;
}
}
};
TextAnimatorProperty.prototype.getValue = function () {
if (this._elem.globalData.frameId === this._frameId) {
return;
}
this._frameId = this._elem.globalData.frameId;
this.iterateDynamicProperties();
};
TextAnimatorProperty.prototype.mHelper = new Matrix();
TextAnimatorProperty.prototype.defaultPropsArray = [];
extendPrototype([DynamicPropertyContainer], TextAnimatorProperty);
export default TextAnimatorProperty;

461
node_modules/lottie-web/player/js/utils/text/TextProperty.js generated vendored Normal file
View File

@@ -0,0 +1,461 @@
import {
initialDefaultFrame,
} from '../../main';
import getFontProperties from '../getFontProperties';
import FontManager from '../FontManager';
function TextProperty(elem, data) {
this._frameId = initialDefaultFrame;
this.pv = '';
this.v = '';
this.kf = false;
this._isFirstFrame = true;
this._mdf = false;
if (data.d && data.d.sid) {
data.d = elem.globalData.slotManager.getProp(data.d);
}
this.data = data;
this.elem = elem;
this.comp = this.elem.comp;
this.keysIndex = 0;
this.canResize = false;
this.minimumFontSize = 1;
this.effectsSequence = [];
this.currentData = {
ascent: 0,
boxWidth: this.defaultBoxWidth,
f: '',
fStyle: '',
fWeight: '',
fc: '',
j: '',
justifyOffset: '',
l: [],
lh: 0,
lineWidths: [],
ls: '',
of: '',
s: '',
sc: '',
sw: 0,
t: 0,
tr: 0,
sz: 0,
ps: null,
fillColorAnim: false,
strokeColorAnim: false,
strokeWidthAnim: false,
yOffset: 0,
finalSize: 0,
finalText: [],
finalLineHeight: 0,
__complete: false,
};
this.copyData(this.currentData, this.data.d.k[0].s);
if (!this.searchProperty()) {
this.completeTextData(this.currentData);
}
}
TextProperty.prototype.defaultBoxWidth = [0, 0];
TextProperty.prototype.copyData = function (obj, data) {
for (var s in data) {
if (Object.prototype.hasOwnProperty.call(data, s)) {
obj[s] = data[s];
}
}
return obj;
};
TextProperty.prototype.setCurrentData = function (data) {
if (!data.__complete) {
this.completeTextData(data);
}
this.currentData = data;
this.currentData.boxWidth = this.currentData.boxWidth || this.defaultBoxWidth;
this._mdf = true;
};
TextProperty.prototype.searchProperty = function () {
return this.searchKeyframes();
};
TextProperty.prototype.searchKeyframes = function () {
this.kf = this.data.d.k.length > 1;
if (this.kf) {
this.addEffect(this.getKeyframeValue.bind(this));
}
return this.kf;
};
TextProperty.prototype.addEffect = function (effectFunction) {
this.effectsSequence.push(effectFunction);
this.elem.addDynamicProperty(this);
};
TextProperty.prototype.getValue = function (_finalValue) {
if ((this.elem.globalData.frameId === this.frameId || !this.effectsSequence.length) && !_finalValue) {
return;
}
this.currentData.t = this.data.d.k[this.keysIndex].s.t;
var currentValue = this.currentData;
var currentIndex = this.keysIndex;
if (this.lock) {
this.setCurrentData(this.currentData);
return;
}
this.lock = true;
this._mdf = false;
var i; var
len = this.effectsSequence.length;
var finalValue = _finalValue || this.data.d.k[this.keysIndex].s;
for (i = 0; i < len; i += 1) {
// Checking if index changed to prevent creating a new object every time the expression updates.
if (currentIndex !== this.keysIndex) {
finalValue = this.effectsSequence[i](finalValue, finalValue.t);
} else {
finalValue = this.effectsSequence[i](this.currentData, finalValue.t);
}
}
if (currentValue !== finalValue) {
this.setCurrentData(finalValue);
}
this.v = this.currentData;
this.pv = this.v;
this.lock = false;
this.frameId = this.elem.globalData.frameId;
};
TextProperty.prototype.getKeyframeValue = function () {
var textKeys = this.data.d.k;
var frameNum = this.elem.comp.renderedFrame;
var i = 0; var
len = textKeys.length;
while (i <= len - 1) {
if (i === len - 1 || textKeys[i + 1].t > frameNum) {
break;
}
i += 1;
}
if (this.keysIndex !== i) {
this.keysIndex = i;
}
return this.data.d.k[this.keysIndex].s;
};
TextProperty.prototype.buildFinalText = function (text) {
var charactersArray = [];
var i = 0;
var len = text.length;
var charCode;
var secondCharCode;
var shouldCombine = false;
var shouldCombineNext = false;
var currentChars = '';
while (i < len) {
shouldCombine = shouldCombineNext;
shouldCombineNext = false;
charCode = text.charCodeAt(i);
currentChars = text.charAt(i);
if (FontManager.isCombinedCharacter(charCode)) {
shouldCombine = true;
// It's a potential surrogate pair (this is the High surrogate)
} else if (charCode >= 0xD800 && charCode <= 0xDBFF) {
if (FontManager.isRegionalFlag(text, i)) {
currentChars = text.substr(i, 14);
} else {
secondCharCode = text.charCodeAt(i + 1);
// It's a surrogate pair (this is the Low surrogate)
if (secondCharCode >= 0xDC00 && secondCharCode <= 0xDFFF) {
if (FontManager.isModifier(charCode, secondCharCode)) {
currentChars = text.substr(i, 2);
shouldCombine = true;
} else if (FontManager.isFlagEmoji(text.substr(i, 4))) {
currentChars = text.substr(i, 4);
} else {
currentChars = text.substr(i, 2);
}
}
}
} else if (charCode > 0xDBFF) {
secondCharCode = text.charCodeAt(i + 1);
if (FontManager.isVariationSelector(charCode)) {
shouldCombine = true;
}
} else if (FontManager.isZeroWidthJoiner(charCode)) {
shouldCombine = true;
shouldCombineNext = true;
}
if (shouldCombine) {
charactersArray[charactersArray.length - 1] += currentChars;
shouldCombine = false;
} else {
charactersArray.push(currentChars);
}
i += currentChars.length;
}
return charactersArray;
};
TextProperty.prototype.completeTextData = function (documentData) {
documentData.__complete = true;
var fontManager = this.elem.globalData.fontManager;
var data = this.data;
var letters = [];
var i; var
len;
var newLineFlag; var index = 0; var
val;
var anchorGrouping = data.m.g;
var currentSize = 0; var currentPos = 0; var currentLine = 0; var
lineWidths = [];
var lineWidth = 0;
var maxLineWidth = 0;
var j; var
jLen;
var fontData = fontManager.getFontByName(documentData.f);
var charData; var
cLength = 0;
var fontProps = getFontProperties(fontData);
documentData.fWeight = fontProps.weight;
documentData.fStyle = fontProps.style;
documentData.finalSize = documentData.s;
documentData.finalText = this.buildFinalText(documentData.t);
len = documentData.finalText.length;
documentData.finalLineHeight = documentData.lh;
var trackingOffset = (documentData.tr / 1000) * documentData.finalSize;
var charCode;
if (documentData.sz) {
var flag = true;
var boxWidth = documentData.sz[0];
var boxHeight = documentData.sz[1];
var currentHeight; var
finalText;
while (flag) {
finalText = this.buildFinalText(documentData.t);
currentHeight = 0;
lineWidth = 0;
len = finalText.length;
trackingOffset = (documentData.tr / 1000) * documentData.finalSize;
var lastSpaceIndex = -1;
for (i = 0; i < len; i += 1) {
charCode = finalText[i].charCodeAt(0);
newLineFlag = false;
if (finalText[i] === ' ') {
lastSpaceIndex = i;
} else if (charCode === 13 || charCode === 3) {
lineWidth = 0;
newLineFlag = true;
currentHeight += documentData.finalLineHeight || documentData.finalSize * 1.2;
}
if (fontManager.chars) {
charData = fontManager.getCharData(finalText[i], fontData.fStyle, fontData.fFamily);
cLength = newLineFlag ? 0 : (charData.w * documentData.finalSize) / 100;
} else {
// tCanvasHelper.font = documentData.s + 'px '+ fontData.fFamily;
cLength = fontManager.measureText(finalText[i], documentData.f, documentData.finalSize);
}
if (lineWidth + cLength > boxWidth && finalText[i] !== ' ') {
if (lastSpaceIndex === -1) {
len += 1;
} else {
i = lastSpaceIndex;
}
currentHeight += documentData.finalLineHeight || documentData.finalSize * 1.2;
finalText.splice(i, lastSpaceIndex === i ? 1 : 0, '\r');
// finalText = finalText.substr(0,i) + "\r" + finalText.substr(i === lastSpaceIndex ? i + 1 : i);
lastSpaceIndex = -1;
lineWidth = 0;
} else {
lineWidth += cLength;
lineWidth += trackingOffset;
}
}
currentHeight += (fontData.ascent * documentData.finalSize) / 100;
if (this.canResize && documentData.finalSize > this.minimumFontSize && boxHeight < currentHeight) {
documentData.finalSize -= 1;
documentData.finalLineHeight = (documentData.finalSize * documentData.lh) / documentData.s;
} else {
documentData.finalText = finalText;
len = documentData.finalText.length;
flag = false;
}
}
}
lineWidth = -trackingOffset;
cLength = 0;
var uncollapsedSpaces = 0;
var currentChar;
for (i = 0; i < len; i += 1) {
newLineFlag = false;
currentChar = documentData.finalText[i];
charCode = currentChar.charCodeAt(0);
if (charCode === 13 || charCode === 3) {
uncollapsedSpaces = 0;
lineWidths.push(lineWidth);
maxLineWidth = lineWidth > maxLineWidth ? lineWidth : maxLineWidth;
lineWidth = -2 * trackingOffset;
val = '';
newLineFlag = true;
currentLine += 1;
} else {
val = currentChar;
}
if (fontManager.chars) {
charData = fontManager.getCharData(currentChar, fontData.fStyle, fontManager.getFontByName(documentData.f).fFamily);
cLength = newLineFlag ? 0 : (charData.w * documentData.finalSize) / 100;
} else {
// var charWidth = fontManager.measureText(val, documentData.f, documentData.finalSize);
// tCanvasHelper.font = documentData.finalSize + 'px '+ fontManager.getFontByName(documentData.f).fFamily;
cLength = fontManager.measureText(val, documentData.f, documentData.finalSize);
}
//
if (currentChar === ' ') {
uncollapsedSpaces += cLength + trackingOffset;
} else {
lineWidth += cLength + trackingOffset + uncollapsedSpaces;
uncollapsedSpaces = 0;
}
letters.push({
l: cLength, an: cLength, add: currentSize, n: newLineFlag, anIndexes: [], val: val, line: currentLine, animatorJustifyOffset: 0,
});
if (anchorGrouping == 2) { // eslint-disable-line eqeqeq
currentSize += cLength;
if (val === '' || val === ' ' || i === len - 1) {
if (val === '' || val === ' ') {
currentSize -= cLength;
}
while (currentPos <= i) {
letters[currentPos].an = currentSize;
letters[currentPos].ind = index;
letters[currentPos].extra = cLength;
currentPos += 1;
}
index += 1;
currentSize = 0;
}
} else if (anchorGrouping == 3) { // eslint-disable-line eqeqeq
currentSize += cLength;
if (val === '' || i === len - 1) {
if (val === '') {
currentSize -= cLength;
}
while (currentPos <= i) {
letters[currentPos].an = currentSize;
letters[currentPos].ind = index;
letters[currentPos].extra = cLength;
currentPos += 1;
}
currentSize = 0;
index += 1;
}
} else {
letters[index].ind = index;
letters[index].extra = 0;
index += 1;
}
}
documentData.l = letters;
maxLineWidth = lineWidth > maxLineWidth ? lineWidth : maxLineWidth;
lineWidths.push(lineWidth);
if (documentData.sz) {
documentData.boxWidth = documentData.sz[0];
documentData.justifyOffset = 0;
} else {
documentData.boxWidth = maxLineWidth;
switch (documentData.j) {
case 1:
documentData.justifyOffset = -documentData.boxWidth;
break;
case 2:
documentData.justifyOffset = -documentData.boxWidth / 2;
break;
default:
documentData.justifyOffset = 0;
}
}
documentData.lineWidths = lineWidths;
var animators = data.a; var animatorData; var
letterData;
jLen = animators.length;
var based; var ind; var
indexes = [];
for (j = 0; j < jLen; j += 1) {
animatorData = animators[j];
if (animatorData.a.sc) {
documentData.strokeColorAnim = true;
}
if (animatorData.a.sw) {
documentData.strokeWidthAnim = true;
}
if (animatorData.a.fc || animatorData.a.fh || animatorData.a.fs || animatorData.a.fb) {
documentData.fillColorAnim = true;
}
ind = 0;
based = animatorData.s.b;
for (i = 0; i < len; i += 1) {
letterData = letters[i];
letterData.anIndexes[j] = ind;
if ((based == 1 && letterData.val !== '') || (based == 2 && letterData.val !== '' && letterData.val !== ' ') || (based == 3 && (letterData.n || letterData.val == ' ' || i == len - 1)) || (based == 4 && (letterData.n || i == len - 1))) { // eslint-disable-line eqeqeq
if (animatorData.s.rn === 1) {
indexes.push(ind);
}
ind += 1;
}
}
data.a[j].s.totalChars = ind;
var currentInd = -1; var
newInd;
if (animatorData.s.rn === 1) {
for (i = 0; i < len; i += 1) {
letterData = letters[i];
if (currentInd != letterData.anIndexes[j]) { // eslint-disable-line eqeqeq
currentInd = letterData.anIndexes[j];
newInd = indexes.splice(Math.floor(Math.random() * indexes.length), 1)[0];
}
letterData.anIndexes[j] = newInd;
}
}
}
documentData.yOffset = documentData.finalLineHeight || documentData.finalSize * 1.2;
documentData.ls = documentData.ls || 0;
documentData.ascent = (fontData.ascent * documentData.finalSize) / 100;
};
TextProperty.prototype.updateDocumentData = function (newData, index) {
index = index === undefined ? this.keysIndex : index;
var dData = this.copyData({}, this.data.d.k[index].s);
dData = this.copyData(dData, newData);
this.data.d.k[index].s = dData;
this.recalculate(index);
this.setCurrentData(dData);
this.elem.addDynamicProperty(this);
};
TextProperty.prototype.recalculate = function (index) {
var dData = this.data.d.k[index].s;
dData.__complete = false;
this.keysIndex = 0;
this._isFirstFrame = true;
this.getValue(dData);
};
TextProperty.prototype.canResizeFont = function (_canResize) {
this.canResize = _canResize;
this.recalculate(this.keysIndex);
this.elem.addDynamicProperty(this);
};
TextProperty.prototype.setMinimumFontSize = function (_fontValue) {
this.minimumFontSize = Math.floor(_fontValue) || 1;
this.recalculate(this.keysIndex);
this.elem.addDynamicProperty(this);
};
export default TextProperty;

179
node_modules/lottie-web/player/js/utils/text/TextSelectorProperty.js generated vendored Normal file
View File

@@ -0,0 +1,179 @@
import {
extendPrototype,
} from '../functionExtensions';
import DynamicPropertyContainer from '../helpers/dynamicProperties';
import PropertyFactory from '../PropertyFactory';
import BezierFactory from '../../3rd_party/BezierEaser';
const TextSelectorProp = (function () {
var max = Math.max;
var min = Math.min;
var floor = Math.floor;
function TextSelectorPropFactory(elem, data) {
this._currentTextLength = -1;
this.k = false;
this.data = data;
this.elem = elem;
this.comp = elem.comp;
this.finalS = 0;
this.finalE = 0;
this.initDynamicPropertyContainer(elem);
this.s = PropertyFactory.getProp(elem, data.s || { k: 0 }, 0, 0, this);
if ('e' in data) {
this.e = PropertyFactory.getProp(elem, data.e, 0, 0, this);
} else {
this.e = { v: 100 };
}
this.o = PropertyFactory.getProp(elem, data.o || { k: 0 }, 0, 0, this);
this.xe = PropertyFactory.getProp(elem, data.xe || { k: 0 }, 0, 0, this);
this.ne = PropertyFactory.getProp(elem, data.ne || { k: 0 }, 0, 0, this);
this.sm = PropertyFactory.getProp(elem, data.sm || { k: 100 }, 0, 0, this);
this.a = PropertyFactory.getProp(elem, data.a, 0, 0.01, this);
if (!this.dynamicProperties.length) {
this.getValue();
}
}
TextSelectorPropFactory.prototype = {
getMult: function (ind) {
if (this._currentTextLength !== this.elem.textProperty.currentData.l.length) {
this.getValue();
}
var x1 = 0;
var y1 = 0;
var x2 = 1;
var y2 = 1;
if (this.ne.v > 0) {
x1 = this.ne.v / 100.0;
} else {
y1 = -this.ne.v / 100.0;
}
if (this.xe.v > 0) {
x2 = 1.0 - this.xe.v / 100.0;
} else {
y2 = 1.0 + this.xe.v / 100.0;
}
var easer = BezierFactory.getBezierEasing(x1, y1, x2, y2).get;
var mult = 0;
var s = this.finalS;
var e = this.finalE;
var type = this.data.sh;
if (type === 2) {
if (e === s) {
mult = ind >= e ? 1 : 0;
} else {
mult = max(0, min(0.5 / (e - s) + (ind - s) / (e - s), 1));
}
mult = easer(mult);
} else if (type === 3) {
if (e === s) {
mult = ind >= e ? 0 : 1;
} else {
mult = 1 - max(0, min(0.5 / (e - s) + (ind - s) / (e - s), 1));
}
mult = easer(mult);
} else if (type === 4) {
if (e === s) {
mult = 0;
} else {
mult = max(0, min(0.5 / (e - s) + (ind - s) / (e - s), 1));
if (mult < 0.5) {
mult *= 2;
} else {
mult = 1 - 2 * (mult - 0.5);
}
}
mult = easer(mult);
} else if (type === 5) {
if (e === s) {
mult = 0;
} else {
var tot = e - s;
/* ind += 0.5;
mult = -4/(tot*tot)*(ind*ind)+(4/tot)*ind; */
ind = min(max(0, ind + 0.5 - s), e - s);
var x = -tot / 2 + ind;
var a = tot / 2;
mult = Math.sqrt(1 - (x * x) / (a * a));
}
mult = easer(mult);
} else if (type === 6) {
if (e === s) {
mult = 0;
} else {
ind = min(max(0, ind + 0.5 - s), e - s);
mult = (1 + (Math.cos((Math.PI + Math.PI * 2 * (ind) / (e - s))))) / 2; // eslint-disable-line
}
mult = easer(mult);
} else {
if (ind >= floor(s)) {
if (ind - s < 0) {
mult = max(0, min(min(e, 1) - (s - ind), 1));
} else {
mult = max(0, min(e - ind, 1));
}
}
mult = easer(mult);
}
// Smoothness implementation.
// The smoothness represents a reduced range of the original [0; 1] range.
// if smoothness is 25%, the new range will be [0.375; 0.625]
// Steps are:
// - find the lower value of the new range (threshold)
// - if multiplier is smaller than that value, floor it to 0
// - if it is larger,
// - subtract the threshold
// - divide it by the smoothness (this will return the range to [0; 1])
// Note: If it doesn't work on some scenarios, consider applying it before the easer.
if (this.sm.v !== 100) {
var smoothness = this.sm.v * 0.01;
if (smoothness === 0) {
smoothness = 0.00000001;
}
var threshold = 0.5 - smoothness * 0.5;
if (mult < threshold) {
mult = 0;
} else {
mult = (mult - threshold) / smoothness;
if (mult > 1) {
mult = 1;
}
}
}
return mult * this.a.v;
},
getValue: function (newCharsFlag) {
this.iterateDynamicProperties();
this._mdf = newCharsFlag || this._mdf;
this._currentTextLength = this.elem.textProperty.currentData.l.length || 0;
if (newCharsFlag && this.data.r === 2) {
this.e.v = this._currentTextLength;
}
var divisor = this.data.r === 2 ? 1 : 100 / this.data.totalChars;
var o = this.o.v / divisor;
var s = this.s.v / divisor + o;
var e = (this.e.v / divisor) + o;
if (s > e) {
var _s = s;
s = e;
e = _s;
}
this.finalS = s;
this.finalE = e;
},
};
extendPrototype([DynamicPropertyContainer], TextSelectorPropFactory);
function getTextSelectorProp(elem, data, arr) {
return new TextSelectorPropFactory(elem, data, arr);
}
return {
getTextSelectorProp: getTextSelectorProp,
};
}());
export default TextSelectorProp;