var script = function script(props) {
  var els = {
    el: null,
    readModeDiv: null,
    editModeDiv: null,
    editModeCTA: null,
    readModeCTA: null
  };

  var init = function init() {
    els.el = props.el;
    els.readModeDiv = els.el.querySelector('.readmode');
    els.editModeDiv = els.el.querySelector('.editmode');
    els.editModeCTA = els.el.querySelector('.edit-cta');
    els.readModeCTA = els.el.querySelector('.read-cta');
    addListeners();
  };

  var addListeners = function addListeners() {
    els.editModeCTA.addEventListener('click', function (e) {
      e.preventDefault();
      els.editModeDiv.classList.remove('hidden');
      els.readModeDiv.classList.add('hidden');
    });
    els.readModeCTA.addEventListener('click', function (e) {
      e.preventDefault(); // just reload the page to get any changes from server

      window.location.reload();
    });
  };

  return {
    init: init
  };
};

window.app.add({
  name: 'profileForm',
  script: script
});

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var script = function script(props) {
    // get page url
    var pageUrl = window.location.pathname; // fake for testing
    // pageUrl = '/staff/board-of-directors/simon-fraser';

    var init = function init() {
        // *** make api call, and generate content via frontend/alchemy-templates.js
        var fetchData = /*#__PURE__*/function () {
            var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
                var data;
                return regeneratorRuntime.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                _context.next = 2;
                                return props.fetchData(props.attributes);

                            case 2:
                                data = _context.sent;
                                parseData(data.payload.Result, props.attributes);

                            case 4:
                            case "end":
                                return _context.stop();
                        }
                    }
                }, _callee);
            }));

            return function fetchData() {
                return _ref.apply(this, arguments);
            };
        }();

        if (props.attributes.datasource) {
            fetchData();
        }
    }; // *** parsing specific to this component - if encountering a similar requirement consider refactoring into a utility


    var parseData = function parseData(data, options) {
        // set to empty array if nothing in results to choke errors
        if (!data) data = []; //exclude staff member from carousel if we are on the staff bio page

        var updated = [];
        updated = data.filter(function (item) {
            return item['Url'] != pageUrl;
        }); //compare pageurl excluding domain to staff href

        data = updated;
        var jsonMap = props.utils.attributeParser(props.el.getAttribute('data-json-mapping'));
        var criteria = []; // *** in this case we are splitting data into chunks relative to unique 'RoleId' sets

        data.map(function (item) {
            item[options.key].map(function (id) {
                criteria.push(id);
                return true;
            });
        });
        criteria = _toConsumableArray(new Set(criteria)); // *** unique values only
        // *** chunk data by criteria

        var chunks = criteria.map(function (value) {
            return data.filter(function (item) {
                return item[options.key].includes(value);
            });
        }); // *** build nodes from data

        var nodes = chunks.map(function (chunk) {
            return chunk.map(function (item) {
                return window.alchemyTemplates.getTemplate({
                    type: props.attributes.template || '',
                    map: jsonMap,
                    parent: props.el
                }, item);
            });
        });

        var getLabel = function getLabel(criteria) {
            var values = options.values.filter(function (item) {
                return item[0] === criteria;
            });

            if (values.length > 0) {
                return values[0][1];
            }

            return '...';
        }; // *** wrap output object and return


        var result = nodes.map(function (item, index) {
            return {
                label: getLabel(criteria[index]),
                nodes: nodes[index]
            };
        });
        build(result);
    }; // *** populate behaviours with generated content from api data


    var build = function build(nodes) {
        var defaultIndex = 0; // check if we actually have any nodes...

        var hasNoResults = nodes.length === 0; // if we have nothing dont proceed./

        if (hasNoResults) {
            showNoResults();
            return;
        } else {
            props.el.classList.remove('tabstack--noresults');
        } // *** data to populate tabswitcher and select


        var getTabButtons = function getTabButtons() {
            return nodes.map(function (item) {
                return {
                    label: item.label
                };
            });
        }; // *** TABSWITCHER


        var tabSwitcher = props.getBehaviour(props.el.querySelector('.tab-switcher-control'));
        tabSwitcher.inject(getTabButtons(), defaultIndex); // ...
        // *** SELECT

        var selectControl = props.getBehaviour(props.el.querySelector('.select-control'));
        selectControl.inject(getTabButtons(), defaultIndex); // ...
        // *** TABSTACK

        var tabStack = props.getBehaviour(props.el.querySelector('.tabstack'));
        tabStack.inject(nodes, defaultIndex); // ...
        // *** CAROUSEL

        var carousel = props.getBehaviour(props.el.querySelector('.carousel'));

        var updateCarousel = function updateCarousel(index) {
            var data = nodes[index].nodes.map(function (item) {
                return item.cloneNode(true); // *** clone node to use again, otherwise it will be removed from tabstack
            });
            carousel.inject(data, defaultIndex);
        }; // ...
        // *** use select control events to update carousel


        props.events.on('BEHAVIOUR_BINDING_SIGNAL', function (payload) {
            if (payload.sender !== tabSwitcher.getOptions().config.uid && payload.sender !== selectControl.getOptions().config.uid) return;
            updateCarousel(payload.data.index);
        });
        updateCarousel(defaultIndex);
    };

    var showNoResults = function showNoResults() {
        // const tabContainer = props.el.querySelector('.tabstack');
        // if nothing comes back from api lets append a message to tell user
        var noResultsDiv = document.createElement('div');
        var resultsText = props.attributes.noresult ? props.attributes.noresult : '';
        noResultsDiv.classList.add('tabstack__no-results');
        noResultsDiv.innerText = resultsText;
        props.el.appendChild(noResultsDiv); // hide anything we dont need with csss, like selects, etc

        props.el.classList.add('tabstack--noresults');

        
        // quick fix hide entire component if results are empty AND text is set to hide
        if (resultsText=="hide") {
            props.el.style.display = 'none';
    
        }
    };

    return {
        init: init
    };
};

window.app.add({
    name: 'staffCarousel',
    // *** ensure unique
    script: script
});

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var script = function script(props) {
    var init = function init() {
        // *** make api call, and generate content via frontend/alchemy-templates.js
        var fetchData = /*#__PURE__*/function () {
            var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
                var queryParams, _data, _data2;

                return regeneratorRuntime.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                // @ja pass tags through to queryparams
                                queryParams = getAllTags(props.attributes);

                                if (!queryParams) {
                                    _context.next = 8;
                                    break;
                                }

                                _context.next = 4;
                                return props.fetchData(props.attributes, queryParams);

                            case 4:
                                _data = _context.sent;
                                parseData(_data.payload.Result, props.attributes);
                                _context.next = 12;
                                break;

                            case 8:
                                _context.next = 10;
                                return props.fetchData(props.attributes);

                            case 10:
                                _data2 = _context.sent;
                                parseData(_data2.payload.Result, props.attributes);

                            case 12:
                            case "end":
                                return _context.stop();
                        }
                    }
                }, _callee);
            }));

            return function fetchData() {
                return _ref.apply(this, arguments);
            };
        }();

        if (props.attributes.datasource) {
            fetchData();
        }
    }; // *** @ja added in extra AllTags param to api for added filtering


    var getAllTags = function getAllTags(attrs) {
        if (!attrs.allTags) return null; // be present

        var rawTags = attrs.allTags;
        var regex = /\'/g;
        var tags = rawTags.replace(regex, '');
        if (typeof tags !== 'string' || tags === '') return null; // be a string and not empty

        if (tags.indexOf('|' > -1)) {
            var tagArray = tags.split('|');
            var str = tagArray.join(',');
            return {
                AllTags: str
            };
        } else {
            return {
                AllTags: tags
            };
        }
    }; // *** parsing specific to this component - if encountering a similar requirement consider refactoring into a utility


    var parseData = function parseData(data, options) {
        data.map(function (item, index) {
            // flatten out this reviewType obj so we can filter against it
            for (var _i = 0, _Object$entries = Object.entries(item['ReviewType']); _i < _Object$entries.length; _i++) {
                var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
                    key = _Object$entries$_i[0],
                    value = _Object$entries$_i[1];

                item[key] = value;
            } // if we have video information...


            if (item['VideoData'] && item['VideoData']['VideoType'] !== null) {
                // we need a unique carousel thumb id
                item['VideoUID'] = "video-carousel-thumb-".concat(index); // and we also need to construct the config string properly...

                item['VideoConfig'] = makeVideoConfigString(item['VideoData']);
            }
        });
        var jsonMap = props.utils.attributeParser(props.el.getAttribute('data-json-mapping'));
        var criteria = []; // *** in this case we are splitting data into chunks relative to unique 'RoleId' sets

        data.map(function (item) {
            criteria.push(item[options.key]); // *** get all values
        });
        criteria = _toConsumableArray(new Set(criteria)); // *** unique values only
        // *** chunk data by criteria

        var chunks = criteria.map(function (value) {
            return data.filter(function (item) {
                return item[options.key] === value;
            });
        }); // *** build nodes from data

        var nodes = chunks.map(function (chunk) {
            return chunk.map(function (item) {
                return window.alchemyTemplates.getTemplate({
                    type: props.attributes.template || '',
                    map: jsonMap,
                    parent: props.el
                }, item);
            });
        });

        var getLabel = function getLabel(criteria) {
            var values = options.values.filter(function (item) {
                return item[0] === criteria;
            });

            if (values.length > 0) {
                return values[0][1];
            }

            return '...';
        }; // *** wrap output object and return


        var result = nodes.map(function (item, index) {
            return {
                label: getLabel(criteria[index]),
                nodes: nodes[index]
            };
        });
        build(result);
    }; // *** populate behaviours with generated content from api data


    var build = function build(nodes) {
        var defaultIndex = 0; // check if we actually have any nodes...

        var hasNoResults = nodes.length === 0; // if we have nothing dont proceed./

        if (hasNoResults) {
            showNoResults();
            return;
        } else {
            props.el.classList.remove('tabstack--noresults');
        } // *** data to populate tabswitcher and select


        var getTabButtons = function getTabButtons() {
            return nodes.map(function (item) {
                return {
                    label: item.label
                };
            });
        }; // *** TABSWITCHER


        var tabSwitcher = props.getBehaviour(props.el.querySelector('.tab-switcher-control'));
        tabSwitcher.inject(getTabButtons(), defaultIndex); // ...
        // *** SELECT

        var selectControl = props.getBehaviour(props.el.querySelector('.select-control'));
        selectControl.inject(getTabButtons(), defaultIndex); // *** TABSTACK

        var tabStack = props.getBehaviour(props.el.querySelector('.tabstack'));
        tabStack.inject(nodes, defaultIndex); // ...
        // *** CAROUSEL

        var carousel = props.getBehaviour(props.el.querySelector('.carousel'));

        var updateCarousel = function updateCarousel(index) {
            var data = nodes[index].nodes.map(function (item) {
                return item.cloneNode(true); // *** clone node to use again, otherwise it will be removed from tabstack
            });
            carousel.inject(data, defaultIndex); // an array of thumb items

            var thumbs = data.map(function (item) {
                return item.querySelector("[data-behaviour=\"video-player\"]");
            });
            var clipboards = data.map(function (item) {
                return item.querySelector("[data-behaviour=\"clipboard\"]");
            });
            var shareBTNS = data.map(function (item) {
                return item.querySelector("[data-behaviour=\"asset-share\"]");
            });
            var filtered = thumbs.filter(function (item) {
                return item !== null;
            });
            var filterClipboard = clipboards.filter(function (item) {
                return item !== null;
            });
            var filterShareBTN = shareBTNS.filter(function (item) {
                return item !== null;
            });
            carousel.inject(data, defaultIndex); // have to register these event handlers manually now..

            setTimeout(function () {
                primeThumbs(filtered);
                primeClipboards(filterClipboard);
                primeShareBTNS(filterShareBTN);
            }, 1000);
        }; // ...
        // *** use select control events to update carousel


        props.events.on('BEHAVIOUR_BINDING_SIGNAL', function (payload) {
            if (payload.sender !== tabSwitcher.getOptions().config.uid && payload.sender !== selectControl.getOptions().config.uid) return;
            updateCarousel(payload.data.index);
        });
        updateCarousel(defaultIndex);
    };

    var showNoResults = function showNoResults() {
        // const tabContainer = props.el.querySelector('.tabstack');
        // if nothing comes back from api lets append a message to tell user
        var noResultsDiv = document.createElement('div');
        var resultsText = props.attributes.noresult ? props.attributes.noresult : '';
        noResultsDiv.classList.add('tabstack__no-results');
        noResultsDiv.innerText = resultsText;
        props.el.appendChild(noResultsDiv); // hide anything we dont need with csss, like selects, etc

        props.el.classList.add('tabstack--noresults');

        // quick fix hide entire component if results are empty AND text is set to hide
        if (resultsText == "hide") {
            props.el.style.display = 'none';

            const anchor = props.el.querySelector('.offset-anchor');
            if (anchor) {
                if (anchor.id) {
                    // fire an event for the stickynav to pickup
                    props.events.emit('STICKYNAV_REMOVE_ITEM', {
                        id: anchor.id,
                    });
                }
            }
        }
    };

    var makeVideoConfigString = function makeVideoConfigString(obj) {
        var returnStr;
        var type = obj['VideoType'];

        switch (type) {
            case 'contenthub':
                returnStr = "type: html5, src: ".concat(obj['VideoUrl']);
                break;

            case 'youtube':
                returnStr = "type: youtube, ytVideoId: ".concat(obj['VideoId']);
                break;

            case 'vimeo':
                returnStr = "type: vimeo, vimVideoId: ".concat(obj['VideoId']);
                break;

            case 'brightcove':
                returnStr = "type: brightcove, bcVideoId: ".concat(obj['VideoId'], ", bcAccountId: ").concat(obj['VideoAccountId'], ", bcPlayerId: ").concat(obj['VideoPlayerId']);
                break;
        } // add poster img if present..


        if (obj['VideoPoster'] && obj['VideoPoster'] !== null) returnStr += ", poster: ".concat(obj['VideoPoster']);
        return returnStr;
    };

    var primeThumbs = function primeThumbs(thumbs) {
        var videoThumbs = _toConsumableArray(thumbs); // Manually register these thumb items with the VideoPlayer behaviour


        videoThumbs.map(function (item, index) {
            item.getAttribute('data-behaviour-uid');
            props.registerBehaviour(item);
        });
    };

    var primeClipboards = function primeClipboards(clipboards) {
        var videoClipboards = _toConsumableArray(clipboards); // Manually register these thumb items with the VideoPlayer behaviour


        videoClipboards.map(function (item, index) {
            item.getAttribute('data-behaviour-uid');
            props.registerBehaviour(item);
        });
    };

    var primeShareBTNS = function primeShareBTNS(shareBTNS) {
        var videoShareBTNS = _toConsumableArray(shareBTNS); // Manually register these thumb items with the VideoPlayer behaviour


        videoShareBTNS.map(function (item, index) {
            item.getAttribute('data-behaviour-uid');
            props.registerBehaviour(item);
        });
    };

    return {
        init: init
    };
};

window.app.add({
    name: 'videoThumbsCarousel',
    // *** ensure unique
    script: script
});
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

/**
 * simple script to toggle accordion - consider creating a generic utility for this functionality, ensuring namespacing
 */
var script = function script(props) {
    var els = {};

    var init = function init() {
        // *** keep references to els
        els.accordion = props.el.querySelector('.accordion');
        els.textInputs = _toConsumableArray(els.accordion.querySelectorAll('input[type=checkbox]')); // *** add listeners

        els.textInputs.map(function (item) {
            item.addEventListener('click', function () {
                update(item.getAttribute('id'));
            });
        });
    };

    var update = function update(id) {
        els.textInputs.map(function (item) {
            if (item.getAttribute('id') !== id) {
                item.checked = false;
            }
        });
    };

    return {
        init: init
    };
};

window.app.add({
    name: 'featuredGeographicalRegion',
    // *** ensure unique
    script: script
});

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

// *** TODO refactor into easily reusable object for all heroes to avoid duplicating this script
var script = function script(props) {
    var els = _defineProperty({
        el: null,
        ctaButton: null,
        selectField1: null
    }, "selectField1", null);

    var init = function init() {
        els.el = props.el;
        els.ctaButton = els.el.querySelector(".timeline-nav-tab");
        els.dropdown = els.el.querySelector(".dropdown__button--timeline");
        els.selectField1 = els.dropdown.querySelector("#timelineDropdpwn");
        els.selectField1.addEventListener("change", function (e) {
            if (e.target.value != "") {
                selectedOption(e.target.value);
            }
        });
        Tabs();
    };

    var Tabs = function Tabs() {
        var bindAll = function bindAll() {
            var menuElements = document.querySelectorAll('[data-tab]');

            for (var i = 0; i < menuElements.length; i++) {
                menuElements[i].addEventListener('click', change, false);
            }
        };

        var clear = function clear() {
            var menuElements = document.querySelectorAll('[data-tab]');

            for (var i = 0; i < menuElements.length; i++) {
                menuElements[i].classList.remove('active');
                var id = menuElements[i].getAttribute('data-tab');
                document.getElementById(id).classList.remove('active');
            }
        };

        var change = function change(e) {
            clear();
            e.target.classList.add('active');
            var id = e.currentTarget.getAttribute('data-tab');
            document.getElementById(id).classList.add('active');
        };

        bindAll();
    };

    var selectedOption = function selectedOption(e) {
        console.log("i m indise");

        if (document.querySelector('#papa div.active') !== null) {
            document.querySelector('#papa div.active').classList.remove('active');
        }

        var tabarea = e;
        console.log(tabarea, "area");
        document.getElementById(tabarea).classList.add('active');
    };

    return {
        init: init
    };
};

window.app.add({
    name: "timeline",
    script: script
});

var script = function script(props) {

    var init = function init() {
        const countryAddressLinksList = [...document.body.querySelectorAll(`.countryAddressLink`)];
        const languageConfirmationYes = document.getElementById('language-confirmation-yes');
        const languageConfirmationText = document.getElementById('languageConfirmationText');
        const confirmationPopupText = document.getElementById('confirmationPopupText');
        if (confirmationPopupText && confirmationPopupText.value) {
            languageConfirmationText.innerHTML = confirmationPopupText.value;
        }
        countryAddressLinksList.map((item) => {
            item.onclick = function () {
                languageConfirmationYes.dataset.redirectionUrl = `${item.dataset.redirectionUrl}`;
                languageConfirmationYes.dataset.iscountryPage = `true`;
            }
        })
    };

    return {
        init: init
    };
};

window.app.add({
    name: 'countryAddressPage',
    // *** ensure unique
    script: script
});
/**
 * Example component script
 * Component scripts are managed by an instance of `src/core/js/view/AbstractComponent.js` which mediates
 * between the core and the components, injecting components with configuration, events etc
 * import statements here are allowed but must be used with caution TODO explain how and why
 * @param {Object} props - TODO
 * @return {{init: init, foo: foo}}
 */
var script = function script(props) {
  // *** mandatory function - called by `AbstractComponent` on instantiation
  var init = function init() {
    console.log('/_example/ -init ', props);
  }; // *** some functions in `AbstractComponent` can be overridden here TODO document which ones


  var canOverrideThis = function canOverrideThis(args) {
    console.log('/_example/ -canOverrideThis', args);
  };

  return {
    init: init,
    canOverrideThis: canOverrideThis
  };
};
/**
 * Component scripts are registered with the core like this.
 * Ensure that the value of `name` is unique, and matches the `data-component` attribute
 * in `index.html` for this component
 */


window.app.add({
  name: '_example',
  // *** ensure unique
  script: script
});

/**
 * consent-revealer
 * finds all elements with the class 'consent-revealer' and adds a click event listener to radio buttons
 *  consenting sets a session cookie and hides the consent
 *  declining diverts user to a url - url is set in the data-component-props="redirect: 'https://www.google.com'">

 * @param {Object} props - TODO
 * @return {{init: init, foo: foo}}
 */
var script = function script(props) {
    // *** mandatory function - called by `AbstractComponent` on instantiation
    var subProps = {};
    var els = {
        el: null,
        wrapper: null,
        intro: null,
        content: null,
        consent: null,
        agree: null,
        disagree: null
    };
    var cookieSet = false;

    var init = function init() {
        console.log('/consent-revealer/ -init ', props);
        els.el = props.el;
        els.wrapper = els.el.querySelector(".consent-revealer--wrapper");
        els.intro = els.wrapper.querySelector(".consent-revealer--text");
        els.consent = els.wrapper.querySelector(".consent-revealer--cta");
        els.agree = els.consent.querySelector("input#agree");
        els.disagree = els.consent.querySelector("input#disagree");
        els.content = els.el.querySelector(".consent-revealer--content");
        props.attributes.redirect;
        checkACookieExists();
        addListeners();
    };

    var addListeners = function addListeners() {
        els.agree.addEventListener("click", function () {
            cookieSet = true;
            setSessionCookie();
            toggleReveal(cookieSet);
        });
        els.disagree.addEventListener("click", function () {// *** @as removed - SMIT-3578. no requirement to do anything with this action...
            // redirect(redirectUrl);
        });
    }; // set cookie function


    var setSessionCookie = function setSessionCookie() {
        document.cookie = "S&N-investor-consent=true";
    };

    var checkACookieExists = function checkACookieExists() {
        if (document.cookie.split(';').some(function (item) {
            return item.trim().startsWith('S&N-investor-consent=true');
        })) {
            cookieSet = true;
        }

        setTimeout(function () {
            toggleReveal(cookieSet);
        }, 100);
    }; // show hide consent function


    var toggleReveal = function toggleReveal(consent) {
        if (consent) {
            els.wrapper.classList.add("hide");
            els.content.classList.remove("hide");

            if (!subProps.tableScroller) {
                subProps.tableScroller = props.getBehaviour(props.el.querySelector('.table-scroller'));
            }

            subProps.tableScroller.update();
        } else {
            els.wrapper.classList.remove("hide");
            els.content.classList.add("hide");
        }
    };

    return {
        init: init
    };
};
/**
 * Component scripts are registered with the core like this.
 * Ensure that the value of `name` is unique, and matches the `data-component` attribute
 * in `index.html` for this component
 */


window.app.add({
    name: 'consent-revealer',
    script: script
});

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

/**
 * Homepage tabs
 * API endpoint set in component, and html is injected into the tab content
 * behaviours need tobe reinitiatlised on load
 * @param {Object} props - TODO
 * @return {{init: init, foo: foo}}
 */
var script = function script(props) {
    var els = {
        el: null,
        navHeader: null,
        breadcrumbs: null,
        tabGroup: null,
        tabContent: null,
        content: null,
        viewportInner: null
    };
    var tabs,
        endpoint,
        tabGroupHeight,
        breadcrumbs,
        tabContentObjects = [];

    var init = function init() {
        // console.log('/homepage-tabs/ -init ', props);
        els.el = props.el;
        els.tabGroup = els.el.querySelector('.tab-group');
        els.navHeader = document.querySelector('header');
        els.breadcrumbs = document.querySelector('.breadcrumbs');
        els.viewportInner = document.querySelector('.viewport__inner');
        els.tabContent = document.querySelector('.tab-content-wrapper');
        tabs = els.el.querySelectorAll('.tab');
        endpoint = els.el.getAttribute('data-component-props');
        generateTabs(); // only run once

        setUpTabs(); // can be re run on resize etc

        props.events.on(props.config.eventNames.APP_RESIZE_END, function (payload) {
            setUpTabs();
        });
    }; // *** @as refactored


    var generateTabs = function generateTabs() {
        var defaultIndex = 0; // *** tab index to arrive at

        var _tabs = _toConsumableArray(tabs); // *** cast to array


        var numTabs = _tabs.length;
        var numTabsReady = 0; // *** count tabs cooked

        _tabs.map(function (tab, index) {
            tab.addEventListener('click', function () {
                handleTabClick(tab);
            });
            var panel = document.createElement('div');
            panel.classList.add('tab-content--panel');
            panel.setAttribute('id', tab.getAttribute('id'));
            els.tabContent.append(panel);
            tabContentObjects.push({
                tabId: tab.getAttribute('id'),
                loaded: false
            }); //  store tab status

            loadFromApi(tab.getAttribute("id"), endpoint + tab.dataset.attributeUrl + "?sc_mode=normal", els.tabContent); // *** mutation observer - fires when content rendered from api call
            var observer = new MutationObserver(function (entries) {
                if (!!entries) {
                    observer.disconnect();

                    _toConsumableArray(panel.querySelectorAll('[data-behaviour]')).map(function (item) {
                        props.registerBehaviour(item); // *** initialise behaviour
                    });

                    handleTabClick(tab); // *** initialise tab : TODO visible tab switching on pageload, hide everything until done

                    numTabsReady += 1;

                    if (numTabsReady === numTabs) {
                        // *** now content rendered and behaviours init'd
                        handleTabClick(_tabs[defaultIndex]);
                    }
                }
            });
            observer.observe(panel, {
                subtree: true,
                childList: true
            });
        });
    };

    var setUpTabs = function setUpTabs() {
        // calc height of tabgroup and set position
        tabGroupHeight = outerHeight(els.tabGroup);
        outerHeight(els.navHeader);
        getPosition(els.tabContent);
        breadcrumbs = outerHeight(els.breadcrumbs);
        setTabGroupPosition(tabGroupHeight);
        setViewportHeight(breadcrumbs);
    };

    var setTabGroupPosition = function setTabGroupPosition(tabGroupHeight) {
        props.events.on(props.config.eventNames.APP_BREAKPOINT_READY, function (payload) {
            if (payload.breakpoint == 'mobile') {
                els.el.style = '';
            }

            if (payload.breakpoint == 'tablet-portrait') {
                els.el.style.bottom = tabGroupHeight + 16 + 'px'; // need to make this more dynamic

                els.el.style.marginBottom = '-' + parseInt(tabGroupHeight) + 'px'; // this fixes gap below tabs
            }

            if (payload.breakpoint == 'desktop' || payload.breakpoint == 'tablet-landscape') {
                els.el.style.bottom = tabGroupHeight + 20 + 'px'; // need to make this more dynamic

                els.el.style.marginBottom = '-' + parseInt(tabGroupHeight) + 'px'; // this fixes gap below tabs

                els.el.style.overflow = 'hidden';
            }
        });
    };

    var setViewportHeight = function setViewportHeight(breadcrumbs) {
        els.viewportInner.style.marginTop = '-' + 1.5 * breadcrumbs + 'px';
    };

    var getPosition = function getPosition(el) {
        return el.getBoundingClientRect().top;
    };

    var handleTabClick = function handleTabClick(clicked) {
        // console.log('/index/ -handleTabClick', clicked);
        // reset selected class
        Array.from(document.querySelectorAll('.tab')).forEach(function (el) {
            el.classList.remove('selected');
        });
        clicked.classList.add('selected');
        var id = clicked.getAttribute('id');
        showTabContent(id);
    };

    var showTabContent = function showTabContent(id) {
        // console.log('/index/ -showTabContent', id);
        var elems = document.querySelectorAll('.tab-content--panel');
        [].forEach.call(elems, function (el) {
            el.classList.remove('active');
        });
        els.tabContent.querySelector("#".concat(id)).classList.add('active'); // scrollTo(els.tabContent, tabContentPos, 500);
        // inject behaviour on first display
        //

        if (findObject(id).loaded == false || findObject(id).loaded == 'undefined') {
            // console.log('/index/ -showTabContent READY?'); // injectBehaviours(els.tabContent.querySelector(`#${id}`)); // only run once per load // TEST

            findObject(id).loaded = true;
        }

        props.events.emit(props.config.eventNames.APP_BREAKPOINT_READY, _objectSpread(_objectSpread({}, props.utils.mediaQueries.getValue()), {}, {
            isArtificialOrigin: true // *** subscriber can interpret this

        }));
    };

    var loadFromApi = function loadFromApi(id, endpoint, destination) {
        // console.log('/index/ -loadFromApi', id, endpoint);
        fetch(endpoint).then(function (response) {
            if (response.ok) {
                return response.text();
            }

            throw new Error('no tab URL found');
        }).then(function (text) {
            if (text != '') {
                destination.querySelector("#".concat(id)).innerHTML = text;
                if (endpoint.toLowerCase().includes('/tabs/education')) {
                    inspectGenericButtonAction();
                }
            }
        })["catch"](function (error) {
            // catch
            console.warn('Request failed', error);
        });
    }; //

    var inspectGenericButtonAction = function inspectGenericButtonAction() {
        var actions = [props.config.eventNames.LAUNCH_POPOVER, props.config.eventNames.CLOSE_POPOVER, 'FOLLOW_LINK', 'AWAIT_FETCH'];

        _toConsumableArray(document.body.querySelectorAll("[data-button-action]")).map(function (item) {
            var action = item.getAttribute('data-button-action');
            if (!action) return;
            var args = props.utils.attributeParser(action, null, 'json');
            var key = Object.keys(args)[0];
            if (!actions.includes(key)) return;
            item.addEventListener('click', function () {
                ////console.log('/popover/ -button click:', key, args[key]);
                props.events.emit(key, {
                    args: args
                });
            });
        });
    }; // *** manage item scripts if present


    var findObject = function findObject(id) {
        // find object in array
        return tabContentObjects.find(function (obj) {
            return obj.tabId == id;
        });
    };


    var outerHeight = function outerHeight(element) {
        // @ja bugfix:: return 0 if no element
        if (!element) return 0;
        var height = element.offsetHeight,
            style = window.getComputedStyle(element);
        return height + parseFloat(style.paddingTop) + parseFloat(style.paddingBottom) + parseFloat(style.borderBottom);
    };

    return {
        init: init
    };
};
/**
 * Component scripts are registered with the core like this.
 * Ensure that the value of `name` is unique, and matches the `data-component` attribute
 * in `index.html` for this component
 */


window.app.add({
    name: 'homepage-tabs',
    // *** ensure unique
    script: script
});

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() { }; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

/**
 * 
 * @param {Object} props - TODO
 * @return {{init: init, foo: foo}}
 */
var script = function script(props) {
    var els = {
        el: null,
        select: null,
        cardstacks: [],
        selectOptions: {}
    }; // *** mandatory function - called by `AbstractComponent` on instantiation

    var init = function init() {
        console.log('/static-dd-module/ -init ', props);
        els.el = props.el;
        els.select = els.el.querySelector("select");
        els.cardstacks = els.el.querySelectorAll(".cardstack.makeDropdown");
        generateSelect(els.cardstacks);
        initDisplay(els.cardstacks);
    };

    var generateSelect = function generateSelect(cardstacks) {
        // generate select
        var _iterator = _createForOfIteratorHelper(cardstacks),
            _step;

        try {
            for (_iterator.s(); !(_step = _iterator.n()).done;) {
                var cardstack = _step.value;
                els.select.insertAdjacentHTML('beforeend', "<option value=\"".concat(cardstack.getAttribute("id"), "\">").concat(cardstack.dataset.selectnamegen, "</option>"));
            }
        } catch (err) {
            _iterator.e(err);
        } finally {
            _iterator.f();
        }

        els.select.firstElementChild.selected = true;
    };

    var initDisplay = function initDisplay(cardstacks) {
        els.cardstacks.item(0).classList.add("active");
        els.select.addEventListener("change", function (e) {
            var _iterator2 = _createForOfIteratorHelper(cardstacks),
                _step2;

            try {
                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
                    var cardstack = _step2.value;
                    cardstack.classList.remove("active");
                }
            } catch (err) {
                _iterator2.e(err);
            } finally {
                _iterator2.f();
            }

            els.el.querySelector("#".concat(e.target.value)).classList.add("active");
        });
    };

    return {
        init: init
    };
};
/**
 * Component scripts are registered with the core like this.
 * Ensure that the value of `name` is unique, and matches the `data-component` attribute
 * in `index.html` for this component
 */


window.app.add({
    name: 'static-dd-module',
    // *** ensure unique
    script: script
});

const MegaMenu = (props) => {
    const els = {};

    const classes = {
        main: 'header__mega-menu',
        isExpanded: 'header__mega-menu--is-expanded',
        inner: 'mega-menu__inner',
        item: 'mega-menu__item',
        itemIsActive: 'mega-menu__item--is-active',
    };

    const state = {
        items: [],
        isExpanded: false,
        currentIndex: null,
    };

    const init = () => {
        els.el = props.el.querySelector(`.${classes.main}`);
        els.inner = props.el.querySelector(`.${classes.inner}`);
        state.items = [...els.el.querySelectorAll(`.${classes.item}`)];
    };

    const update = (itemIndex) => {
        itemIndex = itemIndex - 1; // *** to avoid index: 0 in markup
        if (state.currentIndex === itemIndex) return;
        state.items.map((item, index) => {
            if (index === itemIndex) {
                showItem(item);
                state.currentIndex = itemIndex;
            } else {
                hideItem(item);
            }
        });
    };

    const expand = (item) => {
        let startHeight;
        let time;
        let easeType;
        if (state.isExpanded) {
            startHeight = els.inner.getBoundingClientRect().height;
            time = 0.25;
            easeType = 'power2.in';
        } else {
            startHeight = 0;
            time = props.config.timings.animation.medium() / 1.25;
            easeType = 'power2.out';
        }

        const height = item.getBoundingClientRect().height;

        props.TweenMax.set(els.inner, { height: startHeight, opacity: 1 });
        props.TweenMax.to(els.inner, time, {
            height: `${height}px`,
            opacity: 1,
            ease: easeType,
            onStart: () => {
                state.isExpanded = true;
                els.el.classList.add(classes.isExpanded);
            }
        });
    };

    const collapse = () => {
        const time = props.config.timings.animation.short();

        props.TweenMax.to(els.inner, time, {
            height: 0,
            opacity: 1,
            ease: 'power2.out',
            onStart: () => {
                state.isExpanded = false;
                els.inner.style.overflow = 'hidden';
                state.currentIndex = null;
            },
            onComplete: () => {
                els.el.classList.remove(classes.isExpanded);
            },
        });
    };

    const showItem = (item) => {
        const time = props.config.timings.animation.medium();
        const delay = props.config.timings.animation.short() / 2;
        const child = item.children[0];

        props.TweenMax.set(child, { opacity: 0, y: '-70px', scale: 1 });
        props.TweenMax.to(child, time, {
            opacity: 1,
            y: 0,
            ease: 'power1.out',
            delay,
            onStart: () => {
                item.classList.add(classes.itemIsActive);
                expand(item);
            },
        });
    };

    const hideItem = (item) => {
        const time = props.config.timings.animation.medium() / 1.25;
        const child = item.children[0];
        const delay = 0;

        props.TweenMax.to(child, time, {
            opacity: 0,
            y: '+40px',
            scale: 0.97,
            ease: 'power2.out',
            delay,
            onStart: () => { },
            onComplete: () => {
                item.classList.remove(classes.itemIsActive);
            },
        });
    };

    return {
        init,
        update,
        collapse,
    };
};

const SearchResults = (props) => {

    const els = {
        main: null,
        inner: null,

        mobileHeader: null,
    };

    const classes = {
        main: 'search-results',
        inner: 'search-results__inner',
        isActive: 'search-results--is-active',
        mobileHeader: 'mobile-header',
    };

    const state = {
        isMobile: false,
    };

    const init = () => {
        els.main = props.el.querySelector(`.${classes.main}`);
        els.inner = els.main.querySelector(`.${classes.inner}`);
        els.mobileHeader = props.el.querySelector(`.${classes.mobileHeader}`);

        props.events.on(props.config.eventNames.APP_BREAKPOINT_READY, (payload) => {
            state.isMobile = (payload.breakpoint === 'mobile');
        });
    };

    const update = () => {
        //console.log('/SearchResults/ -update');
    };

    const expand = () => {

        if (state.isMobile) {
            expandMobile();
            return;
        }

        // *** fixes some nasty scroll height issue, but need to tidy this up!
        const ref = props.el.querySelector('.search-panel__background-fill');
        const h = ref.getBoundingClientRect().height;
        const viewHeight = window.innerHeight - h;

        const time = props.config.timings.animation.long() / 2;
        const delay = props.config.timings.animation.long() / 1.5;

        props.TweenMax.set(els.main, { height: 0, opacity: 0, y: '-30px' });
        props.TweenMax.to(els.main, time, {
            height: `${viewHeight}px`,
            opacity: 1,
            y: 0,
            ease: 'Expo.inout',
            delay,
            onStart: () => {
                els.main.classList.add(classes.isActive);
                els.inner.scroll(0, 0);
            }
        });
    };

    const collapse = () => {

        if (state.isMobile) {
            collapseMobile();
            return;
        }

        const time = props.config.timings.animation.long() / 2.5;
        const delay = props.config.timings.animation.long() / 4;

        props.TweenMax.to(els.main, time, {
            height: 0,
            opacity: 0,
            y: '-20px',
            ease: 'Expo.out',
            delay,
            onStart: () => {
                els.main.classList.add(classes.isActive);
            }
        });
    };

    const expandMobile = () => {

        const offsetY = els.mobileHeader.getBoundingClientRect().height;
        const y = `-${offsetY * 2}px`;

        // *** fixes some nasty scroll height issue, but need to tidy this up!
        const ref1 = props.el.querySelector('.mobile-header');
        const ref2 = props.el.querySelector('.mobile__search-panel');
        const h = ref1.getBoundingClientRect().height + ref2.getBoundingClientRect().height;
        const viewHeight = window.innerHeight - h;

        const time = props.config.timings.animation.short();

        props.TweenMax.set(els.main, { height: `${viewHeight}px`, opacity: 1, y });
        props.TweenMax.to(els.main, time, {
            y: 0,
            ease: 'Expo.out',
            delay: 0,
            onStart: () => {
                els.main.classList.add(classes.isActive);
                els.inner.scroll(0, 0);
            }
        });
    };

    const collapseMobile = () => {

        const time = 0;

        props.TweenMax.to(els.main, time, {
            height: 0,
            opacity: 0,
            ease: 'Expo.out',
            delay: 0,
            onStart: () => { },
            onComplete: () => {
                els.main.classList.add(classes.isActive);
            }
        });
    };

    return {
        init,
        update,
        expand,
        collapse,
    }
};

const SearchRequest = (props) => {

    const els = {
        input: null,
        submitButton: null,
    };

    const classes = {
        submitButtonIsActive: 'search-panel__button-submit--is-active',
        inputIsBusy: 'search-panel__input--is-busy',
    };

    const state = {
        inputValueDefault: '',
        inputValueCurrent: '',
    };

    const subProps = {
        minLength: 3,
    };

    const init = (options) => {

        if (!props.attributes) {
            //console.warn('/SearchRequest/ -no search props provided!');
            return;
        }

        const { searchUrl, lang, queryKey } = props.attributes;
        const hasQuery = (searchUrl && lang && queryKey);
        if (!hasQuery) {
            //console.warn('/SearchRequest/ -query not declared on header, quitting');
            return;
        }

        els.input = options.input;
        els.submitButton = options.submitButton;

        els.input.addEventListener('keyup', (e) => {
            state.inputValueCurrent = e.target.value;
            toggleUi();
            if (e.keyCode !== 13) return;
            submit();
        });

        els.submitButton.addEventListener('click', (e) => {
            submit();
        });
    };

    const toggleUi = () => {
        if (state.inputValueCurrent.length >= subProps.minLength) {
            els.submitButton.classList.add(classes.submitButtonIsActive);
        } else {
            els.submitButton.classList.remove(classes.submitButtonIsActive);
        }
    };

    const clear = () => {
        state.inputValueCurrent = state.inputValueDefault;
        els.input.value = state.inputValueCurrent;
        toggleUi();
    };

    /**
     *
     * @param expression = optionally passed in from predictive search
     * @return {Promise<void>}
     */
    const submit = async (expression = null) => {

        //console.log('/SearchRequest/ -submit', expression);

        if (expression && expression.value) {
            state.inputValueCurrent = expression.value;
        }

        if (state.inputValueCurrent.length < subProps.minLength) return;
        const { searchUrl, lang, queryKey } = props.attributes;

        // analytics
        analytics.sendIt({ "event": "search", "searchInput": state.inputValueCurrent, "searchLocation": "topNavigation" });

        // *** local testing - i think Justin set up a dev/prod thing, will check but please test with this one
        // const query = `https://mc-00dafe5d-1d07-4fef-8351-590422-cd.azurewebsites.net${searchUrl}#${queryKey}=${state.inputValueCurrent}&lang=${lang}`;
        // *** production
        const query = `${searchUrl}?${queryKey}=${state.inputValueCurrent}&lang=${lang}`;
        window.location.href = query; // *** ~redirect
        els.input.classList.add(classes.inputIsBusy);
        clear();

        // *** API request version...
        /*const fetchOptions = {
          datasource: query,
          caller: props.name,
        };
      
        const data = await props.fetchData(fetchOptions);
        
        if (data.status === 'fail') {
          console.log('/SearchRequest/ -submit FAIL', data);
          els.input.value = data.payload;
        } else {
          console.log('/SearchRequest/ -submit OK', data);
          // *** now what?
        }*/
    };

    return {
        init,
        clear,
        submit,
    }
};

/**
 * example attribute blob on parent root:
 *     data-predictive-search='
 *      {"datasource": "https://uat-cd.smith-nephew.com/en/api/coveo/getcoveoautocompleteresult",
 *      "queryKey1": "SearchText={*}",
 *      "queryKey2": "SearchHub=mainSearch",
 *      "throttleMs": "333"}'
 *
 * TODO restrict special chars? handle empty string?
 * @param props
 * @param _els
 * @return {{init: init}}
 * @constructor
 */

const PredictiveSearch = (props, _els) => {

    let els = {};

    const classes = {
        panel: 'predictive-search-results',
        panelIsActive: 'predictive-search-results--is-active',
        inner: 'predictive-search-results__inner',
        item: 'predictive-search-results__item',
        itemLabel: 'predictive-search-results__item__label',
        itemLabelHighlight: 'predictive-search-results__item__label--highlight',
    };

    const state = {
        inputValue: '',
        panelIsActive: false,
        submitCallback: null,
        isMobile: false,
    };

    const subProps = {
        replaceChar: '{*}',
        submitDelayMs: 333, // *** pause before firing off to submit callback, feels like slightly better ux
        timer: null,
        throttleMs: 0,
        datasource: null,
        queryKey1: null,
        queryKey2: null,
    };

    /**
     *
     * @param submitCallback = fn to route user selection to submit (in SearchRequest.js)
     */
    const init = (submitCallback) => {

        els = _els;
        state.submitCallback = submitCallback; // *** from parent

        // console.log('/PredictiveSearch/ -init', props, els);

        // *** parse @data-predictive-search on parent root
        const attr = props.el.getAttribute('data-predictive-search');
        if (!attr) {
            //console.warn('/PredictiveSearch/ -init --please configure @data-predictive-search, quitting');
            return;
        }

        const parsedAttr = props.utils.attributeParser(attr, null, 'json');
        subProps.datasource = parsedAttr['datasource'] || null;
        subProps.queryKey1 = parsedAttr['queryKey1'] || null;
        subProps.queryKey2 = parsedAttr['queryKey2'] || null;
        subProps.throttleMs = parseInt(parsedAttr['throttleMs'] || 0, 10);
        // *** TODO more safety checks?

        scaffold();

        els.input.addEventListener('keyup', (e) => {
            if (validate()) {
                startTimer();
            }
        });

        props.events.on(props.config.eventNames.APP_BREAKPOINT_READY, (payload) => {
            state.isMobile = (payload.breakpoint === 'mobile');
        });

        document.body.addEventListener('click', (e) => {
            const isThis = e.target.classList.contains(classes.panel);
            if (!isThis) toggleExpand(false);
        });
    };


    const scaffold = () => {

        els.panel = props.el.querySelector(`.${classes.panel}`);

        // *** TODO remove duplicate inner

        const stub = document.createElement('div');
        stub.innerHTML = `<div class="${classes.inner}"></div>`;

        els.inner = stub.firstElementChild;
        els.panel.append(els.inner);
    };


    // *** add validation rules here if required
    const validate = () => {

        let isValid = true;
        state.inputValue = els.input.value;
        if (state.inputValue.length === 0) isValid = false;

        if (!isValid) {
            toggleExpand(false);
        }

        return isValid;
    };

    // *** throttle requests
    const startTimer = () => {
        clearTimeout(subProps.timer);
        subProps.timer = setTimeout(() => {
            dispatch();
        }, subProps.throttleMs);

    };

    // *** call api and handle response
    const dispatch = () => {

        const { datasource, queryKey1, queryKey2, replaceChar } = subProps;

        const formQuery = () => {
            return queryKey1.replace(replaceChar, state.inputValue);
        };

        const fetchOptions = {
            datasource: `${datasource}?${formQuery()}&${queryKey2}`,
            caller: props.name,
        };

        const call = async () => {
            const data = await props.fetchData(fetchOptions);
            if (data.status === 'fail') {
                //console.warn('/PredictiveSearch/ -submit FAIL', data);
                // toggleExpand(false);
            } else {
                update(data);
            }
        };
        call();
    };

    const update = (data) => {

        // *** clear items
        while (els.inner.lastChild) {
            els.inner.removeChild(els.inner.lastChild);
        }

        const results = data.payload.Result.completions;

        if (!results.length) {
            toggleExpand(false);
            return;
        }

        results.map((item) => {
            const itemEl = renderItemTemplate(item);
            els.inner.appendChild(itemEl);

            itemEl.addEventListener('click', () => {
                onItemSelected(item);
            });
        });

        toggleExpand(true);
    };

    const onItemSelected = (item) => {
        els.input.value = item.expression;

        // *** pause submission (for effect), allows user to see input field text reflect the suggestion they just clicked on
        setTimeout(() => {
            state.submitCallback({
                value: item.expression,
                origin: 'predictive-search',
            });
        }, subProps.submitDelayMs);

        toggleExpand(false);
    };

    const renderItemTemplate = (item) => {

        const getLabel = () => {

            let s1 = item.highlighted.match(/{(.*?)}/g) || []; // *** between {.}
            let s2 = item.highlighted.match(/\[(.*?)\]/g) || []; // *** between [.]
            let finalLabel = item.highlighted;
            // *** remove delimiters manually, ios safari doesn't support regex lookahead...
            if (s1[0]) {
                let markedUpLabel = s1[0].replaceAll('{', `<span class="${classes.itemLabelHighlight}">`).replace('}', `</span>`);
                finalLabel = finalLabel.replaceAll(s1[0], markedUpLabel);
            }
            if (s2[0]) {
                finalLabel = finalLabel.replaceAll('[', '');
                finalLabel = finalLabel.replaceAll(']', '');
            }

            if (s1[0]) {
                return finalLabel
            }
            return `<span class="${classes.itemLabelHighlight}">${item.expression}</span>`
        };

        const stub = document.createElement('div');
        const tmpl = `
      <div class="${classes.item}">
        <span class="sn-icon-search"></span>
        <div class="${classes.itemLabel}">
          ${getLabel()}
        </div>
      </div>
    `;

        stub.innerHTML = tmpl;
        return stub.firstElementChild;
    };

    const setPanelWidth = () => {
        if (state.isMobile) return;
        const rect = els.inputWrapper.getBoundingClientRect();
        els.panel.style.width = `${rect.width}px`;
    };

    const toggleExpand = (bool) => {
        const time = props.config.timings.animation.short();

        if (bool) {
            props.TweenMax.to(els.panel, time / 2, {
                opacity: 1,
                onStart: () => {
                    els.panel.classList.add(classes.panelIsActive);
                    setPanelWidth();
                }
            });
            return;
        }

        props.TweenMax.to(els.panel, time, {
            opacity: 0,
            onComplete: () => {
                els.panel.classList.remove(classes.panelIsActive);
            }
        });
    };

    return {
        init,
        toggleExpand,
    }
};

const SearchHead = (props) => {

    const els = {
        main: null,
        fill: null,
        searchButton: null,
        inputWrapper: null,
        input: null,
    };

    const classes = {
        parent: 'user-nav__search-panel',
        main: 'search-panel__inner',
        fill: 'search-panel__background-fill',
        searchButton: 'search-panel__button',
        searchButtonCloseState: 'search-panel__button--close-state',
        searchInputWrapper: 'search-panel__input-wrapper',
        isActive: 'user-nav__search-panel--is-active',
        preventScroll: 'scrolling--prevent',

        headerSearchIsActive: 'header--search-is-active', // *** for mobile header ui

        submitButton: 'search-panel__button-submit',

        // *** for calculations only
        globalNav: 'header__global-nav',
        breadcrumbs: 'breadcrumbs',
    };

    const state = {
        isExpanded: false,
        defaultHeight: null,
    };

    const components = {
        searchResults: null,
        searchRequest: null,
        predictiveSearch: null,
    };

    const init = () => {
        //console.log('/SearchHead/ -init', props);

        els.parent = props.el.querySelector(`.${classes.parent}`);
        els.main = props.el.querySelector(`.${classes.main}`);
        els.searchButton = props.el.querySelector(`.${classes.searchButton}`);
        els.inputWrapper = props.el.querySelector(`.${classes.searchInputWrapper}`);
        els.submitButton = props.el.querySelector(`.${classes.submitButton}`);
        els.input = els.inputWrapper.querySelector('input');

        els.fill = document.createElement('div');
        els.fill.classList.add(classes.fill);
        els.main.append(els.fill);

        components.searchResults = SearchResults(props);
        components.searchResults.init();

        components.searchRequest = SearchRequest(props);
        components.searchRequest.init({
            input: els.input,
            submitButton: els.submitButton,
        });

        components.predictiveSearch = PredictiveSearch(props, {
            input: els.input,
            inputWrapper: els.inputWrapper,
        });
        components.predictiveSearch.init(forceSubmit); // *** pass in callback to route user selection to fire request
    };

    const forceSubmit = (data) => {
        //console.log('/SearchHead/ -forceSubmit', data);
        components.searchRequest.submit(data);
    };

    /**
     *
     * @param action
     * @param callback - inform index.js of state change
     */
    const update = (action, callback) => {

        if (!state.isExpanded) {
            disableScrolling(true);
            expand();
            components.searchResults.expand();
            callback({ searchIsActive: true });

        } else {
            disableScrolling(false);
            collapse();
            components.searchResults.collapse();
            components.searchRequest.clear();
            components.predictiveSearch.toggleExpand(false);
            callback({ searchIsActive: false });
        }
    };

    const disableScrolling = (bool) => {
        if (bool) {
            document.body.classList.add(classes.preventScroll);
        } else {
            document.body.classList.remove(classes.preventScroll);
        }
    };

    /**
     * EXPAND
     */
    const expand = () => {

        const globalNavRect = props.el.querySelector(`.${classes.globalNav}`).getBoundingClientRect();
        const headerRect = props.el.getBoundingClientRect();

        // *** defense - breadcrumbs may not be present
        const breadcrumbsEl = props.el.querySelector(`.${classes.breadcrumbs}`);
        let breadcrumbsHeight = 0;
        if (breadcrumbsEl) breadcrumbsHeight = breadcrumbsEl.getBoundingClientRect().height;


        state.defaultHeight = els.main.getBoundingClientRect().height;

        const height = `${headerRect.height - breadcrumbsHeight}px`;
        const yOffset = `${-globalNavRect.height}px`;

        const totalTime = props.config.timings.animation.long() / 1.5;
        const time1 = totalTime / 1.25;
        const time2 = totalTime / 3;

        // *** setup
        props.TweenMax.set(els.fill, {
            transformOrigin: 'right top',
            skewX: 30,
            height: state.defaultHeight,
            y: 0,
        });

        // *** fill slide
        props.TweenMax.to(els.fill, time1, {
            width: '100%',
            height: `${height - 10}px`,
            ease: 'Back.inout',
            skewX: 0,
            onStart: () => {
                state.isExpanded = true; // *** set state
                els.parent.classList.add(classes.isActive);
                props.el.classList.add(classes.headerSearchIsActive);
                els.searchButton.style.pointerEvents = 'none';
            },
            onComplete: () => {
                els.searchButton.style.pointerEvents = 'all';
                els.searchButton.classList.add(classes.searchButtonCloseState);
            }
        });

        // *** fill y
        props.TweenMax.to(els.fill, time2, {
            height,
            y: yOffset,
            ease: 'Expo.inout',
            delay: time1,
        });

        // *** fadein input
        props.TweenMax.set(els.inputWrapper, { opacity: 0 });
        props.TweenMax.to(els.inputWrapper, time1, {
            opacity: 1,
            ease: 'Expo.out',
            delay: time1,
            onComplete: () => {
                els.input.focus();
            }
        });
    };

    /**
     * COLLAPSE
     */
    const collapse = () => {

        const totalTime = props.config.timings.animation.long() / 1.3;
        const time1 = totalTime / 1.25;

        // *** slide out fill
        props.TweenMax.set(els.fill, {
            transformOrigin: 'right top',
            skewX: 0,
        });
        props.TweenMax.to(els.fill, totalTime, {
            width: 0,
            skewX: 30,
            ease: 'Expo.in',
            onStart: () => {
                state.isExpanded = false; // *** set state
                els.parent.classList.remove(classes.isActive);
                props.el.classList.remove(classes.headerSearchIsActive);
                els.searchButton.classList.remove(classes.searchButtonCloseState);
                els.searchButton.style.pointerEvents = 'none';
            },
            onComplete: () => {
                els.searchButton.style.pointerEvents = 'all';
            }
        });

        // *** fade out input
        props.TweenMax.to(els.inputWrapper, time1 / 2, {
            opacity: 0,
            ease: 'Expo.out',
            delay: 0,
        });
    };

    return {
        init,
        update,
    }
};

const Mobile = (props) => {

    const els = {

        hamburgerButton: null,
        inner: null,

        input: null,
        submitButton: null,

        inputWrapper: null,
    };

    const components = {
        searchRequest: null,
        predictiveSearch: null,
    };

    const classes = {
        preventScroll: 'scrolling--prevent',
        inner: 'header__inner',
        hamburgerButton: 'mobile-header__hamburger-button',
        mobileMenuExpanded: 'header--mobile__is-expanded',

        input: 'mobile__search-panel__input',
        submitButton: 'mobile__search-panel__button-submit',

        inputWrapper: 'mobile__search-panel__input-wrapper',
    };

    const state = {
        isMobile: false,
        isMobileMenuExpanded: false,
    };

    const init = () => {

        props.events.on(props.config.eventNames.APP_BREAKPOINT_READY, (payload) => {
            state.isMobile = (payload.breakpoint === 'mobile');
        });

        els.inner = props.el.querySelector(`.${classes.inner}`);
        els.hamburgerButton = props.el.querySelector(`.${classes.hamburgerButton}`);

        els.input = props.el.querySelector(`.${classes.input}`);
        els.submitButton = props.el.querySelector(`.${classes.submitButton}`);

        els.inputWrapper = props.el.querySelector(`.${classes.inputWrapper}`);

        components.searchRequest = SearchRequest(props);
        components.searchRequest.init({
            input: els.input,
            submitButton: els.submitButton,
        });

        components.predictiveSearch = PredictiveSearch(props, {
            input: els.input,
            inputWrapper: els.inputWrapper,
        });
        components.predictiveSearch.init(forceSubmit); // *** pass in callback to route user selection to fire request

        els.hamburgerButton.addEventListener('click', (e) => {
            if (!state.isMobileMenuExpanded) {
                expand();
                disableScrolling(true);
            } else {
                collapse();
                disableScrolling(false);
                components.searchRequest.clear();
            }
        });
    };

    const forceSubmit = (data) => {
        //console.log('/Mobile/ -forceSubmit', data);
        components.searchRequest.submit(data);
    };

    const update = (action) => {
        if (!state.isMobile) return;
        if (action['searchIsActive']) {
            collapse();
            components.searchRequest.clear();
        }
    };

    const expand = () => {

        const time = props.config.timings.animation.medium() / 1.5;

        props.TweenMax.set(els.inner, { height: 0 });
        props.TweenMax.to(els.inner, time, {
            height: '100vh',
            ease: 'Expo.inout',
            onStart: () => {
                state.isMobileMenuExpanded = true;
                props.el.classList.add(classes.mobileMenuExpanded);
            },
            onComplete: () => {
                els.input.focus();
            }
        });
    };

    const collapse = () => {
        const time = props.config.timings.animation.medium() / 2;

        props.TweenMax.to(els.inner, time, {
            height: 0,
            ease: 'Expo.inout',
            onStart: () => { },
            onComplete: () => {
                state.isMobileMenuExpanded = false;
                props.el.classList.remove(classes.mobileMenuExpanded);
            }
        });
    };

    const disableScrolling = (bool) => {
        if (bool) {
            document.body.classList.add(classes.preventScroll);
        } else {
            document.body.classList.remove(classes.preventScroll);
        }
    };

    return {
        init,
        update,
    }

};

const LoginControl = (props) => {

    const classes = {
        loggedIn: 'user-nav__logged-in',
        expandButton: 'user-nav__profile-options-button',
        expandedView: 'user-nav__logged-in__options',
        expandedViewIsActive: 'user-nav__logged-in__options--is-expanded',
    };

    const els = {
        el: null,
        expandButton: null,
        expandButtonClone: null,
        expandedView: null,
    };

    const state = {
        isEnabled: false,
        isExpanded: false,
    };

    const init = () => {
        els.el = props.el.querySelector(`.${classes.loggedIn}`);

        if (!els.el) return; // *** user logged out, quit

        state.isEnabled = true;

        els.expandButton = els.el.querySelector(`.${classes.expandButton}`);
        els.expandedView = els.el.querySelector(`.${classes.expandedView}`);
        els.expandButtonClone = els.expandButton.cloneNode(true);
        els.expandButtonClone.classList.add(`${classes.expandButton}--clone`);

        els.expandedView.prepend(els.expandButtonClone);

        els.expandButton.addEventListener('click', () => {
            toggleExpand(true);
        });

        els.expandButtonClone.addEventListener('click', () => {
            toggleExpand(false);
        });
    };

    const toggleExpand = (bool) => {

        if (!state.isEnabled) return;

        const time = props.config.timings.animation.short();

        if (bool) {
            props.TweenMax.to(els.expandedView, time, {
                opacity: 1,
                onStart: () => {
                    els.expandedView.classList.add(classes.expandedViewIsActive);
                }
            });
            return;
        }

        props.TweenMax.to(els.expandedView, time / 2, {
            opacity: 0,
            onComplete: () => {
                els.expandedView.classList.remove(classes.expandedViewIsActive);
            }
        });
    };

    return {
        init,
        toggleExpand,
    }
};

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var script = function script(props) {
    var els = {
        pillarNav: null,
        searchButton: null,
        mobileSearchButton: null
    };
    var components = {
        megaMenu: null,
        search: null,
        mobile: null,
        loginControl: null
    };
    var state = {
        pillarNavButtons: []
    };
    var classes = {
        pillarNavButton: 'pillar-nav__button',
        pillarNavButtonSelected: 'pillar-nav__button--selected',
        megaMenuItem: 'mega-menu__item',
        searchButton: 'search-panel__button',
        mobileSearchButton: 'mobile-header__search-panel__button',
        isInitialising: 'header--is-initialising',
        enableAnimationFlag: 'feature--header-animation',
        loginControlButton: 'user-nav__profile-options-button'
    };

    var init = function init() {
        // console.log('/header/ -init', props);
        components.megaMenu = MegaMenu(props);
        components.megaMenu.init();
        components.search = SearchHead(props);
        components.search.init();
        components.mobile = Mobile(props);
        components.mobile.init();
        components.loginControl = LoginControl(props);
        components.loginControl.init();
        props.events.on(props.config.eventNames.APP_BREAKPOINT_READY, function (payload) { }); // *** click off listener to close open items

        document.body.addEventListener('click', function (e) {
            var isPillarNav = e.target.classList.contains(classes.pillarNavButton);
            var isMegaMenuItem = e.target.classList.contains(classes.megaMenuItem);
            var isLoginControl = false;

            try {
                isLoginControl = e.target.parentNode.classList.contains(classes.loginControlButton);
            } catch (e) {// *** do nothing, catches strange misfire when clicking on accordion tab
            }

            if (!isPillarNav && !isMegaMenuItem && !isLoginControl) {
                collapseElements();
            }

            if (isPillarNav) components.loginControl.toggleExpand(false); // TODO slight overlap, might need to force a delay

            if (isLoginControl) {
                components.megaMenu.collapse();
                updatePillarNavSelection(0);
            }
        });
        window.addEventListener('scroll', function (e) {
            collapseElements();
        });

        var collapseElements = function collapseElements() {
            components.megaMenu.collapse();
            components.loginControl.toggleExpand(false);
            updatePillarNavSelection(0);
        }; // @as TODO close meganav on scroll


        initPillarNav();
        initSearchPanel(); // *** animation is enabled by inclusion of 'feature--header-animation' class on body
        initCorporatePageLink(); // open confirmation popup for corporate page link
        showCustomerPortalLink(); //Checking customer portal Link based on Cookie
        if (document.body.classList.contains(classes.enableAnimationFlag)) {
            tweenIn();
        } else {
            props.el.classList.remove(classes.isInitialising);
        }
    };

    var tweenIn = function tweenIn() {
        var time = props.config.timings.animation.longest() * 1.3;
        var predelay = time / 4;
        var inner = props.el.querySelector('.header__inner');

        var children = _toConsumableArray(inner.children).reverse();

        props.TweenMax.set(props.el, {
            y: '-150px'
        });
        props.TweenMax.to(props.el, time, {
            y: 0,
            opacity: 1,
            // ease: 'Sine.out',
            ease: 'expo.out',
            delay: 0
        });
        children.map(function (item, index) {
            props.TweenMax.set(item, {
                y: '+40px',
                opacity: 0
            });
            props.TweenMax.to(item, time / 1.5, {
                y: 0,
                opacity: 1,
                // ease: 'Sine.out',
                ease: 'expo.out',
                delay: predelay + index / 8
            });
        });
        props.el.classList.remove(classes.isInitialising);
    };

    var showCustomerPortalLink = function showCustomerPortalLink() {
        const cookieArr = document.cookie.split(';');
        const customerPortalLink = 'CustomerPortalUser='
        for (let i = 0; i < cookieArr.length; i++) {
            let cookieName = cookieArr[i];
            while (cookieName.charAt(0) == ' ') {
                cookieName = cookieName.substring(1);
            }
            if (cookieName.indexOf(customerPortalLink) !== -1 && cookieName.substring(customerPortalLink.length, cookieName.length) == 'true') {
                const customerPortalLinkEl = document.getElementById('customer-portal-link');
                if (customerPortalLinkEl) {
                    customerPortalLinkEl.style.display = 'flex'
                }
            }
        }
    }

    var initCorporatePageLink = function initCorporatePageLink() {
        const corporatePageLinks = [...document.querySelectorAll('[data-corporate-page-link="true"]')];
        corporatePageLinks.map((item) => {
            item.onclick = function () {
                props.events.emit('LAUNCH_POPOVER', {
                    args: {
                        "LAUNCH_POPOVER": 'language-confirmation',
                    },
                });
                const languageConfirmationYes = document.getElementById('language-confirmation-yes');
                const languageConfirmationText = document.getElementById('languageConfirmationText');
                const confirmationPopupText = document.getElementById('confirmationPopupText');
                if (item.dataset.languageConfirmationText) {
                    languageConfirmationText.innerHTML = `${item.dataset.languageConfirmationText}`
                } else if (confirmationPopupText && confirmationPopupText.value) {
                    languageConfirmationText.innerHTML = confirmationPopupText.value;
                }
                languageConfirmationYes.dataset.redirectionUrl = `${item.dataset.redirectionUrl}`;
                languageConfirmationYes.dataset.corporatePageLink = `${item.dataset.corporatePageLink}`;
            }
        })
    }

    var initPillarNav = function initPillarNav() {
        state.pillarNavButtons = _toConsumableArray(props.el.querySelectorAll(".".concat(classes.pillarNavButton)));
        state.pillarNavButtons.map(function (item, index) {
            item.addEventListener('click', function (e) {
                onSelection(item);
            });
        });

        var onSelection = function onSelection(target) {
            var action = props.utils.attributeParser(target.getAttribute('data-button-action'));
            components.megaMenu.update(action.index);
            updatePillarNavSelection(action.index);
        };
    }; // *** pass 0 to clear all


    var updatePillarNavSelection = function updatePillarNavSelection(index) {
        // console.log('/index/ -updatePillarNavSelection', index);
        state.pillarNavButtons.map(function (item, itemIndex) {
            if (itemIndex === index - 1) {
                item.classList.add(classes.pillarNavButtonSelected);
            } else {
                item.classList.remove(classes.pillarNavButtonSelected);
            }
        });
    };

    var initSearchPanel = function initSearchPanel() {
        els.searchButton = props.el.querySelector(".".concat(classes.searchButton));
        els.mobileSearchButton = props.el.querySelector(".".concat(classes.mobileSearchButton)); // *** desktop

        els.searchButton.addEventListener('click', function (e) {
            var action = props.utils.attributeParser(e.currentTarget.getAttribute('data-button-action'));
            components.search.update(action, function (state) {
                analyticsHandler(state);
            });
        }); // *** mobile

        els.mobileSearchButton.addEventListener('click', function (e) {
            var action = props.utils.attributeParser(e.currentTarget.getAttribute('data-button-action'));
            components.search.update(action, function (args) {
                components.mobile.update(args); // *** will cause mobile nav to close if currently open

                analyticsHandler(args);
            });
        });
    }; // here for now


    var analyticsHandler = function analyticsHandler(state) {
        if (state.searchIsActive) {
            analytics.sendIt({
                "event": "startSearch",
                "searchLocation": 'topNavigation'
            });
        } else {
            analytics.sendIt({
                "event": "closeSearch",
                "searchLocation": 'topNavigation'
            });
        }
    };

    return {
        init: init
    };
};

window.app.add({
    name: 'header_4348986efc58',
    // *** ensure unique
    script: script
});

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var script = function script(props) {
  var els = {
    el: null,
    textBlock: null,
    cardstack: null,
    spinner: null
  };
  var state = {
    currentApiId: null
  };
  var subProps = {
    paginator: null
  };

  var init = function init() {
    els.el = props.el;
    els.textBlock = els.el.querySelector('.text-block');
    els.cardstack = els.el.querySelector('.cardstack');
    els.spinner = document.createElement('div');
    els.spinner.classList.add('spinner');
    els.spinner.classList.add('ellipsis-spinner');
    els.el.insertBefore(els.spinner, els.cardstack); // *** from hero dropdown

    props.events.on(props.config.eventNames.HERO_DROPDOWN_SELECTION, function (payload) {
      state.currentApiId = payload.selection.id;
      getData({
        id: state.currentApiId,
        pageNumber: 1
      });
      updateTextBlock(payload.selection);
    }); // from paginator

    props.events.on('BEHAVIOUR_BINDING_SIGNAL', function (payload) {
      if (payload.sender !== subProps.paginator.getOptions().config.uid) return;
      getData({
        id: state.currentApiId,
        pageNumber: payload.data.pageNumber
      });
    }); // *** for spinner

    props.events.on(props.config.eventNames.APP_NETWORK_ACTIVITY, function (payload) {
      if (payload.caller !== props.name) return;

      switch (payload.state) {
        case 'start':
          els.spinner.classList.add('spinner--is-active');
          break;

        case 'end':
          els.spinner.classList.remove('spinner--is-active');
          break;
      }
    });
  }; // *** called on event change


  var getData = function getData(options) {
    var fetchOptions = {
      datasource: "".concat(props.attributes.datasource),
      caller: props.name
    }; // *** base request for new API schema, update 'PageNumber' dynamically

    var requestParams = props.requestModel.format({
      Key: props.attributes.key,
      Values: options.id,
      Paginate: props.attributes.paginate,
      PageSize: props.attributes.pageSize,
      PageNumber: options.pageNumber
    }); // *** make api call, and generate content via frontend/alchemy-templates.js

    var fetchData = /*#__PURE__*/function () {
      var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
        var data;
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return props.fetchData(fetchOptions, requestParams);

              case 2:
                data = _context.sent;
                updateList(data.payload.Result, props.attributes.template);
                updatePaginator(data.payload);

              case 5:
              case "end":
                return _context.stop();
            }
          }
        }, _callee);
      }));

      return function fetchData() {
        return _ref.apply(this, arguments);
      };
    }();

    if (props.attributes.datasource) {
      fetchData();
    }
  };

  var updatePaginator = function updatePaginator(data) {
    if (!subProps.paginator) {
      subProps.paginator = props.getBehaviour(props.el.querySelector('.paginator'));
    }

    subProps.paginator.update(data, state.currentApiId);
  };

  var updateTextBlock = function updateTextBlock(data) {
    // console.log('/index/ -updateTextBlock', data);
    var time = props.config.timings.animation["short"](); // *** fade out and update content

    props.TweenMax.to(els.textBlock, time, {
      opacity: 0,
      onComplete: function onComplete() {
        els.textBlock.innerHTML = "\n          <h2>".concat(data.title || '', "</h2>\n          <div class=\"paragraphs\">\n            <p>").concat(data.description || '', "</p>\n          </div>\n      ");
      }
    }); // *** fade back in

    props.TweenMax.to(els.textBlock, time, {
      opacity: 1,
      delay: time,
      onStart: function onStart() {
        props.el.scrollIntoView();
      }
    });
  };

  var updateList = function updateList(data, template) {
    console.log('/index/ -update', data);
    var jsonMap = props.utils.attributeParser(props.el.getAttribute('data-json-mapping'));
    var nodes = data.map(function (item) {
      return window.alchemyTemplates.getTemplate({
        type: template || '',
        map: jsonMap,
        parent: props.el
      }, item);
    });
    var time = props.config.timings.animation["short"](); // *** fade out container

    props.TweenMax.to(els.cardstack, time, {
      opacity: 0,
      onComplete: function onComplete() {
        // *** destroy
        _toConsumableArray(els.cardstack.children).map(function (item) {
          item.remove();
        }); // *** create


        nodes.map(function (item) {
          els.cardstack.append(item);
        });
      }
    }); // *** fade in container

    props.TweenMax.to(els.cardstack, time, {
      opacity: 1,
      delay: time,
      onStart: function onStart() {
        props.el.scrollIntoView();
      }
    });
  };

  return {
    init: init
  };
};

window.app.add({
  name: 'treatmentOptionsBody_a2df88c3d3ae',
  // *** ensure unique
  script: script
});

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var script = function script(props) {
  var els = {
    el: null,
    textBlock: null,
    cardstack: null,
    spinner: null
  };
  var state = {
    currentApiId: null
  };
  var subProps = {
    paginator: null
  };

  var init = function init() {
    els.el = props.el;
    els.textBlock = els.el.querySelector('.text-block');
    els.cardstack = els.el.querySelector('.cardstack');
    els.spinner = document.createElement('div');
    els.spinner.classList.add('spinner');
    els.spinner.classList.add('ellipsis-spinner');
    els.el.insertBefore(els.spinner, els.cardstack);
    console.log('*** /index/ -init HCP', props.name);
    props.events.on(props.config.eventNames.HERO_DROPDOWN_SELECTION, function (payload) {
      console.log('/index/ -HERO_DROPDOWN_SELECTION', payload);
      state.currentApiId = payload.selection.id;
      getData({
        id: payload.selection.id
      });
      updateTextBlock(payload.selection);
    }); // from paginator

    props.events.on('BEHAVIOUR_BINDING_SIGNAL', function (payload) {
      if (payload.sender !== subProps.paginator.getOptions().config.uid) return;
      getData({
        id: state.currentApiId,
        pageNumber: payload.data.pageNumber
      });
    });
    props.events.on(props.config.eventNames.APP_NETWORK_ACTIVITY, function (payload) {
      if (payload.caller !== props.name) return;

      switch (payload.state) {
        case 'start':
          els.spinner.classList.add('spinner--is-active');
          break;

        case 'end':
          els.spinner.classList.remove('spinner--is-active');
          break;
      }
    });
  };

  var getData = function getData(options) {
    var fetchOptions = {
      datasource: "".concat(props.attributes.datasource),
      caller: props.name
    }; // *** base request for new API schema, update 'PageNumber' dynamically

    var requestParams = props.requestModel.format({
      Key: props.attributes.key,
      Values: options.id,
      Paginate: props.attributes.paginate,
      PageSize: props.attributes.pageSize,
      PageNumber: options.pageNumber
    }); // *** make api call, and generate content via frontend/alchemy-templates.js

    var fetchData = /*#__PURE__*/function () {
      var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
        var data;
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return props.fetchData(fetchOptions, requestParams);

              case 2:
                data = _context.sent;
                updateList(data.payload.Result, props.attributes.template);
                updatePaginator(data.payload);

              case 5:
              case "end":
                return _context.stop();
            }
          }
        }, _callee);
      }));

      return function fetchData() {
        return _ref.apply(this, arguments);
      };
    }();

    if (props.attributes.datasource) {
      fetchData();
    }
  };

  var updatePaginator = function updatePaginator(data) {
    if (!subProps.paginator) {
      subProps.paginator = props.getBehaviour(props.el.querySelector('.paginator'));
    }

    subProps.paginator.update(data, state.currentApiId);
  };

  var updateTextBlock = function updateTextBlock(data) {
    console.log('/index/ -updateTextBlock', data);
    var time = props.config.timings.animation["short"](); // *** fade out and update content

    props.TweenMax.to(els.textBlock, time, {
      opacity: 0,
      onComplete: function onComplete() {
        els.textBlock.innerHTML = "\n          <h2>".concat(data.title || '', "</h2>\n          <div class=\"paragraphs\">\n            <p>").concat(data.description || '', "</p>\n          </div>\n      ");
      }
    }); // *** fade back in

    props.TweenMax.to(els.textBlock, time, {
      opacity: 1,
      delay: time,
      onStart: function onStart() {
        props.el.scrollIntoView();
      }
    });
  };

  var updateList = function updateList(data, template) {
    console.log('/index/ -update', data);
    var jsonMap = props.utils.attributeParser(props.el.getAttribute('data-json-mapping'));
    var nodes = data.map(function (item) {
      return window.alchemyTemplates.getTemplate({
        type: template || '',
        map: jsonMap,
        parent: props.el
      }, item);
    });
    var time = props.config.timings.animation["short"](); // *** fade out container

    props.TweenMax.to(els.cardstack, time, {
      opacity: 0,
      onComplete: function onComplete() {
        // *** destroy
        _toConsumableArray(els.cardstack.children).map(function (item) {
          item.remove();
        }); // *** create


        nodes.map(function (item) {
          els.cardstack.append(item);
        });
      }
    }); // *** fade in container

    props.TweenMax.to(els.cardstack, time, {
      opacity: 1,
      delay: time,
      onStart: function onStart() {
        props.el.scrollIntoView();
      }
    });
  };

  return {
    init: init
  };
};

window.app.add({
  name: 'treatmentOptionsBody_de326844dbbd',
  // *** ensure unique
  script: script
});

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var script = function script(props) {
    var state = {
        showText: 'Show videos',
        hideText: 'Hide videos',
        accordionOpen: true,
        thumbsInitialised: false,
        classes: {
            accordionLabel: '.accordion__tab',
            accordionText: '.accordion__tab-label',
            thumb: '.image-wrapper--video',
            active: 'image-wrapper--active',
            accordionCheckbox: '#video-carousel-1',
            player: 'videoplayer',
            inner: 'videoplayer__inner',
            errorMessage: 'videoplayer__error-message',
            hasError: 'videoplayer--has-error'
        },
        autoOpenAccordion: true
    };
    var els = {
        el: null,
        thumbs: null,
        carousel: null,
        accordionLabel: null,
        accordionText: null,
        accordionCheckbox: null
    };

    var init = function init() {
        els.el = props.el;
        els.accordionLabel = els.el.querySelector(state.classes.accordionLabel);
        els.accordionText = els.el.querySelector(state.classes.accordionText);
        els.carousel = els.el.querySelector('.carousel'); // *** automate accordion expansion

        els.accordionCheckbox = els.el.querySelector(state.classes.accordionCheckbox);
        els.accordionCheckbox.setAttribute('checked', 'yes');
        var text = state.accordionOpen ? state.hideText : state.showText;
        els.accordionText.innerHTML = "<h5>".concat(text, "</h5>");
        els.accordionText.addEventListener('click', function () {
            toggleExpand();
        }, false);

        var toggleExpand = function toggleExpand() {
            console.log('/index/ -toggleExpand');
            state.accordionOpen = !state.accordionOpen;
            var text = state.accordionOpen ? state.hideText : state.showText;
            els.accordionText.innerHTML = "<h5>".concat(text, "</h5>");
        }; // *** use select control events to update carousel


        props.events.on('BEHAVIOUR_BINDING_SIGNAL', function (payload) {
            var carouselUID = els.carousel.getAttribute('data-behaviour-uid');
            if (payload.sender !== carouselUID) return;
            if (payload.type === 'CAROUSEL_UPDATING') primeThumbs();
        });
        addErrorMessage();
    };
    /**
     * @as NOTE prob should add this as a decorator elsewhere
     * controller (such as this file) is responsible for rendering error message
     * in response to `videoplayer--has-error` class which is added by video behaviours
     */


    var addErrorMessage = function addErrorMessage() {
        if (!props.attributes || !props.attributes.errorMessage) {
            // console.warn('/index/ -addErrorMessage NO ERROR DEFINED');
            return;
        } // *** observe when new video is triggered


        var observer = new MutationObserver(function (entries) {
            if (!!entries) {
                var nodes = _toConsumableArray(entries[0].addedNodes);

                if (nodes[0] && nodes[0].nodeName.toLowerCase() === 'div') {
                    if (nodes[0].classList.contains("".concat(state.classes.player))) {
                        exec();
                    }
                }
            }
        });
        observer.observe(els.el, {
            subtree: true,
            childList: true
        }); // *** add markup, consumes props.attributes.errorMessage, e.g. data-component-props="errorMessage: We couldn't play that video"

        var exec = function exec() {
            els.inner = els.el.querySelector(".".concat(state.classes.inner));
            if (els.inner.querySelector(".".concat(state.classes.errorMessage))) return;
            var stub = document.createElement('div');
            var message = document.createElement('p');
            stub.classList.add("".concat(state.classes.errorMessage));
            message.innerText = props.attributes.errorMessage;
            stub.appendChild(message);
            els.inner.appendChild(stub);
        };
    };

    var removeBorders = function removeBorders() {
        els.thumbs.map(function (item) {
            item.classList.remove(state.classes.active);
        });
    };

    var primeThumbs = function primeThumbs() {
        if (state.thumbsInitialised) return;
        state.thumbsInitialised = true;
        els.thumbs = _toConsumableArray(els.el.querySelectorAll(state.classes.thumb));
        els.thumbs[0].classList.add(state.classes.active);
        els.thumbs.map(function (item) {
            item.addEventListener('click', function (e) {
                e.preventDefault();
                removeBorders();
                item.classList.add(state.classes.active);
            });
        });
    };

    return {
        init: init
    };
};

window.app.add({
    name: 'videoCarousel',
    // *** ensure unique
    script: script
});

var script = function script(props) {
    var state = {
        tabIndex: 0
    };
    var els = {
        el: null,
        tabstack: 0
    };

    var init = function init() {
        els.el = props.el;
        els.tabstack = els.el.querySelector('.tabstack');
        props.events.on('BEHAVIOUR_BINDING_SIGNAL', function (payload) {
            var tabstackUID = els.tabstack.getAttribute('data-behaviour-uid');
            if (payload.sender !== tabstackUID) return;

            if (payload.type === 'TABSWITCHER_UPDATING') {
                if (state.tabIndex != payload.data.index) {
                    props.events.emit(props.config.eventNames.PAUSE_OTHER_VIDEOS, {
                        player: 999 // nb set out of range to ignore

                    });
                    state.tabIndex = payload.data.index;
                }
            }
        });
    };

    return {
        init: init
    };
};

window.app.add({
    name: 'videoTabs',
    script: script
});

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var script = function script(props) {
  var init = function init() {
    // *** make api call, and generate content via frontend/alchemy-templates.js
    var fetchData = /*#__PURE__*/function () {
      var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
        var data;
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return props.fetchData(props.attributes);

              case 2:
                data = _context.sent;
                parseData(data.payload.Result, props.attributes);

              case 4:
              case "end":
                return _context.stop();
            }
          }
        }, _callee);
      }));

      return function fetchData() {
        return _ref.apply(this, arguments);
      };
    }();

    if (props.attributes.datasource) {
      fetchData();
    }
  };

  var parseData = function parseData(data, options) {
    var jsonMap = props.utils.attributeParser(props.el.getAttribute('data-json-mapping'));
    var criteria = []; // *** in this case we are splitting data into chunks relative to unique 'RoleId' sets

    data.map(function (item) {
      item[options.key].map(function (id) {
        criteria.push(id);
        return true;
      });
    });
    criteria = _toConsumableArray(new Set(criteria)); // *** unique values only
    // *** chunk data by criteria

    var chunks = criteria.map(function (value) {
      return data.filter(function (item) {
        return item[options.key].includes(value);
      });
    }); // *** build nodes from data

    var nodes = chunks.map(function (chunk) {
      return chunk.map(function (item) {
        return window.alchemyTemplates.getTemplate({
          type: props.attributes.template || '',
          map: jsonMap,
          parent: props.el
        }, item);
      });
    });

    var getLabel = function getLabel(criteria) {
      var values = options.values.filter(function (item) {
        return item[0] === criteria;
      });

      if (values.length > 0) {
        return values[0][1];
      }

      return '...';
    }; // *** wrap output object and return


    var result = nodes.map(function (item, index) {
      return {
        label: getLabel(criteria[index]),
        nodes: nodes[index]
      };
    });
    build(result);
  }; // *** populate behaviours with generated content from api data


  var build = function build(nodes) {
    var defaultIndex = 0; // check if we actually have any nodes...

    var hasNoResults = nodes.length === 0; // if we have nothing dont proceed./

    if (hasNoResults) {
      showNoResults();
      return;
    } else {
      props.el.classList.remove('tabstack--noresults');
    } // *** data to populate tabswitcher and select


    var getTabButtons = function getTabButtons() {
      return nodes.map(function (item) {
        return {
          label: item.label
        };
      });
    }; // *** TABSWITCHER


    var tabSwitcher = props.getBehaviour(props.el.querySelector('.tab-switcher-control'));
    tabSwitcher.inject(getTabButtons(), defaultIndex); // ...
    // *** SELECT

    var selectControl = props.getBehaviour(props.el.querySelector('.select-control'));
    selectControl.inject(getTabButtons(), defaultIndex); // ...
    // *** TABSTACK

    var tabstackEl = props.el.querySelector('.tabstack');
    var tabStack = props.getBehaviour(tabstackEl);
    tabStack.inject(nodes, defaultIndex); // *** @as - a little untidy, but this method is new, should improve the above to use the output of this method
    // *** @as removed (SMIT-2688), reverting to default behaviour (non scrollfader)
    // const tabstackOptions = props.getBehaviourRaw(tabstackEl).options;
    // tabstackOptions.state.selfAnimate = false; // *** causes this tabstack to rely on scrollfader to animate cards
    // ...
    // *** CAROUSEL

    var carousel = props.getBehaviour(props.el.querySelector('.carousel'));

    var updateCarousel = function updateCarousel(index) {
      var data = nodes[index].nodes.map(function (item) {
        return item.cloneNode(true); // *** clone node to use again, otherwise it will be removed from tabstack
      });
      carousel.inject(data);
    }; // *** use select control events to update carousel


    props.events.on('BEHAVIOUR_BINDING_SIGNAL', function (payload) {
      if (payload.sender !== selectControl.getOptions().config.uid) return;
      updateCarousel(payload.data.index);
    });
    updateCarousel(defaultIndex);
  };

  var showNoResults = function showNoResults() {
    // const tabContainer = props.el.querySelector('.tabstack');
    // if nothing comes back from api lets append a message to tell user
    var noResultsDiv = document.createElement('div');
    var resultsText = props.attributes.noresult ? props.attributes.noresult : '';
    noResultsDiv.classList.add('tabstack__no-results');
    noResultsDiv.innerText = resultsText;
    props.el.appendChild(noResultsDiv); // hide anything we dont need with csss, like selects, etc

    props.el.classList.add('tabstack--noresults');
  };

  return {
    init: init
  };
};

window.app.add({
  name: 'adaptiveDynamicTabstack',
  // *** ensure unique
  script: script
});

const SelfDeclaration = (props) => {

    const state = {
        isActive: false,
    };

    const setActive = (bool) => {
        //console.log('/SelfDeclaration/ -setActive', bool);
        state.isActive = bool;
    };

    const init = () => {

        state.isActive = true;

        props.events.on('AWAIT_FETCH', (payload) => {
            //console.log('/SelfDeclaration/ -', state.isActive);
            if (!state.isActive) return;
            //console.log('/popover/ -AWAIT_FETCH', payload.args);
            getData(payload.args);
        });
    };

    const getData = (options) => {

        if (!options.datasource) {
            //console.warn('/SelfDeclaration/ -getData --no datasource, quitting');
            return;
        }

        const fetchOptions = {
            datasource: `${options.datasource}`,
            caller: props.name,
        };
        const requestParams = props.requestModel.format({
            Key: '', Values: '', // *** simple request doesn't need anything
        });

        const fetchData = async () => {
            const data = await props.fetchData(fetchOptions, requestParams);
            //console.log('/SelfDeclaration/ -fetchData --success?', data.payload['Success']);

            if (data.payload['Success']) {
                //console.log('/SelfDeclaration/ -fetchData DONE');

                // redirect to new page url if redirection url is there
                const hcpConfirmationYes = document.getElementById('hcpConfirmationYes');
                const redirectionUrl = hcpConfirmationYes.dataset.redirectionUrl;
                props.events.emit(props.config.eventNames.CLOSE_POPOVER, {
                    args: {
                        CLOSE_POPOVER: 'closed on fetch success',
                        options,
                    }
                })
                if (redirectionUrl) {
                    window.location.href = redirectionUrl;
                }
            }
            // *** do something on failure
        };

        fetchData();
    };


    const destroy = () => {

    };

    return {
        init,
        setActive,
        destroy,
    }
};

const FormChangeEmail = (props) => {
    const els = {
        el: null,
        fields: null,
    };

    const setActive = (bool) => {
    };

    const init = (data) => {
        objectify(data);
        // get the relevant fields
        els.el = props.el.querySelector('form[data-form-type=change-email]');
        if (els.el) {
            els.el.fields = [...els.el.querySelectorAll('input[type=email]')];
        }
        props.events.on(props.config.eventNames.FORM_PARTIAL_SUCCESS, (payload) => {
            if (payload.type !== 'change-email') return;
            closePopup(payload);
            window.location.reload();
            //openCodePopupAndClose(payload);
        });
    };

    const emptyFields = () => {
        if (els.el.fields) {
            els.el.fields.map((item) => {
                item.value = '';
            });
        }
    };

    const closePopup = (data = {}) => {
        emptyFields();
        // close current popup first
        props.events.emit(props.config.eventNames.CLOSE_POPOVER);
    };

    /* This is just for data coming in from the dom element being clicked to launch popup */
    const objectify = (data) => {
        const items = data.split(',');
        items.map((item) => {
            const itemPair = item.split(':');
            itemPair[0].trim();
            itemPair[1].trim();
        });
    };

    return {
        init,
        setActive,
    };
};

const FormChangeEmailCode = (props) => {
    const els = {
        el: null,
        fields: null,
    };

    const state = {
        uid: null,
        isActive: false,
        dataObject: {},
    };

    const setActive = (bool) => {
        state.isActive = bool;
    };

    const init = (data) => {
        // add form id and element id so we can use them later..
        state.dataObject = props.utils.toFlatPropertyMap(data);
        state.isActive = true;
        // get the relevant fields
        els.el = props.el.querySelector('form[data-form-type=change-email-code]');
        if (els.el) {
            els.el.fields = [...els.el.querySelectorAll('input[type=text]')];
        }
        props.events.on(props.config.eventNames.FORM_PARTIAL_SUCCESS, (payload) => {
            if (payload.type !== 'change-email-code') return;
            saveEmailAndClose(payload);
        });
    };

    const emptyFields = () => {
        if (els.el.fields) {
            els.el.fields = [...els.el.querySelectorAll('input[type=text]')];
            els.el.fields.map((item) => {
                item.value = '';
            });
        }
    };

    const saveEmailAndClose = (payload) => {
        emptyFields();
        props.events.emit(props.config.eventNames.CLOSE_POPOVER, {
            data: {
                formId: state.dataObject.formId,
                elementId: state.dataObject.elementId,
                elementValue: state.dataObject['data.Result.Profile.SecondEmail'],
                Success: payload['data']['Success'],
                StatusMessage: payload['data']['StatusMessage'],
            },
        });
    };

    return {
        init,
        setActive,
    };
};

const FormChangePassword = (props) => {
    const els = {
        el: null,
        form: null,
    };

    const state = {
        uid: null,
        isActive: false,
        dataObject: {},
    };

    const setActive = (bool) => {
        state.isActive = bool;
    };

    const init = (data) => {
        state.isActive = true;
        // add form id and element id so we can use them later..
        objectify(data);
        // get the relevant fields
        els.el = props.el.querySelector('form[data-form-type=change-password]');
        if (els.el) {
            els.el.fields = [...els.el.querySelectorAll('input[type=password]')];
        }
        // listen for the form submit event from formController
        props.events.on(props.config.eventNames.FORM_PARTIAL_SUCCESS, (payload) => {
            if (payload.type !== 'change-password') return;
            ClosePopup(payload);
        });
    };

    const emptyFields = () => {
        if (els.el.fields) {
            els.el.fields = [...els.el.querySelectorAll('input[type=password]')];
            els.el.fields.map((item) => {
                item.value = '';
            });
        }
    };

    const ClosePopup = (payload) => {
        emptyFields();
        props.events.emit(props.config.eventNames.CLOSE_POPOVER, {
            data: {
                formId: state.dataObject.formId,
                elementId: state.dataObject.elementId,
                Success: payload['data']['Success'],
                StatusMessage: payload['data']['StatusMessage'],
            },
        });
    };

    /* This is just for data coming in from the dom element being clicked to launch popup */
    const objectify = (data) => {
        const items = data.split(',');
        items.map((item) => {
            const itemPair = item.split(':');
            const key = itemPair[0].trim();
            const val = itemPair[1].trim();
            state.dataObject[key] = val;
        });
    };

    return {
        init,
        setActive,
    };
};

const ProductQuickview = (props) => {

    const classes = {
        title: 'product-quickview__title',
        productDescriptor: 'product-quickview__title__product-descriptor',
        description: 'product-quickview__description',
        imageWrapper: 'image-wrapper__popup',
        ctaButton: 'product-quickview__cta-button',
        ctaButtonLabel: 'product-quickview__cta-button__label',
    };

    const els = {
        el: null,
    };

    const setActive = (bool) => {
        //console.log('/ProductQuickview/ -setActive', bool);
    };

    const init = (options) => {
        update(options, props);
    };

    // ***
    const update = (options, props) => {

        // console.log('/ProductQuickview/ -update --options:', options);
        // console.log('/ProductQuickview/ -update --props:', props);

        els.el = props.el.querySelector(`[data-popover-type="product-quickview"]`);
        els.title = els.el.querySelector(`.${classes.title}`);
        els.description = els.el.querySelector(`.${classes.description}`);
        els.imageWrapper = els.el.querySelector(`.${classes.imageWrapper}`);

        els.title.innerHTML = options.raw.title;
        els.description.innerHTML = options.raw.description;

        els.ctaButton = els.el.querySelector(`.${classes.ctaButton}`);
        els.ctaButton.href = options.raw.url;

        els.ctaButtonLabel = els.ctaButton.querySelector(`.${classes.ctaButtonLabel}`);
        els.ctaButtonLabel.innerText = options.raw.ctaButtonLabel;

        // console.log('/ProductQuickview/ -update --els:', els);

        if (options.raw.productDescriptor) {
            const span = document.createElement('span');
            span.classList.add(classes.productDescriptor);
            span.innerText = options.raw.productDescriptor;
            els.title.append(span);
        }

        // *** image
        const oldImage = els.imageWrapper.querySelector('img');
        if (oldImage) oldImage.remove();
        const image = document.createElement('img');
        image.setAttribute('src', options.raw.image);
        image.setAttribute('alt', options.raw.title);
        els.imageWrapper.appendChild(image);
    };

    const destroy = () => {

    };

    return {
        init,
        setActive,
        update,
        destroy,
    }
};

const PageSharePopOver = (props) => {

    const els = {
        el: null,
        urlField: null,
        copyBtn: null,
    };

    const setActive = (bool) => {
    };

    const init = () => {

        els.el = props.el;
        els.urlField = els.el.querySelector('.share-url-field');
        els.urlField.value = window.location.href;
    };


    return {
        init,
        setActive,
    };
};

// import Behaviours from '../../../core/js/behaviours';

const LanguageSelector = (props) => {

    const els = {
        el: null,
        parentInner: null, // *** for calcs only
        tabstack: null,
    };

    const state = {
        groups: null,
    };

    const classes = {
        group: 'language-selector__group',
        tabstack: 'tabstack',
        selectorItem: 'language-selector__item',
        itemIsEnabled: 'popover__item--is-enabled',
    };

    const setActive = (bool) => {
        state.isActive = bool;
    };


    const init = () => {

        // console.log('/LanguageSelector/ -init', props);

        els.selectorItem = [...document.body.querySelectorAll(`.${classes.selectorItem}`)];

        els.selectorItem.map((item) => {

            item.onclick = function () {
                const languageConfirmationYes = document.getElementById('language-confirmation-yes');
                const languageConfirmationText = document.getElementById('languageConfirmationText');
                languageConfirmationText.innerHTML = `${item.dataset.languageConfirmationText}`
                const redirectionUrl = getRedirectionUrl(item.dataset.redirectionUrl);
                languageConfirmationYes.dataset.redirectionUrl = redirectionUrl;
                const languageSelector = document.querySelector('[data-popover-type="language-selector"]');
                languageSelector.classList.remove(classes.itemIsEnabled);
            }

        })
    }

    // get redirection url
    const getRedirectionUrl = (url) => {
        let redirectionUrl = url;
        const country = localStorage.getItem("country");
        if (country === "true") {
            const productsList = ['allevyn-foam-dressings-new', 'allevyn-adhesive-global', 'allevyn-gentle-border-lite-global', 'allevyn-gentle-border', 'allevyn-life'];
            productsList.forEach(item => {
                if (window.location.pathname.includes(item)) {
                    let pathArr = window.location.pathname.split('/');
                    pathArr.splice(0, 2);
                    const productUrl = pathArr.join('/');
                    redirectionUrl = `${url}${productUrl}`;
                    localStorage.removeItem("country");
                }
            });
        }
        return redirectionUrl;
    }

    // *** invoked on parent animation done, use this optional method if dom inspection required
    const ready = (parentEls, props) => {
        if (!els.parentInner) {
            els.parentInner = parentEls.inner;
        }
        props.events.on(props.config.eventNames.APP_BREAKPOINT_READY, (payload) => {
            setHeights(props);
        });
        setHeights(props);
    };

    const setHeights = (props) => {

        if (!els.el) {
            els.el = document.body.querySelector(`[data-popover-type="language-selector"]`);
            state.groups = [...els.el.querySelectorAll(`.${classes.group}`)];
            els.tabstack = els.parentInner.querySelector(`.${classes.tabstack}`);

            // *** override tabstack defaults and force update
            const tabstackOptions = props.getBehaviourRaw(els.tabstack).options;
            tabstackOptions.state.selfAnimate = true;
            tabstackOptions.state.setHeight = false;
            tabstackOptions.update(0);
        }

        let maxHeight = 0;
        state.groups.map((item) => {
            const h = item.getBoundingClientRect().height;
            if (h > maxHeight) maxHeight = h;
        });

        els.tabstack.style.height = `${maxHeight}px`;
    };

    return {
        init,
        setActive,
        ready,
    };


};

const LanguageConfirmation = (props) => {
    const state = {
        isActive: false,
    };

    const classes = {
        itemIsEnabled: 'popover__item--is-enabled',
    }
    const setActive = (bool) => {

        state.isActive = bool;

    };

    const init = () => {

        // console.log('/LanguageConfirmation/ -init', props);

        const languageConfirmationNo = document.getElementById('language-confirmation-no');
        const languageConfirmationYes = document.getElementById('language-confirmation-yes');

        languageConfirmationYes.onclick = () => {
            onLanguageConfirmation();
        }

        languageConfirmationNo.onclick = function () {

            const languageConfirmationYes = document.getElementById('language-confirmation-yes');
            const corporatePageLink = languageConfirmationYes.dataset.corporatePageLink;
            const isCountryPage = languageConfirmationYes.dataset.iscountryPage;
            if (corporatePageLink === "true") {
                delete languageConfirmationYes.dataset.corporatePageLink;
                props.events.emit(props.config.eventNames.CLOSE_POPOVER, {
                    args: {
                        CLOSE_POPOVER: 'closed confirmation popup'
                    }
                });
            } else if (isCountryPage === "true") {
                delete languageConfirmationYes.dataset.isCountryPage;
                props.events.emit(props.config.eventNames.CLOSE_POPOVER, {
                    args: {
                        CLOSE_POPOVER: 'closed confirmation popup'
                    }
                });
            } else {
                const languageSelector = document.querySelector('[data-popover-type="language-selector"]');
                const languageConfirmation = document.querySelector('[data-popover-type="language-confirmation"]');
                languageConfirmation.classList.remove(classes.itemIsEnabled)
                languageSelector.classList.add(classes.itemIsEnabled);
            }
        }

    }

    const onLanguageConfirmation = async () => {
        const languageConfirmationYes = document.getElementById('language-confirmation-yes');
        const redirectionUrl = languageConfirmationYes.dataset && languageConfirmationYes.dataset.redirectionUrl ?
            languageConfirmationYes.dataset.redirectionUrl : '';
        const corporatePageLink = languageConfirmationYes.dataset.corporatePageLink;
        const isCountryPage = languageConfirmationYes.dataset.iscountryPage;
        if (corporatePageLink === "true") {
            window.open(`${redirectionUrl}`, '_blank');
            delete languageConfirmationYes.dataset.corporatePageLink;
            props.events.emit(props.config.eventNames.CLOSE_POPOVER, {
                args: {
                    CLOSE_POPOVER: 'closed confirmation popup'
                }
            });
        } else if (isCountryPage === "true") {
            window.location.href = redirectionUrl;
            delete languageConfirmationYes.dataset.isCountryPage;
            props.events.emit(props.config.eventNames.CLOSE_POPOVER, {
                args: {
                    CLOSE_POPOVER: 'closed confirmation popup'
                }
            });
        } else {
            const fetchOptions = {
                datasource: `/en/api/hcp/ManualCountrySelection`,
                caller: props.name,
            };
            const requestParams = props.requestModel.format({
                Key: '', Values: '', // *** simple request doesn't need anything
            });
            const data = await props.fetchData(fetchOptions, requestParams);
            if (data.payload && data.payload['Success'] && data.payload['Result'] && redirectionUrl) {
                window.location.href = redirectionUrl;
            }
        }
    }

    return {
        init,
        setActive,
    };
};





const LMSDetails = (props) => {

    const classes = {
        title: 'lms-details__title',
        description: 'lms-details__description',
        imageWrapper: 'image-wrapper__popup',
        ctaButton: 'lms-details__cta-button',
        ctaButtonLabel: 'lms-details__cta-button__label',
    };

    const els = {
        el: null,
    };

    const setActive = (bool) => {
        //console.log('/LMSDetails/ -setActive', bool);
    };

    const init = (options) => {
        update(options, props);
    };

    // ***
    const update = (options, props) => {

        // console.log('/LMSDetails/ -update --options:', options);
        // console.log('/LMSDetails/ -update --props:', props);

        els.el = props.el.querySelector(`[data-popover-type="lms-details"]`);
        els.title = els.el.querySelector(`.${classes.title}`);
        els.description = els.el.querySelector(`.${classes.description}`);
        //els.imageWrapper = els.el.querySelector(`.${classes.imageWrapper}`);

        els.title.innerHTML = options.raw.args.title;
        els.description.innerHTML = options.raw.args.description;

        els.ctaButton = els.el.querySelector(`.${classes.ctaButton}`);
        els.ctaButton.href = options.raw.args.url;

        els.ctaButtonLabel = els.ctaButton.querySelector(`.${classes.ctaButtonLabel}`);
        els.ctaButtonLabel.innerText = options.raw.args.ctaButtonLabel;

        // console.log('/LMSDetails/ -update --els:', els);

        // *** image, if ever needed
        //const oldImage = els.imageWrapper.querySelector('img');
        //if (oldImage) oldImage.remove();
        //const image = document.createElement('img');
        //image.setAttribute('src', options.raw.image);
        //image.setAttribute('alt', options.raw.title);
        //els.imageWrapper.appendChild(image);
    };

    const destroy = () => {

    };

    return {
        init,
        setActive,
        update,
        destroy,
    }
};

const HcpAhpraVerification = (props) => {

    const state = {
        isActive: false,
    };

    const classes = {
        itemIsEnabled: 'popover__item--is-enabled',
        toggleHcpAhpraSection: 'toggle-hcp-ahpra-section'
    }

    const setActive = (bool) => {
        state.isActive = bool;
    };

    const init = () => {
        // console.log('/HcpAhpraVerification/ -init', props);
    }

    return {
        init,
        setActive,
    };
};


function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var script = function script(props) {
    var _types;

    // *** optional js helpers - mapped with same name as the markup blob
    var types = (_types = {}, _defineProperty(_types, 'self-declaration', SelfDeclaration), _defineProperty(_types, 'form-change-email', FormChangeEmail), _defineProperty(_types, 'form-change-email-code', FormChangeEmailCode), _defineProperty(_types, 'form-change-password', FormChangePassword), _defineProperty(_types, 'product-quickview', ProductQuickview), _defineProperty(_types, 'page-share-popover', PageSharePopOver), _defineProperty(_types, 'language-selector', LanguageSelector), _defineProperty(_types, 'language-confirmation', LanguageConfirmation), _defineProperty(_types, 'lms-details', LMSDetails), _defineProperty(_types, 'ahpra-self-declaration', HcpAhpraVerification), _types);
    var state = {
        initialisedScripts: [],
        // TEST
        currentScript: null,
        // *** ref to item script
        hasItem: false // *** true if has item (via dom)

    };
    var classes = {
        isEnabled: 'popover--is-enabled',
        itemIsEnabled: 'popover__item--is-enabled',
        inner: 'popover__inner',
        item: 'popover__item',
        closeBtn: 'popover__close-btn',
        preventScroll: 'scrolling--prevent'
    };
    var els = {
        el: null,
        inner: null,
        closeBtn: null,
        items: []
    };
    var subProps = {
        animateYValue: '+30vh'
    };

    var init = function init() {
        //console.log('/popovers/ -init -props:', props); 
        //console.log('/popovers/ -init --types:', types);

        els.el = props.el;
        els.inner = els.el.querySelector(".".concat(classes.inner));
        els.closeBtn = els.el.querySelector(".".concat(classes.closeBtn));
        els.items = _toConsumableArray(els.inner.querySelectorAll(".".concat(classes.item)));
        /*props.events.on(props.config.eventNames.APP_BREAKPOINT_READY, (payload) => {
          console.log('/popover/ -APP_BREAKPOINT_READY', state.currentScript);
        });*/

        props.events.on(props.config.eventNames.LAUNCH_POPOVER, function (payload) {
            // console.log('/popovers/ -LAUNCH_POPOVER', payload);
            // check for product page while page render through qr code or not
            let isPopoverEnable = true;
            if (window.location.hash.includes('#country')) {
                if (payload.popoverLaunch === 'onload') {
                    isPopoverEnable = false;
                }
            }
            if (isPopoverEnable) {
                var vo = payload.args ? {
                    type: payload.args['LAUNCH_POPOVER']
                } : payload;
                vo.raw = _objectSpread({}, payload); // extra thing here for form stuff

                if (payload.args && payload.args['DATA']) vo['data'] = payload.args['DATA'];
                initItem(vo);
                show(vo);
            }
        });
        props.events.on(props.config.eventNames.CLOSE_POPOVER, function (payload) {
            // //console.log('/popover/ -CLOSE_POPOVER', payload);
            deactivateItems();
            hide();
        });
        props.events.on('FOLLOW_LINK', function (payload) {
            ////console.log('/popover/ -FOLLOW_LINK', payload);
            // TODO 'target' (e.g. '_self') available in payload, honour this
            window.location = payload.args['FOLLOW_LINK'];
        });
        
        inspectGenericButtonAction();
        // *** auto open language selector popup for less waste more care page Qr code product page
        if (window.location.hash.includes('#country')) {
            inspectLessWasteAndMoreCareQRCodeProductPage();
        }
    };

    var inspectLessWasteAndMoreCareQRCodeProductPage = function inspectLessWasteAndMoreCareQRCodeProductPage() {
        localStorage.setItem("country", "true");
        const productsList = ['allevyn-foam-dressings-new', 'allevyn-adhesive-global', 'allevyn-gentle-border-lite-global', 'allevyn-gentle-border', 'allevyn-life'];
        productsList.forEach(item => {
            if (window.location.pathname.includes(item)) {
                props.events.emit('LAUNCH_POPOVER', {
                    args: {
                        "LAUNCH_POPOVER": 'language-selector',
                    },
                });
            }
        })
    }

    // *** inspect page for relevant button actions
    var inspectGenericButtonAction = function inspectGenericButtonAction() {
        var actions = [props.config.eventNames.LAUNCH_POPOVER, props.config.eventNames.CLOSE_POPOVER, 'FOLLOW_LINK', 'AWAIT_FETCH'];

        _toConsumableArray(document.body.querySelectorAll("[data-button-action]")).map(function (item) {
            var action = item.getAttribute('data-button-action');
            if (!action) return;
            var args = props.utils.attributeParser(action, null, 'json');
            var key = Object.keys(args)[0];
            if (!actions.includes(key)) return;
            item.addEventListener('click', function () {
                ////console.log('/popover/ -button click:', key, args[key]);
                props.events.emit(key, {
                    args: args
                });
            });
        });
    }; // *** manage item scripts if present


    var getScript = function getScript(options) {
        var script = types[options.type];
        if (!script) return; // *** no matching script, quit

        state.currentScript = script;
        state.currentScript().setActive(true); // TEST see below FIXIT

        var existing = state.initialisedScripts.find(function (item) {
            return item.type === options.type;
        });

        if (existing) {
            // ***  script already init'd
            // existing.script().setActive(true); // FIXIT - fires twice, test against state.currentScript().setActive(true);
            var updateFn = existing.script()['update'];
            if (updateFn) updateFn(options, props);
            return;
        } ////console.log('/index/ -getScript', options);
        // *** init and store


        if (options.data) {
            options.data;
            script(props).init(options.data);
        } else {
            script(props).init(options);
        }

        state.initialisedScripts.push({
            type: options.type,
            script: script
        });
    }; // *** deactivate item scripts (requires defence implemented in script)


    var deactivateItems = function deactivateItems() {
        state.initialisedScripts.map(function (item) {
            if (item) item.script().setActive(false);
        });
    };

    var initItem = function initItem(options) {
        var target = els.items.find(function (item) {
            return item.getAttribute('data-popover-type') === options.type;
        }); //console.log('/popover/ -initItem --options', options);
        //console.log('/popover/ -initItem --target', target);

        if (target) {
            getScript(options); // *** script is optional

            target.classList.add(classes.itemIsEnabled);
            state.hasItem = true;
            return;
        }

        state.hasItem = false;
    };

    var show = function show(options) {
        //console.log('/popover/ -show', options);
        if (!state.hasItem) {
            //console.warn('/popover/ -show --no matching item, quitting');
            return;
        }

        var tm = props.config.timings.animation.medium() / 1.5;
        var preDelay = options.popoverDelay ? options.popoverDelay : 0; //els.el.style.top = `${window.scrollY}px`;
        //console.log('/index/ -show', window.scrollY);

        props.TweenMax.to(els.el, tm, {
            opacity: 1,
            delay: preDelay,
            ease: 'Expo.out',
            onStart: function onStart() {
                els.el.classList.add(classes.isEnabled);
                disableScrolling(true);
            },
            onComplete: function onComplete() {
                // *** add an optional 'ready' method to subclasses if dom inspection required (e.g. getBoundingClientRect)
                var readyFn = state.currentScript()['ready'];
                if (readyFn) readyFn(els, props);
            }
        });
        props.TweenMax.set(els.inner, {
            y: subProps.animateYValue // scale: 0.98

        });
        props.TweenMax.to(els.inner, tm, {
            opacity: 1,
            y: 0,
            scale: 1,
            delay: preDelay + tm * 1.1,
            ease: 'Expo.out'
        });
    }; // *** HIDE


    var hide = function hide() {
        var tm = props.config.timings.animation.medium() / 1.75;
        props.TweenMax.to(els.el, tm, {
            opacity: 0,
            delay: tm * 1.1,
            onComplete: function onComplete() {
                els.el.classList.remove(classes.isEnabled);
                els.items.map(function (item) {
                    item.classList.remove(classes.itemIsEnabled); // *** clear children
                });
                disableScrolling(false);
                state.currentScript = null; // TEST
            }
        });
        props.TweenMax.to(els.inner, tm / 1.25, {
            opacity: 0,
            ease: 'Expo.in',
            y: subProps.animateYValue
        });
    };

    var disableScrolling = function disableScrolling(bool) {
        if (bool) {
            document.body.classList.add(classes.preventScroll);
        } else {
            document.body.classList.remove(classes.preventScroll);
        }
    }; // REMOVE testing only

    /*  window.h = () => {
        hide();
      };
      window.s = () => {
        show({});
      };*/
    // ---


    return {
        init: init
    };
};

window.app.add({
    name: 'popoverDriver_4e9f45076f35',
    script: script
});