		{
		"name": "Bolt Manifest",
		"bolt-sticky.min.js": "/bolt-sticky.min.js"
		"bolt-sticky.min.js": "/bolt-sticky.min.js",
		"bolt-sticky.min.js.map": "/bolt-sticky.min.js.map"
		}

1095

dist/bolt-sticky.min.js

		@@ -1,1 +0,1094 @@
		!function(t){function s(i){if(e[i])return e[i].exports;var n=e[i]={i:i,l:!1,exports:{}};return t[i].call(n.exports,n,n.exports,s),n.l=!0,n.exports}var e={};s.m=t,s.c=e,s.d=function(t,e,i){s.o(t,e)\|\|Object.defineProperty(t,e,{configurable:!1,enumerable:!0,get:i})},s.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return s.d(e,"a",e),e},s.o=function(t,s){return Object.prototype.hasOwnProperty.call(t,s)},s.p="/scripts/",s(s.s=0)}([function(t,s,e){"use strict";(0,function(t){return t&&t.__esModule?t:{default:t}}(e(1)).default)(".js-bolt-sticky")},function(t,s,e){"use strict";function i(t,s){var e=void 0!==s?s:{};this.version="2.0.13",this.userAgent=window.navigator.userAgent\|\|"no `userAgent` provided by the browser",this.props={noStyles:e.noStyles\|\|!1,stickyBitStickyOffset:e.stickyBitStickyOffset\|\|0,parentClass:e.parentClass\|\|"js-stickybit-parent",scrollEl:e.scrollEl\|\|window,stickyClass:e.stickyClass\|\|"js-is-sticky",stuckClass:e.stuckClass\|\|"js-is-stuck",useStickyClasses:e.useStickyClasses\|\|!1,verticalPosition:e.verticalPosition\|\|"top"};var i=this.props;i.positionVal=this.definePosition()\|\|"fixed";var n=i.verticalPosition,o=i.noStyles,r=i.positionVal;this.els="string"==typeof t?document.querySelectorAll(t):t,"length"in this.els\|\|(this.els=[this.els]),this.instances=[];for(var a=0;a<this.els.length;a+=1){var l=this.els[a],c=l.style;if("top"!==n\|\|o\|\|(c[n]=i.stickyBitStickyOffset+"px"),"fixed"!==r&&!1===i.useStickyClasses)c.position=r;else{"fixed"!==r&&(c.position=r);var p=this.addInstance(l,i);this.instances.push(p)}}return this}Object.defineProperty(s,"__esModule",{value:!0}),i.prototype.definePosition=function(){for(var t=["","-o-","-webkit-","-moz-","-ms-"],s=document.head.style,e=0;e<t.length;e+=1)s.position=t[e]+"sticky";var i="fixed";return void 0!==s.position&&(i=s.position),s.position="",i},i.prototype.addInstance=function(t,s){var e=this,i={el:t,parent:t.parentNode,props:s},n=i.props;i.parent.className+=" "+s.parentClass;var o=n.scrollEl;return i.isWin=o===window,i.isWin\|\|(o=this.getClosestParent(i.el,o)),this.computeScrollOffsets(i),i.state="default",i.stateContainer=function(){e.manageState(i)},o.addEventListener("scroll",i.stateContainer),i},i.prototype.getClosestParent=function(t,s){var e=document.querySelector(s),i=t;if(i.parentElement===e)return e;for(;i.parentElement!==e;)i=i.parentElement;return e},i.prototype.computeScrollOffsets=function(t){var s=t,e=s.props,i=s.parent,n=s.isWin,o=0,r=i.getBoundingClientRect().top;return n\|\|"fixed"!==e.positionVal\|\|(o=e.scrollEl.getBoundingClientRect().top,r=i.getBoundingClientRect().top-o),s.offset=o+e.stickyBitStickyOffset,s.stickyStart=r-s.offset,s.stickyStop=r+i.offsetHeight-(s.el.offsetHeight+s.offset),s},i.prototype.toggleClasses=function(t,s,e){var i=t,n=i.className.split(" ");e&&-1===n.indexOf(e)&&n.push(e);var o=n.indexOf(s);-1!==o&&n.splice(o,1),i.className=n.join(" ")},i.prototype.manageState=function(t){var s=t,e=s.el,i=s.props,n=s.state,o=s.stickyStart,r=s.stickyStop,a=e.style,l=i.noStyles,c=i.positionVal,p=i.scrollEl,u=i.stickyClass,f=i.stuckClass,y=i.verticalPosition,d=p.requestAnimationFrame;s.isWin&&void 0!==d\|\|(d=function(t){t()});var v=this.toggleClasses,h=s.isWin?p.scrollY\|\|p.pageYOffset:p.scrollTop,k=h<=o&&"sticky"===n,g=h>=r&&"sticky"===n;return h>o&&h<r&&("default"===n\|\|"stuck"===n)?(s.state="sticky",d(function(){v(e,f,u),a.position=c,l\|\|(a.bottom="",a[y]=i.stickyBitStickyOffset+"px")})):k?(s.state="default",d(function(){v(e,u),"fixed"===c&&(a.position="")})):g&&(s.state="stuck",d(function(){v(e,u,f),"fixed"!==c\|\|l\|\|(a.top="",a.bottom="0",a.position="absolute")})),s},i.prototype.removeInstance=function(t){var s=t.el,e=t.props,i=this.toggleClasses;s.style.position="",s.style[e.verticalPosition]="",i(s,e.stickyClass),i(s,e.stuckClass),i(s.parentNode,e.parentClass)},i.prototype.cleanup=function(){for(var t=0;t<this.instances.length;t+=1){var s=this.instances[t];s.props.scrollEl.removeEventListener("scroll",s.stateContainer),this.removeInstance(s)}this.manageState=!1,this.instances=[]},s.default=function(t,s){return new i(t,s)}}]);
		/******/ (function(modules) { // webpackBootstrap
		/******/ function hotDisposeChunk(chunkId) {
		/******/ delete installedChunks[chunkId];
		/******/ }
		/******/ var parentHotUpdateCallback = window["webpackHotUpdate"];
		/******/ window["webpackHotUpdate"] =
		/******/ function webpackHotUpdateCallback(chunkId, moreModules) { // eslint-disable-line no-unused-vars
		/******/ hotAddUpdateChunk(chunkId, moreModules);
		/******/ if(parentHotUpdateCallback) parentHotUpdateCallback(chunkId, moreModules);
		/******/ } ;
		/******/
		/******/ function hotDownloadUpdateChunk(chunkId) { // eslint-disable-line no-unused-vars
		/******/ var head = document.getElementsByTagName("head")[0];
		/******/ var script = document.createElement("script");
		/******/ script.type = "text/javascript";
		/******/ script.charset = "utf-8";
		/******/ script.src = __webpack_require__.p + "" + chunkId + "." + hotCurrentHash + ".hot-update.js";
		/******/ ;
		/******/ head.appendChild(script);
		/******/ }
		/******/
		/******/ function hotDownloadManifest(requestTimeout) { // eslint-disable-line no-unused-vars
		/******/ requestTimeout = requestTimeout \|\| 10000;
		/******/ return new Promise(function(resolve, reject) {
		/******/ if(typeof XMLHttpRequest === "undefined")
		/******/ return reject(new Error("No browser support"));
		/******/ try {
		/******/ var request = new XMLHttpRequest();
		/******/ var requestPath = __webpack_require__.p + "" + hotCurrentHash + ".hot-update.json";
		/******/ request.open("GET", requestPath, true);
		/******/ request.timeout = requestTimeout;
		/******/ request.send(null);
		/******/ } catch(err) {
		/******/ return reject(err);
		/******/ }
		/******/ request.onreadystatechange = function() {
		/******/ if(request.readyState !== 4) return;
		/******/ if(request.status === 0) {
		/******/ // timeout
		/******/ reject(new Error("Manifest request to " + requestPath + " timed out."));
		/******/ } else if(request.status === 404) {
		/******/ // no update available
		/******/ resolve();
		/******/ } else if(request.status !== 200 && request.status !== 304) {
		/******/ // other failure
		/******/ reject(new Error("Manifest request to " + requestPath + " failed."));
		/******/ } else {
		/******/ // success
		/******/ try {
		/******/ var update = JSON.parse(request.responseText);
		/******/ } catch(e) {
		/******/ reject(e);
		/******/ return;
		/******/ }
		/******/ resolve(update);
		/******/ }
		/******/ };
		/******/ });
		/******/ }
		/******/
		/******/
		/******/
		/******/ var hotApplyOnUpdate = true;
		/******/ var hotCurrentHash = "ba4ecacefca14a8de020"; // eslint-disable-line no-unused-vars
		/******/ var hotRequestTimeout = 10000;
		/******/ var hotCurrentModuleData = {};
		/******/ var hotCurrentChildModule; // eslint-disable-line no-unused-vars
		/******/ var hotCurrentParents = []; // eslint-disable-line no-unused-vars
		/******/ var hotCurrentParentsTemp = []; // eslint-disable-line no-unused-vars
		/******/
		/******/ function hotCreateRequire(moduleId) { // eslint-disable-line no-unused-vars
		/******/ var me = installedModules[moduleId];
		/******/ if(!me) return __webpack_require__;
		/******/ var fn = function(request) {
		/******/ if(me.hot.active) {
		/******/ if(installedModules[request]) {
		/******/ if(installedModules[request].parents.indexOf(moduleId) < 0)
		/******/ installedModules[request].parents.push(moduleId);
		/******/ } else {
		/******/ hotCurrentParents = [moduleId];
		/******/ hotCurrentChildModule = request;
		/******/ }
		/******/ if(me.children.indexOf(request) < 0)
		/******/ me.children.push(request);
		/******/ } else {
		/******/ console.warn("[HMR] unexpected require(" + request + ") from disposed module " + moduleId);
		/******/ hotCurrentParents = [];
		/******/ }
		/******/ return __webpack_require__(request);
		/******/ };
		/******/ var ObjectFactory = function ObjectFactory(name) {
		/******/ return {
		/******/ configurable: true,
		/******/ enumerable: true,
		/******/ get: function() {
		/******/ return __webpack_require__[name];
		/******/ },
		/******/ set: function(value) {
		/******/ __webpack_require__[name] = value;
		/******/ }
		/******/ };
		/******/ };
		/******/ for(var name in __webpack_require__) {
		/******/ if(Object.prototype.hasOwnProperty.call(__webpack_require__, name) && name !== "e") {
		/******/ Object.defineProperty(fn, name, ObjectFactory(name));
		/******/ }
		/******/ }
		/******/ fn.e = function(chunkId) {
		/******/ if(hotStatus === "ready")
		/******/ hotSetStatus("prepare");
		/******/ hotChunksLoading++;
		/******/ return __webpack_require__.e(chunkId).then(finishChunkLoading, function(err) {
		/******/ finishChunkLoading();
		/******/ throw err;
		/******/ });
		/******/
		/******/ function finishChunkLoading() {
		/******/ hotChunksLoading--;
		/******/ if(hotStatus === "prepare") {
		/******/ if(!hotWaitingFilesMap[chunkId]) {
		/******/ hotEnsureUpdateChunk(chunkId);
		/******/ }
		/******/ if(hotChunksLoading === 0 && hotWaitingFiles === 0) {
		/******/ hotUpdateDownloaded();
		/******/ }
		/******/ }
		/******/ }
		/******/ };
		/******/ return fn;
		/******/ }
		/******/
		/******/ function hotCreateModule(moduleId) { // eslint-disable-line no-unused-vars
		/******/ var hot = {
		/******/ // private stuff
		/******/ _acceptedDependencies: {},
		/******/ _declinedDependencies: {},
		/******/ _selfAccepted: false,
		/******/ _selfDeclined: false,
		/******/ _disposeHandlers: [],
		/******/ _main: hotCurrentChildModule !== moduleId,
		/******/
		/******/ // Module API
		/******/ active: true,
		/******/ accept: function(dep, callback) {
		/******/ if(typeof dep === "undefined")
		/******/ hot._selfAccepted = true;
		/******/ else if(typeof dep === "function")
		/******/ hot._selfAccepted = dep;
		/******/ else if(typeof dep === "object")
		/******/ for(var i = 0; i < dep.length; i++)
		/******/ hot._acceptedDependencies[dep[i]] = callback \|\| function() {};
		/******/ else
		/******/ hot._acceptedDependencies[dep] = callback \|\| function() {};
		/******/ },
		/******/ decline: function(dep) {
		/******/ if(typeof dep === "undefined")
		/******/ hot._selfDeclined = true;
		/******/ else if(typeof dep === "object")
		/******/ for(var i = 0; i < dep.length; i++)
		/******/ hot._declinedDependencies[dep[i]] = true;
		/******/ else
		/******/ hot._declinedDependencies[dep] = true;
		/******/ },
		/******/ dispose: function(callback) {
		/******/ hot._disposeHandlers.push(callback);
		/******/ },
		/******/ addDisposeHandler: function(callback) {
		/******/ hot._disposeHandlers.push(callback);
		/******/ },
		/******/ removeDisposeHandler: function(callback) {
		/******/ var idx = hot._disposeHandlers.indexOf(callback);
		/******/ if(idx >= 0) hot._disposeHandlers.splice(idx, 1);
		/******/ },
		/******/
		/******/ // Management API
		/******/ check: hotCheck,
		/******/ apply: hotApply,
		/******/ status: function(l) {
		/******/ if(!l) return hotStatus;
		/******/ hotStatusHandlers.push(l);
		/******/ },
		/******/ addStatusHandler: function(l) {
		/******/ hotStatusHandlers.push(l);
		/******/ },
		/******/ removeStatusHandler: function(l) {
		/******/ var idx = hotStatusHandlers.indexOf(l);
		/******/ if(idx >= 0) hotStatusHandlers.splice(idx, 1);
		/******/ },
		/******/
		/******/ //inherit from previous dispose call
		/******/ data: hotCurrentModuleData[moduleId]
		/******/ };
		/******/ hotCurrentChildModule = undefined;
		/******/ return hot;
		/******/ }
		/******/
		/******/ var hotStatusHandlers = [];
		/******/ var hotStatus = "idle";
		/******/
		/******/ function hotSetStatus(newStatus) {
		/******/ hotStatus = newStatus;
		/******/ for(var i = 0; i < hotStatusHandlers.length; i++)
		/******/ hotStatusHandlers[i].call(null, newStatus);
		/******/ }
		/******/
		/******/ // while downloading
		/******/ var hotWaitingFiles = 0;
		/******/ var hotChunksLoading = 0;
		/******/ var hotWaitingFilesMap = {};
		/******/ var hotRequestedFilesMap = {};
		/******/ var hotAvailableFilesMap = {};
		/******/ var hotDeferred;
		/******/
		/******/ // The update info
		/******/ var hotUpdate, hotUpdateNewHash;
		/******/
		/******/ function toModuleId(id) {
		/******/ var isNumber = (+id) + "" === id;
		/******/ return isNumber ? +id : id;
		/******/ }
		/******/
		/******/ function hotCheck(apply) {
		/******/ if(hotStatus !== "idle") throw new Error("check() is only allowed in idle status");
		/******/ hotApplyOnUpdate = apply;
		/******/ hotSetStatus("check");
		/******/ return hotDownloadManifest(hotRequestTimeout).then(function(update) {
		/******/ if(!update) {
		/******/ hotSetStatus("idle");
		/******/ return null;
		/******/ }
		/******/ hotRequestedFilesMap = {};
		/******/ hotWaitingFilesMap = {};
		/******/ hotAvailableFilesMap = update.c;
		/******/ hotUpdateNewHash = update.h;
		/******/
		/******/ hotSetStatus("prepare");
		/******/ var promise = new Promise(function(resolve, reject) {
		/******/ hotDeferred = {
		/******/ resolve: resolve,
		/******/ reject: reject
		/******/ };
		/******/ });
		/******/ hotUpdate = {};
		/******/ var chunkId = 0;
		/******/ { // eslint-disable-line no-lone-blocks
		/*****/ /globals chunkId */
		/******/ hotEnsureUpdateChunk(chunkId);
		/******/ }
		/******/ if(hotStatus === "prepare" && hotChunksLoading === 0 && hotWaitingFiles === 0) {
		/******/ hotUpdateDownloaded();
		/******/ }
		/******/ return promise;
		/******/ });
		/******/ }
		/******/
		/******/ function hotAddUpdateChunk(chunkId, moreModules) { // eslint-disable-line no-unused-vars
		/******/ if(!hotAvailableFilesMap[chunkId] \|\| !hotRequestedFilesMap[chunkId])
		/******/ return;
		/******/ hotRequestedFilesMap[chunkId] = false;
		/******/ for(var moduleId in moreModules) {
		/******/ if(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {
		/******/ hotUpdate[moduleId] = moreModules[moduleId];
		/******/ }
		/******/ }
		/******/ if(--hotWaitingFiles === 0 && hotChunksLoading === 0) {
		/******/ hotUpdateDownloaded();
		/******/ }
		/******/ }
		/******/
		/******/ function hotEnsureUpdateChunk(chunkId) {
		/******/ if(!hotAvailableFilesMap[chunkId]) {
		/******/ hotWaitingFilesMap[chunkId] = true;
		/******/ } else {
		/******/ hotRequestedFilesMap[chunkId] = true;
		/******/ hotWaitingFiles++;
		/******/ hotDownloadUpdateChunk(chunkId);
		/******/ }
		/******/ }
		/******/
		/******/ function hotUpdateDownloaded() {
		/******/ hotSetStatus("ready");
		/******/ var deferred = hotDeferred;
		/******/ hotDeferred = null;
		/******/ if(!deferred) return;
		/******/ if(hotApplyOnUpdate) {
		/******/ // Wrap deferred object in Promise to mark it as a well-handled Promise to
		/******/ // avoid triggering uncaught exception warning in Chrome.
		/******/ // See https://bugs.chromium.org/p/chromium/issues/detail?id=465666
		/******/ Promise.resolve().then(function() {
		/******/ return hotApply(hotApplyOnUpdate);
		/******/ }).then(
		/******/ function(result) {
		/******/ deferred.resolve(result);
		/******/ },
		/******/ function(err) {
		/******/ deferred.reject(err);
		/******/ }
		/******/ );
		/******/ } else {
		/******/ var outdatedModules = [];
		/******/ for(var id in hotUpdate) {
		/******/ if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
		/******/ outdatedModules.push(toModuleId(id));
		/******/ }
		/******/ }
		/******/ deferred.resolve(outdatedModules);
		/******/ }
		/******/ }
		/******/
		/******/ function hotApply(options) {
		/******/ if(hotStatus !== "ready") throw new Error("apply() is only allowed in ready status");
		/******/ options = options \|\| {};
		/******/
		/******/ var cb;
		/******/ var i;
		/******/ var j;
		/******/ var module;
		/******/ var moduleId;
		/******/
		/******/ function getAffectedStuff(updateModuleId) {
		/******/ var outdatedModules = [updateModuleId];
		/******/ var outdatedDependencies = {};
		/******/
		/******/ var queue = outdatedModules.slice().map(function(id) {
		/******/ return {
		/******/ chain: [id],
		/******/ id: id
		/******/ };
		/******/ });
		/******/ while(queue.length > 0) {
		/******/ var queueItem = queue.pop();
		/******/ var moduleId = queueItem.id;
		/******/ var chain = queueItem.chain;
		/******/ module = installedModules[moduleId];
		/******/ if(!module \|\| module.hot._selfAccepted)
		/******/ continue;
		/******/ if(module.hot._selfDeclined) {
		/******/ return {
		/******/ type: "self-declined",
		/******/ chain: chain,
		/******/ moduleId: moduleId
		/******/ };
		/******/ }
		/******/ if(module.hot._main) {
		/******/ return {
		/******/ type: "unaccepted",
		/******/ chain: chain,
		/******/ moduleId: moduleId
		/******/ };
		/******/ }
		/******/ for(var i = 0; i < module.parents.length; i++) {
		/******/ var parentId = module.parents[i];
		/******/ var parent = installedModules[parentId];
		/******/ if(!parent) continue;
		/******/ if(parent.hot._declinedDependencies[moduleId]) {
		/******/ return {
		/******/ type: "declined",
		/******/ chain: chain.concat([parentId]),
		/******/ moduleId: moduleId,
		/******/ parentId: parentId
		/******/ };
		/******/ }
		/******/ if(outdatedModules.indexOf(parentId) >= 0) continue;
		/******/ if(parent.hot._acceptedDependencies[moduleId]) {
		/******/ if(!outdatedDependencies[parentId])
		/******/ outdatedDependencies[parentId] = [];
		/******/ addAllToSet(outdatedDependencies[parentId], [moduleId]);
		/******/ continue;
		/******/ }
		/******/ delete outdatedDependencies[parentId];
		/******/ outdatedModules.push(parentId);
		/******/ queue.push({
		/******/ chain: chain.concat([parentId]),
		/******/ id: parentId
		/******/ });
		/******/ }
		/******/ }
		/******/
		/******/ return {
		/******/ type: "accepted",
		/******/ moduleId: updateModuleId,
		/******/ outdatedModules: outdatedModules,
		/******/ outdatedDependencies: outdatedDependencies
		/******/ };
		/******/ }
		/******/
		/******/ function addAllToSet(a, b) {
		/******/ for(var i = 0; i < b.length; i++) {
		/******/ var item = b[i];
		/******/ if(a.indexOf(item) < 0)
		/******/ a.push(item);
		/******/ }
		/******/ }
		/******/
		/******/ // at begin all updates modules are outdated
		/******/ // the "outdated" status can propagate to parents if they don't accept the children
		/******/ var outdatedDependencies = {};
		/******/ var outdatedModules = [];
		/******/ var appliedUpdate = {};
		/******/
		/******/ var warnUnexpectedRequire = function warnUnexpectedRequire() {
		/******/ console.warn("[HMR] unexpected require(" + result.moduleId + ") to disposed module");
		/******/ };
		/******/
		/******/ for(var id in hotUpdate) {
		/******/ if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
		/******/ moduleId = toModuleId(id);
		/******/ var result;
		/******/ if(hotUpdate[id]) {
		/******/ result = getAffectedStuff(moduleId);
		/******/ } else {
		/******/ result = {
		/******/ type: "disposed",
		/******/ moduleId: id
		/******/ };
		/******/ }
		/******/ var abortError = false;
		/******/ var doApply = false;
		/******/ var doDispose = false;
		/******/ var chainInfo = "";
		/******/ if(result.chain) {
		/******/ chainInfo = "\nUpdate propagation: " + result.chain.join(" -> ");
		/******/ }
		/******/ switch(result.type) {
		/******/ case "self-declined":
		/******/ if(options.onDeclined)
		/******/ options.onDeclined(result);
		/******/ if(!options.ignoreDeclined)
		/******/ abortError = new Error("Aborted because of self decline: " + result.moduleId + chainInfo);
		/******/ break;
		/******/ case "declined":
		/******/ if(options.onDeclined)
		/******/ options.onDeclined(result);
		/******/ if(!options.ignoreDeclined)
		/******/ abortError = new Error("Aborted because of declined dependency: " + result.moduleId + " in " + result.parentId + chainInfo);
		/******/ break;
		/******/ case "unaccepted":
		/******/ if(options.onUnaccepted)
		/******/ options.onUnaccepted(result);
		/******/ if(!options.ignoreUnaccepted)
		/******/ abortError = new Error("Aborted because " + moduleId + " is not accepted" + chainInfo);
		/******/ break;
		/******/ case "accepted":
		/******/ if(options.onAccepted)
		/******/ options.onAccepted(result);
		/******/ doApply = true;
		/******/ break;
		/******/ case "disposed":
		/******/ if(options.onDisposed)
		/******/ options.onDisposed(result);
		/******/ doDispose = true;
		/******/ break;
		/******/ default:
		/******/ throw new Error("Unexception type " + result.type);
		/******/ }
		/******/ if(abortError) {
		/******/ hotSetStatus("abort");
		/******/ return Promise.reject(abortError);
		/******/ }
		/******/ if(doApply) {
		/******/ appliedUpdate[moduleId] = hotUpdate[moduleId];
		/******/ addAllToSet(outdatedModules, result.outdatedModules);
		/******/ for(moduleId in result.outdatedDependencies) {
		/******/ if(Object.prototype.hasOwnProperty.call(result.outdatedDependencies, moduleId)) {
		/******/ if(!outdatedDependencies[moduleId])
		/******/ outdatedDependencies[moduleId] = [];
		/******/ addAllToSet(outdatedDependencies[moduleId], result.outdatedDependencies[moduleId]);
		/******/ }
		/******/ }
		/******/ }
		/******/ if(doDispose) {
		/******/ addAllToSet(outdatedModules, [result.moduleId]);
		/******/ appliedUpdate[moduleId] = warnUnexpectedRequire;
		/******/ }
		/******/ }
		/******/ }
		/******/
		/******/ // Store self accepted outdated modules to require them later by the module system
		/******/ var outdatedSelfAcceptedModules = [];
		/******/ for(i = 0; i < outdatedModules.length; i++) {
		/******/ moduleId = outdatedModules[i];
		/******/ if(installedModules[moduleId] && installedModules[moduleId].hot._selfAccepted)
		/******/ outdatedSelfAcceptedModules.push({
		/******/ module: moduleId,
		/******/ errorHandler: installedModules[moduleId].hot._selfAccepted
		/******/ });
		/******/ }
		/******/
		/******/ // Now in "dispose" phase
		/******/ hotSetStatus("dispose");
		/******/ Object.keys(hotAvailableFilesMap).forEach(function(chunkId) {
		/******/ if(hotAvailableFilesMap[chunkId] === false) {
		/******/ hotDisposeChunk(chunkId);
		/******/ }
		/******/ });
		/******/
		/******/ var idx;
		/******/ var queue = outdatedModules.slice();
		/******/ while(queue.length > 0) {
		/******/ moduleId = queue.pop();
		/******/ module = installedModules[moduleId];
		/******/ if(!module) continue;
		/******/
		/******/ var data = {};
		/******/
		/******/ // Call dispose handlers
		/******/ var disposeHandlers = module.hot._disposeHandlers;
		/******/ for(j = 0; j < disposeHandlers.length; j++) {
		/******/ cb = disposeHandlers[j];
		/******/ cb(data);
		/******/ }
		/******/ hotCurrentModuleData[moduleId] = data;
		/******/
		/******/ // disable module (this disables requires from this module)
		/******/ module.hot.active = false;
		/******/
		/******/ // remove module from cache
		/******/ delete installedModules[moduleId];
		/******/
		/******/ // when disposing there is no need to call dispose handler
		/******/ delete outdatedDependencies[moduleId];
		/******/
		/******/ // remove "parents" references from all children
		/******/ for(j = 0; j < module.children.length; j++) {
		/******/ var child = installedModules[module.children[j]];
		/******/ if(!child) continue;
		/******/ idx = child.parents.indexOf(moduleId);
		/******/ if(idx >= 0) {
		/******/ child.parents.splice(idx, 1);
		/******/ }
		/******/ }
		/******/ }
		/******/
		/******/ // remove outdated dependency from module children
		/******/ var dependency;
		/******/ var moduleOutdatedDependencies;
		/******/ for(moduleId in outdatedDependencies) {
		/******/ if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) {
		/******/ module = installedModules[moduleId];
		/******/ if(module) {
		/******/ moduleOutdatedDependencies = outdatedDependencies[moduleId];
		/******/ for(j = 0; j < moduleOutdatedDependencies.length; j++) {
		/******/ dependency = moduleOutdatedDependencies[j];
		/******/ idx = module.children.indexOf(dependency);
		/******/ if(idx >= 0) module.children.splice(idx, 1);
		/******/ }
		/******/ }
		/******/ }
		/******/ }
		/******/
		/******/ // Not in "apply" phase
		/******/ hotSetStatus("apply");
		/******/
		/******/ hotCurrentHash = hotUpdateNewHash;
		/******/
		/******/ // insert new code
		/******/ for(moduleId in appliedUpdate) {
		/******/ if(Object.prototype.hasOwnProperty.call(appliedUpdate, moduleId)) {
		/******/ modules[moduleId] = appliedUpdate[moduleId];
		/******/ }
		/******/ }
		/******/
		/******/ // call accept handlers
		/******/ var error = null;
		/******/ for(moduleId in outdatedDependencies) {
		/******/ if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) {
		/******/ module = installedModules[moduleId];
		/******/ if(module) {
		/******/ moduleOutdatedDependencies = outdatedDependencies[moduleId];
		/******/ var callbacks = [];
		/******/ for(i = 0; i < moduleOutdatedDependencies.length; i++) {
		/******/ dependency = moduleOutdatedDependencies[i];
		/******/ cb = module.hot._acceptedDependencies[dependency];
		/******/ if(cb) {
		/******/ if(callbacks.indexOf(cb) >= 0) continue;
		/******/ callbacks.push(cb);
		/******/ }
		/******/ }
		/******/ for(i = 0; i < callbacks.length; i++) {
		/******/ cb = callbacks[i];
		/******/ try {
		/******/ cb(moduleOutdatedDependencies);
		/******/ } catch(err) {
		/******/ if(options.onErrored) {
		/******/ options.onErrored({
		/******/ type: "accept-errored",
		/******/ moduleId: moduleId,
		/******/ dependencyId: moduleOutdatedDependencies[i],
		/******/ error: err
		/******/ });
		/******/ }
		/******/ if(!options.ignoreErrored) {
		/******/ if(!error)
		/******/ error = err;
		/******/ }
		/******/ }
		/******/ }
		/******/ }
		/******/ }
		/******/ }
		/******/
		/******/ // Load self accepted modules
		/******/ for(i = 0; i < outdatedSelfAcceptedModules.length; i++) {
		/******/ var item = outdatedSelfAcceptedModules[i];
		/******/ moduleId = item.module;
		/******/ hotCurrentParents = [moduleId];
		/******/ try {
		/******/ __webpack_require__(moduleId);
		/******/ } catch(err) {
		/******/ if(typeof item.errorHandler === "function") {
		/******/ try {
		/******/ item.errorHandler(err);
		/******/ } catch(err2) {
		/******/ if(options.onErrored) {
		/******/ options.onErrored({
		/******/ type: "self-accept-error-handler-errored",
		/******/ moduleId: moduleId,
		/******/ error: err2,
		/******/ orginalError: err, // TODO remove in webpack 4
		/******/ originalError: err
		/******/ });
		/******/ }
		/******/ if(!options.ignoreErrored) {
		/******/ if(!error)
		/******/ error = err2;
		/******/ }
		/******/ if(!error)
		/******/ error = err;
		/******/ }
		/******/ } else {
		/******/ if(options.onErrored) {
		/******/ options.onErrored({
		/******/ type: "self-accept-errored",
		/******/ moduleId: moduleId,
		/******/ error: err
		/******/ });
		/******/ }
		/******/ if(!options.ignoreErrored) {
		/******/ if(!error)
		/******/ error = err;
		/******/ }
		/******/ }
		/******/ }
		/******/ }
		/******/
		/******/ // handle errors in accept handlers and self accepted module load
		/******/ if(error) {
		/******/ hotSetStatus("fail");
		/******/ return Promise.reject(error);
		/******/ }
		/******/
		/******/ hotSetStatus("idle");
		/******/ return new Promise(function(resolve) {
		/******/ resolve(outdatedModules);
		/******/ });
		/******/ }
		/******/
		/******/ // The module cache
		/******/ var installedModules = {};
		/******/
		/******/ // The require function
		/******/ function __webpack_require__(moduleId) {
		/******/
		/******/ // Check if module is in cache
		/******/ if(installedModules[moduleId]) {
		/******/ return installedModules[moduleId].exports;
		/******/ }
		/******/ // Create a new module (and put it into the cache)
		/******/ var module = installedModules[moduleId] = {
		/******/ i: moduleId,
		/******/ l: false,
		/******/ exports: {},
		/******/ hot: hotCreateModule(moduleId),
		/******/ parents: (hotCurrentParentsTemp = hotCurrentParents, hotCurrentParents = [], hotCurrentParentsTemp),
		/******/ children: []
		/******/ };
		/******/
		/******/ // Execute the module function
		/******/ modules[moduleId].call(module.exports, module, module.exports, hotCreateRequire(moduleId));
		/******/
		/******/ // Flag the module as loaded
		/******/ module.l = true;
		/******/
		/******/ // Return the exports of the module
		/******/ return module.exports;
		/******/ }
		/******/
		/******/
		/******/ // expose the modules object (__webpack_modules__)
		/******/ __webpack_require__.m = modules;
		/******/
		/******/ // expose the module cache
		/******/ __webpack_require__.c = installedModules;
		/******/
		/******/ // define getter function for harmony exports
		/******/ __webpack_require__.d = function(exports, name, getter) {
		/******/ if(!__webpack_require__.o(exports, name)) {
		/******/ Object.defineProperty(exports, name, {
		/******/ configurable: false,
		/******/ enumerable: true,
		/******/ get: getter
		/******/ });
		/******/ }
		/******/ };
		/******/
		/******/ // getDefaultExport function for compatibility with non-harmony modules
		/******/ __webpack_require__.n = function(module) {
		/******/ var getter = module && module.__esModule ?
		/******/ function getDefault() { return module['default']; } :
		/******/ function getModuleExports() { return module; };
		/******/ __webpack_require__.d(getter, 'a', getter);
		/******/ return getter;
		/******/ };
		/******/
		/******/ // Object.prototype.hasOwnProperty.call
		/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
		/******/
		/******/ // __webpack_public_path__
		/******/ __webpack_require__.p = "/scripts/";
		/******/
		/******/ // __webpack_hash__
		/******/ __webpack_require__.h = function() { return hotCurrentHash; };
		/******/
		/******/ // Load entry module and return exports
		/******/ return hotCreateRequire(0)(__webpack_require__.s = 0);
		/******/ })
		/************************************************************************/
		/******/ ([
		/* 0 */
		/***/ (function(module, __webpack_exports__, __webpack_require__) {

		"use strict";
		Object.defineProperty(__webpack_exports__, "__esModule", { value: true });

		// CONCATENATED MODULE: /Users/sghoweri/sites/bolt-master/node_modules/stickybits/dist/stickybits.es.js
		/*
		STICKYBITS 💉
		--------
		> a lightweight alternative to `position: sticky` polyfills 🍬
		--------
		- each method is documented above it our view the readme
		- Stickybits does not manage polymorphic functionality (position like properties)
		* polymorphic functionality: (in the context of describing Stickybits)
		means making things like `position: sticky` be loosely supported with position fixed.
		It also means that features like `useStickyClasses` takes on styles like `position: fixed`.
		--------
		defaults 🔌
		--------
		- version = `package.json` version
		- userAgent = viewer browser agent
		- target = DOM element selector
		- noStyles = boolean
		- offset = number
		- parentClass = 'string'
		- scrollEl = window \|\| DOM element selector
		- stickyClass = 'string'
		- stuckClass = 'string'
		- useStickyClasses = boolean
		- verticalPosition = 'string'
		--------
		props🔌
		--------
		- p = props {object}
		--------
		instance note
		--------
		- stickybits parent methods return this
		- stickybits instance methods return an instance item
		--------
		nomenclature
		--------
		- target => el => e
		- props => o \|\| p
		- instance => item => it
		--------
		methods
		--------
		- .definePosition = defines sticky or fixed
		- .addInstance = an array of objects for each Stickybits Target
		- .getClosestParent = gets the parent for non-window scroll
		- .computeScrollOffsets = computes scroll position
		- .toggleClasses = older browser toggler
		- .manageState = manages sticky state
		- .removeClass = older browser support class remover
		- .removeInstance = removes an instance
		- .cleanup = removes all Stickybits instances and cleans up dom from stickybits
		*/
		function Stickybits(target, obj) {
		var o = typeof obj !== 'undefined' ? obj : {};
		this.version = '2.0.13';
		this.userAgent = window.navigator.userAgent \|\| 'no `userAgent` provided by the browser';
		this.props = {
		noStyles: o.noStyles \|\| false,
		stickyBitStickyOffset: o.stickyBitStickyOffset \|\| 0,
		parentClass: o.parentClass \|\| 'js-stickybit-parent',
		scrollEl: o.scrollEl \|\| window,
		stickyClass: o.stickyClass \|\| 'js-is-sticky',
		stuckClass: o.stuckClass \|\| 'js-is-stuck',
		useStickyClasses: o.useStickyClasses \|\| false,
		verticalPosition: o.verticalPosition \|\| 'top'
		};
		var p = this.props;
		/*
		define positionVal
		----
		- uses a computed (`.definePosition()`)
		- defined the position
		*/
		p.positionVal = this.definePosition() \|\| 'fixed';
		var vp = p.verticalPosition;
		var ns = p.noStyles;
		var pv = p.positionVal;
		this.els = typeof target === 'string' ? document.querySelectorAll(target) : target;
		if (!('length' in this.els)) this.els = [this.els];
		this.instances = [];
		for (var i = 0; i < this.els.length; i += 1) {
		var el = this.els[i];
		var styles = el.style;
		if (vp === 'top' && !ns) styles[vp] = p.stickyBitStickyOffset + 'px';
		if (pv !== 'fixed' && p.useStickyClasses === false) {
		styles.position = pv;
		} else {
		// const stickyManager = new ManageSticky(el, p)
		if (pv !== 'fixed') styles.position = pv;
		var instance = this.addInstance(el, p);
		// instances are an array of objects
		this.instances.push(instance);
		}
		}
		return this;
		}

		/*
		setStickyPosition ✔️
		--------
		— most basic thing stickybits does
		=> checks to see if position sticky is supported
		=> defined the position to be used
		=> stickybits works accordingly
		*/
		Stickybits.prototype.definePosition = function () {
		var prefix = ['', '-o-', '-webkit-', '-moz-', '-ms-'];
		var test = document.head.style;
		for (var i = 0; i < prefix.length; i += 1) {
		test.position = prefix[i] + 'sticky';
		}
		var stickyProp = 'fixed';
		if (typeof test.position !== 'undefined') stickyProp = test.position;
		test.position = '';
		return stickyProp;
		};

		/*
		addInstance ✔️
		--------
		— manages instances of items
		- takes in an el and props
		- returns an item object
		---
		- target = el
		- o = {object} = props
		- scrollEl = 'string'
		- verticalPosition = number
		- off = boolean
		- parentClass = 'string'
		- stickyClass = 'string'
		- stuckClass = 'string'
		---
		- defined later
		- parent = dom element
		- state = 'string'
		- offset = number
		- stickyStart = number
		- stickyStop = number
		- returns an instance object
		*/
		Stickybits.prototype.addInstance = function addInstance(el, props) {
		var _this = this;

		var item = {
		el: el,
		parent: el.parentNode,
		props: props
		};
		var p = item.props;
		item.parent.className += ' ' + props.parentClass;
		var se = p.scrollEl;
		item.isWin = se === window;
		if (!item.isWin) se = this.getClosestParent(item.el, se);
		this.computeScrollOffsets(item);
		item.state = 'default';
		item.stateContainer = function () {
		_this.manageState(item);
		};
		se.addEventListener('scroll', item.stateContainer);
		return item;
		};

		/*
		--------
		getParent 👨‍
		--------
		- a helper function that gets the target element's parent selected el
		- only used for non `window` scroll elements
		- supports older browsers
		*/
		Stickybits.prototype.getClosestParent = function getClosestParent(el, matchSelector) {
		// p = parent element
		var p = document.querySelector(matchSelector);
		var e = el;
		if (e.parentElement === p) return p;
		// traverse up the dom tree until we get to the parent
		while (e.parentElement !== p) {
		e = e.parentElement;
		} // return parent element
		return p;
		};

		/*
		computeScrollOffsets 📊
		---
		computeScrollOffsets for Stickybits
		- defines
		- offset
		- start
		- stop
		*/
		Stickybits.prototype.computeScrollOffsets = function computeScrollOffsets(item) {
		var it = item;
		var p = it.props;
		var parent = it.parent;
		var iw = it.isWin;
		var scrollElOffset = 0;
		var stickyStart = parent.getBoundingClientRect().top;
		if (!iw && p.positionVal === 'fixed') {
		scrollElOffset = p.scrollEl.getBoundingClientRect().top;
		stickyStart = parent.getBoundingClientRect().top - scrollElOffset;
		}
		it.offset = scrollElOffset + p.stickyBitStickyOffset;
		it.stickyStart = stickyStart - it.offset;
		it.stickyStop = stickyStart + parent.offsetHeight - (it.el.offsetHeight + it.offset);
		return it;
		};

		/*
		toggleClasses ⚖️
		---
		toggles classes (for older browser support)
		r = removed class
		a = added class
		*/
		Stickybits.prototype.toggleClasses = function toggleClasses(el, r, a) {
		var e = el;
		var cArray = e.className.split(' ');
		if (a && cArray.indexOf(a) === -1) cArray.push(a);
		var rItem = cArray.indexOf(r);
		if (rItem !== -1) cArray.splice(rItem, 1);
		e.className = cArray.join(' ');
		};

		/*
		manageState 📝
		---
		- defines the state
		- normal
		- sticky
		- stuck
		*/
		Stickybits.prototype.manageState = function manageState(item) {
		// cache object
		var it = item;
		var e = it.el;
		var p = it.props;
		var state = it.state;
		var start = it.stickyStart;
		var stop = it.stickyStop;
		var stl = e.style;
		// cache props
		var ns = p.noStyles;
		var pv = p.positionVal;
		var se = p.scrollEl;
		var sticky = p.stickyClass;
		var stuck = p.stuckClass;
		var vp = p.verticalPosition;
		/*
		requestAnimationFrame
		---
		- use rAF
		- or stub rAF
		*/
		var rAF = se.requestAnimationFrame;
		if (!it.isWin \|\| typeof rAF === 'undefined') {
		rAF = function rAFDummy(f) {
		f();
		};
		}
		/*
		define scroll vars
		---
		- scroll
		- notSticky
		- isSticky
		- isStuck
		*/
		var tC = this.toggleClasses;
		var scroll = it.isWin ? se.scrollY \|\| se.pageYOffset : se.scrollTop;
		var notSticky = scroll > start && scroll < stop && (state === 'default' \|\| state === 'stuck');
		var isSticky = scroll <= start && state === 'sticky';
		var isStuck = scroll >= stop && state === 'sticky';
		/*
		Unnamed arrow functions within this block
		---
		- help wanted or discussion
		- view test.stickybits.js
		- `stickybits .manageState `position: fixed` interface` for more awareness 👀
		*/
		if (notSticky) {
		it.state = 'sticky';
		rAF(function () {
		tC(e, stuck, sticky);
		stl.position = pv;
		if (ns) return;
		stl.bottom = '';
		stl[vp] = p.stickyBitStickyOffset + 'px';
		});
		} else if (isSticky) {
		it.state = 'default';
		rAF(function () {
		tC(e, sticky);
		if (pv === 'fixed') stl.position = '';
		});
		} else if (isStuck) {
		it.state = 'stuck';
		rAF(function () {
		tC(e, sticky, stuck);
		if (pv !== 'fixed' \|\| ns) return;
		stl.top = '';
		stl.bottom = '0';
		stl.position = 'absolute';
		});
		}
		return it;
		};

		/*
		removes an instance 👋
		--------
		- cleanup instance
		*/
		Stickybits.prototype.removeInstance = function removeInstance(instance) {
		var e = instance.el;
		var p = instance.props;
		var tC = this.toggleClasses;
		e.style.position = '';
		e.style[p.verticalPosition] = '';
		tC(e, p.stickyClass);
		tC(e, p.stuckClass);
		tC(e.parentNode, p.parentClass);
		};

		/*
		cleanup 🛁
		--------
		- cleans up each instance
		- clears instance
		*/
		Stickybits.prototype.cleanup = function cleanup() {
		for (var i = 0; i < this.instances.length; i += 1) {
		var instance = this.instances[i];
		instance.props.scrollEl.removeEventListener('scroll', instance.stateContainer);
		this.removeInstance(instance);
		}
		this.manageState = false;
		this.instances = [];
		};

		/*
		export
		--------
		exports StickBits to be used 🏁
		*/
		function stickybits(target, o) {
		return new Stickybits(target, o);
		}

		/* harmony default export */ var stickybits_es = (stickybits);
		// CONCATENATED MODULE: ./src/sticky.js


		stickybits_es('.js-bolt-sticky');

		/***/ })
		/******/ ]);
		//# sourceMappingURL=bolt-sticky.min.js.map

package.json

		@@ -13,3 +13,3 @@ {
		],
		"version": "0.1.0-beta.2",
		"version": "0.1.0-beta.4",
		"maintainers": [
		@@ -47,3 +47,3 @@ {
		"devDependencies": {
		"@bolt/build-webpack": "^0.5.0-beta.2"
		"@bolt/build-webpack": "^0.5.0-beta.4"
		},
		@@ -50,0 +50,0 @@ "scripts": {

@bolt/components-sticky - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics