var _____WB$wombat$assign$function_____ = function(name) {return (self._wb_wombat && self._wb_wombat.local_init && self._wb_wombat.local_init(name)) || self[name]; };
if (!self.__WB_pmw) { self.__WB_pmw = function(obj) { this.__WB_source = obj; return this; } }
{
  let window = _____WB$wombat$assign$function_____("window");
  let self = _____WB$wombat$assign$function_____("self");
  let document = _____WB$wombat$assign$function_____("document");
  let location = _____WB$wombat$assign$function_____("location");
  let top = _____WB$wombat$assign$function_____("top");
  let parent = _____WB$wombat$assign$function_____("parent");
  let frames = _____WB$wombat$assign$function_____("frames");
  let opener = _____WB$wombat$assign$function_____("opener");

/******/ (function(modules) { // webpackBootstrap
/******/     // 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] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.loaded = 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;
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var _mobileMenu = __webpack_require__(1);
	
	var _mobileMenu2 = _interopRequireDefault(_mobileMenu);
	
	var _forms = __webpack_require__(2);
	
	var _forms2 = _interopRequireDefault(_forms);
	
	var _header = __webpack_require__(3);
	
	var _header2 = _interopRequireDefault(_header);
	
	var _footer = __webpack_require__(4);
	
	var _footer2 = _interopRequireDefault(_footer);
	
	var _browseBy = __webpack_require__(5);
	
	var _browseBy2 = _interopRequireDefault(_browseBy);
	
	var _product = __webpack_require__(6);
	
	var _product2 = _interopRequireDefault(_product);
	
	var _inspiration = __webpack_require__(8);
	
	var _inspiration2 = _interopRequireDefault(_inspiration);
	
	var _blog = __webpack_require__(9);
	
	var _blog2 = _interopRequireDefault(_blog);
	
	var _findYourColor = __webpack_require__(10);
	
	var _findYourColor2 = _interopRequireDefault(_findYourColor);
	
	var _accordion = __webpack_require__(12);
	
	var _accordion2 = _interopRequireDefault(_accordion);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	$(document).ready(function () {
	  $('link[href*="layout.min.css"]').remove();
	  _mobileMenu2.default.create();
	  _header2.default.offsetHeight();
	  _footer2.default.wrapMenu();
	  _footer2.default.setupExpanders();
	  _header2.default.addDropdownCarets();
	  _browseBy2.default.styleInit();
	  _browseBy2.default.metalRoofingInit();
	  _browseBy2.default.pageInit();
	  _product2.default.detailsInit();
	  _product2.default.colorsInit();
	  _product2.default.iconInit();
	  _inspiration2.default.init();
	  _forms2.default.wrapSelectFields();
	  _findYourColor2.default.init();
	  _accordion2.default.init();
	
	  if ($('body').hasClass('blog')) {
	    _blog2.default.topicsHeader();
	    _blog2.default.subscribeInit();
	    _blog2.default.wrapImages();
	    _blog2.default.markEmpties();
	  }
	
	  if ($('body').hasClass('blog--post')) {
	    _blog2.default.getSharePos();
	  }
	});
	
	$(window).load(function () {
	  _forms2.default.scrollOnValidationError();
	  _forms2.default.wrapSelectFields();
	
	  if ($('body').hasClass('blog--post')) {
	    _blog2.default.getSharePos();
	  }
	});
	
	$(window).resize(function () {
	  _header2.default.offsetHeight();
	
	  if ($('body').hasClass('blog--post') && $(window).width() >= 768) {
	    _blog2.default.getSharePos();
	  }
	});
	
	$(window).scroll(function () {
	  var windowWidth = $(window).width();
	
	  if (windowWidth >= 992) {
	    _header2.default.checkScroll();
	  }
	
	  if ($('body').hasClass('blog--post') && $(window).width() >= 768) {
	    _blog2.default.checkShareScroll();
	  }
	});

/***/ },
/* 1 */
/***/ function(module, exports) {

	'use strict';
	
	var open = function open() {
	  $('.menu-trigger__container').addClass('open');
	  $('.mobile-menu').addClass('open');
	  $('body').addClass('menu-open');
	};
	
	var close = function close() {
	  $('.menu-trigger__container').removeClass('open');
	  $('.mobile-menu').removeClass('open');
	  $('body').removeClass('menu-open');
	};
	
	exports.create = function () {
	  var $trigger = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : $('.menu-trigger__container');
	  var $main = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : $('.site-header__main-menu > div');
	  var $secondary = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : $('.site-header__sub-menu');
	  var $message = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : $('.site-header__expert');
	  var $close = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : $('.mobile-menu__close-btn');
	
	  var mainMenu = $main.html();
	  var secondaryMenu = $secondary.html();
	  var message = $message.html();
	
	  $('body').append('<div class="mobile-menu">\n      <div class="inner">\n        <div class="mobile-menu__main">' + mainMenu + '</div>\n        <div class="mobile-menu__secondary"><ul>' + secondaryMenu + '</ul></div>\n      </div>\n      <div class="mobile-menu__bottom">' + message + '</div>\n    </div>');
	
	  $trigger.click(function mobileMenuTriggerClick() {
	    if ($trigger.hasClass('open')) {
	      close();
	    } else {
	      open();
	    }
	  });
	
	  $close.click(function mobileMenuCloseClick() {
	    close();
	  });
	};

/***/ },
/* 2 */
/***/ function(module, exports) {

	'use strict';
	
	exports.scrollOnValidationError = function () {
	  var $allForms = $('.hs-form');
	  var scrollOffset = 10; // if you have a fixed header, accommodate for that here
	
	  $allForms.each(function eachForm() {
	    var $form = $(this);
	    var scrollToError = function scrollToError(name) {
	      var $error = $form.find('input[name="' + name + '"]').parent().parent();
	      if ($error.length > 0) {
	        $('html, body').animate({
	          scrollTop: $error.offset().top - scrollOffset
	        }, 'slow');
	      }
	    };
	
	    $form.submit(function formSubmit() {
	      setTimeout(function () {
	        var context = JSON.parse($form.find('input[name="hs_context"]').attr('value'));
	        if (context.hasOwnProperty('formValidity')) {
	          (function () {
	            var validity = context.formValidity;
	            var errorHappened = false;
	            Object.keys(validity).forEach(function (key) {
	              // only trigger on first error if there are several
	              if (!errorHappened && !validity[key].valid) {
	                errorHappened = true;
	                scrollToError(key);
	              }
	            });
	          })();
	        }
	      }, 100);
	    });
	  });
	};
	
	exports.wrapSelectFields = function () {
	  var $select = $('select.hs-input');
	  var $parent = $select.parent().parent();
	
	  if (!$parent.hasClass('hs_dropdown_select')) {
	    $select.parent().parent().addClass('hs_dropdown_select');
	  }
	};

/***/ },
/* 3 */
/***/ function(module, exports) {

	'use strict';
	
	exports.offsetHeight = function () {
	  var $header = $('.site-header');
	  var headerHeight = $header.outerHeight();
	
	  $('.body-container .widget-span:not(:empty)').first().css('padding-top', headerHeight + 'px');
	};
	
	exports.checkScroll = function () {
	  var $header = $('.site-header');
	  var subHeaderHeight = $('.site-header__sub').outerHeight() + 1;
	  var currentScroll = $(window).scrollTop();
	  var isFixed = $header.hasClass('site-header--fixed');
	
	  if (currentScroll >= subHeaderHeight && !isFixed) {
	    $header.addClass('site-header--fixed');
	    $header.css('top', '-' + subHeaderHeight + 'px');
	  } else if (currentScroll < subHeaderHeight && isFixed) {
	    $header.removeClass('site-header--fixed');
	    $header.attr('style', '');
	  }
	};
	
	exports.addDropdownCarets = function () {
	  $('.site-header li.hs-menu-depth-1.hs-item-has-children > a').wrapInner('<span></span>');
	};

/***/ },
/* 4 */
/***/ function(module, exports) {

	'use strict';
	
	exports.wrapMenu = function () {
	  var $footerMenu = $('.site-footer__main-menu');
	  var wideWrapper = '<div class="site-footer__column site-footer__column--wide"></div>';
	  var narrowWrapper = '<div class="site-footer__column site-footer__column--narrow"></div>';
	
	  $footerMenu.find('.hs-menu-depth-1:first-child').wrap(wideWrapper);
	  $footerMenu.find('.hs-menu-depth-1:nth-child(2)').wrap(narrowWrapper);
	  $footerMenu.find('.hs-menu-depth-1:eq(3), .hs-menu-depth-1:eq(2)').wrapAll(narrowWrapper);
	  $footerMenu.find('> div > ul > .hs-menu-depth-1').wrapAll(narrowWrapper);
	};
	
	exports.setupExpanders = function () {
	  var $firstTier = $('.site-footer__main-menu .hs-menu-depth-1 > a');
	
	  $firstTier.click(function firstTierClicked(event) {
	    if ($(window).width() < 768) {
	      event.preventDefault();
	      $(this).parent().toggleClass('expand');
	    }
	  });
	};

/***/ },
/* 5 */
/***/ function(module, exports) {

	'use strict';
	
	exports.styleInit = function () {
	  var $browseByStyle = $('.browse-by-style');
	
	  if ($browseByStyle.length > 0) {
	    $browseByStyle.each(function eachBrowseByStyle() {
	      var $menu = $(this).find('.browse-by-style__menu');
	      var content = $('.site-header a:contains("Browse By Style")').parent().find('> ul').html();
	
	      $menu.html(content);
	    });
	  }
	};
	
	exports.metalRoofingInit = function () {
	  var $nest = $('.metal-roofing-and-siding-menu');
	
	  if ($nest.length > 0) {
	    var $source = $nest.find('.metal-roofing-and-siding-menu__source');
	    var $categoryMenu = $nest.find('.metal-roofing-and-siding-menu__menu--category');
	    var $styleMenu = $nest.find('.metal-roofing-and-siding-menu__menu--style');
	    var $colorMenu = $nest.find('.metal-roofing-and-siding-menu__menu--color');
	
	    var categoryContent = $source.find('a:contains("Browse By Collection")').parent().find('> ul').html();
	    var styleContent = $source.find('a:contains("Browse By Style")').parent().find('> ul').html();
	    var colorContent = $source.find('a:contains("Browse By Color")').parent().find('> ul').html();
	
	    $categoryMenu.html(categoryContent);
	    $styleMenu.html(styleContent);
	    $colorMenu.html(colorContent);
	
	    $nest.find('.metal-roofing-and-siding-menu__menu li.hs-item-has-children > a').wrap('<div class="metal-roofing-and-siding-menu__expander"></div>');
	
	    $nest.find('.metal-roofing-and-siding-menu__expander').click(function expanderClicked() {
	      $(this).parent().toggleClass('open');
	      $(this).toggleClass('metal-roofing-and-siding-menu__expander--open');
	    });
	
	    $source.detach();
	  }
	};
	
	exports.pageInit = function () {
	  var $nest = $('.browse-by-header');
	
	  if ($nest.length > 0) {
	    (function () {
	      var $onPageNav = $('.browse-by-header__on-page-nav');
	      var $sections = $('.product-category-section');
	      var type = $nest.attr('data-type');
	      var $source = $nest.find('.browse-by-header__source a:contains("Browse By ' + type + '")').parent().find('> ul');
	      var sectionsList = '';
	
	      $sections.each(function eachProductSection() {
	        var title = $(this).find('.product-category-section__title').text();
	        var anchor = $(this).find('.product-category-section__anchor').attr('id');
	        sectionsList += '<li><a href="#' + anchor + '">' + title + '</a></li>';
	
	        var $thisNav = $(this).find('.product-category-section__menu');
	        var content = $source.find('.hs-menu-depth-3 > a:contains("' + title + '")').parent().find('> ul').html();
	        $thisNav.html(content);
	
	        var productCount = $thisNav.find('li').length;
	        $thisNav.find('> li:nth-child(n+7)').wrapAll('<div class="product-category-section__more"></div>');
	        if (productCount > 6) {
	          $thisNav.append('<li class="product-category-section__expander"><span>View More</span></li>');
	        }
	
	        $thisNav.find('.product-category-section__expander > span').click(function expanderClicked() {
	          $(this).detach();
	          $thisNav.find('.product-category-section__more > li').unwrap();
	        });
	      });
	
	      $onPageNav.html(sectionsList);
	
	      $onPageNav.find('a').click(function onPageNavClicked(event) {
	        event.preventDefault();
	
	        var headerHeight = $('.site-header__main').outerHeight();
	        var href = $(this).attr('href').replace('#', '');
	        var $target = $('a[id="' + href + '"]');
	
	        $('html, body').animate({
	          scrollTop: $target.offset().top - headerHeight
	        }, 1000);
	      });
	
	      $nest.find('.browse-by-header__source').detach();
	    })();
	  }
	};

/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var _objectFitImages = __webpack_require__(7);
	
	var _objectFitImages2 = _interopRequireDefault(_objectFitImages);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	exports.checkDetailsCount = function () {
	  var totalDetails = $('.product-details__flexible .product-detail').length;
	  var expandedDetails = $('.product-details__flexible .product-detail--expanded').length;
	  var $expandAll = $('.product-sidebar-header__expand-all');
	
	  if (totalDetails === expandedDetails) {
	    $expandAll.text('Close All');
	  } else {
	    $expandAll.text('Expand All');
	  }
	};
	
	exports.detailsInit = function () {
	  if ($('body').hasClass('product-page')) {
	    (function () {
	      var $detailsFlexible = $('.product-details__flexible');
	      var $details = $detailsFlexible.find('.product-detail');
	      var $expandAll = $('.product-sidebar-header__expand-all');
	
	      $details.each(function eachDetails() {
	        var $that = $(this);
	        $(this).find('.product-detail__trigger').click(function detailsTriggerClicked() {
	          $that.toggleClass('product-detail--expanded');
	          exports.checkDetailsCount();
	        });
	      });
	
	      $expandAll.click(function expandAllClicked() {
	        var expandText = $(this).text();
	
	        if (expandText === 'Close All') {
	          $details.removeClass('product-detail--expanded');
	        } else if (expandText === 'Expand All') {
	          $details.addClass('product-detail--expanded');
	        }
	
	        exports.checkDetailsCount();
	      });
	    })();
	  }
	};
	
	exports.triggerColorModal = function ($elem) {
	  var $modal = $('.colors__modal');
	  var $pattern = $('.colors__modal-pattern');
	  var $caption = $('.colors__modal-caption');
	
	  var styles = $elem.attr('style');
	  var name = $elem.attr('data-name');
	
	  $pattern.attr('style', styles);
	  $caption.text(name);
	  $modal.addClass('colors__modal--open');
	};
	
	exports.colorsInit = function () {
	  var $colors = $('.colors');
	
	  if ($colors.length > 0) {
	    var $color = $colors.find('.colors__color');
	
	    $color.click(function colorClick() {
	      exports.triggerColorModal($(this));
	    });
	  }
	
	  $('.colors__modal-close').click(function colorModalClosed() {
	    $('.colors__modal').removeClass('colors__modal--open');
	  });
	};
	
	exports.iconInit = function () {
	  (0, _objectFitImages2.default)('.product-material__image');
	};

/***/ },
/* 7 */
/***/ function(module, exports) {

	/*! npm.im/object-fit-images */
	'use strict';
	
	var ಠ = 'data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw=='; // transparent image, used as accessor and replacing image
	var propRegex = /(object-fit|object-position)\s*:\s*([-\w\s%]+)/g;
	var testImg = new Image();
	var supportsObjectFit = 'object-fit' in testImg.style;
	var supportsObjectPosition = 'object-position' in testImg.style;
	var supportsCurrentSrc = typeof testImg.currentSrc === 'string';
	var nativeGetAttribute = testImg.getAttribute;
	var nativeSetAttribute = testImg.setAttribute;
	var autoModeEnabled = false;
	
	function getStyle(el) {
		var style = getComputedStyle(el).fontFamily;
		var parsed;
		var props = {};
		while ((parsed = propRegex.exec(style)) !== null) {
			props[parsed[1]] = parsed[2];
		}
		return props;
	}
	
	function fixOne(el, requestedSrc) {
		if (el[ಠ].parsingSrcset) {
			return;
		}
		var style = getStyle(el);
		style['object-fit'] = style['object-fit'] || 'fill'; // default value
	
		// If the fix was already applied, don't try to skip fixing,
		// - because once you go ofi you never go back.
		// - Wait, that doesn't rhyme.
		// - This ain't rap, bro.
		if (!el[ಠ].s) {
			// fill is the default behavior so no action is necessary
			if (style['object-fit'] === 'fill') {
				return;
			}
	
			// Where object-fit is supported and object-position isn't (Safari < 10)
			if (
				!el[ಠ].skipTest && // unless user wants to apply regardless of browser support
				supportsObjectFit && // if browser already supports object-fit
				!style['object-position'] // unless object-position is used
			) {
				return;
			}
		}
	
		var src = el[ಠ].ios7src || el.currentSrc || el.src;
	
		if (requestedSrc) {
			// explicitly requested src takes precedence
			// TODO: this still should overwrite srcset
			src = requestedSrc;
		} else if (el.srcset && !supportsCurrentSrc && window.picturefill) {
			var pf = window.picturefill._.ns;
			// prevent infinite loop
			// fillImg sets the src which in turn calls fixOne
			el[ಠ].parsingSrcset = true;
	
			// parse srcset with picturefill where currentSrc isn't available
			if (!el[pf] || !el[pf].evaled) {
				// force synchronous srcset parsing
				window.picturefill._.fillImg(el, {reselect: true});
			}
	
			if (!el[pf].curSrc) {
				// force picturefill to parse srcset
				el[pf].supported = false;
				window.picturefill._.fillImg(el, {reselect: true});
			}
			delete el[ಠ].parsingSrcset;
	
			// retrieve parsed currentSrc, if any
			src = el[pf].curSrc || src;
		}
	
		// store info on object for later use
		if (el[ಠ].s) {
			el[ಠ].s = src;
			if (requestedSrc) {
				// the attribute reflects the user input
				// the property is the resolved URL
				el[ಠ].srcAttr = requestedSrc;
			}
		} else {
			el[ಠ] = {
				s: src,
				srcAttr: requestedSrc || nativeGetAttribute.call(el, 'src'),
				srcsetAttr: el.srcset
			};
			el.src = ಠ;
	
			try {
				// remove srcset because it overrides src
				if (el.srcset) {
					el.srcset = '';
	
					// restore non-browser-readable srcset property
					Object.defineProperty(el, 'srcset', {
						value: el[ಠ].srcsetAttr
					});
				}
	
				keepSrcUsable(el);
			} catch (err) {
				el[ಠ].ios7src = src;
			}
		}
	
		el.style.backgroundImage = 'url("' + src + '")';
		el.style.backgroundPosition = style['object-position'] || 'center';
		el.style.backgroundRepeat = 'no-repeat';
	
		if (/scale-down/.test(style['object-fit'])) {
			// `object-fit: scale-down` is either `contain` or `auto`
			if (!el[ಠ].i) {
				el[ಠ].i = new Image();
				el[ಠ].i.src = src;
			}
	
			// naturalWidth is only available when the image headers are loaded,
			// this loop will poll it every 100ms.
			// There's currently no check to prevent this loop from starting twice
			// as a consequence of calling ofi() twice on the same image, but it's light
			// and causes no issues, so it's not worth ensuring that it doesn't.
			(function loop() {
				// https://bugs.chromium.org/p/chromium/issues/detail?id=495908
				if (el[ಠ].i.naturalWidth) {
					if (el[ಠ].i.naturalWidth > el.width || el[ಠ].i.naturalHeight > el.height) {
						el.style.backgroundSize = 'contain';
					} else {
						el.style.backgroundSize = 'auto';
					}
					return;
				}
				setTimeout(loop, 100);
			})();
		} else {
			el.style.backgroundSize = style['object-fit'].replace('none', 'auto').replace('fill', '100% 100%');
		}
	}
	
	function keepSrcUsable(el) {
		var descriptors = {
			get: function get() {
				return el[ಠ].s;
			},
			set: function set(src) {
				delete el[ಠ].i; // scale-down's img sizes need to be updated too
				fixOne(el, src);
				return src;
			}
		};
		Object.defineProperty(el, 'src', descriptors);
		Object.defineProperty(el, 'currentSrc', {get: descriptors.get}); // it should be read-only
	}
	
	function hijackAttributes() {
		if (!supportsObjectPosition) {
			HTMLImageElement.prototype.getAttribute = function (name) {
				if (this[ಠ] && (name === 'src' || name === 'srcset')) {
					return this[ಠ][name + 'Attr'];
				}
				return nativeGetAttribute.call(this, name);
			};
	
			HTMLImageElement.prototype.setAttribute = function (name, value) {
				if (this[ಠ] && (name === 'src' || name === 'srcset')) {
					this[name === 'src' ? 'src' : name + 'Attr'] = String(value);
				} else {
					nativeSetAttribute.call(this, name, value);
				}
			};
		}
	}
	
	function fix(imgs, opts) {
		var startAutoMode = !autoModeEnabled && !imgs;
		opts = opts || {};
		imgs = imgs || 'img';
		if (supportsObjectPosition && !opts.skipTest) {
			return false;
		}
	
		// use imgs as a selector or just select all images
		if (typeof imgs === 'string') {
			imgs = document.querySelectorAll('img');
		} else if (!imgs.length) {
			imgs = [imgs];
		}
	
		// apply fix to all
		for (var i = 0; i < imgs.length; i++) {
			imgs[i][ಠ] = imgs[i][ಠ] || opts;
			fixOne(imgs[i]);
		}
	
		if (startAutoMode) {
			document.body.addEventListener('load', function (e) {
				if (e.target.tagName === 'IMG') {
					fix(e.target, {
						skipTest: opts.skipTest
					});
				}
			}, true);
			autoModeEnabled = true;
			imgs = 'img'; // reset to a generic selector for watchMQ
		}
	
		// if requested, watch media queries for object-fit change
		if (opts.watchMQ) {
			window.addEventListener('resize', fix.bind(null, imgs, {
				skipTest: opts.skipTest
			}));
		}
	}
	
	fix.supportsObjectFit = supportsObjectFit;
	fix.supportsObjectPosition = supportsObjectPosition;
	
	hijackAttributes();
	
	module.exports = fix;

/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var _objectFitImages = __webpack_require__(7);
	
	var _objectFitImages2 = _interopRequireDefault(_objectFitImages);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	var flexCount = void 0;
	var fancyCount = void 0;
	
	exports.loader = function () {
	  var trigger = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
	
	  var $nest = $('.project-inspiration__nest');
	  if (trigger === true) {
	    $nest.addClass('project-inspiration__nest--loading');
	  } else if (trigger === false) {
	    $nest.removeClass('project-inspiration__nest--loading');
	  }
	};
	
	exports.triggerFlex = function () {
	  var trigger = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
	
	  var $nest = $('.project-inspiration__nest');
	  if (trigger === true) {
	    $nest.addClass('project-inspiration__nest--filters-engaged');
	  } else if (trigger === false) {
	    $nest.removeClass('project-inspiration__nest--filters-engaged');
	  }
	};
	
	exports.selectorEscape = function (selector) {
	  return selector.replace(/([;&,\.\+\*\~':"\!\^#$%@\[\]\(\)=>\|])/g, '\\$1');
	};
	
	exports.addPaginationNumbers = function () {
	  var $items = $('.project-inspiration-item');
	  var $fancyItems = $('.project-inspiration__fancy .project-inspiration-item');
	  var $flexItems = $('.project-inspiration__flexible .project-inspiration-item');
	
	  $items.removeAttr('data-pagination-number');
	
	  $fancyItems.each(function numberFancies(i) {
	    $(this).attr('data-pagination-number', i);
	  });
	
	  var filteredCount = 0;
	  $flexItems.each(function numberFlex() {
	    var $parent = $(this).parent();
	    if ($parent.hasClass('filtered')) {
	      $(this).attr('data-pagination-number', filteredCount);
	      filteredCount++;
	    }
	  });
	
	  fancyCount = $fancyItems.length;
	  flexCount = filteredCount;
	};
	
	exports.paginateModal = function (direction, $elem) {
	  exports.addPaginationNumbers();
	
	  var isFiltered = $('.project-inspiration__nest').hasClass('project-inspiration__nest--filters-engaged');
	  var paginationNumber = parseInt($elem.attr('data-pagination-number'), 10);
	
	  var $parent = void 0;
	  var length = void 0;
	  if (isFiltered) {
	    $parent = $('.project-inspiration__flexible');
	    length = flexCount;
	  } else {
	    $parent = $('.project-inspiration__fancy');
	    length = fancyCount;
	  }
	
	  if (direction === 'previous') {
	    var $prev = void 0;
	
	    if (paginationNumber === 0) {
	      $prev = $parent.find('.project-inspiration-item[data-pagination-number="' + (length - 1) + '"]');
	    } else {
	      var prev = paginationNumber - 1;
	      $prev = $parent.find('.project-inspiration-item[data-pagination-number="' + prev + '"]');
	    }
	
	    exports.populateModal($prev);
	  } else if (direction === 'next') {
	    var $next = void 0;
	
	    if (paginationNumber === length - 1) {
	      $next = $parent.find('.project-inspiration-item[data-pagination-number="0"]');
	    } else {
	      var next = paginationNumber + 1;
	      $next = $parent.find('.project-inspiration-item[data-pagination-number="' + next + '"]');
	    }
	
	    exports.populateModal($next);
	  }
	};
	
	exports.populateModal = function ($elem) {
	  // the targets
	  var $image = $('.project-inspiration-modal__image');
	  var $products = $('.project-inspiration-modal__list--products');
	  var $collections = $('.project-inspiration-modal__list--collections');
	  var $styles = $('.project-inspiration-modal__list--styles');
	  var $colors = $('.project-inspiration-modal__list--colors');
	
	  // the content
	  var image = $elem.find('.project-inspiration-item__details').attr('data-image');
	  var products = $elem.find('.project-inspiration-item__details--products').html();
	  var collections = $elem.find('.project-inspiration-item__details--collections').html();
	  var styles = $elem.find('.project-inspiration-item__details--styles').html();
	  var colors = $elem.find('.project-inspiration-item__details--colors').html();
	
	  // populating
	  $image.attr('src', image);
	  $products.html(products);
	  $collections.html(collections);
	  $styles.html(styles);
	  $colors.html(colors);
	
	  // IE workaround
	  (0, _objectFitImages2.default)('.project-inspiration-modal__image', {
	    watchMQ: true
	  });
	
	  // pagination stuff
	  var $previous = $('.project-inspiration-modal__previous');
	  var $next = $('.project-inspiration-modal__next');
	
	  $previous.unbind('click');
	  $next.unbind('click');
	
	  $previous.click(function previousClicked() {
	    exports.paginateModal('previous', $elem);
	  });
	
	  $next.click(function nextClicked() {
	    exports.paginateModal('next', $elem);
	  });
	};
	
	exports.closeModal = function () {
	  var $modal = $('.project-inspiration-modal');
	  $modal.removeClass('project-inspiration-modal--open');
	  $('body').removeClass('modal-open');
	};
	
	exports.triggerModal = function ($elem) {
	  var $modal = $('.project-inspiration-modal');
	  exports.populateModal($elem);
	  $modal.addClass('project-inspiration-modal--open');
	  $('body').addClass('modal-open');
	};
	
	exports.triggerEmpty = function () {
	  var empty = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
	
	  var $emptyMessage = $('.project-inspiration__empty-message');
	  if (empty === true) {
	    $emptyMessage.addClass('project-inspiration__empty-message--open');
	  } else {
	    $emptyMessage.removeClass('project-inspiration__empty-message--open');
	  }
	};
	
	exports.checkFilteredCount = function () {
	  var $flex = $('.project-inspiration__flexible');
	
	  var foundItemCount = $flex.find('.filtered').length;
	  if (foundItemCount < 1) {
	    exports.triggerEmpty(true);
	  } else {
	    exports.triggerEmpty(false);
	  }
	};
	
	exports.unfilter = function () {
	  var uncheckButtonsToo = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
	
	  var $flex = $('.project-inspiration__flexible');
	  var $items = $flex.find('.project-inspiration-item');
	
	  $items.parent().removeClass('filtered');
	  if (uncheckButtonsToo === true) {
	    $('.project-inspiration__filter').removeClass('project-inspiration__filter--active');
	  }
	};
	
	exports.filter = function (term) {
	  if (term === false) {
	    // reset
	    exports.triggerFlex(false);
	  } else {
	    exports.loader(true);
	    var $flex = $('.project-inspiration__flexible');
	    var $items = $flex.find('.project-inspiration-item');
	
	    exports.unfilter();
	
	    $items.each(function eachItem() {
	      var $styles = $(this).find('.project-inspiration-item__details--styles');
	      var escapedTerm = exports.selectorEscape(term);
	      var findTerms = $styles.find('li:contains("' + escapedTerm + '")');
	
	      if (findTerms.length > 0) {
	        $(this).parent().addClass('filtered');
	      }
	    });
	    exports.triggerFlex(true);
	    exports.checkFilteredCount();
	    exports.loader(false);
	  }
	};
	
	exports.search = function (query) {
	  var convertedQuery = query.toLowerCase();
	  var $flex = $('.project-inspiration__flexible');
	  var $items = $flex.find('.project-inspiration-item');
	
	  exports.loader(true);
	  exports.unfilter(true);
	
	  $items.each(function eachSearchedItem() {
	    var text = $(this).text().toLowerCase();
	
	    if (text.indexOf(convertedQuery) >= 0) {
	      $(this).parent().addClass('filtered');
	    }
	  });
	
	  exports.checkFilteredCount();
	  exports.loader(false);
	};
	
	exports.fancyLayout = function () {
	  var $fancy = $('.project-inspiration__fancy');
	  var $flex = $('.project-inspiration__flexible');
	  var $normal = $flex.find('.project-inspiration-item:not(.project-inspiration-item--featured)');
	  var $featured = $flex.find('.project-inspiration-item--featured');
	  var $resource = $flex.find('.project-inspiration-resource');
	
	  // first row
	  $normal.slice(0, 2).addClass('in-fancy').clone().appendTo($fancy);
	  $resource.slice(0, 1).addClass('in-fancy').clone().appendTo($fancy);
	  $normal.slice(3, 4).addClass('in-fancy').clone().appendTo($fancy);
	  $featured.slice(0, 1).addClass('in-fancy').clone().appendTo($fancy);
	
	  // second row
	  $normal.slice(5, 7).addClass('in-fancy').clone().appendTo($fancy);
	  $resource.slice(2, 3).addClass('in-fancy').clone().appendTo($fancy);
	  $normal.slice(8, 9).addClass('in-fancy').clone().appendTo($fancy);
	
	  // third row
	  $featured.slice(1, 2).addClass('in-fancy').clone().appendTo($fancy);
	  $normal.slice(10, 11).addClass('in-fancy').clone().appendTo($fancy);
	  $resource.slice(4, 5).addClass('in-fancy').clone().appendTo($fancy);
	  $normal.slice(12, 14).addClass('in-fancy').clone().appendTo($fancy);
	
	  $fancy.find('> *').wrap('<div></div>');
	  $fancy.find('> div').each(function eachWrapper(i) {
	    $(this).attr('data-count', i);
	  });
	
	  var $fancyFeatured = $fancy.find('.project-inspiration-item--featured');
	  $fancyFeatured.addClass('corners');
	  $fancyFeatured.first().addClass('corners--bottom-left');
	  $fancyFeatured.last().addClass('corners--bottom-right');
	
	  var $layout = $fancy.find('> div');
	  $layout.slice(0, 4).wrapAll('<div class="project-inspiration__fancy--four"></div>');
	  $layout.slice(4, 5).wrapAll('<div class="project-inspiration__fancy--half"></div>');
	  $layout.slice(5, 9).wrapAll('<div class="project-inspiration__fancy--row"></div>');
	  $layout.slice(9, 10).wrapAll('<div class="project-inspiration__fancy--half"></div>');
	  $layout.slice(10, 14).wrapAll('<div class="project-inspiration__fancy--four"></div>');
	
	  // and the rest
	  $flex.find('> span > div > *:not(.in-fancy)').clone().appendTo($fancy).wrapAll('<div class="project-inspiration__fancy--row project-inspiration__fancy--the-rest"></div>');
	  $fancy.find('.project-inspiration__fancy--the-rest > *').wrap('<div></div>');
	};
	
	exports.init = function () {
	  if ($('body').hasClass('project-inspiration')) {
	    (function () {
	      var $filters = $('.project-inspiration__filter');
	      var $search = $('.project-inspiration__search-input');
	
	      $filters.click(function filterClicked() {
	        if ($(this).hasClass('project-inspiration__filter--active')) {
	          $(this).removeClass('project-inspiration__filter--active');
	          exports.filter(false);
	          exports.triggerEmpty(false);
	        } else {
	          $filters.removeClass('project-inspiration__filter--active');
	          $(this).addClass('project-inspiration__filter--active');
	          exports.filter($(this).text());
	        }
	      });
	
	      $search.keyup(function searchValueChanged(event) {
	        var currentVal = $(this).val();
	        if (event.which === 13) {
	          // enter key, should close keyboard on mobile
	          $(this).blur();
	        } else {
	          if (currentVal !== '') {
	            exports.triggerFlex(true);
	            exports.search(currentVal);
	          } else {
	            exports.unfilter(true);
	            exports.triggerFlex(false);
	          }
	        }
	      });
	
	      if (!$('html').hasClass('hs-inline-edit')) {
	        // is on live page
	        exports.fancyLayout();
	
	        var $items = $('.project-inspiration-item');
	        var $close = $('.project-inspiration-modal__close');
	
	        $items.click(function itemClicked() {
	          exports.triggerModal($(this));
	        });
	
	        $close.click(function closeModalClicked() {
	          exports.closeModal();
	        });
	
	        exports.addPaginationNumbers();
	        exports.loader(false);
	      } else {
	        // is in editor
	        exports.loader(false);
	      }
	    })();
	  }
	};

/***/ },
/* 9 */
/***/ function(module, exports) {

	'use strict';
	
	var rightPos = 0;
	var topPos = 0;
	
	exports.getSharePos = function () {
	  var $share = $('.post__floating-share');
	  $share.removeClass('post__floating-share--travel').removeClass('post__floating-share--bottom');
	
	  topPos = $share.offset().top;
	  rightPos = $(window).width() - ($share.offset().left + $share.outerWidth());
	};
	
	exports.checkShareScroll = function () {
	  var $share = $('.post__floating-share');
	  var $content = $('.blog__content-inner');
	  var headerHeight = $('.site-header').outerHeight();
	  var offset = 30;
	  var postBottom = $content.offset().top + $content.outerHeight() - $share.outerHeight() - headerHeight - offset;
	  var scrollPos = $(window).scrollTop();
	  var heightDiff = topPos - headerHeight - offset;
	
	  if (scrollPos >= heightDiff && scrollPos < postBottom && !$share.hasClass('post__floating-share--travel')) {
	    $share.addClass('post__floating-share--travel');
	    $share.css('right', rightPos);
	    $share.css('top', headerHeight + offset);
	    $share.removeClass('post__floating-share--bottom');
	  } else if (scrollPos < heightDiff && $share.hasClass('post__floating-share--travel')) {
	    $share.removeClass('post__floating-share--travel');
	    $share.attr('style', '');
	  } else if (scrollPos >= postBottom && $share.hasClass('post__floating-share--travel')) {
	    $share.removeClass('post__floating-share--travel');
	    $share.addClass('post__floating-share--bottom');
	    $share.attr('style', '');
	  }
	};
	
	exports.toggleAllTopics = function () {
	  var $more = $('.blog-header__more-topics');
	  $more.toggleClass('blog-header__more-topics--open');
	};
	
	exports.topicsHeader = function () {
	  var $allTopics = $('.blog-header__more-topics--content li');
	  var $topLevelTopics = $('.blog-header__topics');
	  var $trigger = $('.blog-header__more-topics--trigger');
	
	  $allTopics.slice(0, 5).prependTo($topLevelTopics);
	
	  $trigger.click(function moreTopicsClicked() {
	    exports.toggleAllTopics();
	  });
	};
	
	exports.toggleSubscribe = function () {
	  var $modal = $('.blog-subscribe-modal');
	  $modal.toggleClass('blog-subscribe-modal--open');
	};
	
	exports.subscribeInit = function () {
	  var $trigger = $('.blog-header__subscribe');
	  var $close = $('.blog-subscribe-modal__close');
	
	  $trigger.click(function subscribeTriggerClicked() {
	    exports.toggleSubscribe();
	  });
	
	  $close.click(function subscribeCloseClicked() {
	    exports.toggleSubscribe();
	  });
	};
	
	exports.wrapImages = function () {
	  var $blogContent = $('#hs_cos_wrapper_post_body');
	  $blogContent.find('p img').closest('p').addClass('has-image');
	};
	
	exports.markEmpties = function () {
	  var $blogContent = $('#hs_cos_wrapper_post_body');
	  $blogContent.find('p').filter(function filterForEmpties() {
	    return $.trim($(this).text()) === '' && $(this).children().length === 0;
	  }).addClass('is-empty');
	};

/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var _tinycolor = __webpack_require__(11);
	
	var _tinycolor2 = _interopRequireDefault(_tinycolor);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	var availableColors = void 0;
	
	var state = {
	  projectType: 'Residential',
	  roofColor: 'Dark Gray',
	  sidingColor: 'Sierra Tan',
	  trimColor: 'Medium Brown',
	  wainscotColor: 'Hemlock Green',
	  availableOptions: {
	    residential: {
	      roof: true,
	      siding: true,
	      wainscot: false,
	      trim: true
	    },
	    commercial: {
	      roof: true,
	      siding: true,
	      wainscot: true,
	      trim: true
	    },
	    agricultural: {
	      roof: true,
	      siding: true,
	      wainscot: false,
	      trim: true
	    }
	  }
	};
	
	exports.updateText = function () {
	  var $typeSelectors = $('.find-your-color__types-selector');
	  var $currentTypeSelector = $('.find-your-color__types-selector[data-type="' + state.projectType + '"]');
	  var $roofColor = $('.find-your-color__selector--roof .find-your-color__selector-current-value');
	  var $sidingColor = $('.find-your-color__selector--siding .find-your-color__selector-current-value');
	  var $trimColor = $('.find-your-color__selector--trim .find-your-color__selector-current-value');
	  var $wainscotColor = $('.find-your-color__selector--wainscot .find-your-color__selector-current-value');
	
	  $typeSelectors.removeClass('find-your-color__types-selector--active');
	  $currentTypeSelector.addClass('find-your-color__types-selector--active');
	
	  $roofColor.text(state.roofColor);
	  $sidingColor.text(state.sidingColor);
	  $trimColor.text(state.trimColor);
	  $wainscotColor.text(state.wainscotColor);
	};
	
	exports.updateViewImage = function () {
	  var activeClass = 'find-your-color__view--active';
	  if (state.projectType === 'Residential') {
	    $('.find-your-color__view:not(.find-your-color__view--residential)').removeClass(activeClass);
	    $('.find-your-color__view--residential').addClass(activeClass);
	  } else if (state.projectType === 'Commercial') {
	    $('.find-your-color__view:not(.find-your-color__view--commercial)').removeClass(activeClass);
	    $('.find-your-color__view--commercial').addClass(activeClass);
	  } else if (state.projectType === 'Agricultural') {
	    $('.find-your-color__view:not(.find-your-color__view--agricultural)').removeClass(activeClass);
	    $('.find-your-color__view--agricultural').addClass(activeClass);
	  }
	};
	
	exports.getHexColor = function (colorName) {
	  var hex = $.grep(availableColors, function (e) {
	    return e.name === colorName;
	  })[0].color;
	
	  return hex;
	};
	 
	exports.updateColors = function () {
	  var $allLayers = $('.find-your-color__layer');
	  var $roofLayer = $('.find-your-color__layer--roof');
	  var $sidingLayer = $('.find-your-color__layer--siding');
	  var $trimLayer = $('.find-your-color__layer--trim');
	  var $wainscotLayer = $('.find-your-color__layer--wainscot');
	
	  var roofHexColor = exports.getHexColor(state.roofColor);
	  var sidingHexColor = exports.getHexColor(state.sidingColor);
	  var trimHexColor = exports.getHexColor(state.trimColor);
	  var wainscotHexColor = exports.getHexColor(state.wainscotColor);
	
	  $allLayers.attr('data-is-bright', 'false');
	  $roofLayer.find('[fill]').css('fill', roofHexColor);
	  $sidingLayer.find('[fill]').css('fill', sidingHexColor);
	  $trimLayer.find('[fill]').css('fill', trimHexColor);
	  $wainscotLayer.find('[fill]').css('fill', wainscotHexColor);
	
	  // detect light colors
	  var threshold = 192;
	  if ((0, _tinycolor2.default)(roofHexColor).getBrightness() > threshold) {
	    $roofLayer.attr('data-is-bright', 'true');
	  }
	
	  if ((0, _tinycolor2.default)(sidingHexColor).getBrightness() > threshold) {
	    $sidingLayer.attr('data-is-bright', 'true');
	  }
	
	  if ((0, _tinycolor2.default)(trimHexColor).getBrightness() > threshold) {
	    $trimLayer.attr('data-is-bright', 'true');
	  }
	
	  if ((0, _tinycolor2.default)(wainscotHexColor).getBrightness() > threshold) {
	    $wainscotLayer.attr('data-is-bright', 'true');
	  }
	};
	
	exports.updateAvailableOptions = function () {
	  var currentObj = void 0;
	  var availableKeys = void 0;
	  if (state.projectType === 'Residential') {
	    currentObj = state.availableOptions.residential;
	    availableKeys = Object.keys(state.availableOptions.residential);
	  } else if (state.projectType === 'Commercial') {
	    currentObj = state.availableOptions.commercial;
	    availableKeys = Object.keys(state.availableOptions.commercial);
	  } else if (state.projectType === 'Agricultural') {
	    currentObj = state.availableOptions.agricultural;
	    availableKeys = Object.keys(state.availableOptions.agricultural);
	  }
	
	  $.each(availableKeys, function (i, v) {
	    if (currentObj[v] !== true) {
	      $('.find-your-color__selector--' + v).addClass('find-your-color__selector--disabled');
	    } else {
	      $('.find-your-color__selector--' + v).removeClass('find-your-color__selector--disabled');
	    }
	  });
	};
	
	exports.switchView = function () {
	  exports.updateText();
	  exports.updateViewImage();
	  exports.updateColors();
	  exports.updateAvailableOptions();
	};
	
	exports.populateSelectors = function () {
	  var $selector = $('.find-your-color__selector');
	  var $selectorContent = $selector.find('.find-your-color__selector-content');
	  $selectorContent.each(function eachSelectorContent() {
	    var $current = $(this).parent().find('.find-your-color__selector-current-value');
	    var selectorContent = '';
	    $.each(availableColors, function eachColor(i, v) {
	      selectorContent += '<li class="find-your-color__selector-item" data-name="' + v.name + '" data-color="' + v.color + '"><figure class="find-your-color__selector-color" style="background-color: ' + v.color + '"></figure><span class="find-your-color__selector-name">' + v.name + '</span></li>';
	    });
	
	    $(this).html(selectorContent);
	    $current.html(availableColors[0].name);
	  });
	
	  $selector.click(function eachSelector() {
	    if ($(this).hasClass('find-your-color__selector--active')) {
	      $(this).removeClass('find-your-color__selector--active');
	    } else {
	      $selector.removeClass('find-your-color__selector--active');
	      $(this).addClass('find-your-color__selector--active');
	    }
	  });
	
	  var $colors = $('.find-your-color__selector-item');
	  $colors.click(function colorClicked() {
	    var colorName = $(this).attr('data-name');
	    var $parentSelector = $(this).parent().parent();
	    var selectorType = $parentSelector.attr('data-type');
	
	    if (selectorType === 'Roof') {
	      state.roofColor = colorName;
	    } else if (selectorType === 'Siding') {
	      state.sidingColor = colorName;
	    } else if (selectorType === 'Trim') {
	      state.trimColor = colorName;
	    } else if (selectorType === 'Wainscot') {
	      state.wainscotColor = colorName;
	    }
	
	    exports.switchView();
	  });
	};
	
	exports.projectTypeSelectors = function () {
	  var $typeSelectors = $('.find-your-color__types-selector');
	  $typeSelectors.click(function typeSelectorClicked() {
	    var type = $(this).attr('data-type');
	    state.projectType = type;
	
	    exports.switchView();
	  });
	};
	
	exports.reset = function () {
	  state.roofColor = 'Dark Gray';
	  state.sidingColor = 'Sierra Tan';
	  state.trimColor = 'Medium Brown';
	  state.wainscotColor = 'Hemlock Green';
	
	  exports.switchView();
	};
	
	exports.setResetTrigger = function () {
	  var $reset = $('.find-your-color__reset');
	  $reset.click(function resetClicked() {
	    exports.reset();
	  });
	};
	
	exports.revealView = function () {
	  var $container = $('.find-your-color__view-container');
	
	  $container.addClass('find-your-color__view-container--revealed');
	}; 
	
	exports.init = function () {
	  if ($('body').hasClass('find-a-color-page')) {
	    (function () {
	      var jsonUrl = 'https://web.archive.org/web/20220123224936/https://cdn2.hubspot.net/hubfs/1608284/1_Sales_Team_Attachments/colors.json';
	      $.getJSON(jsonUrl).done(function (data) {
	        availableColors = data;
	        exports.populateSelectors();
	        exports.projectTypeSelectors();
	        exports.setResetTrigger();
	        exports.updateColors();
	        exports.updateAvailableOptions();
	        exports.updateText();
	        exports.revealView();
	      }).fail(function () {
	        console.log('Failed to load colors from "' + jsonUrl + '".');
	      });
	    })();
	  }
	};

/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;// TinyColor v1.4.1
	// https://github.com/bgrins/TinyColor
	// Brian Grinstead, MIT License
	
	(function(Math) {
	
	var trimLeft = /^\s+/,
	    trimRight = /\s+$/,
	    tinyCounter = 0,
	    mathRound = Math.round,
	    mathMin = Math.min,
	    mathMax = Math.max,
	    mathRandom = Math.random;
	
	function tinycolor (color, opts) {
	
	    color = (color) ? color : '';
	    opts = opts || { };
	
	    // If input is already a tinycolor, return itself
	    if (color instanceof tinycolor) {
	       return color;
	    }
	    // If we are called as a function, call using new instead
	    if (!(this instanceof tinycolor)) {
	        return new tinycolor(color, opts);
	    }
	
	    var rgb = inputToRGB(color);
	    this._originalInput = color,
	    this._r = rgb.r,
	    this._g = rgb.g,
	    this._b = rgb.b,
	    this._a = rgb.a,
	    this._roundA = mathRound(100*this._a) / 100,
	    this._format = opts.format || rgb.format;
	    this._gradientType = opts.gradientType;
	
	    // Don't let the range of [0,255] come back in [0,1].
	    // Potentially lose a little bit of precision here, but will fix issues where
	    // .5 gets interpreted as half of the total, instead of half of 1
	    // If it was supposed to be 128, this was already taken care of by `inputToRgb`
	    if (this._r < 1) { this._r = mathRound(this._r); }
	    if (this._g < 1) { this._g = mathRound(this._g); }
	    if (this._b < 1) { this._b = mathRound(this._b); }
	
	    this._ok = rgb.ok;
	    this._tc_id = tinyCounter++;
	}
	
	tinycolor.prototype = {
	    isDark: function() {
	        return this.getBrightness() < 128;
	    },
	    isLight: function() {
	        return !this.isDark();
	    },
	    isValid: function() {
	        return this._ok;
	    },
	    getOriginalInput: function() {
	      return this._originalInput;
	    },
	    getFormat: function() {
	        return this._format;
	    },
	    getAlpha: function() {
	        return this._a;
	    },
	    getBrightness: function() {
	        //http://www.w3.org/TR/AERT#color-contrast
	        var rgb = this.toRgb();
	        return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;
	    },
	    getLuminance: function() {
	        //http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
	        var rgb = this.toRgb();
	        var RsRGB, GsRGB, BsRGB, R, G, B;
	        RsRGB = rgb.r/255;
	        GsRGB = rgb.g/255;
	        BsRGB = rgb.b/255;
	
	        if (RsRGB <= 0.03928) {R = RsRGB / 12.92;} else {R = Math.pow(((RsRGB + 0.055) / 1.055), 2.4);}
	        if (GsRGB <= 0.03928) {G = GsRGB / 12.92;} else {G = Math.pow(((GsRGB + 0.055) / 1.055), 2.4);}
	        if (BsRGB <= 0.03928) {B = BsRGB / 12.92;} else {B = Math.pow(((BsRGB + 0.055) / 1.055), 2.4);}
	        return (0.2126 * R) + (0.7152 * G) + (0.0722 * B);
	    },
	    setAlpha: function(value) {
	        this._a = boundAlpha(value);
	        this._roundA = mathRound(100*this._a) / 100;
	        return this;
	    },
	    toHsv: function() {
	        var hsv = rgbToHsv(this._r, this._g, this._b);
	        return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a };
	    },
	    toHsvString: function() {
	        var hsv = rgbToHsv(this._r, this._g, this._b);
	        var h = mathRound(hsv.h * 360), s = mathRound(hsv.s * 100), v = mathRound(hsv.v * 100);
	        return (this._a == 1) ?
	          "hsv("  + h + ", " + s + "%, " + v + "%)" :
	          "hsva(" + h + ", " + s + "%, " + v + "%, "+ this._roundA + ")";
	    },
	    toHsl: function() {
	        var hsl = rgbToHsl(this._r, this._g, this._b);
	        return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this._a };
	    },
	    toHslString: function() {
	        var hsl = rgbToHsl(this._r, this._g, this._b);
	        var h = mathRound(hsl.h * 360), s = mathRound(hsl.s * 100), l = mathRound(hsl.l * 100);
	        return (this._a == 1) ?
	          "hsl("  + h + ", " + s + "%, " + l + "%)" :
	          "hsla(" + h + ", " + s + "%, " + l + "%, "+ this._roundA + ")";
	    },
	    toHex: function(allow3Char) {
	        return rgbToHex(this._r, this._g, this._b, allow3Char);
	    },
	    toHexString: function(allow3Char) {
	        return '#' + this.toHex(allow3Char);
	    },
	    toHex8: function(allow4Char) {
	        return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);
	    },
	    toHex8String: function(allow4Char) {
	        return '#' + this.toHex8(allow4Char);
	    },
	    toRgb: function() {
	        return { r: mathRound(this._r), g: mathRound(this._g), b: mathRound(this._b), a: this._a };
	    },
	    toRgbString: function() {
	        return (this._a == 1) ?
	          "rgb("  + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ")" :
	          "rgba(" + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ", " + this._roundA + ")";
	    },
	    toPercentageRgb: function() {
	        return { r: mathRound(bound01(this._r, 255) * 100) + "%", g: mathRound(bound01(this._g, 255) * 100) + "%", b: mathRound(bound01(this._b, 255) * 100) + "%", a: this._a };
	    },
	    toPercentageRgbString: function() {
	        return (this._a == 1) ?
	          "rgb("  + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%)" :
	          "rgba(" + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%, " + this._roundA + ")";
	    },
	    toName: function() {
	        if (this._a === 0) {
	            return "transparent";
	        }
	
	        if (this._a < 1) {
	            return false;
	        }
	
	        return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;
	    },
	    toFilter: function(secondColor) {
	        var hex8String = '#' + rgbaToArgbHex(this._r, this._g, this._b, this._a);
	        var secondHex8String = hex8String;
	        var gradientType = this._gradientType ? "GradientType = 1, " : "";
	
	        if (secondColor) {
	            var s = tinycolor(secondColor);
	            secondHex8String = '#' + rgbaToArgbHex(s._r, s._g, s._b, s._a);
	        }
	
	        return "progid:DXImageTransform.Microsoft.gradient("+gradientType+"startColorstr="+hex8String+",endColorstr="+secondHex8String+")";
	    },
	    toString: function(format) {
	        var formatSet = !!format;
	        format = format || this._format;
	
	        var formattedString = false;
	        var hasAlpha = this._a < 1 && this._a >= 0;
	        var needsAlphaFormat = !formatSet && hasAlpha && (format === "hex" || format === "hex6" || format === "hex3" || format === "hex4" || format === "hex8" || format === "name");
	
	        if (needsAlphaFormat) {
	            // Special case for "transparent", all other non-alpha formats
	            // will return rgba when there is transparency.
	            if (format === "name" && this._a === 0) {
	                return this.toName();
	            }
	            return this.toRgbString();
	        }
	        if (format === "rgb") {
	            formattedString = this.toRgbString();
	        }
	        if (format === "prgb") {
	            formattedString = this.toPercentageRgbString();
	        }
	        if (format === "hex" || format === "hex6") {
	            formattedString = this.toHexString();
	        }
	        if (format === "hex3") {
	            formattedString = this.toHexString(true);
	        }
	        if (format === "hex4") {
	            formattedString = this.toHex8String(true);
	        }
	        if (format === "hex8") {
	            formattedString = this.toHex8String();
	        }
	        if (format === "name") {
	            formattedString = this.toName();
	        }
	        if (format === "hsl") {
	            formattedString = this.toHslString();
	        }
	        if (format === "hsv") {
	            formattedString = this.toHsvString();
	        }
	
	        return formattedString || this.toHexString();
	    },
	    clone: function() {
	        return tinycolor(this.toString());
	    },
	
	    _applyModification: function(fn, args) {
	        var color = fn.apply(null, [this].concat([].slice.call(args)));
	        this._r = color._r;
	        this._g = color._g;
	        this._b = color._b;
	        this.setAlpha(color._a);
	        return this;
	    },
	    lighten: function() {
	        return this._applyModification(lighten, arguments);
	    },
	    brighten: function() {
	        return this._applyModification(brighten, arguments);
	    },
	    darken: function() {
	        return this._applyModification(darken, arguments);
	    },
	    desaturate: function() {
	        return this._applyModification(desaturate, arguments);
	    },
	    saturate: function() {
	        return this._applyModification(saturate, arguments);
	    },
	    greyscale: function() {
	        return this._applyModification(greyscale, arguments);
	    },
	    spin: function() {
	        return this._applyModification(spin, arguments);
	    },
	
	    _applyCombination: function(fn, args) {
	        return fn.apply(null, [this].concat([].slice.call(args)));
	    },
	    analogous: function() {
	        return this._applyCombination(analogous, arguments);
	    },
	    complement: function() {
	        return this._applyCombination(complement, arguments);
	    },
	    monochromatic: function() {
	        return this._applyCombination(monochromatic, arguments);
	    },
	    splitcomplement: function() {
	        return this._applyCombination(splitcomplement, arguments);
	    },
	    triad: function() {
	        return this._applyCombination(triad, arguments);
	    },
	    tetrad: function() {
	        return this._applyCombination(tetrad, arguments);
	    }
	};
	
	// If input is an object, force 1 into "1.0" to handle ratios properly
	// String input requires "1.0" as input, so 1 will be treated as 1
	tinycolor.fromRatio = function(color, opts) {
	    if (typeof color == "object") {
	        var newColor = {};
	        for (var i in color) {
	            if (color.hasOwnProperty(i)) {
	                if (i === "a") {
	                    newColor[i] = color[i];
	                }
	                else {
	                    newColor[i] = convertToPercentage(color[i]);
	                }
	            }
	        }
	        color = newColor;
	    }
	
	    return tinycolor(color, opts);
	};
	
	// Given a string or object, convert that input to RGB
	// Possible string inputs:
	//
	//     "red"
	//     "#f00" or "f00"
	//     "#ff0000" or "ff0000"
	//     "#ff000000" or "ff000000"
	//     "rgb 255 0 0" or "rgb (255, 0, 0)"
	//     "rgb 1.0 0 0" or "rgb (1, 0, 0)"
	//     "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1"
	//     "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1"
	//     "hsl(0, 100%, 50%)" or "hsl 0 100% 50%"
	//     "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
	//     "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
	//
	function inputToRGB(color) {
	
	    var rgb = { r: 0, g: 0, b: 0 };
	    var a = 1;
	    var s = null;
	    var v = null;
	    var l = null;
	    var ok = false;
	    var format = false;
	
	    if (typeof color == "string") {
	        color = stringInputToObject(color);
	    }
	
	    if (typeof color == "object") {
	        if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
	            rgb = rgbToRgb(color.r, color.g, color.b);
	            ok = true;
	            format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
	        }
	        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
	            s = convertToPercentage(color.s);
	            v = convertToPercentage(color.v);
	            rgb = hsvToRgb(color.h, s, v);
	            ok = true;
	            format = "hsv";
	        }
	        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
	            s = convertToPercentage(color.s);
	            l = convertToPercentage(color.l);
	            rgb = hslToRgb(color.h, s, l);
	            ok = true;
	            format = "hsl";
	        }
	
	        if (color.hasOwnProperty("a")) {
	            a = color.a;
	        }
	    }
	
	    a = boundAlpha(a);
	
	    return {
	        ok: ok,
	        format: color.format || format,
	        r: mathMin(255, mathMax(rgb.r, 0)),
	        g: mathMin(255, mathMax(rgb.g, 0)),
	        b: mathMin(255, mathMax(rgb.b, 0)),
	        a: a
	    };
	}
	
	
	// Conversion Functions
	// --------------------
	
	// `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:
	// <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>
	
	// `rgbToRgb`
	// Handle bounds / percentage checking to conform to CSS color spec
	// <http://www.w3.org/TR/css3-color/>
	// *Assumes:* r, g, b in [0, 255] or [0, 1]
	// *Returns:* { r, g, b } in [0, 255]
	function rgbToRgb(r, g, b){
	    return {
	        r: bound01(r, 255) * 255,
	        g: bound01(g, 255) * 255,
	        b: bound01(b, 255) * 255
	    };
	}
	
	// `rgbToHsl`
	// Converts an RGB color value to HSL.
	// *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]
	// *Returns:* { h, s, l } in [0,1]
	function rgbToHsl(r, g, b) {
	
	    r = bound01(r, 255);
	    g = bound01(g, 255);
	    b = bound01(b, 255);
	
	    var max = mathMax(r, g, b), min = mathMin(r, g, b);
	    var h, s, l = (max + min) / 2;
	
	    if(max == min) {
	        h = s = 0; // achromatic
	    }
	    else {
	        var d = max - min;
	        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
	        switch(max) {
	            case r: h = (g - b) / d + (g < b ? 6 : 0); break;
	            case g: h = (b - r) / d + 2; break;
	            case b: h = (r - g) / d + 4; break;
	        }
	
	        h /= 6;
	    }
	
	    return { h: h, s: s, l: l };
	}
	
	// `hslToRgb`
	// Converts an HSL color value to RGB.
	// *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
	// *Returns:* { r, g, b } in the set [0, 255]
	function hslToRgb(h, s, l) {
	    var r, g, b;
	
	    h = bound01(h, 360);
	    s = bound01(s, 100);
	    l = bound01(l, 100);
	
	    function hue2rgb(p, q, t) {
	        if(t < 0) t += 1;
	        if(t > 1) t -= 1;
	        if(t < 1/6) return p + (q - p) * 6 * t;
	        if(t < 1/2) return q;
	        if(t < 2/3) return p + (q - p) * (2/3 - t) * 6;
	        return p;
	    }
	
	    if(s === 0) {
	        r = g = b = l; // achromatic
	    }
	    else {
	        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
	        var p = 2 * l - q;
	        r = hue2rgb(p, q, h + 1/3);
	        g = hue2rgb(p, q, h);
	        b = hue2rgb(p, q, h - 1/3);
	    }
	
	    return { r: r * 255, g: g * 255, b: b * 255 };
	}
	
	// `rgbToHsv`
	// Converts an RGB color value to HSV
	// *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
	// *Returns:* { h, s, v } in [0,1]
	function rgbToHsv(r, g, b) {
	
	    r = bound01(r, 255);
	    g = bound01(g, 255);
	    b = bound01(b, 255);
	
	    var max = mathMax(r, g, b), min = mathMin(r, g, b);
	    var h, s, v = max;
	
	    var d = max - min;
	    s = max === 0 ? 0 : d / max;
	
	    if(max == min) {
	        h = 0; // achromatic
	    }
	    else {
	        switch(max) {
	            case r: h = (g - b) / d + (g < b ? 6 : 0); break;
	            case g: h = (b - r) / d + 2; break;
	            case b: h = (r - g) / d + 4; break;
	        }
	        h /= 6;
	    }
	    return { h: h, s: s, v: v };
	}
	
	// `hsvToRgb`
	// Converts an HSV color value to RGB.
	// *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
	// *Returns:* { r, g, b } in the set [0, 255]
	 function hsvToRgb(h, s, v) {
	
	    h = bound01(h, 360) * 6;
	    s = bound01(s, 100);
	    v = bound01(v, 100);
	
	    var i = Math.floor(h),
	        f = h - i,
	        p = v * (1 - s),
	        q = v * (1 - f * s),
	        t = v * (1 - (1 - f) * s),
	        mod = i % 6,
	        r = [v, q, p, p, t, v][mod],
	        g = [t, v, v, q, p, p][mod],
	        b = [p, p, t, v, v, q][mod];
	
	    return { r: r * 255, g: g * 255, b: b * 255 };
	}
	
	// `rgbToHex`
	// Converts an RGB color to hex
	// Assumes r, g, and b are contained in the set [0, 255]
	// Returns a 3 or 6 character hex
	function rgbToHex(r, g, b, allow3Char) {
	
	    var hex = [
	        pad2(mathRound(r).toString(16)),
	        pad2(mathRound(g).toString(16)),
	        pad2(mathRound(b).toString(16))
	    ];
	
	    // Return a 3 character hex if possible
	    if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) {
	        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
	    }
	
	    return hex.join("");
	}
	
	// `rgbaToHex`
	// Converts an RGBA color plus alpha transparency to hex
	// Assumes r, g, b are contained in the set [0, 255] and
	// a in [0, 1]. Returns a 4 or 8 character rgba hex
	function rgbaToHex(r, g, b, a, allow4Char) {
	
	    var hex = [
	        pad2(mathRound(r).toString(16)),
	        pad2(mathRound(g).toString(16)),
	        pad2(mathRound(b).toString(16)),
	        pad2(convertDecimalToHex(a))
	    ];
	
	    // Return a 4 character hex if possible
	    if (allow4Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1) && hex[3].charAt(0) == hex[3].charAt(1)) {
	        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
	    }
	
	    return hex.join("");
	}
	
	// `rgbaToArgbHex`
	// Converts an RGBA color to an ARGB Hex8 string
	// Rarely used, but required for "toFilter()"
	function rgbaToArgbHex(r, g, b, a) {
	
	    var hex = [
	        pad2(convertDecimalToHex(a)),
	        pad2(mathRound(r).toString(16)),
	        pad2(mathRound(g).toString(16)),
	        pad2(mathRound(b).toString(16))
	    ];
	
	    return hex.join("");
	}
	
	// `equals`
	// Can be called with any tinycolor input
	tinycolor.equals = function (color1, color2) {
	    if (!color1 || !color2) { return false; }
	    return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();
	};
	
	tinycolor.random = function() {
	    return tinycolor.fromRatio({
	        r: mathRandom(),
	        g: mathRandom(),
	        b: mathRandom()
	    });
	};
	
	
	// Modification Functions
	// ----------------------
	// Thanks to less.js for some of the basics here
	// <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>
	
	function desaturate(color, amount) {
	    amount = (amount === 0) ? 0 : (amount || 10);
	    var hsl = tinycolor(color).toHsl();
	    hsl.s -= amount / 100;
	    hsl.s = clamp01(hsl.s);
	    return tinycolor(hsl);
	}
	
	function saturate(color, amount) {
	    amount = (amount === 0) ? 0 : (amount || 10);
	    var hsl = tinycolor(color).toHsl();
	    hsl.s += amount / 100;
	    hsl.s = clamp01(hsl.s);
	    return tinycolor(hsl);
	}
	
	function greyscale(color) {
	    return tinycolor(color).desaturate(100);
	}
	
	function lighten (color, amount) {
	    amount = (amount === 0) ? 0 : (amount || 10);
	    var hsl = tinycolor(color).toHsl();
	    hsl.l += amount / 100;
	    hsl.l = clamp01(hsl.l);
	    return tinycolor(hsl);
	}
	
	function brighten(color, amount) {
	    amount = (amount === 0) ? 0 : (amount || 10);
	    var rgb = tinycolor(color).toRgb();
	    rgb.r = mathMax(0, mathMin(255, rgb.r - mathRound(255 * - (amount / 100))));
	    rgb.g = mathMax(0, mathMin(255, rgb.g - mathRound(255 * - (amount / 100))));
	    rgb.b = mathMax(0, mathMin(255, rgb.b - mathRound(255 * - (amount / 100))));
	    return tinycolor(rgb);
	}
	
	function darken (color, amount) {
	    amount = (amount === 0) ? 0 : (amount || 10);
	    var hsl = tinycolor(color).toHsl();
	    hsl.l -= amount / 100;
	    hsl.l = clamp01(hsl.l);
	    return tinycolor(hsl);
	}
	
	// Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.
	// Values outside of this range will be wrapped into this range.
	function spin(color, amount) {
	    var hsl = tinycolor(color).toHsl();
	    var hue = (hsl.h + amount) % 360;
	    hsl.h = hue < 0 ? 360 + hue : hue;
	    return tinycolor(hsl);
	}
	
	// Combination Functions
	// ---------------------
	// Thanks to jQuery xColor for some of the ideas behind these
	// <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>
	
	function complement(color) {
	    var hsl = tinycolor(color).toHsl();
	    hsl.h = (hsl.h + 180) % 360;
	    return tinycolor(hsl);
	}
	
	function triad(color) {
	    var hsl = tinycolor(color).toHsl();
	    var h = hsl.h;
	    return [
	        tinycolor(color),
	        tinycolor({ h: (h + 120) % 360, s: hsl.s, l: hsl.l }),
	        tinycolor({ h: (h + 240) % 360, s: hsl.s, l: hsl.l })
	    ];
	}
	
	function tetrad(color) {
	    var hsl = tinycolor(color).toHsl();
	    var h = hsl.h;
	    return [
	        tinycolor(color),
	        tinycolor({ h: (h + 90) % 360, s: hsl.s, l: hsl.l }),
	        tinycolor({ h: (h + 180) % 360, s: hsl.s, l: hsl.l }),
	        tinycolor({ h: (h + 270) % 360, s: hsl.s, l: hsl.l })
	    ];
	}
	
	function splitcomplement(color) {
	    var hsl = tinycolor(color).toHsl();
	    var h = hsl.h;
	    return [
	        tinycolor(color),
	        tinycolor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l}),
	        tinycolor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l})
	    ];
	}
	
	function analogous(color, results, slices) {
	    results = results || 6;
	    slices = slices || 30;
	
	    var hsl = tinycolor(color).toHsl();
	    var part = 360 / slices;
	    var ret = [tinycolor(color)];
	
	    for (hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360; --results; ) {
	        hsl.h = (hsl.h + part) % 360;
	        ret.push(tinycolor(hsl));
	    }
	    return ret;
	}
	
	function monochromatic(color, results) {
	    results = results || 6;
	    var hsv = tinycolor(color).toHsv();
	    var h = hsv.h, s = hsv.s, v = hsv.v;
	    var ret = [];
	    var modification = 1 / results;
	
	    while (results--) {
	        ret.push(tinycolor({ h: h, s: s, v: v}));
	        v = (v + modification) % 1;
	    }
	
	    return ret;
	}
	
	// Utility Functions
	// ---------------------
	
	tinycolor.mix = function(color1, color2, amount) {
	    amount = (amount === 0) ? 0 : (amount || 50);
	
	    var rgb1 = tinycolor(color1).toRgb();
	    var rgb2 = tinycolor(color2).toRgb();
	
	    var p = amount / 100;
	
	    var rgba = {
	        r: ((rgb2.r - rgb1.r) * p) + rgb1.r,
	        g: ((rgb2.g - rgb1.g) * p) + rgb1.g,
	        b: ((rgb2.b - rgb1.b) * p) + rgb1.b,
	        a: ((rgb2.a - rgb1.a) * p) + rgb1.a
	    };
	
	    return tinycolor(rgba);
	};
	
	
	// Readability Functions
	// ---------------------
	// <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)
	
	// `contrast`
	// Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)
	tinycolor.readability = function(color1, color2) {
	    var c1 = tinycolor(color1);
	    var c2 = tinycolor(color2);
	    return (Math.max(c1.getLuminance(),c2.getLuminance())+0.05) / (Math.min(c1.getLuminance(),c2.getLuminance())+0.05);
	};
	
	// `isReadable`
	// Ensure that foreground and background color combinations meet WCAG2 guidelines.
	// The third argument is an optional Object.
	//      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';
	//      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.
	// If the entire object is absent, isReadable defaults to {level:"AA",size:"small"}.
	
	// *Example*
	//    tinycolor.isReadable("#000", "#111") => false
	//    tinycolor.isReadable("#000", "#111",{level:"AA",size:"large"}) => false
	tinycolor.isReadable = function(color1, color2, wcag2) {
	    var readability = tinycolor.readability(color1, color2);
	    var wcag2Parms, out;
	
	    out = false;
	
	    wcag2Parms = validateWCAG2Parms(wcag2);
	    switch (wcag2Parms.level + wcag2Parms.size) {
	        case "AAsmall":
	        case "AAAlarge":
	            out = readability >= 4.5;
	            break;
	        case "AAlarge":
	            out = readability >= 3;
	            break;
	        case "AAAsmall":
	            out = readability >= 7;
	            break;
	    }
	    return out;
	
	};
	
	// `mostReadable`
	// Given a base color and a list of possible foreground or background
	// colors for that base, returns the most readable color.
	// Optionally returns Black or White if the most readable color is unreadable.
	// *Example*
	//    tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:false}).toHexString(); // "#112255"
	//    tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:true}).toHexString();  // "#ffffff"
	//    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"large"}).toHexString(); // "#faf3f3"
	//    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"small"}).toHexString(); // "#ffffff"
	tinycolor.mostReadable = function(baseColor, colorList, args) {
	    var bestColor = null;
	    var bestScore = 0;
	    var readability;
	    var includeFallbackColors, level, size ;
	    args = args || {};
	    includeFallbackColors = args.includeFallbackColors ;
	    level = args.level;
	    size = args.size;
	
	    for (var i= 0; i < colorList.length ; i++) {
	        readability = tinycolor.readability(baseColor, colorList[i]);
	        if (readability > bestScore) {
	            bestScore = readability;
	            bestColor = tinycolor(colorList[i]);
	        }
	    }
	
	    if (tinycolor.isReadable(baseColor, bestColor, {"level":level,"size":size}) || !includeFallbackColors) {
	        return bestColor;
	    }
	    else {
	        args.includeFallbackColors=false;
	        return tinycolor.mostReadable(baseColor,["#fff", "#000"],args);
	    }
	};
	
	
	// Big List of Colors
	// ------------------
	// <http://www.w3.org/TR/css3-color/#svg-color>
	var names = tinycolor.names = {
	    aliceblue: "f0f8ff",
	    antiquewhite: "faebd7",
	    aqua: "0ff",
	    aquamarine: "7fffd4",
	    azure: "f0ffff",
	    beige: "f5f5dc",
	    bisque: "ffe4c4",
	    black: "000",
	    blanchedalmond: "ffebcd",
	    blue: "00f",
	    blueviolet: "8a2be2",
	    brown: "a52a2a",
	    burlywood: "deb887",
	    burntsienna: "ea7e5d",
	    cadetblue: "5f9ea0",
	    chartreuse: "7fff00",
	    chocolate: "d2691e",
	    coral: "ff7f50",
	    cornflowerblue: "6495ed",
	    cornsilk: "fff8dc",
	    crimson: "dc143c",
	    cyan: "0ff",
	    darkblue: "00008b",
	    darkcyan: "008b8b",
	    darkgoldenrod: "b8860b",
	    darkgray: "a9a9a9",
	    darkgreen: "006400",
	    darkgrey: "a9a9a9",
	    darkkhaki: "bdb76b",
	    darkmagenta: "8b008b",
	    darkolivegreen: "556b2f",
	    darkorange: "ff8c00",
	    darkorchid: "9932cc",
	    darkred: "8b0000",
	    darksalmon: "e9967a",
	    darkseagreen: "8fbc8f",
	    darkslateblue: "483d8b",
	    darkslategray: "2f4f4f",
	    darkslategrey: "2f4f4f",
	    darkturquoise: "00ced1",
	    darkviolet: "9400d3",
	    deeppink: "ff1493",
	    deepskyblue: "00bfff",
	    dimgray: "696969",
	    dimgrey: "696969",
	    dodgerblue: "1e90ff",
	    firebrick: "b22222",
	    floralwhite: "fffaf0",
	    forestgreen: "228b22",
	    fuchsia: "f0f",
	    gainsboro: "dcdcdc",
	    ghostwhite: "f8f8ff",
	    gold: "ffd700",
	    goldenrod: "daa520",
	    gray: "808080",
	    green: "008000",
	    greenyellow: "adff2f",
	    grey: "808080",
	    honeydew: "f0fff0",
	    hotpink: "ff69b4",
	    indianred: "cd5c5c",
	    indigo: "4b0082",
	    ivory: "fffff0",
	    khaki: "f0e68c",
	    lavender: "e6e6fa",
	    lavenderblush: "fff0f5",
	    lawngreen: "7cfc00",
	    lemonchiffon: "fffacd",
	    lightblue: "add8e6",
	    lightcoral: "f08080",
	    lightcyan: "e0ffff",
	    lightgoldenrodyellow: "fafad2",
	    lightgray: "d3d3d3",
	    lightgreen: "90ee90",
	    lightgrey: "d3d3d3",
	    lightpink: "ffb6c1",
	    lightsalmon: "ffa07a",
	    lightseagreen: "20b2aa",
	    lightskyblue: "87cefa",
	    lightslategray: "789",
	    lightslategrey: "789",
	    lightsteelblue: "b0c4de",
	    lightyellow: "ffffe0",
	    lime: "0f0",
	    limegreen: "32cd32",
	    linen: "faf0e6",
	    magenta: "f0f",
	    maroon: "800000",
	    mediumaquamarine: "66cdaa",
	    mediumblue: "0000cd",
	    mediumorchid: "ba55d3",
	    mediumpurple: "9370db",
	    mediumseagreen: "3cb371",
	    mediumslateblue: "7b68ee",
	    mediumspringgreen: "00fa9a",
	    mediumturquoise: "48d1cc",
	    mediumvioletred: "c71585",
	    midnightblue: "191970",
	    mintcream: "f5fffa",
	    mistyrose: "ffe4e1",
	    moccasin: "ffe4b5",
	    navajowhite: "ffdead",
	    navy: "000080",
	    oldlace: "fdf5e6",
	    olive: "808000",
	    olivedrab: "6b8e23",
	    orange: "ffa500",
	    orangered: "ff4500",
	    orchid: "da70d6",
	    palegoldenrod: "eee8aa",
	    palegreen: "98fb98",
	    paleturquoise: "afeeee",
	    palevioletred: "db7093",
	    papayawhip: "ffefd5",
	    peachpuff: "ffdab9",
	    peru: "cd853f",
	    pink: "ffc0cb",
	    plum: "dda0dd",
	    powderblue: "b0e0e6",
	    purple: "800080",
	    rebeccapurple: "663399",
	    red: "f00",
	    rosybrown: "bc8f8f",
	    royalblue: "4169e1",
	    saddlebrown: "8b4513",
	    salmon: "fa8072",
	    sandybrown: "f4a460",
	    seagreen: "2e8b57",
	    seashell: "fff5ee",
	    sienna: "a0522d",
	    silver: "c0c0c0",
	    skyblue: "87ceeb",
	    slateblue: "6a5acd",
	    slategray: "708090",
	    slategrey: "708090",
	    snow: "fffafa",
	    springgreen: "00ff7f",
	    steelblue: "4682b4",
	    tan: "d2b48c",
	    teal: "008080",
	    thistle: "d8bfd8",
	    tomato: "ff6347",
	    turquoise: "40e0d0",
	    violet: "ee82ee",
	    wheat: "f5deb3",
	    white: "fff",
	    whitesmoke: "f5f5f5",
	    yellow: "ff0",
	    yellowgreen: "9acd32"
	};
	
	// Make it easy to access colors via `hexNames[hex]`
	var hexNames = tinycolor.hexNames = flip(names);
	
	
	// Utilities
	// ---------
	
	// `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`
	function flip(o) {
	    var flipped = { };
	    for (var i in o) {
	        if (o.hasOwnProperty(i)) {
	            flipped[o[i]] = i;
	        }
	    }
	    return flipped;
	}
	
	// Return a valid alpha value [0,1] with all invalid values being set to 1
	function boundAlpha(a) {
	    a = parseFloat(a);
	
	    if (isNaN(a) || a < 0 || a > 1) {
	        a = 1;
	    }
	
	    return a;
	}
	
	// Take input from [0, n] and return it as [0, 1]
	function bound01(n, max) {
	    if (isOnePointZero(n)) { n = "100%"; }
	
	    var processPercent = isPercentage(n);
	    n = mathMin(max, mathMax(0, parseFloat(n)));
	
	    // Automatically convert percentage into number
	    if (processPercent) {
	        n = parseInt(n * max, 10) / 100;
	    }
	
	    // Handle floating point rounding errors
	    if ((Math.abs(n - max) < 0.000001)) {
	        return 1;
	    }
	
	    // Convert into [0, 1] range if it isn't already
	    return (n % max) / parseFloat(max);
	}
	
	// Force a number between 0 and 1
	function clamp01(val) {
	    return mathMin(1, mathMax(0, val));
	}
	
	// Parse a base-16 hex value into a base-10 integer
	function parseIntFromHex(val) {
	    return parseInt(val, 16);
	}
	
	// Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
	// <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
	function isOnePointZero(n) {
	    return typeof n == "string" && n.indexOf('.') != -1 && parseFloat(n) === 1;
	}
	
	// Check to see if string passed in is a percentage
	function isPercentage(n) {
	    return typeof n === "string" && n.indexOf('%') != -1;
	}
	
	// Force a hex value to have 2 characters
	function pad2(c) {
	    return c.length == 1 ? '0' + c : '' + c;
	}
	
	// Replace a decimal with it's percentage value
	function convertToPercentage(n) {
	    if (n <= 1) {
	        n = (n * 100) + "%";
	    }
	
	    return n;
	}
	
	// Converts a decimal to a hex value
	function convertDecimalToHex(d) {
	    return Math.round(parseFloat(d) * 255).toString(16);
	}
	// Converts a hex value to a decimal
	function convertHexToDecimal(h) {
	    return (parseIntFromHex(h) / 255);
	}
	
	var matchers = (function() {
	
	    // <http://www.w3.org/TR/css3-values/#integers>
	    var CSS_INTEGER = "[-\\+]?\\d+%?";
	
	    // <http://www.w3.org/TR/css3-values/#number-value>
	    var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";
	
	    // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
	    var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";
	
	    // Actual matching.
	    // Parentheses and commas are optional, but not required.
	    // Whitespace can take the place of commas or opening paren
	    var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
	    var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
	
	    return {
	        CSS_UNIT: new RegExp(CSS_UNIT),
	        rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
	        rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
	        hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
	        hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
	        hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
	        hsva: new RegExp("hsva" + PERMISSIVE_MATCH4),
	        hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
	        hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
	        hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
	        hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
	    };
	})();
	
	// `isValidCSSUnit`
	// Take in a single string / number and check to see if it looks like a CSS unit
	// (see `matchers` above for definition).
	function isValidCSSUnit(color) {
	    return !!matchers.CSS_UNIT.exec(color);
	}
	
	// `stringInputToObject`
	// Permissive string parsing.  Take in a number of formats, and output an object
	// based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`
	function stringInputToObject(color) {
	
	    color = color.replace(trimLeft,'').replace(trimRight, '').toLowerCase();
	    var named = false;
	    if (names[color]) {
	        color = names[color];
	        named = true;
	    }
	    else if (color == 'transparent') {
	        return { r: 0, g: 0, b: 0, a: 0, format: "name" };
	    }
	
	    // Try to match string input using regular expressions.
	    // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
	    // Just return an object and let the conversion functions handle that.
	    // This way the result will be the same whether the tinycolor is initialized with string or object.
	    var match;
	    if ((match = matchers.rgb.exec(color))) {
	        return { r: match[1], g: match[2], b: match[3] };
	    }
	    if ((match = matchers.rgba.exec(color))) {
	        return { r: match[1], g: match[2], b: match[3], a: match[4] };
	    }
	    if ((match = matchers.hsl.exec(color))) {
	        return { h: match[1], s: match[2], l: match[3] };
	    }
	    if ((match = matchers.hsla.exec(color))) {
	        return { h: match[1], s: match[2], l: match[3], a: match[4] };
	    }
	    if ((match = matchers.hsv.exec(color))) {
	        return { h: match[1], s: match[2], v: match[3] };
	    }
	    if ((match = matchers.hsva.exec(color))) {
	        return { h: match[1], s: match[2], v: match[3], a: match[4] };
	    }
	    if ((match = matchers.hex8.exec(color))) {
	        return {
	            r: parseIntFromHex(match[1]),
	            g: parseIntFromHex(match[2]),
	            b: parseIntFromHex(match[3]),
	            a: convertHexToDecimal(match[4]),
	            format: named ? "name" : "hex8"
	        };
	    }
	    if ((match = matchers.hex6.exec(color))) {
	        return {
	            r: parseIntFromHex(match[1]),
	            g: parseIntFromHex(match[2]),
	            b: parseIntFromHex(match[3]),
	            format: named ? "name" : "hex"
	        };
	    }
	    if ((match = matchers.hex4.exec(color))) {
	        return {
	            r: parseIntFromHex(match[1] + '' + match[1]),
	            g: parseIntFromHex(match[2] + '' + match[2]),
	            b: parseIntFromHex(match[3] + '' + match[3]),
	            a: convertHexToDecimal(match[4] + '' + match[4]),
	            format: named ? "name" : "hex8"
	        };
	    }
	    if ((match = matchers.hex3.exec(color))) {
	        return {
	            r: parseIntFromHex(match[1] + '' + match[1]),
	            g: parseIntFromHex(match[2] + '' + match[2]),
	            b: parseIntFromHex(match[3] + '' + match[3]),
	            format: named ? "name" : "hex"
	        };
	    }
	
	    return false;
	}
	
	function validateWCAG2Parms(parms) {
	    // return valid WCAG2 parms for isReadable.
	    // If input parms are invalid, return {"level":"AA", "size":"small"}
	    var level, size;
	    parms = parms || {"level":"AA", "size":"small"};
	    level = (parms.level || "AA").toUpperCase();
	    size = (parms.size || "small").toLowerCase();
	    if (level !== "AA" && level !== "AAA") {
	        level = "AA";
	    }
	    if (size !== "small" && size !== "large") {
	        size = "small";
	    }
	    return {"level":level, "size":size};
	}
	
	// Node: Export function
	if (typeof module !== "undefined" && module.exports) {
	    module.exports = tinycolor;
	}
	// AMD/requirejs: Define the module
	else if (true) {
	    !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {return tinycolor;}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	}
	// Browser: Expose to window
	else {
	    window.tinycolor = tinycolor;
	}
	
	})(Math);


/***/ },
/* 12 */
/***/ function(module, exports) {

	'use strict';
	
	var unique = function unique(array) {
	  return $.grep(array, function (el, index) {
	    return index === $.inArray(el, array);
	  });
	};
	
	exports.init = function () {
	  $('.hs_cos_wrapper_type_custom_widget').each(function () {
	    if ($(this).find('.accordion-section').length > 0) {
	      $(this).addClass('has-accordion');
	    }
	  });
	
	  $('.widget-type-widget_container > span').each(function () {
	    var accordionCount = 0;
	    var groups = [];
	    $(this).find('> div').each(function () {
	      if ($(this).hasClass('has-accordion')) {
	        $(this).attr('data-group', accordionCount);
	        groups.push(accordionCount);
	      } else {
	        accordionCount++;
	      }
	    });
	
	    $.each(unique(groups), function (i, v) {
	      $('.has-accordion[data-group="' + v + '"]').wrapAll('<div class="accordion-group"></div>');
	    });
	
	    $(this).find('.accordion-group').each(function () {
	      var $self = $(this);
	
	      // handle section toggling
	      $self.find('.accordion-section .accordion-section__header').click(function () {
	        if ($(this).parent().hasClass('accordion-section--open')) {
	          $(this).parent().removeClass('accordion-section--open');
	        } else {
	          $self.find('.accordion-section').removeClass('accordion-section--open');
	          $(this).parent().addClass('accordion-section--open');
	        }
	      });
	    });
	  });
	};

/***/ }
/******/ ]);
//# sourceMappingURL=mjfm_main.js.map

}
/*
     FILE ARCHIVED ON 22:49:36 Jan 23, 2022 AND RETRIEVED FROM THE
     INTERNET ARCHIVE ON 06:28:14 Jul 17, 2024.
     JAVASCRIPT APPENDED BY WAYBACK MACHINE, COPYRIGHT INTERNET ARCHIVE.

     ALL OTHER CONTENT MAY ALSO BE PROTECTED BY COPYRIGHT (17 U.S.C.
     SECTION 108(a)(3)).
*/
/*
playback timings (ms):
  captures_list: 0.521
  exclusion.robots: 0.024
  exclusion.robots.policy: 0.015
  esindex: 0.01
  cdx.remote: 228.036
  LoadShardBlock: 123.523 (3)
  PetaboxLoader3.datanode: 81.777 (4)
  PetaboxLoader3.resolve: 148.575 (2)
  load_resource: 174.261
*/