(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){

"use strict";

var _core = _interopRequireDefault(require("@keyframes/core"));

var _keyframes = _interopRequireDefault(require("../src/keyframes.pathfinder"));

function _interopRequireDefault(obj) {

return obj && obj.__esModule ? obj : {

default: obj

};

}

_core.default.plugin(_keyframes.default);

var rules1 = {

name: 'curvey'

};

var rules2 = {

name: 'curveyplus'

};

var rules3 = {

name: 'circular'

};

_core.default.pathfinderOpts.bezierSteps = 100;

rules1 = _core.default.bezierPath(rules1, [-50, 1], [800, 1], [400, 600]);

rules2 = _core.default.bezierPath(rules2, [-50, 100], [800, 100], [400, -100], [50, 600]);

rules3 = _core.default.circlePath(rules3, [100, 100], 40);

_core.default.define([rules1, rules2, rules3]);

window.onload = function () {

var b1 = new _core.default(document.querySelectorAll('.block1')[0]);

var b2 = new _core.default(document.querySelectorAll('.block2')[0]);

var b3 = new _core.default(document.querySelectorAll('.block3')[0]);

b1.play('curvey 10s linear 0s infinite');

b2.play('curveyplus 10s linear 0s infinite');

b3.play('circular 5s linear 0s infinite');

};

},{"../src/keyframes.pathfinder":5,"@keyframes/core":2}],2:[function(require,module,exports){

"use strict";

Object.defineProperty(exports, "__esModule", {

value: true

});

exports.default = void 0;

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

require('es6-object-assign/auto');

var Keyframes =

/*#__PURE__*/

function () {

function Keyframes(elem) {

_classCallCheck(this, Keyframes);

this.elem = elem;

}

_createClass(Keyframes, [{

key: "isSupported",

value: function isSupported() {

return document.body.style.animationName !== undefined;

}

}, {

key: "reset",

value: function reset(callback) {

this.removeEvents();

this.elem.style.animationPlayState = 'running';

this.elem.style.animation = 'none';

if (callback) {

requestAnimationFrame(callback);

}

}

}, {

key: "pause",

value: function pause() {

this.elem.style.animationPlayState = 'paused';

}

}, {

key: "resume",

value: function resume() {

this.elem.style.animationPlayState = 'running';

}

}, {

key: "play",

value: function play(frameOptions, callback) {

var _this = this;

if (this.elem.style.animationName === frameOptions.name) {

this.reset(function () {

return _this.play(frameOptions, callback);

});

return this;

}

var animationcss = Keyframes.playCSS(frameOptions);

var addEvent = function addEvent(type, eventCallback) {

var listenerName = "".concat(type, "Listener");

_this.elem.removeEventListener(type, _this[listenerName]);

_this[listenerName] = eventCallback;

_this.elem.addEventListener(type, _this[listenerName]);

};

this.elem.style.animationPlayState = 'running';

this.elem.style.animation = animationcss;

this.frameOptions = frameOptions;

addEvent('animationiteration', callback || frameOptions.complete);

addEvent('animationend', callback || frameOptions.complete);

return this;

}

}, {

key: "removeEvents",

value: function removeEvents() {

this.elem.removeEventListener('animationiteration', this.animationiterationListener);

this.elem.removeEventListener('animationend', this.animationendListener);

}

}], [{

key: "playCSS",

value: function playCSS(frameOptions) {

var animObjToStr = function animObjToStr(obj) {

var newObj = Object.assign({}, {

duration: '0s',

timingFunction: 'ease',

delay: '0s',

iterationCount: 1,

direction: 'normal',

fillMode: 'forwards'

}, obj);

return [newObj.name, newObj.duration, newObj.timingFunction, newObj.delay, newObj.iterationCount, newObj.direction, newObj.fillMode].join(' ');

};

if (frameOptions.constructor === Array) {

var frameOptionsStrings = [];

for (var i = 0; i < frameOptions.length; i += 1) {

frameOptionsStrings.push(typeof frameOptions[i] === 'string' ? frameOptions[i] : animObjToStr(frameOptions[i]));

}

return frameOptionsStrings.join(', ');

}

if (typeof frameOptions === 'string') {

return frameOptions;

}

return animObjToStr(frameOptions);

}

}, {

key: "generateCSS",

value: function generateCSS(frameData) {

var css = "@keyframes ".concat(frameData.name, " {");

for (var key in frameData) {

if (key !== 'name' && key !== 'media' && key !== 'complete') {

css += "".concat(key, " {");

for (var property in frameData[key]) {

css += "".concat(property, ":").concat(frameData[key][property], ";");

}

css += '}';

}

}

css += '}';

if (frameData.media) {

css = "@media ".concat(frameData.media, "{").concat(css, "}");

}

return css;

}

}, {

key: "generate",

value: function generate(frameData) {

var css = this.generateCSS(frameData);

var oldFrameIndex = Keyframes.rules.indexOf(frameData.name);

if (oldFrameIndex > -1) {

Keyframes.sheet.deleteRule(oldFrameIndex);

delete Keyframes.rules[oldFrameIndex];

}

var ruleIndex = Keyframes.sheet.insertRule(css, 0);

Keyframes.rules[ruleIndex] = frameData.name;

}

}, {

key: "define",

value: function define(frameData) {

if (frameData.length) {

for (var i = 0; i < frameData.length; i += 1) {

this.generate(frameData[i]);

}

} else {

this.generate(frameData);

}

}

}, {

key: "defineCSS",

value: function defineCSS(frameData) {

if (frameData.length) {

var css = '';

for (var i = 0; i < frameData.length; i += 1) {

css += this.generateCSS(frameData[i]);

}

return css;

}

return this.generateCSS(frameData);

}

}, {

key: "plugin",

value: function plugin(pluginFunc) {

if (pluginFunc.constructor === Array) {

for (var i = 0; i < pluginFunc.length; i += 1) {

pluginFunc[i](Keyframes);

}

} else {

pluginFunc(Keyframes);

}

}

}]);

return Keyframes;

}();

if (typeof document !== 'undefined') {

var style = document.createElement('style');

style.setAttribute('id', 'keyframesjs-stylesheet');

document.head.appendChild(style);

Keyframes.sheet = style.sheet;

Keyframes.rules = [];

}

var _default = Keyframes;

exports.default = _default;

},{"es6-object-assign/auto":3}],3:[function(require,module,exports){

'use strict';

require('./index').polyfill();

},{"./index":4}],4:[function(require,module,exports){

/**

* Code refactored from Mozilla Developer Network:

* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign

*/

'use strict';

function assign(target, firstSource) {

if (target === undefined || target === null) {

throw new TypeError('Cannot convert first argument to object');

}

var to = Object(target);

for (var i = 1; i < arguments.length; i++) {

var nextSource = arguments[i];

if (nextSource === undefined || nextSource === null) {

continue;

}

var keysArray = Object.keys(Object(nextSource));

for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {

var nextKey = keysArray[nextIndex];

var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);

if (desc !== undefined && desc.enumerable) {

to[nextKey] = nextSource[nextKey];

}

}

}

return to;

}

function polyfill() {

if (!Object.assign) {

Object.defineProperty(Object, 'assign', {

enumerable: false,

configurable: true,

writable: true,

value: assign

});

}

}

module.exports = {

assign: assign,

polyfill: polyfill

};

},{}],5:[function(require,module,exports){

"use strict";

Object.defineProperty(exports, "__esModule", {

value: true

});

exports.default = void 0;

var _default = function _default(Keyframes) {

function getCirclePoint(radians, radius, center) {

return {

x: center.x + radius * Math.cos(radians),

y: center.y + radius * Math.sin(radians)

};

} //= ===================================\\

// 13thParallel.org Beziér Curve Code \\

// by Dan Pupius (www.pupius.net) \\

//= ===================================\\

var coord = function coord(x, y) {

return {

x: x || 0,

y: y || 0

};

};

function B1(t) {

return t * t * t;

}

function B2(t) {

return 3 * t * t * (1 - t);

}

function B3(t) {

return 3 * t * (1 - t) * (1 - t);

}

function B4(t) {

return (1 - t) * (1 - t) * (1 - t);

}

function getBezier(percent, C1, C2, C3, C4) {

var pos = coord();

pos.x = C1.x * B1(percent) + C2.x * B2(percent) + C3.x * B3(percent) + C4.x * B4(percent);

pos.y = C1.y * B1(percent) + C2.y * B2(percent) + C3.y * B3(percent) + C4.y * B4(percent);

return pos;

}

Keyframes.bezierPath = function (kfro, p1, p2, p3, p4) {

var opts = Keyframes.pathfinderOpts;

if (p4 == null) {

p4 = p1;

}

p1 = coord(p1[0], p1[1]);

p2 = coord(p2[0], p2[1]);

p3 = coord(p3[0], p3[1]);

p4 = coord(p4[0], p4[1]);

var points = {};

var step = 1 / opts.bezierSteps;

for (var i = 0; i <= 1.01; i += step) {

var newpos = getBezier(i, p1, p4, p3, p2);

points["".concat(100 - Math.round(i * 100), "%")] = {

transform: "translate(".concat(newpos.x, "px,").concat(newpos.y, "px)")

};

}

return Object.assign({}, kfro, points);

};

Keyframes.circlePath = function (kfro, center, radius) {

var opts = Keyframes.pathfinderOpts;

var newCenter = coord(center[0], center[1]);

var points = {};

var pieandahalf = 1.5 * Math.PI;

var notmuchpie = Math.PI / 180;

var step = 100 / opts.circleSteps;

var degreestep = 360 / opts.circleSteps;

for (var i = 0; i <= opts.circleSteps; i += 1) {

var degree = degreestep * i;

var radians = pieandahalf + degree * notmuchpie;

var newpos = getCirclePoint(radians, radius, newCenter);

points["".concat(Math.round(step * i), "%")] = {

transform: "translate(".concat(newpos.x, "px,").concat(newpos.y, "px)")

};

}

for (step in kfro) {

var rules = kfro[step];

for (var newstep in points) {

var newrules = points[newstep];

if (step === newstep) {

if (newrules.transform && rules.transform) {

points[newstep].transform = "".concat(newrules.transform, " ").concat(rules.transform);

break;

}

}

}

}

return Object.assign({}, kfro, points);

};

Keyframes.pathfinderOpts = {

bezierSteps: 100,

circleSteps: 100

};

};

exports.default = _default;

},{}]},{},[1]);