ꦫꦣꦺꦤ꧀ꦄꦤ꧀ꦠꦱꦺꦤ

PATH: home / lab2454c / mact34.com / wp-content / plugins / bdthemes-element-pack / assets / vendor / js

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
	typeof define === 'function' && define.amd ? define(['exports'], factory) :
	(factory((global.SpriteSpin = {})));
}(this, (function (exports) { 'use strict';

/**
 * @internal
 */
var Api = /** @class */ (function () {
    function Api(data) {
        this.data = data;
    }
    return Api;
}());
/**
 * Adds methods to the SpriteSpin api
 *
 * @public
 */
function extendApi(methods) {
    var api = Api.prototype;
    for (var key in methods) {
        if (methods.hasOwnProperty(key)) {
            if (api[key]) {
                throw new Error('API method is already defined: ' + key);
            }
            else {
                api[key] = methods[key];
            }
        }
    }
    return api;
}

var $$1 = window.jQuery || window.$;

var canvas;
var context;
function detectionContext() {
    if (context) {
        return context;
    }
    if (!canvas) {
        canvas = document.createElement('canvas');
    }
    if (!canvas || !canvas.getContext) {
        return null;
    }
    context = canvas.getContext('2d');
    return context;
}
/**
 * Idea taken from https://github.com/stomita/ios-imagefile-megapixel
 * Detects whether the image has been sub sampled by the browser and does not have its original dimensions.
 * This method unfortunately does not work for images that have transparent background.
 */
function detectSubsampling(img, width, height) {
    if (!detectionContext()) {
        return false;
    }
    // sub sampling happens on images above 1 megapixel
    if (width * height <= 1024 * 1024) {
        return false;
    }
    // set canvas to 1x1 pixel size and fill it with magenta color
    canvas.width = canvas.height = 1;
    context.fillStyle = '#FF00FF';
    context.fillRect(0, 0, 1, 1);
    // render the image with a negative offset to the left so that it would
    // fill the canvas pixel with the top right pixel of the image.
    context.drawImage(img, -width + 1, 0);
    // check color value to confirm image is covering edge pixel or not.
    // if color still magenta, the image is assumed to be sub sampled.
    try {
        var dat = context.getImageData(0, 0, 1, 1).data;
        return (dat[0] === 255) && (dat[1] === 0) && (dat[2] === 255);
    }
    catch (err) {
        // avoids cross origin exception for chrome when code runs without a server
        return false;
    }
}

/**
 *
 */
function getOuterSize(data) {
    var width = Math.floor(data.width || data.frameWidth || data.target.innerWidth());
    var height = Math.floor(data.height || data.frameHeight || data.target.innerHeight());
    return {
        aspect: width / height,
        height: height,
        width: width
    };
}
function getComputedSize(data) {
    var size = getOuterSize(data);
    if (typeof window.getComputedStyle !== 'function') {
        return size;
    }
    var style = window.getComputedStyle(data.target[0]);
    if (!style.width) {
        return size;
    }
    size.width = Math.floor(Number(style.width.replace('px', '')));
    size.height = Math.floor(size.width / size.aspect);
    return size;
}
/**
 *
 */
function getInnerSize(data) {
    var width = Math.floor(data.frameWidth || data.width || data.target.innerWidth());
    var height = Math.floor(data.frameHeight || data.height || data.target.innerHeight());
    return {
        aspect: width / height,
        height: height,
        width: width
    };
}
/**
 *
 */
function getInnerLayout(mode, inner, outer) {
    // get mode
    var isFit = mode === 'fit';
    var isFill = mode === 'fill';
    var isMatch = mode === 'stretch';
    // resulting layout
    var layout = {
        width: '100%',
        height: '100%',
        top: 0,
        left: 0,
        bottom: 0,
        right: 0,
        position: 'absolute',
        overflow: 'hidden'
    };
    // no calculation here
    if (!mode || isMatch) {
        return layout;
    }
    // get size and aspect
    var aspectIsGreater = inner.aspect >= outer.aspect;
    // mode == original
    var width = inner.width;
    var height = inner.height;
    // keep aspect ratio but fit/fill into container
    if (isFit && aspectIsGreater || isFill && !aspectIsGreater) {
        width = outer.width;
        height = outer.width / inner.aspect;
    }
    if (isFill && aspectIsGreater || isFit && !aspectIsGreater) {
        height = outer.height;
        width = outer.height * inner.aspect;
    }
    // floor the numbers
    width = Math.floor(width);
    height = Math.floor(height);
    // position in center
    layout.width = width;
    layout.height = height;
    layout.top = Math.floor((outer.height - height) / 2);
    layout.left = Math.floor((outer.width - width) / 2);
    layout.right = layout.left;
    layout.bottom = layout.top;
    return layout;
}

var img;
/**
 * gets the original width and height of an image element
 */
function naturalSize(image) {
    // for browsers that support naturalWidth and naturalHeight properties
    if (image.naturalWidth) {
        return {
            height: image.naturalHeight,
            width: image.naturalWidth
        };
    }
    // browsers that do not support naturalWidth and naturalHeight properties have to fall back to the width and
    // height properties. However, the image might have a css style applied so width and height would return the
    // css size. To avoid thet create a new Image object that is free of css rules and grab width and height
    // properties
    //
    // assume that the src has already been downloaded, so no onload callback is needed.
    img = img || new Image();
    img.src = image.src;
    return {
        height: img.height,
        width: img.width
    };
}

/**
 * Measures the image frames that are used in the given data object
 */
function measure(images, options) {
    if (images.length === 1) {
        return [measureSheet(images[0], options)];
    }
    else if (options.framesX && options.framesY) {
        return measureMutipleSheets(images, options);
    }
    else {
        return measureFrames(images, options);
    }
}
function measureSheet(image, options) {
    var result = { id: 0, sprites: [] };
    measureImage(image, options, result);
    var frames = options.frames;
    var framesX = Number(options.framesX) || frames;
    var framesY = Math.ceil(frames / framesX);
    var frameWidth = Math.floor(result.width / framesX);
    var frameHeight = Math.floor(result.height / framesY);
    var divisor = result.isSubsampled ? 2 : 1;
    for (var i = 0; i < frames; i++) {
        var x = (i % framesX) * frameWidth;
        var y = Math.floor(i / framesX) * frameHeight;
        result.sprites.push({
            id: i,
            x: x, y: y,
            width: frameWidth,
            height: frameHeight,
            sampledX: x / divisor,
            sampledY: y / divisor,
            sampledWidth: frameWidth / divisor,
            sampledHeight: frameHeight / divisor
        });
    }
    return result;
}
function measureFrames(images, options) {
    var result = [];
    for (var id = 0; id < images.length; id++) {
        // TODO: optimize
        // dont measure images with same size twice
        var sheet = measureSheet(images[id], { frames: 1, framesX: 1, detectSubsampling: options.detectSubsampling });
        sheet.id = id;
        result.push(sheet);
    }
    return result;
}
function measureMutipleSheets(images, options) {
    var result = [];
    for (var id = 0; id < images.length; id++) {
        // TODO: optimize
        // dont measure images with same size twice
        var sheet = measureSheet(images[id], {
            frames: undefined,
            framesX: options.framesX,
            framesY: options.framesY,
            detectSubsampling: options.detectSubsampling
        });
        sheet.id = id;
        result.push(sheet);
    }
    return result;
}
function measureImage(image, options, result) {
    var size = naturalSize(image);
    result.isSubsampled = options.detectSubsampling && detectSubsampling(image, size.width, size.height);
    result.width = size.width;
    result.height = size.height;
    result.sampledWidth = size.width / (result.isSubsampled ? 2 : 1);
    result.sampledHeight = size.height / (result.isSubsampled ? 2 : 1);
    return result;
}
function findSpecs(metrics, frames, frame, lane) {
    var spriteId = lane * frames + frame;
    var sheetId = 0;
    var sprite = null;
    var sheet = null;
    while (true) {
        sheet = metrics[sheetId];
        if (!sheet) {
            break;
        }
        if (spriteId >= sheet.sprites.length) {
            spriteId -= sheet.sprites.length;
            sheetId++;
            continue;
        }
        sprite = sheet.sprites[spriteId];
        break;
    }
    return { sprite: sprite, sheet: sheet };
}

/**
 * The namespace that is used to bind functions to DOM events and store the data object
 */
var namespace = 'spritespin';
/**
 * Event names that are recognized by SpriteSpin. A module can implement any of these and they will be bound
 * to the target element on which the plugin is called.
 */
var eventNames = [
    'mousedown',
    'mousemove',
    'mouseup',
    'mouseenter',
    'mouseover',
    'mouseleave',
    'mousewheel',
    'wheel',
    'click',
    'dblclick',
    'touchstart',
    'touchmove',
    'touchend',
    'touchcancel',
    'selectstart',
    'gesturestart',
    'gesturechange',
    'gestureend'
];
/**
 *
 */
var callbackNames = [
    'onInit',
    'onProgress',
    'onLoad',
    'onFrameChanged',
    'onFrame',
    'onDraw',
    'onComplete',
    'onDestroy'
];
/**
 * Names of events for that the default behavior should be prevented.
 */
var eventsToPrevent = [
    'dragstart'
];
/**
 * Default set of SpriteSpin options. This also represents the majority of data attributes that are used during the
 * lifetime of a SpriteSpin instance. The data is stored inside the target DOM element on which the plugin is called.
 */
var defaults = {
    source: undefined,
    width: undefined,
    height: undefined,
    frames: undefined,
    framesX: undefined,
    lanes: 1,
    sizeMode: undefined,
    renderer: 'canvas',
    lane: 0,
    frame: 0,
    frameTime: 40,
    animate: false,
    retainAnimate: false,
    reverse: false,
    loop: false,
    stopFrame: 0,
    wrap: true,
    wrapLane: false,
    sense: 1,
    senseLane: undefined,
    orientation: 'horizontal',
    detectSubsampling: true,
    preloadCount: undefined,
    responsive: undefined,
    plugins: [
        '360',
        'drag'
    ]
};

var _Utils = Object.freeze({
	$: $$1,
	getCursorPosition: getCursorPosition,
	detectSubsampling: detectSubsampling,
	getOuterSize: getOuterSize,
	getComputedSize: getComputedSize,
	getInnerSize: getInnerSize,
	getInnerLayout: getInnerLayout,
	measure: measure,
	findSpecs: findSpecs,
	naturalSize: naturalSize,
	preload: preload,
	sourceArray: sourceArray,
	noop: noop$1,
	log: log,
	warn: warn,
	error: error,
	toArray: toArray,
	clamp: clamp,
	wrap: wrap,
	prevent: prevent,
	bind: bind,
	unbind: unbind,
	isFunction: isFunction,
	pixelRatio: pixelRatio
});

/**
 * Applies css attributes to layout the SpriteSpin containers.
 *
 * @internal
 */
function applyLayout(data) {
    // disable selection
    data.target
        .attr('unselectable', 'on')
        .css({
        width: '',
        height: '',
        '-ms-user-select': 'none',
        '-moz-user-select': 'none',
        '-khtml-user-select': 'none',
        '-webkit-user-select': 'none',
        'user-select': 'none'
    });
    var size = data.responsive ? getComputedSize(data) : getOuterSize(data);
    var layout = getInnerLayout(data.sizeMode, getInnerSize(data), size);
    // apply layout on target
    data.target.css({
        width: size.width,
        height: size.height,
        position: 'relative',
        overflow: 'hidden'
    });
    // apply layout on stage
    data.stage
        .css(layout)
        .hide();
    if (!data.canvas) {
        return;
    }
    // apply layout on canvas
    data.canvas.css(layout).hide();
    // apply pixel ratio on canvas
    data.canvasRatio = data.canvasRatio || pixelRatio(data.context);
    if (typeof layout.width === 'number' && typeof layout.height === 'number') {
        data.canvas[0].width = (layout.width * data.canvasRatio) || size.width;
        data.canvas[0].height = (layout.height * data.canvasRatio) || size.height;
    }
    else {
        data.canvas[0].width = (size.width * data.canvasRatio);
        data.canvas[0].height = (size.height * data.canvasRatio);
    }
    // width and height must be set before calling scale
    data.context.scale(data.canvasRatio, data.canvasRatio);
}

/**
 * Gets a state object by name.
 * @internal
 * @param data - The SpriteSpin instance data
 * @param name - The name of the state object
 */
function getState(data, name) {
    data.state = data.state || {};
    data.state[name] = data.state[name] || {};
    return data.state[name];
}
/**
 * Gets a plugin state object by name.
 *
 * @remarks
 * Plugins should use this method to get or create a state object where they can
 * store any instance variables.
 *
 * @public
 * @param data - The SpriteSpin instance data
 * @param name - The name of the plugin
 */
function getPluginState(data, name) {
    var state = getState(data, 'plugin');
    state[name] = state[name] || {};
    return state[name];
}
/**
 * Checks whether a flag is set. See {@link flag}.
 *
 * @public
 * @param data - The SpriteSpin instance data
 * @param key - The name of the flag
 */
function is(data, key) {
    return !!getState(data, 'flags')[key];
}
/**
 * Sets a flag value. See {@link is}.
 *
 * @public
 * @param data - The SpriteSpin instance data
 * @param key - The name of the flag
 * @param value - The value to set
 */
function flag(data, key, value) {
    getState(data, 'flags')[key] = !!value;
}

/**
 * Gets the playback state
 *
 * @public
 * @param data - The SpriteSpin instance data
 */
function getPlaybackState(data) {
    return getState(data, 'playback');
}
function updateLane(data, lane) {
    data.lane = data.wrapLane
        ? wrap(lane, 0, data.lanes - 1, data.lanes)
        : clamp(lane, 0, data.lanes - 1);
}
function updateAnimationFrame(data) {
    data.frame += (data.reverse ? -1 : 1);
    // wrap the frame value to fit in range [0, data.frames)
    data.frame = wrap(data.frame, 0, data.frames - 1, data.frames);
    // stop animation if loop is disabled and the stopFrame is reached
    if (!data.loop && (data.frame === data.stopFrame)) {
        stopAnimation(data);
    }
}
function updateInputFrame(data, frame) {
    data.frame = Number(frame);
    data.frame = data.wrap
        ? wrap(data.frame, 0, data.frames - 1, data.frames)
        : clamp(data.frame, 0, data.frames - 1);
}
function updateAnimation(data) {
    var state = getPlaybackState(data);
    if (state.handler) {
        updateBefore(data);
        updateAnimationFrame(data);
        updateAfter(data);
    }
}
function updateBefore(data) {
    var state = getPlaybackState(data);
    state.lastFrame = data.frame;
    state.lastLane = data.lane;
}
function updateAfter(data) {
    var state = getPlaybackState(data);
    if (state.lastFrame !== data.frame || state.lastLane !== data.lane) {
        data.target.trigger('onFrameChanged.' + namespace, data);
    }
    data.target.trigger('onFrame.' + namespace, data);
    data.target.trigger('onDraw.' + namespace, data);
}
/**
 * Updates the frame or lane number of the SpriteSpin data.
 *
 * @public
 * @param data - The SpriteSpin instance data
 * @param frame - The frame number to set
 * @param lane - The lane number to set
 */
function updateFrame(data, frame, lane) {
    updateBefore(data);
    if (frame != null) {
        updateInputFrame(data, frame);
    }
    if (lane != null) {
        updateLane(data, lane);
    }
    updateAfter(data);
}
/**
 * Stops the running animation.
 *
 * @public
 * @param data - The SpriteSpin instance data
 */
function stopAnimation(data) {
    data.animate = false;
    var state = getPlaybackState(data);
    if (state.handler != null) {
        window.clearInterval(state.handler);
        state.handler = null;
    }
}
/**
 * Starts animation playback if needed.
 *
 * @remarks
 * Starts animation playback if `animate` property is `true` and the animation is not yet running.
 *
 * @public
 * @param data - The SpriteSpin instance data
 */
function applyAnimation(data) {
    var state = getPlaybackState(data);
    if (state.handler && (!data.animate || state.frameTime !== data.frameTime)) {
        stopAnimation(data);
    }
    if (data.animate && !state.handler) {
        state.frameTime = data.frameTime;
        state.handler = window.setInterval(function () { return updateAnimation(data); }, state.frameTime);
    }
}
/**
 * Starts the animation playback
 *
 * @remarks
 * Starts the animation playback and also sets the `animate` property to `true`
 *
 * @public
 * @param data - The SpriteSpin instance data
 */
function startAnimation(data) {
    data.animate = true;
    applyAnimation(data);
}

/**
 * Gets the current input state
 *
 * @public
 * @param data - The SpriteSpin instance data
 */
function getInputState(data) {
    return getState(data, 'input');
}
/**
 * Updates the input state using a mous or touch event.
 *
 * @public
 * @param e - The input event
 * @param data - The SpriteSpin instance data
 */
function updateInput(e, data) {
    var cursor = getCursorPosition(e);
    var state = getInputState(data);
    // cache positions from previous frame
    state.oldX = state.currentX;
    state.oldY = state.currentY;
    state.currentX = cursor.x;
    state.currentY = cursor.y;
    // Fix old position.
    if (state.oldX === undefined || state.oldY === undefined) {
        state.oldX = state.currentX;
        state.oldY = state.currentY;
    }
    // Cache the initial click/touch position and store the frame number at which the click happened.
    // Useful for different behavior implementations. This must be restored when the click/touch is released.
    if (state.startX === undefined || state.startY === undefined) {
        state.startX = state.currentX;
        state.startY = state.currentY;
        state.clickframe = data.frame;
        state.clicklane = data.lane;
    }
    // Calculate the vector from start position to current pointer position.
    state.dX = state.currentX - state.startX;
    state.dY = state.currentY - state.startY;
    // Calculate the vector from last frame position to current pointer position.
    state.ddX = state.currentX - state.oldX;
    state.ddY = state.currentY - state.oldY;
    // Normalize vectors to range [-1:+1]
    state.ndX = state.dX / data.target.innerWidth();
    state.ndY = state.dY / data.target.innerHeight();
    state.nddX = state.ddX / data.target.innerWidth();
    state.nddY = state.ddY / data.target.innerHeight();
}
/**
 * Resets the input state.
 *
 * @public
 */
function resetInput(data) {
    var input = getInputState(data);
    input.startX = input.startY = undefined;
    input.currentX = input.currentY = undefined;
    input.oldX = input.oldY = undefined;
    input.dX = input.dY = 0;
    input.ddX = input.ddY = 0;
    input.ndX = input.ndY = 0;
    input.nddX = input.nddY = 0;
}

// tslint:disable:object-literal-shorthand
// tslint:disable:only-arrow-functions
extendApi({
    // Gets a value indicating whether the animation is currently running.
    isPlaying: function () {
        return getPlaybackState(this.data).handler != null;
    },
    // Gets a value indicating whether the animation looping is enabled.
    isLooping: function () {
        return this.data.loop;
    },
    // Starts/Stops the animation playback
    toggleAnimation: function () {
        if (this.isPlaying()) {
            this.stopAnimation();
        }
        else {
            this.startAnimation();
        }
    },
    // Stops animation playback
    stopAnimation: function () {
        this.data.animate = false;
        stopAnimation(this.data);
    },
    // Starts animation playback
    startAnimation: function () {
        this.data.animate = true;
        applyAnimation(this.data);
    },
    // Sets a value indicating whether the animation should be looped or not.
    // This might start the animation (if the 'animate' data attribute is set to true)
    loop: function (value) {
        this.data.loop = value;
        applyAnimation(this.data);
        return this;
    },
    // Gets the current frame number
    currentFrame: function () {
        return this.data.frame;
    },
    // Updates SpriteSpin to the specified frame.
    updateFrame: function (frame) {
        updateFrame(this.data, frame);
        return this;
    },
    // Skips the given number of frames
    skipFrames: function (step) {
        var data = this.data;
        updateFrame(data, data.frame + (data.reverse ? -step : +step));
        return this;
    },
    // Updates SpriteSpin so that the next frame is shown
    nextFrame: function () {
        return this.skipFrames(1);
    },
    // Updates SpriteSpin so that the previous frame is shown
    prevFrame: function () {
        return this.skipFrames(-1);
    },
    // Starts the animations that will play until the given frame number is reached
    // options:
    //   force [boolean] starts the animation, even if current frame is the target frame
    //   nearest [boolean] animates to the direction with minimum distance to the target frame
    playTo: function (frame, options) {
        var data = this.data;
        options = options || {};
        if (!options.force && data.frame === frame) {
            return;
        }
        if (options.nearest) {
            // distance to the target frame
            var a = frame - data.frame;
            // distance to last frame and the to target frame
            var b = frame > data.frame ? a - data.frames : a + data.frames;
            // minimum distance
            var c = Math.abs(a) < Math.abs(b) ? a : b;
            data.reverse = c < 0;
        }
        data.animate = true;
        data.loop = false;
        data.stopFrame = frame;
        applyAnimation(data);
        return this;
    }
});

var Utils = _Utils;

exports.Utils = Utils;
exports.sourceArray = sourceArray;
exports.Api = Api;
exports.extendApi = extendApi;
exports.instances = instances;
exports.applyEvents = applyEvents;
exports.boot = boot;
exports.create = create;
exports.createOrUpdate = createOrUpdate;
exports.destroy = destroy;
exports.namespace = namespace;
exports.eventNames = eventNames;
exports.callbackNames = callbackNames;
exports.eventsToPrevent = eventsToPrevent;
exports.defaults = defaults;
exports.getInputState = getInputState;
exports.updateInput = updateInput;
exports.resetInput = resetInput;
exports.applyLayout = applyLayout;
exports.getPlaybackState = getPlaybackState;
exports.updateFrame = updateFrame;
exports.stopAnimation = stopAnimation;
exports.applyAnimation = applyAnimation;
exports.startAnimation = startAnimation;
exports.registerPlugin = registerPlugin;
exports.registerModule = registerModule;
exports.getPlugin = getPlugin;
exports.applyPlugins = applyPlugins;
exports.getState = getState;
exports.getPluginState = getPluginState;
exports.is = is;
exports.flag = flag;

Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=spritespin.js.map

[-] SplitText.js [edit]
[-] awesomeCloud.min.js [edit]
[-] prism.min.js [edit]
[-] jquery.progressScroll.js [edit]
[-] jquery.mThumbnailScroller.min.js [edit]
[-] parallax.js [edit]
[-] chart.min.js [edit]
[-] typed.min.js [edit]
[-] jquery.appear.min.js [edit]
[-] lottie.d.ts [edit]
[-] jquery.imagezoom.js [edit]
[-] jquery.tagcanvas.min.js [edit]
[-] prism.js [edit]
[-] metisMenu.js [edit]
[-] lottie.js [edit]
[-] jquery.honeycombs.js [edit]
[-] sidetabs.js [edit]
[-] timeline.min.js [edit]
[-] datatables.min.js [edit]
[-] datatables.uikit.js [edit]
[-] jquery.appear.js [edit]
[+] ..
[-] popper.js [edit]
[-] jquery.jplayer.js [edit]
[-] image-compare-viewer.min.js [edit]
[-] calendly.js [edit]
[-] tilt.jquery.js [edit]
[-] particles.min.js [edit]
[-] jquery.progressHorizontal.min.js [edit]
[-] timeline.js [edit]
[-] jQuery.circleMenu.min.js [edit]
[-] tippy.all.min.js [edit]
[-] calendly.min.js [edit]
[-] jquery.jplayer.min.js [edit]
[-] jquery.newsTicker.min.js [edit]
[-] darkmode.min.js [edit]
[-] goodshare.min.js [edit]
[-] SplitText.min.js [edit]
[-] jquery.newsTicker.js [edit]
[-] jquery.flatWeatherPlugin.min.js [edit]
[-] rvslider.min.js [edit]
[-] gmap.min.js [edit]
[-] jquery.jclock.min.js [edit]
[-] chart.js [edit]
[-] jquery.mousewheel.js [edit]
[-] vanilla-tilt.js [edit]
[-] search.min.js [edit]
[-] jquery.justifiedGallery.min.js [edit]
[-] pageable.min.js [edit]
[-] particles.js [edit]
[-] jquery.imagezoom.min.js [edit]
[-] jquery.mousewheel.min.js [edit]
[-] gmap.js [edit]
[-] news-ticker.min.js [edit]
[-] datatables.uikit.min.js [edit]
[-] tippy.all.js [edit]
[-] gsap.js [edit]
[-] table-of-content.min.js [edit]
[-] gsap.min.js [edit]
[-] metisMenu.min.js [edit]
[-] wavify.min.js [edit]
[-] jquery.progressScroll.min.js [edit]
[-] morphext.min.js [edit]
[-] darkmode.js [edit]
[-] gridtab.min.js [edit]
[-] morphext.js [edit]
[-] image-compare-viewer.js [edit]
[-] parallax.min.js [edit]
[-] search.js [edit]
[-] sidetabs.min.js [edit]
[-] recliner.js [edit]
[-] countUp.js [edit]
[-] clipboard.js [edit]
[-] jquery-asPieProgress.min.js [edit]
[-] wavify.js [edit]
[-] recliner.min.js [edit]
[-] jquery.jclock.js [edit]
[-] pageable.js [edit]
[-] jquery.tagcanvas.js [edit]
[-] gridtab.js [edit]
[-] jquery-qrcode.js [edit]
[-] countUp.min.js [edit]
[-] awesomeCloud.js [edit]
[-] jquery-asPieProgress.js [edit]
[-] lottie.min.js [edit]
[-] moment-timezone-with-data.min.js [edit]
[-] jquery.justifiedGallery.js [edit]
[-] datatables.js [edit]
[-] rvslider.js [edit]
[-] jquery.flatWeatherPlugin.js [edit]
[-] moment.min.js [edit]
[-] jquery.honeycombs.min.js [edit]
[-] table-of-content.js [edit]
[-] goodshare.js [edit]
[-] leaflet.js [edit]
[-] cookieconsent.min.js [edit]
[-] moment-timezone-with-data.js [edit]
[-] jQuery.circleMenu.js [edit]
[-] leaflet.min.js [edit]
[-] vanilla-tilt.min.js [edit]
[-] floating-video.min.js [edit]
[-] typed.js [edit]
[-] popper.min.js [edit]
[-] spritespin.js [edit]
[-] jquery.progressHorizontal.js [edit]
[-] floating-video.js [edit]
[-] jquery.mThumbnailScroller.js [edit]
[-] moment.js [edit]
[-] spritespin.min.js [edit]
[-] tilt.jquery.min.js [edit]
[-] jquery-qrcode.min.js [edit]
[-] cookieconsent.js [edit]