RubyGems - jekyll-theme-chalk - Versions diffs - 0.1.1 - Mend

jekyll-theme-chalk 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (405) hide show

data/_assets/yarn/scrollreveal/.ignore/coverage/server.coverage.js ADDED

@@ -0,0 +1,11 @@
+var liveServer = require('live-server');
+var params = {
+    logLevel: 2,
+    port: 9001,
+    root: './.ignore/coverage/PhantomJS 2.1.1 (Mac OS X 0.0.0)/lcov-report',
+    open: false,
+    wait: 500,
+};
+liveServer.start(params);

data/_assets/yarn/scrollreveal/.ignore/sandbox/css/styles.css ADDED

@@ -0,0 +1,32 @@
+html {
+	padding: 0;
+	margin: 0;
+}
+.noir   { background-color: #0E141F; }
+.yellow { background-color: #FFCB36; }
+.orange { background-color: #FF7C35; }
+.red    { background-color: #E31D65; }
+.green  { background-color: #25A954; }
+.blue   { background-color: #007D97; }
+.purple { background-color: #553AB8; }
+body {
+	padding: 40px;
+	margin: 0;
+}
+.blocks {
+	list-style: none;
+	margin: 0;
+	padding: 0;
+}
+.blocks li {
+	height: 80px;
+	border-radius: 3px;
+}
+.blocks li:not(:last-child) {
+	margin-bottom: 40px;
+}

data/_assets/yarn/scrollreveal/.ignore/sandbox/index.html ADDED

@@ -0,0 +1,68 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Sandbox</title>
+    <link rel="stylesheet" href="./css/styles.css">
+    <style>
+        html {
+            overflow-x: hidden;
+        }
+        .blocks li {
+            visibility: hidden;
+        }
+    </style>
+</head>
+<body class="noir">
+    <ul class="blocks">
+        <li class="red"></li>
+        <li class="orange"></li>
+        <li class="yellow"></li>
+        <li class="green"></li>
+        <li class="blue"></li>
+        <li class="purple"></li>
+        <li class="red"></li>
+        <li class="orange"></li>
+        <li class="yellow"></li>
+        <li class="green"></li>
+        <li class="blue"></li>
+        <li class="purple"></li>
+        <li class="red"></li>
+        <li class="orange"></li>
+        <li class="yellow"></li>
+        <li class="green"></li>
+        <li class="blue"></li>
+        <li class="purple"></li>
+        <li class="red"></li>
+        <li class="orange"></li>
+        <li class="yellow"></li>
+        <li class="green"></li>
+        <li class="blue"></li>
+        <li class="purple"></li>
+    </ul>
+    <script src="./js/scrollreveal.js"></script>
+    <script>
+        const sr = new ScrollReveal();
+        const config = {
+            distance: '100%',
+            duration: 600,
+            origin: 'right',
+            scale: 0.7,
+            // delay: 2000,
+            // useDelay: 'onload',
+            // reset: true,
+            // beforeReveal: (e) => console.log('BEFORE revealed'),
+            // beforeReset: (e) => console.log('BEFORE reset'),
+            // afterReveal: (e) => console.log('AFTER revealed'),
+            // afterReset: (e) => console.log('AFTER reset'),
+            // rotate: { z: 5 },
+            // container: 'ul.blocks',
+            opacity: null,
+            // desktop: false,
+        }
+        sr.reveal('.blocks li', config, 60);
+    </script>
+</body>
+</html>

data/_assets/yarn/scrollreveal/.ignore/sandbox/js/scrollreveal.js ADDED

@@ -0,0 +1,1271 @@
+var ScrollReveal = (function () {
+'use strict';
+var defaults = {
+	origin: 'bottom',
+	distance: '0',
+	duration: 600,
+	delay: 0,
+	rotate: {
+		x: 0,
+		y: 0,
+		z: 0,
+	},
+	opacity: 0,
+	scale: 1,
+	easing: 'cubic-bezier(0.6, 0.2, 0.1, 1)',
+	container: document.documentElement,
+	desktop: true,
+	mobile: true,
+	reset: false,
+	useDelay: 'always',
+	viewFactor: 0.0,
+	viewOffset: {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0,
+	},
+	beforeReveal: function beforeReveal () {},
+	beforeReset: function beforeReset () {},
+	afterReveal: function afterReveal () {},
+	afterReset: function afterReset () {},
+};
+var noop = {
+	clean: function clean () {},
+	destroy: function destroy () {},
+	reveal: function reveal () {},
+	sync: function sync () {},
+	get noop () { return true },
+};
+function deepAssign (target) {
+	var sources = [], len = arguments.length - 1;
+	while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];
+	if (isObject(target)) {
+		each(sources, function (source) {
+			each(source, function (data, key) {
+				if (isObject(data)) {
+					if (!target[key] || !isObject(target[key])) {
+						target[key] = {};
+					}
+					deepAssign(target[key], data);
+				} else {
+					target[key] = data;
+				}
+			});
+		});
+		return target
+	} else {
+		throw new TypeError('Expected an object literal.')
+	}
+}
+function isObject (object) {
+	return object !== null && typeof object === 'object'
+		&& (object.constructor === Object || Object.prototype.toString.call(object) === '[object Object]')
+}
+function each (collection, callback) {
+	if (isObject(collection)) {
+		var keys = Object.keys(collection);
+		for (var i = 0; i < keys.length; i++) {
+			callback(collection[ keys[i] ], keys[i], collection);
+		}
+	} else if (Array.isArray(collection)) {
+		for (var i$1 = 0; i$1 < collection.length; i$1++) {
+			callback(collection[i$1], i$1, collection);
+		}
+	} else {
+		throw new TypeError('Expected either an array or object literal.')
+	}
+}
+var nextUniqueId = (function () {
+	var uid = 0;
+	return function () { return uid++; }
+})();
+var getPrefixedStyleProperty = (function () {
+	var properties = {};
+	var style = document.documentElement.style;
+	function getPrefixedStyleProperty (name, source) {
+		if ( source === void 0 ) source = style;
+		if (name && typeof name === 'string') {
+			if (properties[name]) {
+				return properties[name]
+			}
+			if (typeof source[name] === 'string') {
+				return properties[name] = name
+			}
+			if (typeof source[("-webkit-" + name)] === 'string') {
+				return properties[name] = "-webkit-" + name
+			}
+			throw new RangeError(("Unable to find \"" + name + "\" style property."))
+		}
+		throw new TypeError('Expected a string.')
+	}
+	getPrefixedStyleProperty.clearCache = function () { return properties = {}; };
+	return getPrefixedStyleProperty
+})();
+function isMobile (agent) {
+	if ( agent === void 0 ) agent = navigator.userAgent;
+	return /Android|iPhone|iPad|iPod/i.test(agent)
+}
+function isNode (target) {
+	return typeof window.Node === 'object'
+		? target instanceof window.Node
+		: target !== null
+			&& typeof target === 'object'
+			&& typeof target.nodeType === 'number'
+			&& typeof target.nodeName === 'string'
+}
+function isNodeList (target) {
+	var prototypeToString = Object.prototype.toString.call(target);
+	var regex = /^\[object (HTMLCollection|NodeList|Object)\]$/;
+	return typeof window.NodeList === 'object'
+		? target instanceof window.NodeList
+		: typeof target === 'object'
+			&& typeof target.length === 'number'
+			&& regex.test(prototypeToString)
+			&& (target.length === 0 || isNode(target[0]))
+}
+function transformSupported () {
+	var style = document.documentElement.style;
+	return 'transform' in style || 'WebkitTransform' in style
+}
+function transitionSupported () {
+	var style = document.documentElement.style;
+	return 'transition' in style || 'WebkitTransition' in style
+}
+function isElementVisible (element) {
+	var container = this.store.containers[element.containerId];
+	var viewFactor = element.config.viewFactor;
+	var viewOffset = element.config.viewOffset;
+	var elementBounds = {
+		top: element.geometry.bounds.top + element.geometry.height * viewFactor,
+		right: element.geometry.bounds.right - element.geometry.width * viewFactor,
+		bottom: element.geometry.bounds.bottom - element.geometry.height * viewFactor,
+		left: element.geometry.bounds.left + element.geometry.width * viewFactor,
+	};
+	var containerBounds = {
+		top: container.geometry.bounds.top + container.scroll.top + viewOffset.top,
+		right: container.geometry.bounds.right + container.scroll.left + viewOffset.right,
+		bottom: container.geometry.bounds.bottom + container.scroll.top + viewOffset.bottom,
+		left: container.geometry.bounds.left + container.scroll.left + viewOffset.left,
+	};
+	return elementBounds.top < containerBounds.bottom
+		&& elementBounds.right > containerBounds.left
+		&& elementBounds.bottom > containerBounds.top
+		&& elementBounds.left < containerBounds.right
+		|| element.styles.position === 'fixed'
+}
+function getGeometry (target, isContainer) {
+	/**
+	 * We want to ignore padding and scrollbars for container elements.
+	 * More information here: https://goo.gl/vOZpbz
+	 */
+	var height = (isContainer) ? target.node.clientHeight : target.node.offsetHeight;
+	var width = (isContainer) ? target.node.clientWidth : target.node.offsetWidth;
+	var offsetTop = 0;
+	var offsetLeft = 0;
+	var node = target.node;
+	do {
+		if (!isNaN(node.offsetTop)) {
+			offsetTop += node.offsetTop;
+		}
+		if (!isNaN(node.offsetLeft)) {
+			offsetLeft += node.offsetLeft;
+		}
+		node = node.offsetParent;
+	} while (node)
+	return {
+		bounds: {
+			top: offsetTop,
+			right: offsetLeft + width,
+			bottom: offsetTop + height,
+			left: offsetLeft,
+		},
+		height: height,
+		width: width,
+	}
+}
+function getNode (target, container) {
+	if ( container === void 0 ) container = document;
+	var node = null;
+	if (typeof target === 'string') {
+		try {
+			node = container.querySelector(target);
+			if (!node) { logger(("Querying the selector \"" + target + "\" returned nothing.")); }
+		} catch (err) {
+			logger(("\"" + target + "\" is not a valid selector."));
+		}
+	}
+	return isNode(target) ? target : node
+}
+function getNodes (target, container) {
+	if ( container === void 0 ) container = document;
+	if (isNode(target)) { return [target] }
+	if (isNodeList(target)) { return Array.prototype.slice.call(target) }
+	if (typeof target === 'string') {
+		try {
+			var query = container.querySelectorAll(target);
+			var nodes = Array.prototype.slice.call(query);
+			if (nodes.length) { return nodes }
+			logger(("Querying the selector \"" + target + "\" returned nothing."));
+		} catch (error) {
+			logger(("\"" + target + "\" is not a valid selector."));
+		}
+	}
+	return []
+}
+function getScrolled (container) {
+	return (container.node === document.documentElement)
+		? {
+			top: window.pageYOffset,
+			left: window.pageXOffset,
+		} : {
+			top: container.node.scrollTop,
+			left: container.node.scrollLeft,
+		}
+}
+function logger (message) {
+	var details = [], len = arguments.length - 1;
+	while ( len-- > 0 ) details[ len ] = arguments[ len + 1 ];
+	if (console) {
+		var report = "ScrollReveal: " + message;
+		details.forEach(function (detail) { return report += "\n  - " + detail; });
+		console.log(report); // eslint-disable-line no-console
+	}
+}
+function rinse () {
+	var this$1 = this;
+	var elementIds = {
+		active: [],
+		stale: [],
+	};
+	var containerIds = {
+		active: [],
+		stale: [],
+	};
+	var sequenceIds = {
+		active: [],
+		stale: [],
+	};
+	/**
+	 * Take stock of active element IDs.
+	 */
+	each(getNodes('[data-sr-id]'), function (node) {
+		var id = parseInt(node.getAttribute('data-sr-id'));
+		elementIds.active.push(id);
+	});
+	/**
+	 * Destroy stale elements.
+	 */
+	each(this.store.elements, function (element) {
+		if (elementIds.active.indexOf(element.id) === -1) {
+			elementIds.stale.push(element.id);
+		}
+	});
+	each(elementIds.stale, function (staleId) { return delete this$1.store.elements[staleId]; });
+	/**
+	 * Take stock of active container and sequence IDs.
+	 */
+	each(this.store.elements, function (element) {
+		if (containerIds.active.indexOf(element.containerId) === -1) {
+			containerIds.active.push(element.containerId);
+		}
+		if (element.hasOwnProperty('sequence')) {
+			if (sequenceIds.active.indexOf(element.sequence.id) === -1) {
+				sequenceIds.active.push(element.sequence.id);
+			}
+		}
+	});
+	/**
+	 * Destroy stale containers.
+	 */
+	each(this.store.containers, function (container) {
+		if (containerIds.active.indexOf(container.id) === -1) {
+			containerIds.stale.push(container.id);
+		}
+	});
+	each(containerIds.stale, function (staleId) {
+		this$1.store.containers[staleId].node.removeEventListener('scroll', this$1.delegate);
+		this$1.store.containers[staleId].node.removeEventListener('resize', this$1.delegate);
+		delete this$1.store.containers[staleId];
+	});
+	/**
+	 * Destroy stale sequences.
+	 */
+	each(this.store.sequences, function (sequence) {
+		if (sequenceIds.active.indexOf(sequence.id) === -1) {
+			sequenceIds.stale.push(sequence.id);
+		}
+	});
+	each(sequenceIds.stale, function (staleId) { return delete this$1.store.sequences[staleId]; });
+}
+function clean (target) {
+	var this$1 = this;
+	var dirty;
+	each(getNodes(target), function (node) {
+		var id = node.getAttribute('data-sr-id');
+		if (id !== null) {
+			dirty = true;
+			node.setAttribute('style', this$1.store.elements[id].styles.inline);
+			node.removeAttribute('data-sr-id');
+			delete this$1.store.elements[id];
+		}
+	});
+	if (dirty) { rinse.call(this); }
+}
+function destroy () {
+	var this$1 = this;
+	/**
+	 * Remove all generated styles and element ids
+	 */
+	each(this.store.elements, function (element) {
+		element.node.setAttribute('style', element.styles.inline);
+		element.node.removeAttribute('data-sr-id');
+	});
+	/**
+	 * Remove all event listeners.
+	 */
+	each(this.store.containers, function (container) {
+		if (container.node === document.documentElement) {
+			window.removeEventListener('scroll', this$1.delegate);
+			window.removeEventListener('resize', this$1.delegate);
+		} else {
+			container.node.removeEventListener('scroll', this$1.delegate);
+			container.node.removeEventListener('resize', this$1.delegate);
+		}
+	});
+	/**
+	 * Clear all data from the store
+	 */
+	this.store = {
+		containers: {},
+		elements: {},
+		history: [],
+		sequences: {},
+	};
+}
+/*  @license Redpill v0.4.1
+    Copyright (c) 2017, Fisssion LLC
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    THE SOFTWARE.
+*/
+/**
+ * @module Redpill
+ */
+/**
+* Transformation matrices in the browser come in two flavors:
+*
+*  - `matrix` using 6 values (short)
+*  - `matrix3d` using 16 values (long)
+*
+* This utility follows this [conversion guide](https://goo.gl/EJlUQ1)
+* to expand short form matrices to their equivalent long form.
+*
+* @param  {array} source - Accepts both short and long form matrices.
+* @return {array}
+*/
+function format (source) {
+	if (source.constructor !== Array) {
+		throw new TypeError('Expected array.')
+	}
+	if (source.length === 16) {
+		return source
+	}
+	if (source.length === 6) {
+		var matrix = identity();
+		matrix[0] = source[0];
+		matrix[1] = source[1];
+		matrix[4] = source[2];
+		matrix[5] = source[3];
+		matrix[12] = source[4];
+		matrix[13] = source[5];
+		return matrix
+	}
+	throw new RangeError('Expected array with either 6 or 16 values.')
+}
+/**
+ * Returns a matrix representing no transformation. The product of any matrix
+ * multiplied by the identity matrix will be the original matrix.
+ *
+ * > **Tip:** Similar to how `5 * 1 === 5`, where `1` is the identity number.
+ *
+ * @return {array}
+ */
+function identity () {
+	var matrix = [];
+	for (var i = 0; i < 16; i++) {
+		i % 5 == 0 ? matrix.push(1) : matrix.push(0);
+	}
+	return matrix
+}
+/**
+ * Returns a 4x4 matrix describing the combined transformations
+ * of both arguments.
+ *
+ * > **Note:** Order is very important. For example, rotating 90°
+ * along the Z-axis, followed by translating 500 pixels along the
+ * Y-axis... is not the same as translating 500 pixels along the
+ * Y-axis, followed by rotating 45° along on the Z-axis.
+ *
+ * @param  {array} m1 - Accepts both short and long form matrices.
+ * @param  {array} m2 - Accepts both short and long form matrices.
+ * @return {array}
+ */
+function multiply (m1, m2) {
+	var fm1 = format(m1);
+	var fm2 = format(m2);
+	var product = [];
+	for (var i = 0; i < 4; i++) {
+		var row = [fm1[i], fm1[i + 4], fm1[i + 8], fm1[i + 12]];
+		for (var j = 0; j < 4; j++) {
+			var k = j * 4;
+			var col = [fm2[k], fm2[k + 1], fm2[k + 2], fm2[k + 3]];
+			var result = row[0] * col[0] + row[1] * col[1] + row[2] * col[2] + row[3] * col[3];
+			product[i + k] = result;
+		}
+	}
+	return product
+}
+/**
+ * Attempts to returns a 4x4 matrix describing the CSS transform matrix passed
+ * in, but will return the identity matrix as a fallback.
+ *
+ * **Tip:** In virtually all cases, this method is used to convert a CSS matrix
+ * (retrieved as a `string` from computed styles) to its equivalent array format.
+ *
+ * @param  {string} source - String containing a valid CSS `matrix` or `matrix3d` property.
+ * @return {array}
+ */
+function parse (source) {
+	if (typeof source === 'string') {
+		var match = source.match(/matrix(3d)?\(([^)]+)\)/);
+		if (match) {
+			var raw = match[2].split(', ').map(function (value) { return parseFloat(value); });
+			return format(raw)
+		}
+	}
+	return identity()
+}
+/**
+ * Returns a 4x4 matrix describing X-axis rotation.
+ *
+ * @param  {number} angle - Measured in degrees.
+ * @return {array}
+ */
+function rotateX (angle) {
+	var theta = Math.PI / 180 * angle;
+	var matrix = identity();
+	matrix[5] = matrix[10] = Math.cos(theta);
+	matrix[6] = matrix[9] = Math.sin(theta);
+	matrix[9] *= -1;
+	return matrix
+}
+/**
+ * Returns a 4x4 matrix describing Y-axis rotation.
+ *
+ * @param  {number} angle - Measured in degrees.
+ * @return {array}
+ */
+function rotateY (angle) {
+	var theta = Math.PI / 180 * angle;
+	var matrix = identity();
+	matrix[0] = matrix[10] = Math.cos(theta);
+	matrix[2] = matrix[8] = Math.sin(theta);
+	matrix[2] *= -1;
+	return matrix
+}
+/**
+ * Returns a 4x4 matrix describing Z-axis rotation.
+ *
+ * @param  {number} angle - Measured in degrees.
+ * @return {array}
+ */
+function rotateZ (angle) {
+	var theta = Math.PI / 180 * angle;
+	var matrix = identity();
+	matrix[0] = matrix[5] = Math.cos(theta);
+	matrix[1] = matrix[4] = Math.sin(theta);
+	matrix[4] *= -1;
+	return matrix
+}
+/**
+* Returns a 4x4 matrix describing 2D scaling. The first argument
+* is used for both X and Y-axis scaling, unless an optional
+* second argument is provided to explicitly define Y-axis scaling.
+*
+* @param  {number} scalarX   - Decimal multiplier.
+* @param  {number} [scalarY] - Decimal multiplier.
+* @return {array}
+*/
+function scale (scalarX, scalarY) {
+	var matrix = identity();
+	matrix[0] = scalarX;
+	matrix[5] = scalarY || scalarX;
+	return matrix
+}
+/**
+ * Returns a 4x4 matrix describing X-axis translation.
+ *
+ * @param  {number} distance - Measured in pixels.
+ * @return {array}
+ */
+function translateX (distance) {
+	var matrix = identity();
+	matrix[12] = distance;
+	return matrix
+}
+/**
+ * Returns a 4x4 matrix describing Y-axis translation.
+ *
+ * @param  {number} distance - Measured in pixels.
+ * @return {array}
+ */
+function translateY (distance) {
+	var matrix = identity();
+	matrix[13] = distance;
+	return matrix
+}
+function style (element) {
+	var computed = window.getComputedStyle(element.node);
+	var position = computed.position;
+	var config = element.config;
+	/**
+	 * Generate inline styles
+	 */
+	var inlineRegex = /.+[^;]/g;
+	var inlineStyle = element.node.getAttribute('style') || '';
+	var inlineMatch = inlineRegex.exec(inlineStyle);
+	var inline = (inlineMatch) ? ((inlineMatch[0]) + ";") : '';
+	if (inline.indexOf('visibility: visible') === -1) {
+		inline += (inline.length) ? ' ' : '';
+		inline += 'visibility: visible;';
+	}
+	/**
+	 * Generate opacity styles
+	 */
+	var computedOpacity = parseFloat(computed.opacity);
+	var configOpacity = !isNaN(parseFloat(config.opacity))
+		? parseFloat(config.opacity)
+		: parseFloat(computed.opacity);
+	var opacity = {
+		computed: (computedOpacity !== configOpacity) ? ("opacity: " + computedOpacity + ";") : '',
+		generated: (computedOpacity !== configOpacity) ? ("opacity: " + configOpacity + ";") : '',
+	};
+	/**
+	 * Generate transformation styles
+	 */
+	var transformations = [];
+	if (parseFloat(config.distance)) {
+		var axis = (config.origin === 'top' || config.origin === 'bottom') ? 'Y' : 'X';
+		/**
+		 * Let’s make sure our our pixel distances are negative for top and left.
+		 * e.g. { origin: 'top', distance: '25px' } starts at `top: -25px` in CSS.
+    	 */
+		var distance = config.distance;
+		if (config.origin === 'top' || config.origin === 'left') {
+			distance = /^-/.test(distance)
+				? distance.substr(1)
+				: ("-" + distance);
+		}
+		var ref = distance.match(/(^-?\d+\.?\d?)|(em$|px$|\%$)/g);
+		var value = ref[0];
+		var unit = ref[1];
+		switch (unit) {
+			case 'em':
+				distance = parseInt(computed.fontSize) * value;
+				break
+			case 'px':
+				distance = value;
+				break
+			case '%':
+				distance = (axis === 'Y')
+					? element.node.getBoundingClientRect().height * value / 100
+					: element.node.getBoundingClientRect().width * value / 100;
+				break
+			default:
+				throw new RangeError('Unrecognized or missing distance unit.')
+		}
+		(axis === 'Y')
+			? transformations.push(translateY(distance))
+			: transformations.push(translateX(distance));
+	}
+	if (config.rotate.x) { transformations.push(rotateX(config.rotate.x)); }
+	if (config.rotate.y) { transformations.push(rotateY(config.rotate.y)); }
+	if (config.rotate.z) { transformations.push(rotateZ(config.rotate.z)); }
+	if (config.scale !== 1) { transformations.push(scale(config.scale)); }
+	var transform = {};
+	if (transformations.length) {
+		transform.property = getPrefixedStyleProperty('transform');
+		/**
+		* The default computed transform value should be one of:
+		* undefined || 'none' || 'matrix()' || 'matrix3d()'
+		*/
+		transform.computed = {
+			raw: computed[transform.property],
+			matrix: parse(computed[transform.property]),
+		};
+		transformations.unshift(transform.computed.matrix);
+		var product = transformations.reduce(multiply);
+		transform.generated = {
+			initial: ((transform.property) + ": matrix3d(" + (product.join(', ')) + ");"),
+			final: ((transform.property) + ": matrix3d(" + (transform.computed.matrix.join(', ')) + ");"),
+		};
+	} else {
+		transform.generated = {
+			initial: '',
+			final: '',
+		};
+	}
+	/**
+	 * Generate transition styles
+	 */
+	var transition = {};
+	if (opacity.generated || transform.generated.initial) {
+		transition.property = getPrefixedStyleProperty('transition');
+		transition.computed = computed[transition.property];
+		transition.fragments = [];
+		var delay = config.delay;
+		var duration = config.duration;
+		var easing = config.easing;
+		if (opacity.generated) {
+			transition.fragments.push({
+				delayed: ("opacity " + (duration / 1000) + "s " + easing + " " + (delay / 1000) + "s"),
+				instant: ("opacity " + (duration / 1000) + "s " + easing + " 0s"),
+			});
+		}
+		if (transform.generated.initial) {
+			transition.fragments.push({
+				delayed: ((transform.property) + " " + (duration / 1000) + "s " + easing + " " + (delay / 1000) + "s"),
+				instant: ((transform.property) + " " + (duration / 1000) + "s " + easing + " 0s"),
+			});
+		}
+		/**
+		 * The default computed transition property should be one of:
+		 * undefined || '' || 'all 0s ease 0s' || 'all 0s 0s cubic-bezier()'
+		 */
+		if (transition.computed && !transition.computed.match(/all 0s/)) {
+			transition.fragments.unshift({
+				delayed: transition.computed,
+				instant: transition.computed,
+			});
+		}
+		var composed = transition.fragments.reduce(function (composition, fragment, i) {
+			composition.delayed += (i === 0) ? fragment.delayed : (", " + (fragment.delayed));
+			composition.instant += (i === 0) ? fragment.instant : (", " + (fragment.instant));
+			return composition
+		}, {
+			delayed: '',
+			instant: '',
+		});
+		transition.generated = {
+			delayed: ((transition.property) + ": " + (composed.delayed) + ";"),
+			instant: ((transition.property) + ": " + (composed.instant) + ";"),
+		};
+	}
+	return {
+		inline: inline,
+		opacity: opacity,
+		position: position,
+		transform: transform,
+		transition: transition,
+	}
+}
+function initialize () {
+	var this$1 = this;
+	rinse.call(this);
+	each(this.store.elements, function (element) {
+		var styles = [element.styles.inline];
+		if (element.visible) {
+			styles.push(element.styles.opacity.computed);
+			styles.push(element.styles.transform.generated.final);
+		} else {
+			styles.push(element.styles.opacity.generated);
+			styles.push(element.styles.transform.generated.initial);
+		}
+		element.node.setAttribute('style', styles.join(' '));
+	});
+	each(this.store.containers, function (container) {
+		if (container.node === document.documentElement) {
+			window.addEventListener('scroll', this$1.delegate);
+			window.addEventListener('resize', this$1.delegate);
+		} else {
+			container.node.addEventListener('scroll', this$1.delegate);
+			container.node.addEventListener('resize', this$1.delegate);
+		}
+	});
+	/**
+	 * Manually invoke delegate once to capture
+	 * element and container dimensions, container
+	 * scroll position, and trigger any valid reveals
+	 */
+	this.delegate();
+	this.initTimeout = null;
+}
+function reveal (target, options, interval, sync) {
+	var this$1 = this;
+	/**
+	 * The reveal method has an optional 2nd parameter,
+	 * so here we just shuffle things around to accept
+	 * the interval being passed as the 2nd argument.
+	 */
+	if (typeof options === 'number') {
+		interval = Math.abs(parseInt(options));
+		options = {};
+	} else {
+		interval = Math.abs(parseInt(interval));
+		options = options || {};
+	}
+	var config = deepAssign({}, this.defaults, options);
+	var containers = this.store.containers;
+	var container = getNode(config.container);
+	var targets = getNodes(target, container);
+	if (!targets.length) {
+		logger('Reveal aborted.', 'Reveal cannot be performed on 0 elements.');
+		return
+	}
+	/**
+	 * Verify our platform matches our platform configuration.
+	 */
+	if (!config.mobile && isMobile() || !config.desktop && !isMobile()) {
+		logger('Reveal aborted.', 'This platform has been disabled.');
+		return
+	}
+	/**
+	 * Sequence intervals must be at least 16ms (60fps).
+	 */
+	var sequence;
+	if (interval) {
+		if (interval >= 16) {
+			var sequenceId = nextUniqueId();
+			sequence = {
+				elementIds: [],
+				head: { index: null, blocked: false },
+				tail: { index: null, blocked: false },
+				id: sequenceId,
+				interval: Math.abs(interval),
+			};
+		} else {
+			logger('Reveal failed.', 'Sequence intervals must be at least 16 milliseconds.');
+			return
+		}
+	}
+	var containerId;
+	each(containers, function (storedContainer) {
+		if (!containerId && storedContainer.node === container) {
+			containerId = storedContainer.id;
+		}
+	});
+	if (isNaN(containerId)) {
+		containerId = nextUniqueId();
+	}
+	try {
+		var elements = targets.map(function (node) {
+			var element = {};
+			var existingId = node.getAttribute('data-sr-id');
+			if (existingId) {
+				deepAssign(element, this$1.store.elements[existingId]);
+				/**
+				 * In order to prevent previously generated styles
+				 * from throwing off the new styles, the style tag
+				 * has to be reverted to it's pre-reveal state.
+				 */
+				element.node.setAttribute('style', element.styles.inline);
+			} else {
+				element.id = nextUniqueId();
+				element.node = node;
+				element.seen = false;
+				element.visible = false;
+			}
+			element.config = config;
+			element.containerId = containerId;
+			element.styles = style(element);
+			if (sequence) {
+				element.sequence = {
+					id: sequence.id,
+					index: sequence.elementIds.length,
+				};
+				sequence.elementIds.push(element.id);
+			}
+			return element
+		});
+		/**
+		* Modifying the DOM via setAttribute needs to be handled
+		* separately from reading computed styles in the map above
+		* for the browser to batch DOM changes (limiting reflows)
+		*/
+		each(elements, function (element) {
+			this$1.store.elements[element.id] = element;
+			element.node.setAttribute('data-sr-id', element.id);
+		});
+	} catch (error) {
+		logger('Reveal failed.', error.message);
+		return
+	}
+	containers[containerId] = containers[containerId] || {
+		id: containerId,
+		node: container,
+	};
+	if (sequence) {
+		this.store.sequences[sequence.id] = sequence;
+	}
+	/**
+	* If reveal wasn't invoked by sync, we want to
+	* make sure to add this call to the history.
+	*/
+	if (!sync) {
+		this.store.history.push({ target: target, options: options, interval: interval });
+		/**
+		* Push initialization to the event queue, giving
+		* multiple reveal calls time to be interpretted.
+		*/
+		if (this.initTimeout) {
+			window.clearTimeout(this.initTimeout);
+		}
+		this.initTimeout = window.setTimeout(initialize.bind(this), 0);
+	}
+}
+/**
+ * Re-runs the reveal method for each record stored in history,
+ * for capturing new content asynchronously loaded into the DOM.
+ */
+function sync () {
+	var this$1 = this;
+	each(this.store.history, function (record) {
+		reveal.call(this$1, record.target, record.options, record.interval, true);
+	});
+	initialize.call(this);
+}
+function animate (element) {
+	var this$1 = this;
+	var isDelayed = element.config.useDelay === 'always'
+		|| element.config.useDelay === 'onload' && this.pristine
+		|| element.config.useDelay === 'once' && !element.seen;
+	var sequence = (element.sequence) ? this.store.sequences[element.sequence.id] : null;
+	var styles = [element.styles.inline];
+	if (isElementVisible.call(this, element) && !element.visible) {
+		if (sequence !== null) {
+			if (sequence.head.index === null && sequence.tail.index === null) {
+				sequence.head.index = sequence.tail.index = element.sequence.index;
+				sequence.head.blocked = sequence.tail.blocked = true;
+			} else if (sequence.head.index - 1 === element.sequence.index && !sequence.head.blocked) {
+				sequence.head.index--;
+				sequence.head.blocked = true;
+			} else if (sequence.tail.index + 1 === element.sequence.index && !sequence.tail.blocked) {
+				sequence.tail.index++;
+				sequence.tail.blocked = true;
+			} else { return }
+			window.setTimeout(function () {
+				sequence.head.blocked = sequence.tail.blocked = false;
+				this$1.delegate();
+			}, sequence.interval);
+		}
+		styles.push(element.styles.opacity.computed);
+		styles.push(element.styles.transform.generated.final);
+		if (isDelayed) {
+			styles.push(element.styles.transition.generated.delayed);
+		} else {
+			styles.push(element.styles.transition.generated.instant);
+		}
+		element.seen = true;
+		element.visible = true;
+		registerCallbacks.call(this, element, isDelayed);
+		element.node.setAttribute('style', styles.join(' '));
+	} else {
+		if (!isElementVisible.call(this, element) && element.visible && element.config.reset) {
+			if (sequence) {
+				if (sequence.head.index === element.sequence.index) {
+					sequence.head.index++;
+				} else if (sequence.tail.index === element.sequence.index) {
+					sequence.tail.index--;
+				} else { return }
+			}
+			styles.push(element.styles.opacity.generated);
+			styles.push(element.styles.transform.generated.initial);
+			styles.push(element.styles.transition.generated.instant);
+			element.visible = false;
+			registerCallbacks.call(this, element);
+			element.node.setAttribute('style', styles.join(' '));
+		}
+	}
+}
+function registerCallbacks (element, isDelayed) {
+	var this$1 = this;
+	var duration = (isDelayed)
+		? element.config.duration + element.config.delay
+		: element.config.duration;
+	var afterCallback;
+	if (element.visible) {
+		element.config.beforeReveal(element.node);
+		afterCallback = element.config.afterReveal;
+	} else {
+		element.config.beforeReset(element.node);
+		afterCallback = element.config.afterReset;
+	}
+	var elapsed = 0;
+	if (element.callbackTimer) {
+		elapsed = Date.now() - element.callbackTimer.start;
+		window.clearTimeout(element.callbackTimer.clock);
+	}
+	element.callbackTimer = {
+		start: Date.now(),
+		clock: window.setTimeout(function () {
+			afterCallback(element.node);
+			element.callbackTimer = null;
+			if (element.visible && !element.config.reset) {
+				clean.call(this$1, element.node);
+			}
+		}, duration - elapsed),
+	};
+}
+var polyfill = (function () {
+	var clock = Date.now();
+	return function (callback) {
+		var currentTime = Date.now();
+		if (currentTime - clock > 16) {
+			clock = currentTime;
+			callback(currentTime);
+		} else {
+			setTimeout(function () { return polyfill(callback); }, 0);
+		}
+	}
+})();
+var requestAnimationFrame = window.requestAnimationFrame
+	|| window.webkitRequestAnimationFrame
+	|| window.mozRequestAnimationFrame
+	|| polyfill;
+function delegate (event) {
+	var this$1 = this;
+	if ( event === void 0 ) event = {};
+	requestAnimationFrame(function () {
+		var containers = this$1.store.containers;
+		var elements = this$1.store.elements;
+		switch (event.type) {
+			case 'scroll':
+				each(containers, function (container) { return container.scroll = getScrolled.call(this$1, container); });
+				each(elements, function (element) { return animate.call(this$1, element); });
+				break
+			case 'resize':
+			default:
+				each(containers, function (container) {
+					container.geometry = getGeometry.call(this$1, container, /* isContainer: */ true);
+					container.scroll = getScrolled.call(this$1, container);
+				});
+				each(elements, function (element) {
+					element.geometry = getGeometry.call(this$1, element);
+					animate.call(this$1, element);
+				});
+		}
+		this$1.pristine = false;
+	});
+}
+var version = "4.0.0-beta.2";
+function ScrollReveal (options) {
+	if ( options === void 0 ) options = {};
+	/**
+	 * Support instantiation without the `new` keyword.
+	 */
+	if (typeof this === 'undefined' || Object.getPrototypeOf(this) !== ScrollReveal.prototype) {
+		return new ScrollReveal(options)
+	}
+	if (!ScrollReveal.isSupported()) {
+		logger('Instantiation aborted.', 'This browser is not supported.');
+		return noop
+	}
+	try {
+		Object.defineProperty(this, 'defaults', {
+			get: (function () {
+				var config = {};
+				deepAssign(config, defaults, options);
+				return function () { return config; }
+			})(),
+		});
+	} catch (error) {
+		logger('Instantiation failed.', 'Invalid configuration provided.', error.message);
+		return noop
+	}
+	var container = getNode(this.defaults.container);
+	if (!container) {
+		logger('Instantiation failed.', 'Invalid or missing container.');
+		return noop
+	}
+	if (this.defaults.mobile === isMobile() || this.defaults.desktop === !isMobile()) {
+		document.documentElement.classList.add('sr');
+	}
+	this.store = {
+		containers: {},
+		elements: {},
+		history: [],
+		sequences: {},
+	};
+	this.pristine = true;
+	this.delegate = delegate.bind(this);
+	Object.defineProperty(this, 'version', {
+		get: function () { return version; },
+	});
+	Object.defineProperty(this, 'noop', {
+		get: function () { return false; },
+	});
+}
+ScrollReveal.isSupported = function () { return transformSupported() && transitionSupported(); };
+ScrollReveal.prototype.clean = clean;
+ScrollReveal.prototype.destroy = destroy;
+ScrollReveal.prototype.reveal = reveal;
+ScrollReveal.prototype.sync = sync;
+/////    /////    /////    /////
+/////    /////    /////    /////
+/////    /////    /////    /////
+/////    /////    /////    /////
+/////             /////    /////
+/////             /////    /////
+/////    /////    /////    /////
+/////    /////    /////    /////
+         /////    /////
+         /////    /////
+/////    /////    /////    /////
+/////    /////    /////    /////
+/////    /////    /////    /////
+/////    /////    /////    /////
+/*!
+ * ScrollReveal
+ * ------------
+ * Website : https://scrollreveal.com
+ * Support : https://github.com/jlmakes/scrollreveal/issues
+ * Author  : https://twitter.com/jlmakes
+ *
+ * Licensed under the GNU General Public License 3.0 for
+ * compatible open source projects and non-commercial use.
+ *
+ * For commercial sites, themes, projects, and applications,
+ * keep your source code proprietary and please purchase a
+ * commercial license from https://scrollreveal.com
+ *
+ * Copyright (c) 2014–2017 Julian Lloyd. All rights reserved.
+ */
+return ScrollReveal;
+}());