/* Minification failed. Returning unminified contents.
(1635,13-14): run-time error JS1010: Expected identifier: .
(1635,13-14): run-time error JS1195: Expected expression: .
(3303,17-18): run-time error JS1010: Expected identifier: .
(3303,17-18): run-time error JS1195: Expected expression: .
(4157,11-12): run-time error JS1010: Expected identifier: .
(4157,11-12): run-time error JS1195: Expected expression: .
*/
(function () {
'use strict';
/** Utils
* A collection of utility functions.
*/
// Triggers a custom event on the given element.
function emit(el, eventName) {
var event = document.createEvent('Event');
event.initEvent(eventName, true, true);
el.dispatchEvent(event);
}
// Creates and sends an XMLHttpRequest; requires an options object be passed which may include:
// - url (required)
// - method
// - params
// - success
// - error
function ajax(options) {
var opts = Object.assign({
method: 'GET',
params: {}
}, options);
opts.method = opts.method.toUpperCase();
if (opts.method === 'GET') {
// Build query string
var queryString = Object.keys(opts.params).map(function (key) {
return key + '=' + opts.params[key];
}).join('&');
opts.url += '?' + queryString;
}
var request = new XMLHttpRequest();
request.open(opts.method, opts.url, true);
if (opts.success && typeof opts.success === 'function') {
request.addEventListener('load', function () {
if (request.status >= 200 && request.status < 400) {
opts.success(request.responseText);
} else if (opts.error && typeof opts.error === 'function') {
opts.error();
}
});
}
if (opts.error && typeof opts.error === 'function') {
request.addEventListener('error', opts.error);
}
if (opts.contentType) {
request.setRequestHeader('Content-Type', opts.contentType);
}
if (opts.method === 'POST') {
if (!opts.contentType) {
request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8');
}
request.send(opts.params);
} else {
request.send();
}
}
// Find closest ancestor of an element that matches the given selector
function findAncestor(el, selector) {
// eslint-disable-next-line
while ((el = el.parentElement) && !el.matches(selector)) {}
return el;
}
// https://davidwalsh.name/javascript-debounce-function
function debounce(fn, wait, immediate) {
var _this = this;
var timeout = void 0;
return function () {
var context = _this;
var args = [fn, wait, immediate];
var later = function later() {
timeout = null;
if (!immediate) fn.apply(context, args);
};
var callNow = immediate && !timeout;
clearTimeout(timeout);
timeout = setTimeout(later, wait);
if (callNow) fn.apply(context, args);
};
}
function queryAll(node, selector) {
var result = void 0;
if (selector.length && selector[0] === '>') {
var uniqueClass = 'qa-' + Date.now();
node.classList.add(uniqueClass);
result = document.querySelectorAll('.' + uniqueClass + ' ' + selector);
node.classList.remove(uniqueClass);
} else {
result = node.querySelectorAll(selector);
}
return Array.prototype.slice.call(result);
}
function focusOnce(el) {
el.setAttribute('tabindex', -1);
el.focus();
el.addEventListener('blur', function () {
el.removeAttribute('tabindex');
});
}
var easings = {
/* eslint-disable */
linear: function linear(t, b, c, d) {
return c * t / d + b;
},
easeInOutQuad: function easeInOutQuad(t, b, c, d) {
t /= d / 2;
if (t < 1) return c / 2 * t * t + b;
t--;
return -c / 2 * (t * (t - 2) - 1) + b;
},
easeInOutCubic: function easeInOutCubic(t, b, c, d) {
t /= d / 2;
if (t < 1) return c / 2 * t * t * t + b;
t -= 2;
return c / 2 * (t * t * t + 2) + b;
}
/* eslint-enable */
};
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
var blazy = createCommonjsModule(function (module, exports) {
(function(root, blazy) {
{
// Node. Does not work with strict CommonJS, but
// only CommonJS-like environments that support module.exports,
// like Node.
module.exports = blazy();
}
})(commonjsGlobal, function() {
//private vars
var _source, _viewport, _isRetina, _supportClosest, _attrSrc = 'src', _attrSrcset = 'srcset';
// constructor
return function Blazy(options) {
//IE7- fallback for missing querySelectorAll support
if (!document.querySelectorAll) {
var s = document.createStyleSheet();
document.querySelectorAll = function(r, c, i, j, a) {
a = document.all, c = [], r = r.replace(/\[for\b/gi, '[htmlFor').split(',');
for (i = r.length; i--;) {
s.addRule(r[i], 'k:v');
for (j = a.length; j--;) a[j].currentStyle.k && c.push(a[j]);
s.removeRule(0);
}
return c;
};
}
//options and helper vars
var scope = this;
var util = scope._util = {};
util.elements = [];
util.destroyed = true;
scope.options = options || {};
scope.options.error = scope.options.error || false;
scope.options.offset = scope.options.offset || 100;
scope.options.root = scope.options.root || document;
scope.options.success = scope.options.success || false;
scope.options.selector = scope.options.selector || '.b-lazy';
scope.options.separator = scope.options.separator || '|';
scope.options.containerClass = scope.options.container;
scope.options.container = scope.options.containerClass ? document.querySelectorAll(scope.options.containerClass) : false;
scope.options.errorClass = scope.options.errorClass || 'b-error';
scope.options.breakpoints = scope.options.breakpoints || false;
scope.options.loadInvisible = scope.options.loadInvisible || false;
scope.options.successClass = scope.options.successClass || 'b-loaded';
scope.options.validateDelay = scope.options.validateDelay || 25;
scope.options.saveViewportOffsetDelay = scope.options.saveViewportOffsetDelay || 50;
scope.options.srcset = scope.options.srcset || 'data-srcset';
scope.options.src = _source = scope.options.src || 'data-src';
_supportClosest = Element.prototype.closest;
_isRetina = window.devicePixelRatio > 1;
_viewport = {};
_viewport.top = 0 - scope.options.offset;
_viewport.left = 0 - scope.options.offset;
/* public functions
************************************/
scope.revalidate = function() {
initialize(scope);
};
scope.load = function(elements, force) {
var opt = this.options;
if (elements && elements.length === undefined) {
loadElement(elements, force, opt);
} else {
each(elements, function(element) {
loadElement(element, force, opt);
});
}
};
scope.destroy = function() {
var util = scope._util;
if (scope.options.container) {
each(scope.options.container, function(object) {
unbindEvent(object, 'scroll', util.validateT);
});
}
unbindEvent(window, 'scroll', util.validateT);
unbindEvent(window, 'resize', util.validateT);
unbindEvent(window, 'resize', util.saveViewportOffsetT);
util.count = 0;
util.elements.length = 0;
util.destroyed = true;
};
//throttle, ensures that we don't call the functions too often
util.validateT = throttle(function() {
validate(scope);
}, scope.options.validateDelay, scope);
util.saveViewportOffsetT = throttle(function() {
saveViewportOffset(scope.options.offset);
}, scope.options.saveViewportOffsetDelay, scope);
saveViewportOffset(scope.options.offset);
//handle multi-served image src (obsolete)
each(scope.options.breakpoints, function(object) {
if (object.width >= window.screen.width) {
_source = object.src;
return false;
}
});
// start lazy load
setTimeout(function() {
initialize(scope);
}); // "dom ready" fix
};
/* Private helper functions
************************************/
function initialize(self) {
var util = self._util;
// First we create an array of elements to lazy load
util.elements = toArray(self.options);
util.count = util.elements.length;
// Then we bind resize and scroll events if not already binded
if (util.destroyed) {
util.destroyed = false;
if (self.options.container) {
each(self.options.container, function(object) {
bindEvent(object, 'scroll', util.validateT);
});
}
bindEvent(window, 'resize', util.saveViewportOffsetT);
bindEvent(window, 'resize', util.validateT);
bindEvent(window, 'scroll', util.validateT);
}
// And finally, we start to lazy load.
validate(self);
}
function validate(self) {
var util = self._util;
for (var i = 0; i < util.count; i++) {
var element = util.elements[i];
if (elementInView(element, self.options) || hasClass(element, self.options.successClass)) {
self.load(element);
util.elements.splice(i, 1);
util.count--;
i--;
}
}
if (util.count === 0) {
self.destroy();
}
}
function elementInView(ele, options) {
var rect = ele.getBoundingClientRect();
if(options.container && _supportClosest){
// Is element inside a container?
var elementContainer = ele.closest(options.containerClass);
if(elementContainer){
var containerRect = elementContainer.getBoundingClientRect();
// Is container in view?
if(inView(containerRect, _viewport)){
var top = containerRect.top - options.offset;
var right = containerRect.right + options.offset;
var bottom = containerRect.bottom + options.offset;
var left = containerRect.left - options.offset;
var containerRectWithOffset = {
top: top > _viewport.top ? top : _viewport.top,
right: right < _viewport.right ? right : _viewport.right,
bottom: bottom < _viewport.bottom ? bottom : _viewport.bottom,
left: left > _viewport.left ? left : _viewport.left
};
// Is element in view of container?
return inView(rect, containerRectWithOffset);
} else {
return false;
}
}
}
return inView(rect, _viewport);
}
function inView(rect, viewport){
// Intersection
return rect.right >= viewport.left &&
rect.bottom >= viewport.top &&
rect.left <= viewport.right &&
rect.top <= viewport.bottom;
}
function loadElement(ele, force, options) {
// if element is visible, not loaded or forced
if (!hasClass(ele, options.successClass) && (force || options.loadInvisible || (ele.offsetWidth > 0 && ele.offsetHeight > 0))) {
var dataSrc = getAttr(ele, _source) || getAttr(ele, options.src); // fallback to default 'data-src'
if (dataSrc) {
var dataSrcSplitted = dataSrc.split(options.separator);
var src = dataSrcSplitted[_isRetina && dataSrcSplitted.length > 1 ? 1 : 0];
var srcset = getAttr(ele, options.srcset);
var isImage = equal(ele, 'img');
var parent = ele.parentNode;
var isPicture = parent && equal(parent, 'picture');
// Image or background image
if (isImage || ele.src === undefined) {
var img = new Image();
// using EventListener instead of onerror and onload
// due to bug introduced in chrome v50
// (https://productforums.google.com/forum/#!topic/chrome/p51Lk7vnP2o)
var onErrorHandler = function() {
if (options.error) options.error(ele, "invalid");
addClass(ele, options.errorClass);
unbindEvent(img, 'error', onErrorHandler);
unbindEvent(img, 'load', onLoadHandler);
};
var onLoadHandler = function() {
// Is element an image
if (isImage) {
if(!isPicture) {
handleSources(ele, src, srcset);
}
// or background-image
} else {
ele.style.backgroundImage = 'url("' + src + '")';
}
itemLoaded(ele, options);
unbindEvent(img, 'load', onLoadHandler);
unbindEvent(img, 'error', onErrorHandler);
};
// Picture element
if (isPicture) {
img = ele; // Image tag inside picture element wont get preloaded
each(parent.getElementsByTagName('source'), function(source) {
handleSource(source, _attrSrcset, options.srcset);
});
}
bindEvent(img, 'error', onErrorHandler);
bindEvent(img, 'load', onLoadHandler);
handleSources(img, src, srcset); // Preload
} else { // An item with src like iframe, unity games, simpel video etc
ele.src = src;
itemLoaded(ele, options);
}
} else {
// video with child source
if (equal(ele, 'video')) {
each(ele.getElementsByTagName('source'), function(source) {
handleSource(source, _attrSrc, options.src);
});
ele.load();
itemLoaded(ele, options);
} else {
if (options.error) options.error(ele, "missing");
addClass(ele, options.errorClass);
}
}
}
}
function itemLoaded(ele, options) {
addClass(ele, options.successClass);
if (options.success) options.success(ele);
// cleanup markup, remove data source attributes
removeAttr(ele, options.src);
removeAttr(ele, options.srcset);
each(options.breakpoints, function(object) {
removeAttr(ele, object.src);
});
}
function handleSource(ele, attr, dataAttr) {
var dataSrc = getAttr(ele, dataAttr);
if (dataSrc) {
setAttr(ele, attr, dataSrc);
removeAttr(ele, dataAttr);
}
}
function handleSources(ele, src, srcset){
if(srcset) {
setAttr(ele, _attrSrcset, srcset); //srcset
}
ele.src = src; //src
}
function setAttr(ele, attr, value){
ele.setAttribute(attr, value);
}
function getAttr(ele, attr) {
return ele.getAttribute(attr);
}
function removeAttr(ele, attr){
ele.removeAttribute(attr);
}
function equal(ele, str) {
return ele.nodeName.toLowerCase() === str;
}
function hasClass(ele, className) {
return (' ' + ele.className + ' ').indexOf(' ' + className + ' ') !== -1;
}
function addClass(ele, className) {
if (!hasClass(ele, className)) {
ele.className += ' ' + className;
}
}
function toArray(options) {
var array = [];
var nodelist = (options.root).querySelectorAll(options.selector);
for (var i = nodelist.length; i--; array.unshift(nodelist[i])) {}
return array;
}
function saveViewportOffset(offset) {
_viewport.bottom = (window.innerHeight || document.documentElement.clientHeight) + offset;
_viewport.right = (window.innerWidth || document.documentElement.clientWidth) + offset;
}
function bindEvent(ele, type, fn) {
if (ele.attachEvent) {
ele.attachEvent && ele.attachEvent('on' + type, fn);
} else {
ele.addEventListener(type, fn, { capture: false, passive: true });
}
}
function unbindEvent(ele, type, fn) {
if (ele.detachEvent) {
ele.detachEvent && ele.detachEvent('on' + type, fn);
} else {
ele.removeEventListener(type, fn, { capture: false, passive: true });
}
}
function each(object, fn) {
if (object && fn) {
var l = object.length;
for (var i = 0; i < l && fn(object[i], i) !== false; i++) {}
}
}
function throttle(fn, minDelay, scope) {
var lastCall = 0;
return function() {
var now = +new Date();
if (now - lastCall < minDelay) {
return;
}
lastCall = now;
fn.apply(scope, arguments);
};
}
});
});
/** Carousel
* Creates instances of Carousel based on a CSS selector.
*
* Example use: Any card landing page on Fusion with a carousel
* e.g. http://www.gallup.com/education/227657/improve-k-12.aspx
*/
var blazyInstance = new blazy();
if (window.gel && window.gel.Carousel) {
queryAll(document, '.c-carousel').forEach(function (el) {
queryAll(el, '.c-carousel__container > .c-item').forEach(function (item) {
return item.classList.add('c-carousel__item');
});
el.classList.add('js-carousel--theme-auto');
// create carousel
if (el.classList.contains('c-carousel--tile')) {
// create carousel with per page breakpoints
new window.gel.Carousel(el, { siemaOptions: { perPage: { 1270: 3, 650: 2 } } }); // eslint-disable-line no-new, max-len
} else {
new window.gel.Carousel(el); // eslint-disable-line no-new
}
});
}
queryAll(document, '.c-carousel').forEach(function (el) {
el.addEventListener('gel.carousel.change', function () {
setTimeout(function () {
blazyInstance.revalidate();
}, 100);
});
});
/** Mosaic (layout)
* Displays child elements in a Carousel on mobile and a Mosaic on non-mobile. See implementations
* of either layout in GEL Bootstrap for more specifics on how they work.
*
* Example use: Gallup.com homepage (http://www.gallup.com/)
*/
var MOBILE_BREAKPOINT = 650;
var mosaicContainers = [];
var carousels = [];
function update(el, index) {
// on mobile, initialize a carousel
if (window.innerWidth < MOBILE_BREAKPOINT && !carousels[index]) {
carousels[index] = new window.gel.Carousel(el.querySelector('.c-carousel'));
queryAll(el, '.c-dot-paging').forEach(function (paging) {
return paging.classList.add('c-dot-paging--dark');
});
// on non-mobile, destroy the carousel
} else if (window.innerWidth >= MOBILE_BREAKPOINT && carousels[index]) {
carousels[index].destroy();
carousels[index] = null;
}
}
function updateAll() {
mosaicContainers.forEach(update);
}
if (window.gel && window.gel.Mosaic) {
queryAll(document, '.l-mosaic').forEach(function (el) {
// create mosaic
new window.gel.Mosaic(el, { // eslint-disable-line no-new
blockSelector: '.l-mosaic__block',
sizes: [{
suffix: 'sm', width: 2, fillLast: 2, maxWidth: 2
}, {
suffix: 'md', width: 2, fillLast: 2, maxWidth: 2
}, {
suffix: 'lg', width: 3, fillLast: 3, maxWidth: 2
}]
});
// do some prep work in case we need to show these items as a carousel on mobile
var carousel = document.createElement('div');
carousel.className = 'c-carousel';
el.appendChild(carousel);
var container = document.createElement('div');
container.className = 'c-carousel__container';
carousel.appendChild(container);
queryAll(el, '.l-mosaic__block').forEach(function (item) {
if (!item.hasAttribute('data-carousel-exclude')) {
item.classList.add('c-carousel__item');
container.appendChild(item);
}
});
mosaicContainers.push(el);
});
if (window.gel.Carousel) {
window.addEventListener('resize', debounce(updateAll, 50));
updateAll();
}
}
var classCallCheck = function (instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
};
var createClass = function () {
function defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
return function (Constructor, protoProps, staticProps) {
if (protoProps) defineProperties(Constructor.prototype, protoProps);
if (staticProps) defineProperties(Constructor, staticProps);
return Constructor;
};
}();
var toConsumableArray = function (arr) {
if (Array.isArray(arr)) {
for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
return arr2;
} else {
return Array.from(arr);
}
};
/** Masonry (layout)
* Lays out child elements of the specified container element in a masonry layout
* (i.e. grid of items with nonuniform height).
*
* Example use: Gallup News homepage (http://news.gallup.com/)
*/
var DATA_ATTR = 'data-masonry';
var CLS_ACTIVE = 'js-masonry-active';
var CLS_ITEM = 'js-masonry-item';
var CLS_PREPOSITIONED = 'js-masonry-prepositioned';
var CLS_MEASURE = 'js-masonry-measure';
var CLS_SPACER = 'js-masonry-spacer';
var instances = [];
var Masonry = function () {
function Masonry(container) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
classCallCheck(this, Masonry);
this.container = typeof container === 'string' ? document.querySelector(container) : container;
if (!container) {
throw Error('Masonry: Cannot find specified container element.');
}
Object.assign(this, {
itemSelector: '> section',
updateOnResize: true,
columnWidth: 310,
gutter: 0,
useTransforms: true
}, options);
this.cache = {
columnCount: 1
};
this.container.masonry = this;
instances.push(this);
this.update();
}
createClass(Masonry, [{
key: 'getItems',
value: function getItems() {
if (this.itemSelector.length && this.itemSelector[0] === '>') {
var tempCls = 'masonry-container-' + instances.indexOf(this);
this.container.classList.add(tempCls);
var items = queryAll(document, '.' + tempCls + ' ' + this.itemSelector);
this.container.classList.remove(tempCls);
return items;
}
return queryAll(this.container, this.itemSelector);
}
// Returns number of columns that the container can fit
}, {
key: 'getColumnCount',
value: function getColumnCount() {
var available = this.container.offsetWidth + this.gutter;
var perColumn = this.columnWidth + this.gutter;
return Math.max(Math.floor(available / perColumn), 1);
}
// Returns which column an x coordinate would be in
}, {
key: 'xToCol',
value: function xToCol(x) {
return Math.min(Math.floor(x / this.columnWidth), this.cache.columnCount);
}
// Returns number of columns an item spans
}, {
key: 'getColumnsSpanned',
value: function getColumnsSpanned(el) {
return Math.max(Math.ceil(el.offsetWidth / this.columnWidth), 1);
}
// Does the actual positioning of items in masonry layout
}, {
key: 'layout',
value: function layout() {
var items = this.getItems();
// Abort if there aren't any eligible items in the container
if (!items.length) {
return;
}
this.container.classList.add(CLS_ACTIVE);
// Find out how many columns we can fit, make a 0'd array of that length
var cols = [];
for (var i = 0; i < this.cache.columnCount; i++) {
cols.push(0);
}
// Account for prepositioned items
var prepositioned = this.container.querySelectorAll('.masonry-container > .' + CLS_PREPOSITIONED);
for (var _i = 0; _i < prepositioned.length; _i++) {
var el = prepositioned[_i];
var leftCol = this.xToCol(el.offsetLeft);
var rightCol = this.xToCol(el.offsetLeft + el.offsetWidth - 1);
// Add the tile's height to the affected columns
for (var j = leftCol; j <= rightCol; j++) {
cols[j] = Math.max(el.offsetTop + el.offsetHeight, cols[j]);
}
}
// Layout the rest of the items
for (var _i2 = 0; _i2 < items.length; _i2++) {
var _el = items[_i2];
_el.classList.add(CLS_ITEM);
// Ignore prepositioned items
if (!_el.classList.contains(CLS_PREPOSITIONED)) {
// Find the shortest column
var col = 0;
for (var _j = 1; _j < cols.length; _j++) {
if (cols[col] > cols[_j]) {
col = _j;
}
}
// Assume standard width initially
var colsSpanned = 1;
// If it has the `js-masonry-measure` class, actually measure the width
if (_el.classList.contains(CLS_MEASURE)) {
colsSpanned = Math.min(this.getColumnsSpanned(_el), cols.length);
// If it's too wide to fit, place it in the first column
if (colsSpanned > cols.length - col) {
col = 0;
}
}
// Position the tile
_el.style.top = cols[col] + 'px';
_el.style.left = this.columnWidth * col + 'px';
// Account for the space it occupies
for (var _j2 = 0; _j2 < colsSpanned; _j2++) {
cols[col + _j2] += _el.offsetHeight;
}
// Spacer/"clearing" logic
if (_el.classList.contains(CLS_SPACER)) {
(function () {
var clearHeight = Math.max.apply(Math, toConsumableArray(cols));
cols = cols.map(function (currentValue) {
return Math.max(clearHeight, currentValue);
});
})();
}
}
}
// Set appropriate height on the container so all items are visible
this.container.style.height = Math.max.apply(Math, toConsumableArray(cols)) + 'px';
}
// Disables masonry and restores positioning defaults
}, {
key: 'reset',
value: function reset() {
var fullReset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
this.container.classList.remove(CLS_ACTIVE);
this.container.style.height = '';
if (fullReset) {
this.getItems().forEach(function (el) {
el.classList.remove(CLS_ITEM);
el.style.top = '';
el.style.left = '';
});
}
}
// Checks to see if we need to re-layout or disable the masonry
}, {
key: 'update',
value: function update() {
var forceUpdate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
var cols = this.getColumnCount();
// Only do update if we're forcing an update or the column count has changed
var doUpdate = forceUpdate === true || this.cache.columnCount !== cols;
// Update cached column count for next update
this.cache.columnCount = cols;
if (doUpdate) {
if (cols > 1) {
this.layout();
} else {
this.reset();
}
}
}
}, {
key: 'destroy',
value: function destroy() {
this.reset(true);
instances.splice(instances.indexOf(this), 1);
}
}]);
return Masonry;
}();
var style = document.createElement('style');
style.innerHTML = '\n .' + CLS_ACTIVE + ' {\n position: relative;\n }\n .' + CLS_ACTIVE + ' .' + CLS_ITEM + ' {\n position: absolute;\n }\n';
style.appendChild(document.createTextNode('')); // Webkit hack
document.head.appendChild(style);
/*
** Event Listeners
*/
var updateAll$1 = function updateAll() {
var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
return instances.forEach(function (i) {
return i.update(force);
});
};
var resetAll = function resetAll() {
return instances.forEach(function (i) {
return i.reset();
});
};
// Update masonry instances on window resize if updateOnResize == true
window.addEventListener('resize', debounce(function () {
instances.forEach(function (i) {
return i.updateOnResize && i.update();
});
}, 50));
// Update masonry instances when TypeKit loads
document.body.addEventListener('typekitLoaded', updateAll$1.bind(null, true));
// Disable masonry (call reset()) on print and re-enable after (call layout())
if ('onbeforeprint' in window) {
window.addEventListener('beforeprint', resetAll);
window.addEventListener('afterprint', updateAll$1.bind(null, false));
} else if (window.matchMedia) {
window.matchMedia('print').addListener(function (mql) {
if (mql.matches) {
resetAll();
} else {
updateAll$1();
}
});
}
/*
** Auto-initialize elements with [data-masonry] attribute
*/
queryAll(document, '[' + DATA_ATTR + ']').forEach(function (el) {
var options = {};
var itemSelector = el.getAttribute(DATA_ATTR);
if (itemSelector) {
options.itemSelector = itemSelector;
}
new Masonry(el, options); // eslint-disable-line no-new
});
window.masonry = instances;
/** Typekit
* Adobe-provided script for loading webfonts from Typekit.
*/
// TypeKit loader script from Adobe
// This has been modified as little as possible to make future upgrades easy
(function (d) {
var kits = {
'en': 'svt7wsh',
'ja': 'wzr4sie',
'zh': 'lsv0hxq'
};
var config = {
kitId: kits[document.documentElement.lang.toLowerCase().split('-')[0] || "en"],
scriptTimeout: 3000,
async: true,
active: function active() {
document.fonts.ready.then(function () {
emit(document.body, 'typekitLoaded');
});
}
},
h = d.documentElement,
t = setTimeout(function () {
h.className = h.className.replace(/\bwf-loading\b/g, "") + " wf-inactive";
}, config.scriptTimeout),
tk = d.createElement("script"),
f = false,
s = d.getElementsByTagName("script")[0],
a;
h.className += " wf-loading";
tk.src = 'https://use.typekit.net/' + config.kitId + '.js';
tk.async = true;
tk.onload = tk.onreadystatechange = function () {
a = this.readyState;
if (f || a && a != "complete" && a != "loaded") return;
f = true;
clearTimeout(t);
try {
Typekit.load(config);
} catch (e) {}
};
s.parentNode.insertBefore(tk, s);
})(document);
/** Max lines
* Essentially implements `text-overflow-y` (if it were a thing) -- prevents text in
* elements with `data-overflow="ellipsis"` from overflowing its container by inserting
* an ellipsis at the clipping point and hiding the remainder of the text.
*
* Example use: tiles on any Fusion site (e.g. Gallup News homepage -- http://news.gallup.com/)
*/
// Looks for elements with the data attribute data-overflow="ellipsis"
// Determines whether that element has text that has been hidden by overflow
// Adds an ellipsis to the end of the text that is visible
// Set update to true if you have new elements on the page to check
var fontCache = {};
function setup() {
// Add temporary styles
var style = document.createElement('style');
// Hack for Webkit -- http://davidwalsh.name/add-rules-stylesheets
style.appendChild(document.createTextNode(''));
document.head.appendChild(style);
style.id = 'maxlines-styles';
style.sheet.insertRule('.font-baseline { visibility: hidden; height: 100px; }', 0);
style.sheet.insertRule('.font-baseline span:after { content: \'\'; height: 100%; display: inline-block; }', 1);
}
function reset() {
// Remove temporary styles
document.head.removeChild(document.getElementById('maxlines-styles'));
}
// Recursively get all textnodes that are children of a node.
// Previously we used the treewalker API but there were some
// browser-specific bugs with the API
function textNodesUnder(node) {
var all = [];
var cursor = node;
for (cursor = cursor.firstChild; cursor; cursor = cursor.nextSibling) {
if (cursor.nodeType === 3) all.push(cursor);else all = all.concat(textNodesUnder(cursor));
}
return all;
}
// Calculate a number of font metrics needed for the work
// Most importantly the baseline and the width of an ellipsis
// for a specific element
function fontMetrics(_container) {
var div = document.createElement('div');
var strut = document.createElement('span');
var lineHeight = void 0;
var container = _container || document.body;
var containerStyle = window.getComputedStyle(container);
var hash = [containerStyle.fontFamily, containerStyle.fontSize, containerStyle.fontWeight, containerStyle.lineHeight, containerStyle.letterSpacing].join('-');
if (fontCache[hash]) {
return fontCache[hash];
} else if (containerStyle.display === 'none') {
return null;
}
// Make an ellipsis for this element offscreen so we can measure it
var ellipsis = document.createElement('div');
ellipsis.setAttribute('aria-hidden', true);
ellipsis.style.position = 'absolute';
ellipsis.style.left = '-99999999px';
ellipsis.innerHTML = '…';
container.appendChild(ellipsis);
// Measure it so we can test if an ellipsis fits in letious spots.
var elipWidth = ellipsis.getBoundingClientRect().width * 2;
container.removeChild(ellipsis);
// Thanks to Alan Stearns for the hack!
// http://blogs.adobe.com/webplatform/2014/08/13/one-weird-trick-to-baseline-align-text/
strut.textContent = 'T';
div.appendChild(strut);
div.classList.add('font-baseline');
container.appendChild(div);
var computedStyle = window.getComputedStyle(strut);
lineHeight = parseInt(computedStyle.lineHeight, 10);
strut.style.lineHeight = 0;
var strutHeight = strut.offsetHeight;
var baselineHeight = strut.offsetTop + strutHeight - div.offsetHeight - div.offsetTop;
lineHeight = lineHeight || strutHeight;
div.parentNode.removeChild(div);
// Cache the result before returning it
fontCache[hash] = {
elipWidth: elipWidth,
offset: (lineHeight - strutHeight) / 2 + baselineHeight
};
return fontCache[hash];
}
function maxLines(update) {
setup();
// We are going to process everything which means removing old ellipses.
if (!update) {
// Clean up previous pass. If we are calling this again something has changed.
queryAll(document, '[data-overflow="ellipsis"] .overflow-ellipsis').forEach(function (el) {
el.parentNode.removeChild(el);
});
}
// We only want to check new items
var els = update ? queryAll(document, '[data-overflow="ellipsis"]:not([data-overflow-checked="1"])') : queryAll(document, '[data-overflow="ellipsis"]');
var range = document.createRange(); // Reusable range object
// For each data-overflow element, check to see
// if we need ellipsis and add one if we do
els.forEach(function (el) {
el.normalize();
// Measure the font metrics so we can find the baseline offset for this text
var metrics = fontMetrics(el);
if (!metrics) {
return;
}
// Do we have any overflowing text?
var elRect = el.getBoundingClientRect();
var elBottom = elRect.bottom;
// Measure the position of the last baseline in the element
// Because scrollHeight is an integer and the clientRect is not
// it could be off by as much as a pixel, so subtract 1 from the scrollHeight
// So that we don't inadvertantly try and ellipsis something that actually fits.
var contentBottom = Math.max(elRect.bottom, elRect.top + el.scrollHeight - 1) - metrics.offset;
range.selectNodeContents(el);
// See if the last baseline is being cropped by a parent
var parentBottom = elBottom;
var parentNode = el.parentNode;
// We could save time by caching this, perhaps?
while (parentNode && parentNode.nodeType === 1) {
if (window.getComputedStyle(parentNode).overflow !== 'visible') {
parentBottom = parentNode.getBoundingClientRect().bottom;
if (parentBottom <= elBottom) {
elBottom = parentBottom;
}
}
parentNode = parentNode.parentNode; // eslint-disable-line prefer-destructuring
}
// Mark the element so we can skip it during update calls later
el.setAttribute('data-overflow-checked', 1);
// If this elment is not overflowing, we are done.
if (elBottom >= contentBottom) {
return;
}
// Go through the text nodes to find the last visible text in the element.
var textNodes = textNodesUnder(el);
textNodes.reverse();
// Stop returning true when we've found our match
textNodes.every(function (tn) {
// Find all the whitespace indices in the element.
var result = [];
tn.textContent.replace(/([.,\s]+)/g, function (a, b, index) {
result.push(index);
});
result.reverse();
// Find all the bounding rectangles for the character preceeding
// whitepsace from last to first.
for (var i = 0; i < result.length; i++) {
// If the whitespace character is the first character in the text node, ignore it
// We don't want to put an ellipsis there anyway
if (result[i] !== 0) {
range.setStart(tn, result[i] - 1);
range.setEnd(tn, result[i]);
// Find the position of this whitespace character on the page
var gapRect = range.getBoundingClientRect();
var gapBottom = gapRect.bottom;
var gapRight = gapRect.right;
// IE uses logical pixels for the dimensions reported by range.getBoundingClientRect
// so we need to convert these to match the dimensions reported by the element version
if (window.screen.deviceXDPI) {
gapBottom /= window.screen.deviceXDPI / window.screen.logicalXDPI;
gapRight /= window.screen.deviceXDPI / window.screen.logicalXDPI;
}
// Find the baseline for this character
gapBottom -= metrics.offset;
// If the whitespace character's baseline is visible and there is room
// to the right for an ellipsis, put a span containing the
// ellipsis and some line breaks right before the whitespace.
// The line breaks push the rest of the text to be outside
// of the visible area so that the ellipsis is the last text.
if (gapBottom <= elBottom && gapRight + metrics.elipWidth < elRect.right) {
var newNode = document.createElement('span');
newNode.className = 'overflow-ellipsis';
newNode.setAttribute('aria-hidden', true);
range.setStart(tn, result[i]);
range.setEnd(tn, result[i]);
range.surroundContents(newNode);
newNode.innerHTML = '\u2026Previous \n ' + this.pages.map(function (el, i) {
return '\n \n Go to page ' + (i + 1) + ' \n \n ';
}).join('') + '\n
\n Next or self Navigate Carousel ' + carouselCount + ' Left ';
this.btnRight = document.createElement('button');
this.btnRight.classList.add('c-carousel-inf__btn--right');
this.btnRight.innerHTML = 'Navigate Carousel ' + carouselCount + ' Right ';
this.innerContainer.appendChild(this.btnLeft);
this.innerContainer.appendChild(this.btnRight);
this.btnLeft.addEventListener('click', function () {
_this.animateCarousel(_this.itemWidth);
}, false);
this.btnRight.addEventListener('click', function () {
_this.animateCarousel(-_this.itemWidth);
}, false);
this.slider.addEventListener('touchstart', eventHandlers$1.dragStart.bind(this), false);
this.slider.addEventListener('mousedown', eventHandlers$1.dragStart.bind(this), false);
queryAll(this.slider, 'a').forEach(function (anchor) {
anchor.addEventListener('click', function (e) {
if (_this.dragTotalH > 3) {
e.preventDefault();
}
});
});
this.el.setAttribute(ATTRIBUTE_STATUS$1, STATUS_INITIALIZED$1);
}
createClass(InfiniteCarousel, [{
key: 'translateCarousel',
value: function translateCarousel(deltaX) {
var checkOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
var translateValue = this.currentOffset + deltaX + this.containerWidth / 2 - this.itemWidth - this.itemWidth * this.itemOffsetCount / 2;
this.slider.style.transform = 'translateX(' + translateValue + 'px)';
this.currentOffset += deltaX;
if (checkOffset) {
this.checkOffset();
}
}
}, {
key: 'animateCarousel',
value: function animateCarousel(deltaX, animateDuration) {
var _this2 = this;
if (!this.animating) {
this.animating = true;
var duration = animateDuration || 500; // duration of animation in ms
var ease = easings.easeInOutQuad; // easing function
var time = 0; // Current time in ms
var lastDraw = void 0; // Time of last draw
var deltaXProgress = 0;
var animate = function animate() {
// Update time
var now = new Date().getTime();
time += now - (lastDraw || now);
lastDraw = now;
// Get next scroll point
var tempDeltaX = ease(time, 0, deltaX, duration);
tempDeltaX -= deltaXProgress;
deltaXProgress += tempDeltaX;
// Update scrollTop
_this2.translateCarousel(tempDeltaX);
// If the animation isn't over call animate() for next frame
if (time < duration) {
requestAnimationFrame(animate);
} else {
_this2.animating = false;
_this2.translateCarousel(-_this2.currentOffset);
tiles.blazyInstance.revalidate();
}
};
// Animate first frame
animate();
}
}
}, {
key: 'snapCarousel',
value: function snapCarousel() {
var rounded = Math.round(this.currentOffset % this.itemWidth / this.itemWidth);
var snapped = void 0;
if (rounded === 0) {
snapped = -(this.currentOffset % this.itemWidth);
} else {
snapped = (360 - Math.abs(this.currentOffset % this.itemWidth)) * rounded;
}
this.animateCarousel(snapped);
this.checkOffset();
}
}, {
key: 'checkOffset',
value: function checkOffset() {
var tempOffset = this.currentOffset;
var direction = 0;
if (this.active) {
tempOffset += this.currentX - this.initialX;
}
if (tempOffset >= this.itemWidth / 2) {
direction = -1;
} else if (tempOffset <= -this.itemWidth / 2) {
direction = 1;
}
if (direction !== 0) {
this.translateCarousel(this.itemWidth * direction, false);
this.updateOrder(direction * -1);
tiles.blazyInstance.revalidate();
}
}
}, {
key: 'updateOrder',
value: function updateOrder(direction) {
this.order = (this.order + direction + this.items.length) % this.items.length;
if (this.order === 0) {
this.items.forEach(function (item) {
item.style.order = 0;
});
} else if (this.order === this.items.length - 1) {
for (var i = 1; i < this.items.length; i++) {
this.items[i].style.order = -1;
}
} else if (direction === 1) {
this.items[this.items.length - this.order].style.order = -1;
} else {
this.items[this.items.length - this.order - 1].style.order = 0;
}
}
}]);
return InfiniteCarousel;
}();
queryAll(document, '.' + CLASS_CAROUSEL).forEach(function (el) {
// Prevent repeat initialization
if (el.getAttribute(ATTRIBUTE_STATUS$1) !== STATUS_INITIALIZED$1) {
carouselCount += 1;
el.infiniteCarousel = new InfiniteCarousel(el); // eslint-disable-line no-new
}
});
/** Accordion tabs
* Looks for cards matching `.rel-cardsrvc`. For any accordions (series of Bootstrap collapses)
* found inside the card, creates a second toggle for it and adds it to a row of tab headers.
*
* Example use: http://www.gallup.com/workplace/215375/gallup-analytics-based-hiring.aspx
*/
function updateActiveTab(tabs, active, toggle) {
// Remove active class from current tab
var current = tabs.querySelector('.active');
if (current) {
current.classList.remove('active');
current.querySelector('[aria-expanded]').setAttribute('aria-expanded', 'false');
}
if (toggle.classList.contains('collapsed')) {
active.classList.add('active');
active.querySelector('[aria-expanded]').setAttribute('aria-expanded', 'true');
} else {
active.classList.remove('active');
}
}
queryAll(document, '.rel-cardsrvc').forEach(function (card) {
var tabs = document.createElement('ul');
tabs.className = 'cardsrvc-tabs';
var inlineHeader = card.querySelector('.cardsrvc-inline__header');
if (card.classList.contains('cardsrvc-inline') && inlineHeader) {
inlineHeader.appendChild(tabs);
} else {
card.insertBefore(tabs, card.querySelector('.cardsrvc-content'));
}
var verticalTabs = queryAll(card, '.cardsrvc-vertical-tab');
if (verticalTabs.length > 0) {
card.classList.add('cardsrvc-vertical');
var listItem1 = document.createElement('li');
var tabHeader = card.querySelector('.cardsrvc-title');
if (tabHeader !== null) {
tabs.appendChild(listItem1);
listItem1.appendChild(tabHeader.cloneNode(true));
}
}
var accordionToggles = queryAll(card, '.cardsrvc-acc-tab [data-toggle="collapse"]');
accordionToggles.forEach(function (toggle, index) {
var isSideNavScroll = card.classList.contains('c-tabs-vertical--sidenav--scroll');
var listItem = document.createElement('li');
var tab = toggle.cloneNode(true);
tabs.appendChild(listItem);
listItem.appendChild(tab);
if (isSideNavScroll) {
var contentCard = document.querySelector('#' + tab.attributes['aria-controls'].value);
document.addEventListener('scroll', function () {
var boundingBox = contentCard.getBoundingClientRect();
if (boundingBox.top < 70 && boundingBox.bottom > 70 && !listItem.classList.contains('active')) {
tabs.querySelectorAll('li').forEach(function (tabItem) {
tabItem.classList.remove('active');
});
listItem.classList.add('active');
}
}, false);
tab.removeAttribute('data-toggle');
tab.removeAttribute('data-duration');
tab.removeAttribute('data-parent');
tab.addEventListener('click', function (e) {
e.preventDefault();
scrollToElement(contentCard);
});
} else {
// Add unique ID's to both accordion toggle and tab header
// for Google Analytics tracking purposes
var title = toggle.textContent.replace(/[^a-z0-9]/gi, '');
var cmsID = (toggle.getAttribute('aria-controls') || '').replace('cardsrvc-', '');
toggle.id = 'Accord-' + title + '-' + cmsID; // eslint-disable-line no-param-reassign
tab.id = 'Tab-' + title + '-' + cmsID;
var ariaID = 'AriaTab-' + title + '-' + cmsID;
tab.setAttribute('aria-describedby', ariaID);
var tabDesctiption = document.querySelector('#cardsrvc-' + cmsID + ' .cardsrvc-main');
tabDesctiption.id = ariaID;
tab.addEventListener('click', function (e) {
// Prevent scrolling to anchor
e.preventDefault();
// Don't do anything if the tab is already selected
if (listItem.classList.contains('active')) return;
toggle.click();
updateActiveTab(tabs, listItem, toggle);
tiles.blazyInstance.revalidate();
});
}
// Show first tab by default
if (index === 0) {
toggle.click();
updateActiveTab(tabs, listItem, toggle);
}
toggle.addEventListener('click', function () {
// Scroll content into view on mobile
if (toggle.classList.contains('collapsed') && document.documentElement.clientWidth < 960) {
var _toggle$getBoundingCl = toggle.getBoundingClientRect(),
top = _toggle$getBoundingCl.top;
var _document$querySelect = document.querySelector('#' + toggle.getAttribute('aria-controls')).getBoundingClientRect(),
bottom = _document$querySelect.bottom;
if (top < 0 || bottom > document.documentElement.clientHeight) {
setTimeout(function () {
scrollToElement(toggle);
}, 10);
}
}
accordionToggles.forEach(function (t) {
if (toggle !== t) {
t.classList.remove('collapsed');
}
});
updateActiveTab(tabs, listItem, toggle);
tiles.blazyInstance.revalidate();
});
});
});
/** Timeline tabs
* Creates a timeline from a collection of Bootstrap collapses on a card landing page.
*
* Example use: http://www.gallup.com/education/227672/about.aspx
*/
function createTabTimelineControls(tabTimelineControls, tabButtons, currentIndex) {
// Creates the previous button
var prevControl = document.createElement('button');
var prevControlSr = tabButtons[Math.max(currentIndex - 1, 0)];
prevControlSr = prevControlSr.querySelector('h2').textContent;
prevControl.className = 'tab-timeline__control-prev';
prevControl.innerHTML = 'Go to ' + prevControlSr + ' ';
// Creates the next button
var nextControl = document.createElement('button');
var nextControlSr = tabButtons[Math.min(currentIndex + 1, tabButtons.length - 1)];
nextControlSr = nextControlSr.querySelector('h2').textContent;
nextControl.className = 'tab-timeline__control-next';
nextControl.innerHTML = 'Go to ' + nextControlSr + ' ';
// Assign on click
prevControl.addEventListener('click', function () {
tabButtons[currentIndex - 1].click();
});
// Assign on click
nextControl.addEventListener('click', function () {
tabButtons[currentIndex + 1].click();
});
tabTimelineControls.textContent = '';
if (currentIndex !== 0) {
tabTimelineControls.appendChild(prevControl);
}
if (currentIndex !== tabButtons.length - 1) {
tabTimelineControls.appendChild(nextControl);
}
}
function timelineProgressHandler(elm, i, progress) {
elm.setAttribute('data-current-index', i);
elm.addEventListener('click', function () {
progress.setAttribute('data-current-index', i);
emit(progress, 'CHANGE_INDEX');
});
}
if (document.querySelector('.l-clp--tab-timeline') !== null) {
// Find the accordions sections on the page
queryAll(document, '.rel-cardsrvc').forEach(function (section) {
var sectionCurrentIndex = 0;
// ul tabs section
var tabSection = section.querySelector('.cardsrvc-tabs');
// anchors inside of the tab section
var tabButtons = queryAll(tabSection, '.cardsrvc-accordion');
// toggle links inside of section
var accordionToggles = queryAll(section, '.cardsrvc-acc-tab [data-toggle="collapse"]');
// new div
var tabTimelineLine = document.createElement('div');
// new div
var tabTimelineLineProgress = document.createElement('div');
// new div
var tabTimelineControls = document.createElement('div');
// Adds timeline specific class names
tabSection.classList.add('cardsrvc-tabs--timeline');
tabTimelineLine.classList.add('tab-timeline__line');
tabTimelineLineProgress.classList.add('tab-timeline__line-progress');
tabTimelineControls.classList.add('tab-timeline__controls');
tabTimelineLineProgress.addEventListener('CHANGE_INDEX', function (e) {
var currentIndex = Number(e.target.dataset.currentIndex);
var tabSectionWidth = tabSection.offsetWidth;
var tabButtonWidth = tabButtons[currentIndex].offsetWidth;
var spaceBetween = (tabSectionWidth - tabButtonWidth * tabButtons.length) / (tabButtons.length - 1);
var progressWidth = void 0;
sectionCurrentIndex = currentIndex;
if (tabSectionWidth === 0 || tabButtonWidth === 0) {
// TabSection and tabButtonWidth are hidden because of mobile view
progressWidth = currentIndex / tabButtons.length * 100;
} else if (currentIndex === 0) {
progressWidth = 0;
} else if (currentIndex + 1 === tabButtons.length) {
progressWidth = 100;
} else {
progressWidth = tabButtonWidth * currentIndex + spaceBetween * currentIndex + tabButtonWidth / 2;
progressWidth = progressWidth / tabSectionWidth * 100;
}
e.target.style.width = progressWidth + '%';
tabButtons.forEach(function (button) {
if (button.dataset.currentIndex < currentIndex) {
button.classList.add('past-date');
} else {
button.classList.remove('past-date');
}
});
createTabTimelineControls(tabTimelineControls, tabButtons, currentIndex);
});
// Append progress inside of the tabtimeLine
tabTimelineLine.appendChild(tabTimelineLineProgress);
// Insert tabtimeLine after tabs
tabSection.insertAdjacentElement('afterend', tabTimelineLine);
// Create TimelineControls
createTabTimelineControls(tabTimelineControls, tabButtons, sectionCurrentIndex);
// Insert controls after tabtimeline
tabTimelineLine.insertAdjacentElement('afterend', tabTimelineControls);
// attach handler to each button
tabButtons.forEach(function (tab, i) {
timelineProgressHandler(tab, i, tabTimelineLineProgress);
});
// attach handler to each toggle
accordionToggles.forEach(function (toggle, i) {
timelineProgressHandler(toggle, i, tabTimelineLineProgress);
});
});
}
var gelAutocomplete = createCommonjsModule(function (module) {
(function (root, factory) {
if (module.exports) {
// Node. Does not work with strict CommonJS, but
// only CommonJS-like enviroments that support module.exports,
// like Node.
module.exports = factory();
} else {
// Browser globals
root.gel = root.gel || {};
root.gel.autocomplete = factory();
}
}(commonjsGlobal, function () {
/*
** Constructor
*/
return function Autocomplete(options) {
// Some error checking
if (!options) {
console.log('Error: No options object passed');
return;
}
if (!options.hasOwnProperty('element') || !(options.element instanceof Element)) {
console.log('Error: Invalid input element provided');
return;
}
if (!options.hasOwnProperty('source') || (!Array.isArray(options.source) && typeof options.source !== 'function')) {
console.log('Error: Invalid source provided -- must be an array or function');
return;
}
/*
** Private variables
*/
var self = this;
var cache;
var cachedQuery;
var isHidden;
var suggestionsCount;
var delayTimeout;
// DOM elements
self.element = options.element;
self.container = options.hasOwnProperty('container') && options.container instanceof Element ? options.container : null;
self.suggestionsList = document.createElement('ul');
// Data source
self.source = options.source;
self.sourceIsStatic = Array.isArray(options.source);
// Options
self.cssClass = options.hasOwnProperty('cssClass') ? options.cssClass : null;
self.delay = options.hasOwnProperty('delay') ? options.delay : (self.sourceIsStatic ? 0 : 250);
self.minCharacters = options.hasOwnProperty('minCharacters') ? options.minCharacters : 1;
self.hideOnOutsideClick = options.hasOwnProperty('hideOnOutsideClick') ? options.hideOnOutsideClick : true;
self.maxSuggestions = options.hasOwnProperty('maxSuggestions') ? options.maxSuggestions : -1;
self.maxSuggestionsDisplayed = options.hasOwnProperty('maxSuggestionsDisplayed') ? options.maxSuggestionsDisplayed : -1;
self.exactMatch = options.hasOwnProperty('exactMatch') ? options.exactMatch : true;
self.selfPosition = options.hasOwnProperty('selfPosition') ? options.selfPosition : false;
// Read-only properties
Object.defineProperty(self, 'isHidden', {
get: function () { return isHidden; }
});
Object.defineProperty(self, 'suggestionsCount', {
get: function () { return suggestionsCount; }
});
/*
** Public methods
*/
self.init = function() {
// Initialize private variables
cache = {};
cachedQuery = '';
suggestionsCount = 0;
// Wire up element event listeners
self.element.addEventListener('keydown', keydown);
self.element.addEventListener('keyup', keyup);
self.element.addEventListener('focus', focus);
if (self.hideOnOutsideClick) {
document.addEventListener('click', documentClick);
}
// If we're self-positioning, ignore any specified container (we need to attach to the )
if (self.selfPosition) {
self.container = document.createElement('div');
document.body.appendChild(self.container);
self.container.style.position = 'absolute';
self.reposition();
window.addEventListener('resize', windowResize);
}
// Otherwise, if no container was specified, create one
else if (!self.container) {
var wrapper = document.createElement('div');
wrapper.className = 'gel-autocomplete-wrapper';
self.element.parentElement.insertBefore(wrapper, self.element);
wrapper.appendChild(self.element);
self.container = document.createElement('div');
wrapper.appendChild(self.container);
}
self.container.classList.add('gel-autocomplete');
if (typeof self.cssClass === 'string') {
self.container.classList.add(self.cssClass);
}
self.container.appendChild(self.suggestionsList);
self.hide();
};
self.destroy = function() {
// Remove event listeners
self.element.removeEventListener('keydown', keydown);
self.element.removeEventListener('keyup', keyup);
self.element.removeEventListener('focus', focus);
document.removeEventListener('click', documentClick);
// Remove suggestions list element
self.container.removeChild(self.suggestionsList);
};
// Displays suggestions list
self.show = function() {
if (!isHidden || suggestionsCount < 1) return;
self.suggestionsList.style.display = '';
self.suggestionsList.setAttribute('aria-hidden', false);
isHidden = false;
self.reposition();
fireEvent(self.suggestionsList, 'gel.ac.show');
};
// Hides suggestions list
self.hide = function() {
if (isHidden) return;
self.suggestionsList.style.display = 'none';
self.suggestionsList.setAttribute('aria-hidden', true);
isHidden = true;
fireEvent(self.suggestionsList, 'gel.ac.hide');
};
// Updates suggestions list with suggestions array passed as a parameter
self.update = function(suggestions) {
if (!suggestions || suggestions.length < 1) {
self.clearSuggestions();
return;
}
if (!Array.isArray(suggestions)) {
console.log('Error: Invalid suggestions array');
return;
}
// Update cache
cache[cachedQuery] = suggestions;
if (self.maxSuggestionsDisplayed > 0) {
suggestions = suggestions.slice(0, self.maxSuggestionsDisplayed);
}
var objectArray = typeof suggestions[0] === 'object';
// Clear the current suggestions
self.suggestionsList.innerHTML = '';
// Build the markup for each suggestion
suggestions.forEach(function(suggestion) {
var li = document.createElement('li');
if (objectArray) {
li.setAttribute('data-autocomplete-value', suggestion.value);
if (suggestion.hasOwnProperty('domain')) {
li.setAttribute('data-companyDomain',suggestion.domain);
}
if (suggestion.hasOwnProperty('href')) {
var anchor = document.createElement('a');
anchor.href = suggestion.href;
anchor.innerHTML = suggestion.label;
li.appendChild(anchor);
} else {
li.innerHTML = suggestion.label;
}
} else {
li.setAttribute('data-autocomplete-value', suggestion);
li.innerHTML = suggestion;
}
li.addEventListener('click', function(e) {
self.select(this);
});
li.addEventListener('mouseenter', function(e) {
self.highlight(this);
});
self.suggestionsList.appendChild(li);
});
suggestionsCount = suggestions.length;
if (document.activeElement === self.element) {
self.show();
}
fireEvent(self.suggestionsList, 'gel.ac.update');
};
// Selects a suggestion
self.select = function(item) {
var anchor = item.querySelector('a[href]');
var domain = item.getAttribute('data-companyDomain');
if (anchor) {
window.location = anchor.href;
} else {
if (domain) {
self.element.value = item.getAttribute('data-autocomplete-value');
cachedQuery = item.getAttribute('data-autocomplete-value');
self.clearSuggestions();
document.getElementById('companyDomain').value = domain;
}
self.element.value = item.getAttribute('data-autocomplete-value');
cachedQuery = item.getAttribute('data-autocomplete-value');
self.clearSuggestions();
}
fireEvent(item, 'gel.ac.itemselect');
};
// Highlights a suggestion
self.highlight = function(item) {
self.clearHighlighted();
item.classList.add('highlighted');
fireEvent(item, 'gel.ac.itemhighlight');
};
// Clears highlighted suggestion
self.clearHighlighted = function() {
Array.prototype.forEach.call(self.suggestionsList.querySelectorAll('.highlighted'), function (el) {
el.classList.remove('highlighted');
});
};
// Clears suggestions list
self.clearSuggestions = function() {
self.suggestionsList.innerHTML = '';
suggestionsCount = 0;
self.hide();
};
self.reposition = function() {
if (!self.selfPosition || isHidden) return;
var offset = getPageOffset(self.element);
self.container.style.left = offset.left + 'px';
self.container.style.top = (offset.top + self.element.offsetHeight) + 'px';
self.container.style.width = self.element.offsetWidth + 'px';
fireEvent(self.container, 'gel.ac.reposition');
};
/*
** Private methods
*/
// onkeydown listener for the input element -- handles navigating suggestions with the keyboard
function keydown(e) {
if (suggestionsCount < 1 || [38, 40, 13, 9].indexOf(e.which) < 0) {
return;
}
var highlighted = self.suggestionsList.querySelector('.highlighted');
if (e.which === 38) { // up arrow
if (highlighted && highlighted.previousElementSibling) {
self.highlight(highlighted.previousElementSibling);
} else {
self.highlight(self.suggestionsList.lastElementChild);
}
e.preventDefault();
} else if (e.which === 40) { // down arrow
if (highlighted && highlighted.nextElementSibling) {
self.highlight(highlighted.nextElementSibling);
} else {
self.highlight(self.suggestionsList.firstElementChild);
}
e.preventDefault();
} else if (e.which === 13) { // enter
if (highlighted) {
self.select(highlighted);
e.preventDefault();
}
} else if (e.which == 9) { // tab
self.hide();
}
}
// onkeyup listener for the input element -- gets new suggestions if the user input has changed
function keyup(e) {
var q = self.element.value;
// Don't do anything if the query hasn't changed
if (cachedQuery === q) {
return;
}
cachedQuery = q;
if (q.length >= self.minCharacters) {
// If we have this query cached, use the cache
var suggestions = getCachedSuggestions(q);
if (suggestions) {
self.update(suggestions);
} else {
clearTimeout(delayTimeout);
delayTimeout = setTimeout(function () {
if (self.sourceIsStatic) {
self.update(getSuggestions(q));
} else {
self.source(q, self.update);
}
}, self.delay);
}
} else {
self.update();
}
}
// onfocus listener for the input element
function focus(e) {
self.show();
}
// onclick listener for the document
function documentClick(e) {
if (e.target !== self.element && !self.container.contains(e.target)) {
self.hide();
}
}
// onresize listener for the window
var windowResize = debounce(function() {
self.reposition();
}, 100);
// Searches source array for matches for a given query -- only used if source is a static array
function getSuggestions(q, source) {
var source = source || self.source;
if (source.length < 1) {
return [];
}
var regex = new RegExp(q, 'i');
if (typeof source[0] === 'string') {
return source.filter(function (value) {
return regex.test(value);
});
} else {
return source.filter(function (value) {
return regex.test(value.label);
});
}
}
// Returns cached suggestions for the given query if a relevant cache can be found
function getCachedSuggestions(q) {
// If we've run this exact query before, reuse the suggestions
if (cache[q]) {
return cache[q];
}
// If the server doesn't return only exact matches, we can't emulate it using the cache
if (!self.exactMatch) {
return null;
}
// Otherwise, try to find a cached superset of suggestions
var tempCache;
var prevLength;
var lastRelevantCache;
for (var i = 0; i < q.length; i++) {
tempCache = cache[q.slice(0, i + 1)];
if (!tempCache) break;
// Only use the cached suggestions if the length is less than the max the server returns
// or less than the length of the previous cache (which would mean it must be less than the
// max returned by the server). This ensures there are not additional suggestions that are
// not in the cache.
if (tempCache.length < self.maxSuggestions || tempCache.length < prevLength) {
lastRelevantCache = tempCache;
prevLength = tempCache.length;
} else if (typeof prevLength === 'undefined') {
prevLength = tempCache.length;
} else {
break;
}
}
return lastRelevantCache ? getSuggestions(q, lastRelevantCache) : null;
}
// Auto-initialize
self.init();
};
/*
** Private helper functions
*/
function fireEvent(el, eventName) {
var event = document.createEvent('Event');
event.initEvent(eventName, true, true);
el.dispatchEvent(event);
}
function getPageOffset(el) {
var top = 0;
var left = 0;
if (el.offsetParent) {
do {
top += el.offsetTop;
left += el.offsetLeft;
} while (el = el.offsetParent);
}
return { top: top, left: left };
}
// https://davidwalsh.name/javascript-debounce-function
function debounce(func, wait, immediate) {
var timeout;
return function() {
var context = this, args = arguments;
var later = function() {
timeout = null;
if (!immediate) func.apply(context, args);
};
var callNow = immediate && !timeout;
clearTimeout(timeout);
timeout = setTimeout(later, wait);
if (callNow) func.apply(context, args);
};
}
}));
});
/** Autocomplete
* Looks for elements with `data-autocomplete-source` attribute. Sets up an instance of
* GEL Autocomplete using the URL speficied by the value of `data-autocomplete-source` as
* a data source for suggestions.
*
* Also creates instance of GEL Autocomplete for search on Gallup News to display suggested
* topics.
*
* Example uses:
* - The "organization" field on many contact forms (e.g. http://www.gallup.com/contact.aspx)
* - The suggested topics feature of search on Gallup News (http://news.gallup.com/)
*/
function escapeRegExp(str) {
return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
}
function getSuggestions(url, params, callback) {
ajax({
url: url,
method: 'POST',
contentType: 'application/json; charset=utf-8',
params: JSON.stringify(params),
success: function success(response) {
var suggestions = JSON.parse(response).d;
callback(suggestions);
}
});
}
function getClearbitSuggestions(url, params, callback) {
ajax({
url: url,
method: 'GET',
contentType: 'application/json; charset=utf-8',
params: params,
success: function success(response) {
var suggestions = JSON.parse(response);
suggestions = suggestions.map(function (e) {
return { value: e.name, label: e.name, domain: e.domain };
});
callback(suggestions);
}
});
}
function setup$1(el) {
if (el.hasAttribute('data-autocomplete-simple')) {
el.addEventListener('focus', function () {
if (!el.hasAttribute('data-autocomplete-initialized')) {
getSuggestions(el.getAttribute('data-autocomplete-source'), {}, function (topics) {
var suggestions = topics.map(function (topic) {
return {
value: topic.label,
label: topic.label,
href: '/topic/' + topic.value + '.aspx'
};
});
// eslint-disable-next-line no-new
new gelAutocomplete({
element: el,
container: document.querySelector(el.getAttribute('data-autocomplete-container')),
source: suggestions,
maxSuggestionsDisplayed: 15
});
el.setAttribute('data-autocomplete-initialized', true);
});
}
});
} else if (el.hasAttribute('data-autocomplete-clearbit')) {
// eslint-disable-next-line no-new
new gelAutocomplete({
element: el,
selfPosition: true,
cssClass: 'form-autocomplete',
source: function source(query, callback) {
getClearbitSuggestions(el.getAttribute('data-autocomplete-source'), { query: query }, callback);
}
});
} else {
// eslint-disable-next-line no-new
new gelAutocomplete({
element: el,
selfPosition: true,
cssClass: 'form-autocomplete',
source: function source(q, callback) {
getSuggestions(el.getAttribute('data-autocomplete-source'), { q: q }, callback);
}
});
}
}
queryAll(document, '[data-autocomplete-source]').forEach(setup$1);
// Set up suggested topics for search overlay
var searchOverlay = document.querySelector('.c-search-overlay');
if (searchOverlay && (document.body.classList.contains('sit-newsv9') || document.body.classList.contains('sit-wwwv9'))) {
var loadedSuggestedTopics = false;
searchOverlay.addEventListener('gel.search.show', function () {
if (loadedSuggestedTopics) return;
getSuggestions('/Search/topics.aspx', {}, function (topics) {
window.gel.search.setSuggestionsProvider(function (q, cb) {
if (q.length < 2) {
cb('');
} else {
var regex = new RegExp(escapeRegExp(q), 'i');
var suggestions = topics.filter(function (topic) {
return regex.test(topic.label);
}).map(function (item) {
return '\n \n \n ' + item.label.replace(regex, '$& ') + '\n \n \n ';
}).slice(0, 15).join('');
cb(suggestions);
}
});
loadedSuggestedTopics = true;
});
});
}
/** Progress Bar
* Shows / hides a header element when reading a gallup news article then sets a
* dynamic width for a progress bar to show users reading progress
*
* Example use: Gallup News & WWW articles
* e.g. https://www.gallup.com/workplace/236078/elon-musk-start.aspx
*/
var progressHeader = document.querySelector('.c-progress-header');
var socialIcons = document.querySelector('.section-flex--share');
var scrolling = false;
function updateProgress() {
var progressBar = document.querySelector('.c-progress-bar');
var articleContent = null;
var articleRect = null;
var articleContentDivs = document.querySelectorAll('.article-content');
articleContentDivs.forEach(function (el) {
var clientRect = el.getBoundingClientRect();
if (-clientRect.top > -100 && -clientRect.top < clientRect.height) {
articleContent = el;
articleRect = clientRect;
}
});
if (articleContent !== null) {
progressHeader.style.transform = 'none';
var progressStatus = -articleRect.top / (articleRect.height - 400) * 100;
// always start progress width at 0%
if (progressStatus < 0) {
progressStatus = 0;
} else if (progressStatus >= 100) {
progressStatus = 100;
}
// update progress bar width
progressBar.style.width = progressStatus + '%';
socialIcons.style.display = 'block';
} else {
progressHeader.style.transform = 'translateY(-100px)';
socialIcons.style.display = 'none';
}
scrolling = false;
}
// check for progress element and fire event listener if needed
if (progressHeader) {
progressHeader.style.transform = 'translateY(-100px)';
progressHeader.style.display = 'block';
socialIcons.style.display = 'none';
// if we don't have sticky/fixed nav(s) pin progress header to top of page
if (!document.querySelector('.navbar-sticky') && !document.querySelector('.header-metanav-only')) {
progressHeader.style.top = 0;
}
window.addEventListener('scroll', function () {
if (!scrolling) {
// update progress status before next repaint
requestAnimationFrame(updateProgress);
scrolling = true;
}
});
}
/** Pin to top
* Emulates the behavior of `position: sticky` but also adds a `.item-pinned`
* class when "stuck" to the top to allow styling that state separately.
*
* Example use: http://news.gallup.com/reports/199961/state-american-workplace-report-2017.aspx?ays=1
*/
var items = [];
var pinnedTopPosition = function () {
var stickyNavbar = document.querySelector('.navbar-sticky');
return stickyNavbar ? stickyNavbar.clientHeight : 0;
}();
function update$1() {
for (var i = 0; i < items.length; i++) {
var el = items[i];
var rect = el.placeholder.getBoundingClientRect();
if (rect.top < pinnedTopPosition) {
el.classList.add('item-pinned');
el.style.position = 'fixed';
el.style.top = pinnedTopPosition + 'px';
el.style.left = 0;
el.style.width = '100%';
el.style.height = '';
el.style.zIndex = 1;
el.placeholder.style.height = el.clientHeight + 'px';
} else {
el.classList.remove('item-pinned');
el.style.position = 'absolute';
el.style.top = el.placeholder.offsetTop + 'px';
el.style.left = el.placeholder.offsetLeft + 'px';
el.style.width = rect.width + 'px';
el.style.height = el.originalHeight;
el.style.zIndex = '';
el.placeholder.style.height = el.originalHeight;
}
}
}
function createPlaceholder(el) {
var rect = el.getBoundingClientRect();
var cs = window.getComputedStyle(el);
var placeholder = document.createElement('div');
var ps = placeholder.style;
placeholder.className = 'item-pinnable-placeholder';
el.originalHeight = rect.height + 'px';
ps.height = rect.height + 'px';
ps.marginTop = cs.marginTop;
ps.marginLeft = cs.marginLeft;
ps.marginBottom = cs.marginBottom;
ps.marginRight = cs.marginRight;
ps.cssFloat = cs.cssFloat;
ps.fontSize = '1em';
ps.position = 'static';
ps.padding = 0;
ps.border = 0;
ps.borderSpacing = 0;
return placeholder;
}
function pin(el) {
el.placeholder = createPlaceholder(el);
el.parentNode.insertBefore(el.placeholder, el.nextSibling);
el.parentNode.style.position = 'relative';
items.push(el);
update$1();
}
// Automatically pin any items with `item-pinnable` class
window.onload = function loadPins() {
[].concat(toConsumableArray(document.querySelectorAll('.item-pinnable'))).forEach(pin);
};
// Register event listeners
document.addEventListener('scroll', throttle_1(update$1, 30));
window.addEventListener('resize', throttle_1(update$1, 30));
/** Pop Banner
* Looks for items with a data-banner attribute then extracts its value as an ID and
* determines if a banner ad should be shown based on if that particular ID has
* already been set in local storage (local storage gets set on dismissal or CTA click).
*
* Example use: https://www.gallup.com/workplace/242252/employee-experience.aspx
*/
var banner = document.querySelectorAll('[data-banner]');
function setStorage(i) {
var STORAGE_KEY = 'banner- + ' + banner[i].getAttribute('data-banner');
window.localStorage.setItem(STORAGE_KEY, true);
}
function showBanner(i) {
banner[i].style.display = 'block';
// fade banner in
setTimeout(function () {
banner[i].style.opacity = 1;
// blazy check
tiles.blazyInstance.revalidate();
}, 3000);
// use gel-bootstrap banner.js to dismiss banner and set storage
banner[i].addEventListener('gel.banner.dismiss', function () {
setStorage(i);
document.querySelector('#skipToPopUpModal').style.display = 'none';
});
// dismiss banner upon CTA click
var ctaLinks = banner[i].querySelectorAll('a:not([data-dismiss])');
for (var j = 0; j < ctaLinks.length; j++) {
ctaLinks[j].addEventListener('click', setStorage(i));
}
}
var popBannerElement = document.querySelector('#pop-banner');
var focusOnNav = function focusOnNav(e) {
if (!popBannerElement.contains(e.relatedTarget)) {
// Corporate nav link element
var navLink = document.querySelector('#navbar-collapse-corporate > ul > li > a');
navLink.focus();
popBannerElement.removeEventListener('focusout', focusOnNav);
}
};
// Adding skip to modal link as a first option among skip nav links
var addSkipNavLink = function addSkipNavLink() {
var skipToContentDiv = document.querySelector('#skiptocontent');
var skipToModalLink = document.createElement('a');
skipToModalLink.setAttribute('id', 'skipToPopUpModal');
skipToModalLink.setAttribute('href', '#pop-banner');
// getting link text from the data attribute value
skipToModalLink.innerText = popBannerElement.dataset.skipText;
skipToContentDiv.appendChild(skipToModalLink);
var skipToMainLink = document.querySelector('#skipToMain');
skipToMainLink.before(skipToModalLink);
};
var onSkipNavLinkClick = function onSkipNavLinkClick() {
var skipToModalLink = document.querySelector('#skipToPopUpModal');
if (skipToModalLink) {
skipToModalLink.addEventListener('click', function () {
popBannerElement.addEventListener('focusout', focusOnNav);
});
}
};
function init() {
for (var i = 0; i < banner.length; i++) {
var STORAGE_KEY = 'banner- + ' + banner[i].getAttribute('data-banner');
if (typeof gcb === 'undefined' || gcb.status() === 'loaded') {
// eslint-disable-line no-undef
// we could show banner, only do if user hasn't already dismissed
if (!window.localStorage.getItem(STORAGE_KEY)) {
showBanner(i);
addSkipNavLink();
onSkipNavLinkClick();
break;
}
}
}
}
// check for banner element and initialize
if (banner.length > 0) {
if (document.readyState === 'complete') {
init();
} else {
window.addEventListener('load', init);
}
}
var blazyInstance$4 = new blazy();
var rearrangeItems = document.querySelectorAll('[data-rearrange-id]');
if (rearrangeItems) {
Array.prototype.forEach.call(rearrangeItems, function (el) {
var targetContainer = document.querySelector('[data-itemid="' + el.dataset.rearrangeId + '"] .rearrange-target') || document.querySelector('[data-itemid="' + el.dataset.rearrangeId + '"] .card-item');
if (targetContainer) {
targetContainer.appendChild(el);
}
document.addEventListener('shown.bs.collapse', function () {
blazyInstance$4.revalidate();
});
});
}
var ready = createCommonjsModule(function (module) {
/*!
* domready (c) Dustin Diaz 2014 - License MIT
*/
!function (name, definition) {
module.exports = definition();
}('domready', function () {
var fns = [], listener
, doc = document
, hack = doc.documentElement.doScroll
, domContentLoaded = 'DOMContentLoaded'
, loaded = (hack ? /^loaded|^c/ : /^loaded|^i|^c/).test(doc.readyState);
if (!loaded)
doc.addEventListener(domContentLoaded, listener = function () {
doc.removeEventListener(domContentLoaded, listener);
loaded = 1;
while (listener = fns.shift()) listener();
});
return function (fn) {
loaded ? setTimeout(fn, 0) : fns.push(fn);
}
});
});
/*!
* Stickyfill -- `position: sticky` polyfill
* v. 1.1.1 | https://github.com/wilddeer/stickyfill
* Copyright Oleg Korsunsky | http://wd.dizaina.net/
*
* MIT License
*/
var stickyfill = (function(doc, win) {
if (!doc) {
doc = document;
}
if (!win) {
win = window;
}
var watchArray = [],
scroll,
initialized = false,
html = doc.documentElement,
noop = function() {},
checkTimer,
//visibility API strings
hiddenPropertyName = 'hidden',
visibilityChangeEventName = 'visibilitychange';
//fallback to prefixed names in old webkit browsers
if (doc.webkitHidden !== undefined) {
hiddenPropertyName = 'webkitHidden';
visibilityChangeEventName = 'webkitvisibilitychange';
}
//test getComputedStyle
if (!win.getComputedStyle) {
seppuku();
}
//test for native support
var prefixes = ['', '-webkit-', '-moz-', '-ms-'],
block = document.createElement('div');
for (var i = prefixes.length - 1; i >= 0; i--) {
try {
block.style.position = prefixes[i] + 'sticky';
}
catch(e) {}
if (block.style.position != '') {
seppuku();
}
}
updateScrollPos();
//commit seppuku!
function seppuku() {
init = add = rebuild = pause = stop = kill = noop;
}
function mergeObjects(targetObj, sourceObject) {
for (var key in sourceObject) {
if (sourceObject.hasOwnProperty(key)) {
targetObj[key] = sourceObject[key];
}
}
}
function parseNumeric(val) {
return parseFloat(val) || 0;
}
function updateScrollPos() {
scroll = {
top: win.pageYOffset,
left: win.pageXOffset
};
}
function onScroll() {
if (win.pageXOffset != scroll.left) {
updateScrollPos();
rebuild();
return;
}
if (win.pageYOffset != scroll.top) {
updateScrollPos();
recalcAllPos();
}
}
//fixes flickering
function onWheel(event) {
setTimeout(function() {
if (win.pageYOffset != scroll.top) {
scroll.top = win.pageYOffset;
recalcAllPos();
}
}, 0);
}
function recalcAllPos() {
for (var i = watchArray.length - 1; i >= 0; i--) {
recalcElementPos(watchArray[i]);
}
}
function recalcElementPos(el) {
if (!el.inited) return;
var currentMode = (scroll.top <= el.limit.start? 0: scroll.top >= el.limit.end? 2: 1);
if (el.mode != currentMode) {
switchElementMode(el, currentMode);
}
}
//checks whether stickies start or stop positions have changed
function fastCheck() {
for (var i = watchArray.length - 1; i >= 0; i--) {
if (!watchArray[i].inited) continue;
var deltaTop = Math.abs(getDocOffsetTop(watchArray[i].clone) - watchArray[i].docOffsetTop),
deltaHeight = Math.abs(watchArray[i].parent.node.offsetHeight - watchArray[i].parent.height);
if (deltaTop >= 2 || deltaHeight >= 2) return false;
}
return true;
}
function initElement(el) {
if (isNaN(parseFloat(el.computed.top)) || el.isCell) return;
el.inited = true;
if (!el.clone) clone(el);
if (el.parent.computed.position != 'absolute' &&
el.parent.computed.position != 'relative') el.parent.node.style.position = 'relative';
recalcElementPos(el);
el.parent.height = el.parent.node.offsetHeight;
el.docOffsetTop = getDocOffsetTop(el.clone);
}
function deinitElement(el) {
var deinitParent = true;
el.clone && killClone(el);
mergeObjects(el.node.style, el.css);
//check whether element's parent is used by other stickies
for (var i = watchArray.length - 1; i >= 0; i--) {
if (watchArray[i].node !== el.node && watchArray[i].parent.node === el.parent.node) {
deinitParent = false;
break;
}
}
if (deinitParent) el.parent.node.style.position = el.parent.css.position;
el.mode = -1;
}
function initAll() {
for (var i = watchArray.length - 1; i >= 0; i--) {
initElement(watchArray[i]);
}
}
function deinitAll() {
for (var i = watchArray.length - 1; i >= 0; i--) {
deinitElement(watchArray[i]);
}
}
function switchElementMode(el, mode) {
var nodeStyle = el.node.style;
switch (mode) {
case 0:
nodeStyle.position = 'absolute';
nodeStyle.left = el.offset.left + 'px';
nodeStyle.right = el.offset.right + 'px';
nodeStyle.top = el.offset.top + 'px';
nodeStyle.bottom = 'auto';
nodeStyle.width = 'auto';
nodeStyle.marginLeft = 0;
nodeStyle.marginRight = 0;
nodeStyle.marginTop = 0;
break;
case 1:
nodeStyle.position = 'fixed';
nodeStyle.left = el.box.left + 'px';
nodeStyle.right = el.box.right + 'px';
nodeStyle.top = el.css.top;
nodeStyle.bottom = 'auto';
nodeStyle.width = 'auto';
nodeStyle.marginLeft = 0;
nodeStyle.marginRight = 0;
nodeStyle.marginTop = 0;
break;
case 2:
nodeStyle.position = 'absolute';
nodeStyle.left = el.offset.left + 'px';
nodeStyle.right = el.offset.right + 'px';
nodeStyle.top = 'auto';
nodeStyle.bottom = 0;
nodeStyle.width = 'auto';
nodeStyle.marginLeft = 0;
nodeStyle.marginRight = 0;
break;
}
el.mode = mode;
}
function clone(el) {
el.clone = document.createElement('div');
var refElement = el.node.nextSibling || el.node,
cloneStyle = el.clone.style;
cloneStyle.height = el.height + 'px';
cloneStyle.width = el.width + 'px';
cloneStyle.marginTop = el.computed.marginTop;
cloneStyle.marginBottom = el.computed.marginBottom;
cloneStyle.marginLeft = el.computed.marginLeft;
cloneStyle.marginRight = el.computed.marginRight;
cloneStyle.padding = cloneStyle.border = cloneStyle.borderSpacing = 0;
cloneStyle.fontSize = '1em';
cloneStyle.position = 'static';
cloneStyle.cssFloat = el.computed.cssFloat;
el.node.parentNode.insertBefore(el.clone, refElement);
}
function killClone(el) {
el.clone.parentNode.removeChild(el.clone);
el.clone = undefined;
}
function getElementParams(node) {
var computedStyle = getComputedStyle(node),
parentNode = node.parentNode,
parentComputedStyle = getComputedStyle(parentNode),
cachedPosition = node.style.position;
node.style.position = 'relative';
var computed = {
top: computedStyle.top,
marginTop: computedStyle.marginTop,
marginBottom: computedStyle.marginBottom,
marginLeft: computedStyle.marginLeft,
marginRight: computedStyle.marginRight,
cssFloat: computedStyle.cssFloat
},
numeric = {
top: parseNumeric(computedStyle.top),
marginBottom: parseNumeric(computedStyle.marginBottom),
paddingLeft: parseNumeric(computedStyle.paddingLeft),
paddingRight: parseNumeric(computedStyle.paddingRight),
borderLeftWidth: parseNumeric(computedStyle.borderLeftWidth),
borderRightWidth: parseNumeric(computedStyle.borderRightWidth)
};
node.style.position = cachedPosition;
var css = {
position: node.style.position,
top: node.style.top,
bottom: node.style.bottom,
left: node.style.left,
right: node.style.right,
width: node.style.width,
marginTop: node.style.marginTop,
marginLeft: node.style.marginLeft,
marginRight: node.style.marginRight
},
nodeOffset = getElementOffset(node),
parentOffset = getElementOffset(parentNode),
parent = {
node: parentNode,
css: {
position: parentNode.style.position
},
computed: {
position: parentComputedStyle.position
},
numeric: {
borderLeftWidth: parseNumeric(parentComputedStyle.borderLeftWidth),
borderRightWidth: parseNumeric(parentComputedStyle.borderRightWidth),
borderTopWidth: parseNumeric(parentComputedStyle.borderTopWidth),
borderBottomWidth: parseNumeric(parentComputedStyle.borderBottomWidth)
}
},
el = {
node: node,
box: {
left: nodeOffset.win.left,
right: html.clientWidth - nodeOffset.win.right
},
offset: {
top: nodeOffset.win.top - parentOffset.win.top - parent.numeric.borderTopWidth,
left: nodeOffset.win.left - parentOffset.win.left - parent.numeric.borderLeftWidth,
right: -nodeOffset.win.right + parentOffset.win.right - parent.numeric.borderRightWidth
},
css: css,
isCell: computedStyle.display == 'table-cell',
computed: computed,
numeric: numeric,
width: nodeOffset.win.right - nodeOffset.win.left,
height: nodeOffset.win.bottom - nodeOffset.win.top,
mode: -1,
inited: false,
parent: parent,
limit: {
start: nodeOffset.doc.top - numeric.top,
end: parentOffset.doc.top + parentNode.offsetHeight - parent.numeric.borderBottomWidth -
node.offsetHeight - numeric.top - numeric.marginBottom
}
};
return el;
}
function getDocOffsetTop(node) {
var docOffsetTop = 0;
while (node) {
docOffsetTop += node.offsetTop;
node = node.offsetParent;
}
return docOffsetTop;
}
function getElementOffset(node) {
var box = node.getBoundingClientRect();
return {
doc: {
top: box.top + win.pageYOffset,
left: box.left + win.pageXOffset
},
win: box
};
}
function startFastCheckTimer() {
checkTimer = setInterval(function() {
!fastCheck() && rebuild();
}, 500);
}
function stopFastCheckTimer() {
clearInterval(checkTimer);
}
function handlePageVisibilityChange() {
if (!initialized) return;
if (document[hiddenPropertyName]) {
stopFastCheckTimer();
}
else {
startFastCheckTimer();
}
}
function init() {
if (initialized) return;
updateScrollPos();
initAll();
win.addEventListener('scroll', onScroll);
win.addEventListener('wheel', onWheel);
//watch for width changes
win.addEventListener('resize', rebuild);
win.addEventListener('orientationchange', rebuild);
//watch for page visibility
doc.addEventListener(visibilityChangeEventName, handlePageVisibilityChange);
startFastCheckTimer();
initialized = true;
}
function rebuild() {
if (!initialized) return;
deinitAll();
for (var i = watchArray.length - 1; i >= 0; i--) {
watchArray[i] = getElementParams(watchArray[i].node);
}
initAll();
}
function pause() {
win.removeEventListener('scroll', onScroll);
win.removeEventListener('wheel', onWheel);
win.removeEventListener('resize', rebuild);
win.removeEventListener('orientationchange', rebuild);
doc.removeEventListener(visibilityChangeEventName, handlePageVisibilityChange);
stopFastCheckTimer();
initialized = false;
}
function stop() {
pause();
deinitAll();
}
function kill() {
stop();
//empty the array without loosing the references,
//the most performant method according to http://jsperf.com/empty-javascript-array
while (watchArray.length) {
watchArray.pop();
}
}
function add(node) {
//check if Stickyfill is already applied to the node
for (var i = watchArray.length - 1; i >= 0; i--) {
if (watchArray[i].node === node) return;
}
var el = getElementParams(node);
watchArray.push(el);
if (!initialized) {
init();
}
else {
initElement(el);
}
}
function remove(node) {
for (var i = watchArray.length - 1; i >= 0; i--) {
if (watchArray[i].node === node) {
deinitElement(watchArray[i]);
watchArray.splice(i, 1);
}
} }
//expose Stickyfill
return {
stickies: watchArray,
add: add,
remove: remove,
init: init,
rebuild: rebuild,
pause: pause,
stop: stop,
kill: kill
};
});
var stickyfill$1 = stickyfill();
var activeEl = void 0;
function makeSticky() {
// Make chapter headers sticky
queryAll(document, '.chapter-header').forEach(function (sticky) {
stickyfill$1.add(sticky);
});
}
function init$1() {
// Enable stickyfill if needed
makeSticky();
// Scroll to chapter header when clicked
queryAll(document, '.chapter-accordion').forEach(function (el) {
el.addEventListener('click', function (e) {
var chapterSection = findAncestor(el, '.rel-chapter');
queryAll(chapterSection, '.chapter-img--active').forEach(function (chapterImage) {
chapterImage.classList.remove('chapter-img--active');
});
var image = findAncestor(e.target, '.rel--chapter').querySelector('.chapter-img');
if (image && el.classList.contains('collapsed')) {
image.classList.add('chapter-img--active');
}
activeEl = activeEl === el.parentElement ? null : el.parentElement;
// If we are closing a chapter that is not sticky, don't scroll
if (!activeEl && el.parentElement.getBoundingClientRect().top > 0) {
return;
}
var accordion = findAncestor(e.target, '.chapter-header');
setTimeout(function () {
scrollToElement(accordion);
}, 10);
});
});
}
ready(init$1);
var tooltipItems = document.querySelectorAll('.c-tooltip');
// Handling screen reader class
var srOnly = function srOnly(tooltiptext) {
var srOnlyCheck = tooltiptext.classList.contains('sr-only');
if (srOnlyCheck) {
tooltiptext.classList.remove('sr-only');
}
};
var moveCaretPosition = function moveCaretPosition(remainingWidthLeft, tooltipTextRemainingWidthLeft) {
var style = document.createElement('style');
style.appendChild(document.createTextNode(''));
document.head.appendChild(style);
var arrowStyle = '.c-tooltip__text--bottom-caret:before, .c-tooltip__text--bottom-caret:after { left: ' + (remainingWidthLeft - tooltipTextRemainingWidthLeft) + 'px }';
style.sheet.insertRule(arrowStyle, 0);
};
// Calculating Remaining Width
var remainingWidth = function remainingWidth(tooltiptext, tooltip) {
var tooltipRect = tooltip.getBoundingClientRect();
var bodyElem = document.querySelector('body');
var bodyElemRect = bodyElem.getBoundingClientRect();
var remainingWidthRight = bodyElemRect.right - tooltipRect.left;
var remainingWidthLeft = tooltipRect.left - bodyElemRect.left;
if (remainingWidthRight >= 340) {
tooltiptext.className = 'c-tooltip__text c-tooltip__text--right';
} else if (remainingWidthRight < 340 && remainingWidthLeft > 340) {
tooltiptext.className = 'c-tooltip__text c-tooltip__text--left';
tooltiptext.style.right = tooltipRect.width + 'px';
} else if (remainingWidthLeft < 340 && remainingWidthRight < 340) {
tooltiptext.className = 'c-tooltip__text c-tooltip__text--bottom c-tooltip__text--bottom-caret';
tooltiptext.style.display = 'table';
var tooltipTextRect = tooltip.querySelector('.c-tooltip__text--bottom').getBoundingClientRect();
var tooltipTextRemainingWidthLeft = tooltipTextRect.left;
moveCaretPosition(remainingWidthLeft, tooltipTextRemainingWidthLeft);
}
};
if (tooltipItems) {
var clickOnTooltip = function clickOnTooltip(el) {
var tooltiptext = el.querySelector('.c-tooltip__text');
srOnly(tooltiptext);
tooltiptext.style.display = 'inline-block';
remainingWidth(tooltiptext, el);
};
var clickOutsideTooltip = function clickOutsideTooltip(el) {
var tooltiptext = el.querySelector('.c-tooltip__text');
tooltiptext.style.display = 'none';
tooltiptext.style.right = 'unset';
tooltiptext.className = 'sr-only c-tooltip__text';
};
Array.prototype.forEach.call(tooltipItems, function (el) {
var tooltiptext = el.querySelector('.c-tooltip__text');
tooltiptext.classList.add('sr-only');
el.setAttribute('tabindex', '0');
el.addEventListener('keydown', function (e) {
if (e.key === 'Enter') {
if (el.classList) {
if (tooltiptext.classList.contains('sr-only')) clickOnTooltip(el);else clickOutsideTooltip(el);
}
}
});
el.addEventListener('focusout', function () {
setTimeout(function () {
var newFocus = document.activeElement.parentElement;
if (newFocus.classList.contains('c-tooltip__text')) return;
clickOutsideTooltip(el);
}, 0);
});
el.addEventListener('mouseover', function () {
clickOnTooltip(el);
});
el.addEventListener('mouseout', function () {
clickOutsideTooltip(el);
});
document.body.addEventListener('touchmove', function () {
tooltiptext.style.right = 'unset';
tooltiptext.className = 'sr-only c-tooltip__text';
}, false);
el.addEventListener('touchstart', function () {
clickOnTooltip(el);
});
});
}
function setNavPosition(rotatorNav, rotatorItems) {
var rotatorHeight = rotatorNav.getBoundingClientRect().height;
rotatorNav.style.marginTop = '-' + rotatorHeight + 'px';
for (var i = 0; i < rotatorItems.length; i++) {
var card = rotatorItems[i].querySelector('[class*="c-item--card"]');
card.style.marginBottom = rotatorHeight + 'px';
}
}
function setupRotatorNavigation(rotator, rotatorItems) {
var rotatorNav = document.createElement('div');
rotatorNav.classList.add('c-rotator__nav');
var navPagination = document.createElement('div');
navPagination.classList.add('c-rotator__pagination');
navPagination.setAttribute('role', 'tablist');
var _loop = function _loop(i) {
var navButton = document.createElement('button');
navButton.classList.add('c-rotator__pagination-title');
navButton.dataset.rotatorItem = i;
// setting attributes for screen reader accessibility
navButton.setAttribute('role', 'tab');
navButton.setAttribute('id', 'tab-' + (i + 1));
navButton.setAttribute('aria-selected', false);
navButton.setAttribute('aria-controls', rotatorItems[i].id);
navButton.setAttribute('tabindex', '0');
rotatorItems[i].setAttribute('role', 'tabpanel');
rotatorItems[i].setAttribute('tabindex', '0');
rotatorItems[i].setAttribute('aria-labelledby', 'tab-' + (i + 1));
var shortTitle = rotatorItems[i].querySelector('[data-rotator-title]') || document.createTextNode('Rotator Item ' + (i + 1));
navButton.appendChild(shortTitle);
navButton.addEventListener('click', function () {
// Pause the animation
rotator.classList.add('paused');
// End animation on the current item, remove active class
rotator.querySelector('.c-rotator__item.active').classList.remove('active');
rotator.querySelector('.c-rotator__item.next').classList.remove('next');
navPagination.querySelector('.active').setAttribute('aria-selected', false);
navPagination.querySelector('.active').classList.remove('active');
// Scroll to the selected item if needed
var style = window.getComputedStyle(navPagination);
var leftPadding = style ? parseFloat(style.paddingLeft) : 0;
var buttonBounding = navButton.getBoundingClientRect();
rotatorNav.scroll({
top: 0,
left: rotatorNav.scrollLeft + (buttonBounding.left - leftPadding),
behavior: 'smooth'
});
// Start animation on the selected item
rotatorItems[i].classList.add('active');
rotatorItems[(i + 1) % rotatorItems.length].classList.add('next');
// Updated the pagination active class
navButton.classList.add('active');
navButton.setAttribute('aria-selected', true);
});
navPagination.appendChild(navButton);
};
for (var i = 0; i < rotatorItems.length; i++) {
_loop(i);
}
rotatorNav.appendChild(navPagination);
rotator.appendChild(rotatorNav);
setNavPosition(rotatorNav, rotatorItems);
return rotatorNav;
}
function init$2() {
var rotators = document.querySelectorAll('.c-rotator');
Array.prototype.forEach.call(rotators, function (rotator) {
var rotatorItems = rotator.querySelectorAll('.c-rotator__item');
var rotatorNav = setupRotatorNavigation(rotator, rotatorItems);
var animationEnd = function animationEnd(e, itemIndex, currentItem, nextItem) {
if (e.target.classList.contains('c-rotator__item') && e.target.classList.contains('active')) {
var paginationContainer = rotatorNav.querySelector('.c-rotator__pagination');
var currentPagination = rotatorNav.querySelector('.c-rotator__pagination-title.active');
var newPagination = rotatorNav.querySelector('.c-rotator__pagination-title[data-rotator-item=\'' + (itemIndex + 1) % rotatorItems.length + '\']');
// Animation has ended on the current item, remove active class
currentItem.classList.remove('active');
nextItem.classList.remove('next');
// Scroll to the next item if needed
var style = window.getComputedStyle(paginationContainer);
var leftPadding = style ? parseFloat(style.paddingLeft) : 0;
var buttonBounding = newPagination.getBoundingClientRect();
rotatorNav.scroll({
top: 0,
left: rotatorNav.scrollLeft + (buttonBounding.left - leftPadding),
behavior: 'smooth'
});
// Start animation on the next item
nextItem.classList.add('active');
rotatorItems[(itemIndex + 2) % rotatorItems.length].classList.add('next');
currentPagination.classList.remove('active');
currentPagination.setAttribute('aria-selected', false);
newPagination.classList.add('active');
newPagination.setAttribute('aria-selected', true);
}
};
// Setup Rotator Items
var activeItems = false;
var _loop2 = function _loop2(i) {
rotatorItems[i].addEventListener('animationend', function (e) {
animationEnd(e, i, rotatorItems[i], rotatorItems[(i + 1) % rotatorItems.length]);
}, false);
if (rotatorItems[i].classList.contains('active')) {
activeItems = true;
var _paginationTitle = rotator.querySelector('.c-rotator__pagination-title[data-rotator-item=\'' + i + '\']');
_paginationTitle.classList.add('active');
rotatorItems[i + 1].classList.add('next');
}
};
for (var i = 0; i < rotatorItems.length; i++) {
_loop2(i);
}
var rotatorInner = rotator.querySelector('.c-rotator__inner');
var bFocusPaused = false;
rotatorInner.addEventListener('focusin', function () {
if (!rotator.classList.contains('paused')) {
rotator.classList.add('paused');
bFocusPaused = true;
}
});
rotatorInner.addEventListener('focusout', function () {
if (rotator.classList.contains('paused') && bFocusPaused) {
rotator.classList.remove('paused');
bFocusPaused = false;
}
});
document.addEventListener('resize', throttle_1(function () {
setNavPosition(rotatorNav, rotatorItems);
}, 30));
// if the rotator did not have a default active item, start with the first item
if (!activeItems) {
var paginationTitle = rotator.querySelector('.c-rotator__pagination-title');
window.setTimeout(function () {
paginationTitle.classList.add('active');
paginationTitle.setAttribute('aria-selected', true);
rotatorItems[0].classList.add('active');
rotatorItems[1].classList.add('next');
}, 1000);
}
});
}
ready(init$2);
/** vh Fix for css variable
* certain mobile devices do not mesh well with 100vh elements
* in order to get around this, we can use a css variable
* that is set to the innerHeight of the window
*
* Example use: https://www.gallup.com/home.aspx
*/
function setInnerHeightVar() {
document.documentElement.style.setProperty('--vh', window.innerHeight + 'px');
}
window.addEventListener('resize', setInnerHeightVar);
window.addEventListener('orientationchange', setInnerHeightVar);
setInnerHeightVar();
/* eslint-disable */
/** Collapse
* Fusion specic behavior for the gel collapse functionality
* Example use: https://www.gallup.com/learning/310019/accelerated-strengths-coaching.aspx
*/
document.addEventListener('shown.bs.collapse', function (e) {
var expandTextParent = e.target.nextElementSibling;
if (expandTextParent && expandTextParent.classList.contains('c-expansionText')) {
var expandTextShow = expandTextParent.children[0].children[1];
var expandTextHide = expandTextParent.children[0].children[0];
expandTextShow.style.display = 'initial';
expandTextHide.style.display = 'none';
}
});
document.addEventListener('hide.bs.collapse', function (e) {
var expandTextParent = e.target.nextElementSibling;
if (expandTextParent && expandTextParent.classList.contains('c-expansionText')) {
var expandTextShow = expandTextParent.children[0].children[0];
var expandTextHide = expandTextParent.children[0].children[1];
expandTextShow.style.display = 'initial';
expandTextHide.style.display = 'none';
}
});
// Leading with Strengths collapse feature
var showMoreDivs = document.querySelectorAll('.c-show-more');
showMoreDivs.forEach(function (showMoreDiv) {
document.addEventListener('shown.bs.collapse', function (e) {
var button = e.target.nextElementSibling.querySelector('a[data-toggle="collapse"]');
var collapseBtnText = button.getAttribute('data-btn-collapse');
button.innerHTML = collapseBtnText;
});
document.addEventListener('hide.bs.collapse', function (e) {
var button = e.target.nextElementSibling.querySelector('a[data-toggle="collapse"]');
var expandBtnText = button.getAttribute('data-btn-expand');
button.innerHTML = expandBtnText;
});
});
var preventFocus = function preventFocus(linkElements) {
Array.prototype.forEach.call(linkElements, function (link) {
link.addEventListener('mousedown', function () {
link.classList.add('c-focus-hide');
});
link.addEventListener('focusout', function () {
link.classList.remove('c-focus-hide');
});
});
};
var navbarLinks = document.querySelectorAll('.navbar a, .navbar button');
preventFocus(navbarLinks);
var imageLogos = document.querySelectorAll('.c-image__logo a');
preventFocus(imageLogos);
var footerNavLinks = document.querySelectorAll('.c-sitemap a, .c-legal-banner a');
preventFocus(footerNavLinks);
/** Modal
* Used for the video, podcast, and map webpart modals
*
* Example use: https://www.gallup.com/certifiedcoach/
*/
document.addEventListener('show.bs.modal', function () {
tiles.blazyInstance.revalidate();
});
var aboutTheSpeakerButtons = document.querySelectorAll('[id^="speakerButton"]');
var showSpeakerDescription = function showSpeakerDescription(i) {
var button = document.getElementById('speakerButton-' + i);
button.onclick = function () {
var backdropColor = document.querySelector('.modal-backdrop.fade');
backdropColor.style.opacity = 0.6;
};
};
for (var i = 1; i <= aboutTheSpeakerButtons.length; i++) {
showSpeakerDescription(i);
}
ready(function () {
var firstScrollEl = document.querySelector('[data-initial-scroll]');
if (firstScrollEl) {
var scrollTop = firstScrollEl.getBoundingClientRect().top - 200;
document.documentElement.scrollTop = scrollTop;
document.body.parentNode.scrollTop = scrollTop;
document.body.scrollTop = scrollTop;
}
});
var tables = document.querySelectorAll('.figure-table table');
if (tables) {
for (var i$1 = 0; i$1 < tables.length; i$1++) {
if (tables[i$1].querySelector('[colspan="100"]') && !tables[i$1].classList.contains('no-fixed')) {
tables[i$1].classList.add('no-fixed');
}
}
}
var createExitModalBackdrop = function createExitModalBackdrop() {
var exitModalBackdrop = document.createElement('div');
exitModalBackdrop.classList.add('c-exit-modal__backdrop');
document.body.appendChild(exitModalBackdrop);
};
var exitModal = document.querySelector('[data-exit-modal]');
var dismissModal = function dismissModal() {
var backdrop = document.querySelector('.c-exit-modal__backdrop');
var localStorageKey = 'exitModal-' + exitModal.getAttribute('data-exit-modal');
window.localStorage.setItem(localStorageKey, true);
exitModal.style.display = 'none';
backdrop.style.display = 'none';
};
var showExitModal = function showExitModal() {
var backdrop = document.querySelector('.c-exit-modal__backdrop');
exitModal.style.display = 'block';
backdrop.style.display = 'block';
// fade modal in and focus directly on email input field
setTimeout(function () {
exitModal.style.opacity = 1;
document.querySelector('.c-exit-modal__input').focus();
}, 100);
// dismiss modal upon 'close' button click
exitModal.addEventListener('gel.banner.dismiss', function () {
dismissModal();
});
// dismiss modal upon CTA button click
Array.prototype.forEach.call(exitModal.querySelectorAll('a'), function (link) {
link.addEventListener('click', dismissModal);
});
};
var mouseEvent = function mouseEvent(e) {
var shouldShowExitPopUp = e.clientY < 0;
var localStorageKey = 'exitModal-' + exitModal.getAttribute('data-exit-modal');
var isModalDismissed = window.localStorage.getItem(localStorageKey);
if (shouldShowExitPopUp && !isModalDismissed) {
document.removeEventListener('mouseout', mouseEvent);
showExitModal();
}
};
// store email value in session storage
var storeEmailValue = function storeEmailValue() {
var emailValue = btoa(document.querySelector('.c-exit-modal__input').value);
sessionStorage.setItem('em-email', emailValue);
};
// get email value from session storage and populate in form
var populateEmailValueInForm = function populateEmailValueInForm() {
var formEmail = document.querySelector('input[name="emailAddress"]');
var sessionValue = sessionStorage.getItem('em-email');
if (!exitModal && formEmail && sessionValue) {
formEmail.value = atob(sessionValue || '');
}
sessionStorage.removeItem('em-email');
};
var init$3 = function init() {
createExitModalBackdrop();
setTimeout(function () {
document.addEventListener('mouseout', mouseEvent);
}, 6000);
var email = document.querySelector('.c-exit-modal__input');
email.addEventListener('input', storeEmailValue);
};
if (exitModal) {
if (document.readyState === 'complete') {
init$3();
} else {
window.addEventListener('load', init$3);
}
}
populateEmailValueInForm();
var v11ShowOnceCards = document.querySelectorAll('[data-v11-card]');
// For "show-before" and all other cms items
if (v11ShowOnceCards.length > 0) {
for (var i$2 = 0; i$2 < v11ShowOnceCards.length; i$2++) {
var dataCardVisibilityAttribute = v11ShowOnceCards[i$2].getAttribute('data-card-visibility');
var localStorageKey = v11ShowOnceCards[i$2].getAttribute('data-v11-card');
if (dataCardVisibilityAttribute === 'show-after') {
// eslint-disable-next-line no-continue
continue;
}
if (!window.localStorage.getItem(localStorageKey)) {
v11ShowOnceCards[i$2].style.display = 'block';
window.localStorage.setItem(localStorageKey, true);
}
}
}
var handleShowAfterCards = function handleShowAfterCards() {
var dynamicReportAfterClass = document.querySelector('.g-after');
if (dynamicReportAfterClass) {
v11ShowOnceCards.forEach(function (card) {
var dataCardVisibilityAttribute = card.getAttribute('data-card-visibility');
var localStorageKey = card.getAttribute('data-v11-card');
if (dataCardVisibilityAttribute === 'show-after' && !window.localStorage.getItem(localStorageKey)) {
card.style.display = 'block';
window.localStorage.setItem(localStorageKey, true);
}
});
}
};
// Only for "show-after" cms items
// Using MutationObserver interface to watch for changes being made to the DOM
var observer = new MutationObserver(function (mutations, obs) {
var dynamicReportAfterClass = document.querySelector('.g-after');
if (dynamicReportAfterClass) {
handleShowAfterCards();
obs.disconnect();
}
});
observer.observe(document, {
childList: true,
subtree: true
});
/* V11 Partial Scroll Featured Articles Webpart */
// Initialize variables
var collapseButton = document.querySelector('.feat-v11__btn-collapse');
var collapseContent = document.querySelector('.feat-v11--collapsible');
var fadeElement = document.querySelector('.feat-v11--fade');
var MOBILE_BREAKPOINT$1 = 650;
// Add view more button and fade effect
var addViewMoreButton = function addViewMoreButton() {
var viewMoreBtnText = collapseButton.dataset.viewMore;
collapseContent.style.maxHeight = null;
collapseButton.classList.remove('active');
collapseButton.innerHTML = viewMoreBtnText;
fadeElement.style.display = 'block';
};
// Add view less button and remove fade effect
var addViewLessButton = function addViewLessButton() {
var viewLessBtnText = collapseButton.dataset.viewLess;
collapseContent.style.maxHeight = collapseContent.scrollHeight + 'px';
collapseButton.classList.add('active');
collapseButton.innerHTML = viewLessBtnText;
fadeElement.style.display = 'none';
};
// Toggle view more, view less buttons
var collapseButtonClick = function collapseButtonClick() {
collapseButton.addEventListener('click', function () {
if (collapseContent.style.maxHeight) {
addViewMoreButton();
document.querySelector('.feat-v11--title').scrollIntoView({ behavior: 'smooth' });
} else {
addViewLessButton();
}
});
};
if (collapseButton) {
collapseButtonClick();
}
// Check if child item is inside parent div or not
function handlePartialScroll(listItem, trendingContainer) {
var trendContainerRect = trendingContainer.getBoundingClientRect();
var listItemRect = listItem.getBoundingClientRect();
if (window.innerWidth < MOBILE_BREAKPOINT$1) {
listItem.style.visibility = 'visible';
collapseButton.style.display = 'block';
return;
}
// Expand/collapse button only for mobile
// Reset to initial values on screen resize
collapseButton.style.display = 'none';
addViewMoreButton();
// Get the relative position on the list item on the viewport
var relativePos = {};
relativePos.top = listItemRect.top - trendContainerRect.top;
relativePos.right = listItemRect.right - trendContainerRect.right;
relativePos.bottom = listItemRect.bottom - trendContainerRect.bottom;
relativePos.left = listItemRect.left - trendContainerRect.left;
// If the top, left are -ve and bottom, right coordinates are +ve,
// it means that the child is outside of the parent div
var isInsideContainer = relativePos.top > 0 && relativePos.right < 0 && relativePos.bottom < 0 && relativePos.left > 0;
if (!isInsideContainer) {
listItem.style.visibility = 'hidden';
} else {
listItem.style.visibility = 'visible';
}
}
var trendingListItems = document.querySelectorAll('.trend-v11--item');
var trendingContainer = document.querySelector('.trend-v11--container');
var init$4 = function init() {
trendingListItems.forEach(function (listItem) {
return handlePartialScroll(listItem, trendingContainer);
});
};
init$4();
window.addEventListener('resize', throttle_1(init$4, 100));
/* eslint-disable max-len */
var CLASS_COMPONENT = 'c-horizontal-scroll';
var ATTRIBUTE_STATUS$2 = 'data-horizontal-scroll';
var STATUS_INITIALIZED$2 = 'initialized';
var eventHandlers$2 = {
scroll: function scroll() {
if (window.innerWidth > 960) {
// Check for sticky nav and trigger resize if current sitcky does not match state
var stickyNav = document.querySelector('.navbar-stuck');
var stickyNavHeight = stickyNav ? stickyNav.clientHeight : 0;
if (this.stickyNavHeight !== stickyNavHeight) {
this.stickyNavHeight = stickyNavHeight;
this.resizeEvent();
}
var containerBox = this.container.getBoundingClientRect();
var itemsScroll = this.items.scrollWidth - this.items.clientWidth;
// if our scroll position is above container, items should be at start
if (containerBox.top >= 0) {
this.setTransform(0);
// if our scroll position is inside our container, calculate item scroll position
} else if (containerBox.top < -itemsScroll) {
this.setTransform(-itemsScroll);
// if our scroll position is below container, items should be at end
} else {
this.setTransform(containerBox.top);
}
}
},
resize: function resize() {
var _this = this;
if (window.innerWidth < 960) {
// reset all possible values if coming from a horizontal scroll state
this.header.style.marginTop = '0';
this.header.style.paddingTop = '0';
this.items.style.marginBottom = '0';
this.items.style.paddingBottom = '0';
this.items.style.top = '0';
this.container.style.height = 'auto';
this.header.style.marginBottom = '0';
this.items.style.marginTop = '0';
} else {
// get last viewport padding and multiply by 2 to account for top and bottom
var lastViewportPadding = this.itemsCurrStyle.paddingBottom.slice(0, -2) * 2;
// Calculate new viewport padding needed
var viewportPadding = (window.innerHeight - this.stickyNavHeight - (this.header.clientHeight + this.items.clientHeight - lastViewportPadding)) / 2;
if (viewportPadding < 0) {
viewportPadding = 0;
}
// apply viewport padding
// negative margin so that static padding is used when scroll is not inside container
this.header.style.marginTop = '-' + (viewportPadding + this.stickyNavHeight) + 'px';
this.header.style.paddingTop = viewportPadding + this.stickyNavHeight + 'px';
this.items.style.marginBottom = '-' + viewportPadding + 'px';
this.items.style.paddingBottom = viewportPadding + 'px';
// make sure that items account for the header height, otherwise sticky elements would overlap
this.items.style.top = this.header.clientHeight + 'px';
// calculate contianer height
// horizontal scroll ends when we reach the bottom of the container
this.container.style.height = this.items.scrollWidth - this.items.clientWidth - viewportPadding - this.stickyNavHeight + this.header.clientHeight + this.items.clientHeight + 80 + 'px';
// This makes the header stop in the correct place at the bottom of the container
this.header.style.marginBottom = this.items.clientHeight - viewportPadding + 'px';
this.items.style.marginTop = '-' + (this.items.clientHeight - viewportPadding) + 'px';
// resizing images depending on viewport height
var viewportHeight = window.innerHeight - this.stickyNavHeight;
var horizontalScrollImages = document.querySelectorAll('.c-horiz-image');
Array.prototype.forEach.call(horizontalScrollImages, function (image) {
if (viewportHeight <= _this.totalHeight - 50) {
image.parentElement.style.height = '100px';
image.parentElement.style.overflow = 'hidden';
} else if (_this.totalHeight >= viewportHeight) {
image.parentElement.style.height = '250px';
image.parentElement.style.overflow = 'hidden';
} else {
image.parentElement.removeAttribute('style');
}
});
}
}
};
var HorizontalScroll = function () {
function HorizontalScroll(el) {
var _this2 = this;
classCallCheck(this, HorizontalScroll);
this.container = el;
this.header = el.querySelector('.rel--cardgrp_head');
this.items = el.querySelector('.card-inner--default');
this.itemsCurrStyle = window.getComputedStyle(this.items);
this.stickyNavHeight = 0;
// Calculating height for image resizing
var headerProps = window.getComputedStyle(this.header);
var headerPadding = parseFloat(headerProps.paddingTop) + parseFloat(headerProps.paddingBottom);
var headerDivHeight = this.header.offsetHeight - headerPadding;
var itemsPadding = parseFloat(this.itemsCurrStyle.paddingTop) + parseFloat(this.itemsCurrStyle.paddingBottom);
var itemsHeight = this.items.offsetHeight - itemsPadding;
this.totalHeight = headerDivHeight + itemsHeight;
// initial calculation of values
this.resizeEvent = eventHandlers$2.resize.bind(this);
this.resizeEvent();
// setup event listeners for page resize and scroll events
window.addEventListener('resize', throttle_1(this.resizeEvent, 100), false);
var mouseClick = false;
el.addEventListener('mousedown', function () {
mouseClick = true;
});
el.addEventListener('mouseup', function () {
mouseClick = false;
});
// event listener for keyboard navigation
this.items.addEventListener('focusin', function () {
var itemsScroll = _this2.items.scrollWidth - _this2.items.clientWidth;
var stickyNav = document.querySelector('.navbar-stuck');
var stickyNavHeight = stickyNav ? stickyNav.clientHeight : 0;
// executing only for keypress
if (!mouseClick) {
if (_this2.container.contains(document.activeElement) && document.activeElement.offsetLeft < itemsScroll) {
var scrollPosition = stickyNavHeight + _this2.container.offsetTop + document.activeElement.offsetLeft;
window.scroll(0, scrollPosition);
}
}
mouseClick = false;
});
document.addEventListener('scroll', eventHandlers$2.scroll.bind(this), false);
}
// set X translation for both header and items to the same value so they travel together
createClass(HorizontalScroll, [{
key: 'setTransform',
value: function setTransform(val) {
this.items.style.transform = 'translateX(' + val + 'px)';
this.header.style.transform = 'translateX(' + val + 'px)';
}
}]);
return HorizontalScroll;
}();
ready(function () {
// Auto-initialize using class name
queryAll(document, '.' + CLASS_COMPONENT).forEach(function (el) {
// Prevent repeat initialization
if (el.getAttribute(ATTRIBUTE_STATUS$2) !== STATUS_INITIALIZED$2) {
el.horizontalScroll = new HorizontalScroll(el); // eslint-disable-line no-new
}
});
});
/* eslint-disable no-restricted-syntax */
var blazyInstance$5 = new blazy();
var articles = [{
url: window.location.href,
title: document.title.trim(),
el: document.querySelector('main article'),
viewed: true,
loaded: true
}];
var loading = false;
// Using MutationObserver interface to watch for "articles" getting added to the DOM
// Removing hidden subscribe panels because of having same IDs and causing ADA issues
var articleWrapper = document.querySelector('.article--wrapper');
var removeHiddenSubscribePanels = function removeHiddenSubscribePanels(mutations) {
mutations.forEach(function (mutation) {
if (mutation.type === 'childList' && mutation.target === articleWrapper) {
mutation.addedNodes.forEach(function (node) {
embeddable();
speedbump();
if (node.querySelector('.c-quick-subscribe--skinny')) {
node.querySelector('.c-quick-subscribe--skinny').remove();
}
});
}
});
};
var observer$1 = new MutationObserver(removeHiddenSubscribePanels);
var ObserverConfig = {
childList: true,
subtree: true
};
// Calling Collapse function for the newly added article in Infinite Scroll
function addCollapseToNextArticle() {
var Collapses = document.querySelectorAll('main article:last-of-type [data-toggle="collapse"]');
Collapses.forEach(function (item) {
// eslint-disable-next-line no-new
new window.Collapse(item, {});
});
}
function nextArticle() {
var unloaded = articles.filter(function (a) {
return !a.loaded;
});
if (unloaded.length) {
return unloaded[0];
}
return null;
}
function onScrollHandler() {
var progressHeader = document.querySelector('.c-progress-header');
var scrollPosition = document.body.scrollTop || document.documentElement.scrollTop;
var currentArticle = articles[0];
articles.forEach(function (a) {
if (a.el) {
var _a$el$getBoundingClie = a.el.getBoundingClientRect(),
top = _a$el$getBoundingClie.top;
if (top < 200) {
currentArticle = a;
}
}
});
if (window.location.href !== currentArticle.url && Object.prototype.hasOwnProperty.call(window, 'history')) {
window.history.replaceState(null, currentArticle.title, currentArticle.url);
if (!currentArticle.viewed) {
currentArticle.viewed = true;
}
var currentTopic = currentArticle.el.querySelector('.topic') ? currentArticle.el.querySelector('.topic').innerHTML : '';
var currentTitle = currentArticle.el.querySelector('h1').innerHTML;
progressHeader.querySelector('.c-progress-header__inner > div').innerHTML = '' + currentTopic + '
' + currentTitle + ' ';
progressHeader.querySelector('.section-flex--share').innerHTML = currentArticle.el.querySelector('.section-flex--share').innerHTML;
}
var content = document.querySelector('main article:last-of-type .article-content');
var contentPosition = content.getBoundingClientRect().top + scrollPosition - 100;
var next = nextArticle();
var progressStatus = (scrollPosition - contentPosition) / content.clientHeight * 100;
// always start progress width at 0%
if (scrollPosition < contentPosition) {
progressStatus = 0;
}
// cap progress width at 100%
if (progressStatus >= 100) {
progressStatus = 100;
}
// update progress bar width
if (progressStatus > 50 && !loading && next) {
observer$1.observe(articleWrapper, ObserverConfig);
loading = true;
var url = next.url;
if (!url || next.loaded) {
return;
}
// Add the raw content flag to the url
if (url.indexOf('?') >= 0) {
url += '&rawContent=1';
} else {
url += '?rawContent=1';
}
fetch(url).then(function (r) {
return r.text();
}).then(function (html) {
var placeholder = document.createElement('div');
placeholder.innerHTML = html;
Array.prototype.forEach.call(placeholder.querySelectorAll('script, .c-quick-subscribe.ite-webpart'), function (el) {
el.parentNode.removeChild(el);
});
Array.prototype.forEach.call(placeholder.querySelectorAll('.figure-table table'), function (el) {
if (el.querySelector('[colspan="100"]') && !el.classList.contains('no-fixed')) {
el.classList.add('no-fixed');
}
});
var newArticleWrapper = placeholder.querySelector('main .article--wrapper article');
if (newArticleWrapper) {
next.title = placeholder.querySelector('title').textContent;
document.querySelector('main article:last-of-type').insertAdjacentHTML('afterend', newArticleWrapper.outerHTML);
next.el = document.querySelector('main article:last-of-type');
addCollapseToNextArticle();
}
next.loaded = true;
blazyInstance$5.revalidate();
loading = false;
});
}
}
// Initialize infinte scroll based on featured tiles
var relatedArticles = document.querySelectorAll('.section-flex--tiles .tile-feature .tile-linktext a');
if (relatedArticles.length > 0) {
relatedArticles.forEach(function (el) {
articles.push({
url: el.href,
loaded: false
});
});
document.addEventListener('scroll', throttle_1(onScrollHandler, 100));
}
var blazyRevalidate = function blazyRevalidate() {
tiles.blazyInstance.revalidate();
};
var navDropdowns = document.querySelectorAll('.c-global-nav__dropdown-flex');
if (navDropdowns) {
Array.prototype.forEach.call(navDropdowns, function (el) {
el.addEventListener('mouseover', blazyRevalidate);
el.addEventListener('click', blazyRevalidate);
});
}
function showGroupFades(fadeGroup) {
var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
fadeGroup[index].classList.add('in');
if (index + 1 < fadeGroup.length) {
setTimeout(function () {
showGroupFades(fadeGroup, index + 1);
}, 100);
}
}
var observer$2 = new IntersectionObserver(function (entries, obs) {
entries.forEach(function (entry) {
if (entry.isIntersecting) {
if (entry.target.classList.contains('c-anim-group')) {
var fadeElementsInGroup = entry.target.querySelectorAll('[class*=c-fade-anim]');
showGroupFades(fadeElementsInGroup);
obs.unobserve(entry.target);
} else {
entry.target.classList.add('in');
obs.unobserve(entry.target);
}
}
});
}, { threshold: 0.7 });
var fades = document.querySelectorAll('[class*=c-fade-anim]');
fades.forEach(function (fadeEl) {
observer$2.observe(fadeEl);
});
var fadeGroups = document.querySelectorAll('.c-anim-group');
fadeGroups.forEach(function (fadeGroup) {
observer$2.observe(fadeGroup);
var fadeElementsInGroup = fadeGroup.querySelectorAll('[class*=c-fade-anim]');
fadeElementsInGroup.forEach(function (fadeEl) {
observer$2.unobserve(fadeEl);
});
});
/** Position sticky
* Polyfills `position: sticky` using Stickyfill.
*/
var stickyfill$2 = stickyfill();
queryAll(document, '.position-sticky').forEach(function (el) {
return stickyfill$2.add(el);
});
/* eslint-disable no-plusplus */
var blazyInstance$6 = new blazy();
var SLIDER_COMPONENT = 'slider__items';
var activeSlider = void 0;
var eventHandlers$3 = {
touchStart: function touchStart(e) {
this.isDragging = true;
this.startX = e.touches[0].clientX - this.sliderOffset.left;
this.translateX = 0;
activeSlider = this.slider;
document.addEventListener('touchmove', throttle_1(eventHandlers$3.touchMove.bind(this), 30), { passive: false });
document.addEventListener('touchend', eventHandlers$3.touchEnd.bind(this), false);
},
touchMove: function touchMove(e) {
if (!this.isDragging) return;
blazyInstance$6.revalidate();
var currentX = e.touches[0].clientX - this.sliderOffset.left;
this.translateX = currentX - this.startX;
activeSlider.style.transform = 'translateX(' + (this.currentPosition + this.translateX) + 'px)';
activeSlider.style.transition = 'none';
this.handleNextButtonState();
},
touchEnd: function touchEnd(e) {
var _this = this;
if (!this.isDragging) return;
this.isDragging = false;
this.endX = e.changedTouches[0].clientX - this.sliderOffset.left;
var deltaX = this.endX - this.startX;
activeSlider.style.transition = 'transform 0.3s ease';
setTimeout(function () {
// Snap to the nearest slide
_this.currentPosition += _this.translateX;
var targetX = Math.round(_this.currentPosition / _this.tileWidth) * _this.tileWidth;
var maxIndex = Math.min(Math.abs(targetX), _this.lastEndingSlidesIndex * _this.tileWidth);
activeSlider.style.transform = 'translateX(' + -maxIndex + 'px)';
_this.currentPosition = -maxIndex;
// check if first slide is in view, and if swiping right
if (targetX >= 0 && deltaX > 0) {
var minIndex = 0;
activeSlider.style.transform = 'translateX(' + minIndex + 'px)';
_this.currentPosition = minIndex;
}
_this.handlePreviousButtonState();
_this.handleNextButtonState();
}, 300);
document.removeEventListener('touchend', eventHandlers$3.touchEnd.bind(this), false);
document.removeEventListener('touchmove', eventHandlers$3.touchMove.bind(this), false);
},
windowResize: function windowResize() {
this.updateButtonStates();
}
};
var SliderComponent = function () {
function SliderComponent(el) {
var _this2 = this;
classCallCheck(this, SliderComponent);
this.slider = el;
this.sliderContainer = el.parentElement;
this.items = Array.from(el.querySelectorAll('.slider__item'));
this.currentSlide = 0;
this.currentPosition = 0;
this.totalSlides = this.items.length;
this.lastSlide = el.querySelector('.slider__item:last-child');
this.tileWidth = el.querySelector('.slider__item').offsetWidth + 16;
this.prevBtn = this.sliderContainer.previousElementSibling.querySelector('.slider__btn--prev');
this.nextBtn = this.sliderContainer.previousElementSibling.querySelector('.slider__btn--next');
this.sliderOffset = this.slider.getBoundingClientRect();
this.lastSlideOffsetRight = 0;
// To calculate how many slides to be shown in slider at the end
this.lastSlidesToShow = Math.floor(this.sliderContainer.offsetWidth / this.tileWidth);
this.lastVisibleSlidesWidth = this.lastSlidesToShow * this.tileWidth;
this.lastEndingSlidesIndex = this.totalSlides - this.lastSlidesToShow;
// Touch events variables
this.isDragging = false;
this.startX = 0;
this.endX = 0;
this.translateX = 0;
this.updateButtonStates();
window.addEventListener('resize', throttle_1(eventHandlers$3.windowResize.bind(this), 30));
this.nextBtn.addEventListener('click', function () {
_this2.currentSlide = Math.abs(_this2.currentPosition) / _this2.tileWidth;
var maxSlideWidth = _this2.lastEndingSlidesIndex * _this2.tileWidth;
if (Math.abs(_this2.currentPosition) < maxSlideWidth) {
_this2.currentSlide++;
_this2.slideTilesOnClick();
} else {
_this2.updateButtonStates();
}
});
this.prevBtn.addEventListener('click', function () {
_this2.currentSlide = Math.abs(_this2.currentPosition) / _this2.tileWidth;
if (_this2.currentSlide > 0) {
_this2.currentSlide--;
_this2.slideTilesOnClick();
}
});
this.sliderContainer.addEventListener('touchstart', eventHandlers$3.touchStart.bind(this), false);
// Ensure the focused slider item remains visible when tabbing through items
this.slider.addEventListener('focusin', function (e) {
var itemEl = e.target.closest('.slider__item');
if (!itemEl || !_this2.slider.contains(itemEl)) return;
var index = _this2.items.indexOf(itemEl);
if (index === -1) return;
_this2.scrollToIndex(index);
});
}
createClass(SliderComponent, [{
key: 'slideTilesOnClick',
value: function slideTilesOnClick() {
var _this3 = this;
blazyInstance$6.revalidate();
var newPosition = -this.currentSlide * this.tileWidth;
this.slider.style.transform = 'translateX(' + newPosition + 'px)';
this.currentPosition = newPosition;
setTimeout(function () {
_this3.updateButtonStates();
}, 300);
}
// Scroll the slider so that the item at the given index is visible,
// clamping to avoid whitespace at the end.
}, {
key: 'scrollToIndex',
value: function scrollToIndex(index) {
var _this4 = this;
// Recalculate end constraints in case of responsive changes
this.tileWidth = this.slider.querySelector('.slider__item').offsetWidth + 16;
this.lastSlidesToShow = Math.floor(this.sliderContainer.offsetWidth / this.tileWidth) || 1;
this.lastEndingSlidesIndex = Math.max(0, this.totalSlides - this.lastSlidesToShow);
var clampedIndex = Math.min(Math.max(index, 0), this.lastEndingSlidesIndex);
this.currentSlide = clampedIndex;
var newPosition = -clampedIndex * this.tileWidth;
blazyInstance$6.revalidate();
this.slider.style.transform = 'translateX(' + newPosition + 'px)';
this.currentPosition = newPosition;
// Update buttons after the transform transition window
setTimeout(function () {
_this4.updateButtonStates();
}, 300);
}
}, {
key: 'updateButtonStates',
value: function updateButtonStates() {
this.handlePreviousButtonState();
this.handleNextButtonState();
}
}, {
key: 'handlePreviousButtonState',
value: function handlePreviousButtonState() {
if (this.currentPosition === 0) {
this.prevBtn.disabled = true;
this.prevBtn.classList.add('slider__btn--disabled');
} else {
this.prevBtn.disabled = false;
this.prevBtn.classList.remove('slider__btn--disabled');
}
}
}, {
key: 'handleNextButtonState',
value: function handleNextButtonState() {
this.lastSlideOffsetRight = this.lastSlide.getBoundingClientRect().right;
var sliderViewportSize = this.sliderContainer.offsetWidth + this.sliderOffset.left;
if (this.lastSlideOffsetRight <= sliderViewportSize) {
this.nextBtn.disabled = true;
this.nextBtn.classList.add('slider__btn--disabled');
} else {
this.nextBtn.disabled = false;
this.nextBtn.classList.remove('slider__btn--disabled');
}
}
}]);
return SliderComponent;
}();
queryAll(document, '.' + SLIDER_COMPONENT).forEach(function (el) {
el.slider = new SliderComponent(el);
});
// only grab the first sticky footer as we only allow one on a page
var stickyFooter = document.querySelector('.c-v12-sticky-footer');
var siteFooter = document.querySelector('.footer-default');
var displayFooter = function displayFooter() {
stickyFooter.querySelector('.c-v12-sticky-footer__content').style.height = 'auto';
stickyFooter.style.display = 'block';
siteFooter.style.paddingBottom = stickyFooter.offsetHeight + 'px';
};
var hideFooter = function hideFooter() {
stickyFooter.style.display = 'none';
siteFooter.style.paddingBottom = '0';
};
var init$5 = function init() {
if (typeof gcb === 'undefined' || window.gcb.status() === 'loaded') {
displayFooter();
}
document.addEventListener('gcb.banner.closed', function () {
setTimeout(function () {
displayFooter();
}, 3000);
});
document.addEventListener('gcb.banner.hidden', function () {
setTimeout(function () {
displayFooter();
}, 3000);
});
document.addEventListener('gcb.banner.full', function () {
hideFooter();
});
document.addEventListener('gcb.banner.open', function () {
hideFooter();
});
var submitBtn = stickyFooter.querySelector('.c-v12-sticky-footer__btn');
var emailInput = stickyFooter.querySelector('.c-v12-sticky-footer__email');
submitBtn.addEventListener('click', function () {
var enteredText = emailInput.value;
document.cookie = 'fusionSubscribeEmail=' + enteredText + ';domain=gallup.com;path=/;';
window.location.pathname = '/subscribe.aspx';
});
// Check if there are any pop banners on the page and add extra space to them
var banners = document.querySelectorAll('.c-banner');
var toggle = stickyFooter.querySelector('.c-v12-sticky-footer__toggle');
if (banners) {
banners.forEach(function (banner) {
banner.style.marginBottom = stickyFooter.offsetHeight + 'px';
banner.style.maxHeight = 'calc(84vh - ' + stickyFooter.offsetHeight + 'px';
banner.style.transition = 'margin 0.5s';
toggle.addEventListener('click', function () {
setTimeout(function () {
banner.style.marginBottom = stickyFooter.offsetHeight + 'px';
banner.style.maxHeight = 'calc(84vh - ' + stickyFooter.offsetHeight + 'px';
}, 100);
});
});
}
};
// check for banner element and initialize
if (stickyFooter && siteFooter) {
if (document.readyState === 'complete') {
init$5();
} else {
window.addEventListener('load', init$5);
}
}
window.a11yTabs = function tabsComponentIIFE() {
var tabInstances = new WeakMap();
/**
* Instantiates the component
* @constructor
* @param {DOM Node} element
*/
var TabComponent = function TabComponent(element, options) {
if (!element || !element.nodeType) {
throw new Error('The DOM element was not found when creating the tab component');
}
var defaults = {
tabList: '.c-tab__list',
tabItem: '.c-tab__item',
tabLink: '.c-tab__link',
tabPanel: '.c-tab__panel'
};
this.options = Object.assign(defaults, options);
this.element = element;
this.tabList = element.querySelector(this.options.tabList);
this.tabItems = [].slice.call(this.tabList.querySelectorAll(this.options.tabItem));
this.tabLinks = [].slice.call(this.tabList.querySelectorAll(this.options.tabLink));
this.tabPanels = [].slice.call(element.querySelectorAll(this.options.tabPanel));
this.currentIndex = 0;
this.tabList.setAttribute('role', 'tablist');
this.tabItems.forEach(function (item, index) {
item.setAttribute('role', 'presentation');
if (index === 0) {
item.setAttribute('data-tab-active', '');
}
});
this.tabLinks.forEach(function (item, index) {
item.setAttribute('role', 'tab');
item.setAttribute('id', 'tab' + index);
if (index > 0) {
item.setAttribute('tabindex', '-1');
} else {
item.setAttribute('aria-selected', 'true');
}
});
this.tabPanels.forEach(function (item, index) {
item.setAttribute('role', 'tabpanel');
item.setAttribute('aria-labelledby', 'tab' + index);
item.setAttribute('tabindex', '-1');
if (index > 0) {
item.setAttribute('hidden', '');
}
});
// eslint-disable-next-line no-use-before-define
this.eventCallback = handleEvents.bind(this);
this.tabList.addEventListener('click', this.eventCallback, false);
this.tabList.addEventListener('keydown', this.eventCallback, false);
tabInstances.set(this.element, this);
};
TabComponent.prototype = {
/**
* Event handler for all tab interactions
* @param {number} index - Index of the tab being activiated
* @param {string} direction -
*/
handleTabInteraction: function handleTabInteraction(index, direction) {
var curIndex = this.currentIndex;
var newIndex = index;
// The click event does not pass in a direction. This is for keyboard support
if (direction) {
if (direction === 37) {
newIndex = index - 1;
} else {
newIndex = index + 1;
}
}
// Supports continuous tabbing when reaching beginning or end of tab list
if (newIndex < 0) {
newIndex = this.tabLinks.length - 1;
} else if (newIndex === this.tabLinks.length) {
newIndex = 0;
}
// update tabs
this.tabLinks[curIndex].setAttribute('tabindex', '-1');
this.tabLinks[curIndex].removeAttribute('aria-selected');
this.tabItems[curIndex].removeAttribute('data-tab-active');
this.tabLinks[newIndex].setAttribute('aria-selected', 'true');
this.tabItems[newIndex].setAttribute('data-tab-active', '');
this.tabLinks[newIndex].removeAttribute('tabindex');
this.tabLinks[newIndex].focus();
// update tab panels
this.tabPanels[curIndex].setAttribute('hidden', '');
this.tabPanels[newIndex].removeAttribute('hidden');
this.currentIndex = newIndex;
tiles.blazyInstance.revalidate();
return this;
},
/**
* Set tab panel focus
* @param {number} index - Tab panel index to receive focus
*/
handleTabpanelFocus: function handleTabPanelFocus(index) {
this.tabPanels[index].focus();
return this;
}
};
/**
* Creates or returns existing component
* @param {string} selector
*/
function createTabComponent(element, options) {
if (!element) {
return null;
}
return tabInstances.get(element) || new TabComponent(element, options);
}
/**
* Destroys an existing component
* @param {DOM Node} element
*/
function destroyTabComponent(element) {
if (!element || !element.nodeType) {
throw new Error('The DOM element was not found when deleting the tab component');
}
var component = tabInstances.get(element);
component.tabList.removeAttribute('role', 'tablist');
component.tabItems.forEach(function (item, index) {
item.removeAttribute('role', 'presentation');
if (index === 0) {
item.removeAttribute('data-tab-active');
}
});
component.tabLinks.forEach(function (item, index) {
item.removeAttribute('role', 'tab');
item.removeAttribute('id', 'tab' + index);
if (index > 0) {
item.removeAttribute('tabindex', '-1');
} else {
item.removeAttribute('aria-selected', 'true');
}
});
component.tabPanels.forEach(function (item, index) {
item.removeAttribute('role', 'tabpanel');
item.removeAttribute('aria-labelledby', 'tab' + index);
item.removeAttribute('tabindex', '-1');
if (index > 0) {
item.removeAttribute('hidden');
}
});
component.tabList.removeEventListener('click', component.eventCallback);
component.tabList.removeEventListener('keydown', component.eventCallback);
tabInstances.delete(component.element);
}
/**
* Handles all event listener callbacks
* @param {event} event
*/
function handleEvents(event) {
if (event.type === 'click') {
var index = this.tabLinks.indexOf(event.target.closest('.c-tab__link'));
if (index === -1) return;
event.preventDefault();
TabComponent.prototype.handleTabInteraction.call(this, index);
}
if (event.type === 'keydown') {
var _index = this.tabLinks.indexOf(event.target);
// Left and right arrows
if (event.which === 37 || event.which === 39) {
event.preventDefault();
TabComponent.prototype.handleTabInteraction.call(this, _index, event.which);
}
// Down arrow
if (event.which === 40) {
event.preventDefault();
TabComponent.prototype.handleTabpanelFocus.call(this, _index);
}
}
}
return {
create: createTabComponent,
destroy: destroyTabComponent
};
}(window, document);
document.querySelectorAll('.c-tab').forEach(function (tabContainer) {
window.a11yTabs.create(tabContainer);
});
var loadDataWrapper = function loadDataWrapper() {
if (!window.datawrappermessage) {
window.datawrappermessage = true;
window.addEventListener('message', function (e) {
var dataWrapperHeight = e.data['datawrapper-height'];
if (typeof dataWrapperHeight !== 'undefined') {
document.querySelectorAll('iframe').forEach(function (iframe) {
if (iframe.contentWindow === e.source) {
Object.keys(e.data['datawrapper-height']).forEach(function (key) {
iframe.style.height = e.data['datawrapper-height'][key] + 'px';
window.dispatchEvent(new Event('resize'));
});
}
});
}
});
}
};
loadDataWrapper();
document.addEventListener('DOMContentLoaded', function () {
var jsonLdScript = document.querySelector('script[type="application/ld+json"]');
if (!jsonLdScript) return; // return if no JSON-LD script
var jsonLdObject = void 0;
try {
jsonLdObject = JSON.parse(jsonLdScript.textContent);
} catch (error) {
console.error('Error parsing JSON-LD:', error);
return;
}
var CollectionPage = document.querySelector('[data-jsonld="CollectionPage"]');
var VideoObject = document.querySelector('[data-jsonld="VideoObject"]');
var iFrames = document.querySelectorAll('iframe[data-gcb-content-type="video"]');
var topicPage = document.querySelector('.masonry-container');
var topicPageTiles = document.querySelectorAll('.masonry-container .cmstile');
function getYouTubeThumbnailUrl(iFrameUrl) {
var videoIDMatch = iFrameUrl.match(/youtube\.com\/embed\/([^?&]+)/);
if (videoIDMatch && videoIDMatch[1]) {
var videoId = videoIDMatch[1];
return 'https://i.ytimg.com/vi_webp/' + videoId + '/sddefault.webp';
}
return null;
}
// Collection of videos
if (CollectionPage && iFrames.length > 0) {
var itemListElement = [];
iFrames.forEach(function (iframe) {
var videoUrl = iframe.dataset.gcbSrc;
if (!videoUrl) return; // return if no URL
var videoName = iframe.getAttribute('title');
if (!videoName) return;
videoName = videoName.replace(/[/:"\\]/g, '').trim();
var videoDescription = videoName;
var thumbnailUrl = getYouTubeThumbnailUrl(videoUrl);
// JSON-LD needs a timezone offset in the date string
var uploadDateValue = new Date(jsonLdObject.datePublished).toISOString();
var listItem = {
'@type': 'ListItem',
position: itemListElement.length + 1,
item: {
'@type': 'VideoObject',
name: videoName,
description: videoDescription,
embedUrl: videoUrl,
thumbnailUrl: thumbnailUrl,
uploadDate: uploadDateValue
}
};
itemListElement.push(listItem);
});
jsonLdObject.mainEntity.itemListElement = itemListElement;
jsonLdScript.textContent = JSON.stringify(jsonLdObject);
}
// Topic page
if (CollectionPage && topicPage && topicPageTiles.length > 0) {
var _itemListElement = [];
topicPageTiles.forEach(function (tile) {
var articleUrlElement = tile.querySelector('.tile-linktext a');
if (!articleUrlElement) return; // return if no url
var articleUrl = articleUrlElement.href;
var articleTitle = articleUrlElement.textContent.trim();
var listItem = {
'@type': 'ListItem',
position: _itemListElement.length + 1,
url: articleUrl,
item: {
'@type': 'Article',
headline: articleTitle,
url: articleUrl
}
};
_itemListElement.push(listItem);
});
jsonLdObject.mainEntity.itemListElement = _itemListElement;
jsonLdScript.textContent = JSON.stringify(jsonLdObject);
}
// Video object
if (VideoObject && iFrames.length > 0) {
var firstIframe = iFrames[0];
var videoUrl = firstIframe.dataset.gcbSrc;
if (!videoUrl) return; // return if no url
var thumbnailUrl = getYouTubeThumbnailUrl(videoUrl);
var videoName = firstIframe.getAttribute('title') || null;
var videoDescription = firstIframe.getAttribute('title') || null;
var videoObject = {
'@type': 'VideoObject',
name: videoName,
description: videoDescription,
embedUrl: videoUrl,
thumbnailUrl: thumbnailUrl,
url: window.location.href,
uploadDate: jsonLdObject.datePublished
};
jsonLdObject.mainEntity = videoObject;
jsonLdScript.textContent = JSON.stringify(jsonLdObject);
}
});
/** Google Analytics
* Hooks up "click" event listeners for GA tracking based on the
* `data-ga-category` attribute.
*/
// Google analytics events tracking using data attributes
queryAll(document, '[data-ga-category]').forEach(function (link) {
link.addEventListener('click', function () {
var attr = link.dataset;
var action = attr.gaAction ? attr.gaAction : 'Click';
window.ga('send', 'event', attr.gaCategory, action, attr.gaLabel, {
hitCallback: function hitCallback() {// Execute default action
}
});
});
});
// GTM YouTube videos tracking
var iFrames = document.querySelectorAll('iframe.b-lazy');
if (iFrames) {
Array.prototype.forEach.call(iFrames, function (iFrame) {
var reinitializeGTMLoadEvent = function reinitializeGTMLoadEvent() {
// eslint-disable-next-line no-undef
dataLayer.push({ event: 'gtm.load' });
};
// Calling on iFrame src value change
iFrame.addEventListener('load', reinitializeGTMLoadEvent);
});
}
// Script bundle for Gallup.com
}());
//# sourceMappingURL=site-www.js.map
;